# Nested Lists

### Problem Statement :

```Given the names and grades for each student in a class of N students, store them in a nested list and print the name(s) of any student(s) having the second lowest grade.

Note: If there are multiple students with the second lowest grade, order their names alphabetically and print each name on a new line.

Example:
records=[["chi",20.0], ["beta", 50.0], ["alpha",50.0]]

The ordered list of scores is [20.0,50.0] , so the second lowest score is 50.0. There are two students with that score: ["alpha", "beta"]. Ordered alphabetically, the names are printed as:
alpha
beta

Input Format:
The first line contains an integer, N , the number of students.
The  subsequent 2N lines describe each student over 2 lines.
- The first line contains a student's name.
- The second line contains their grade.

Constraints:
2<=N<=5

There will always be one or more students having the second lowest grade.

Output Format:
Print the name(s) of any student(s) having the second lowest grade in. If there are multiple students, order their names alphabetically and print each one on a new line.```

### Solution :

```                            ```Solution in C :

if __name__ == '__main__':
lis=[]
for _ in range(int(input())):
name = input()
score = float(input())

lis.append([name,score])

lis.sort(key=lambda lis:lis[1])

second_lowest=[]
for i in range(len(lis)):
if lis[i][1]!=lis[0][1]:
second_lowest.append(lis[i][0])
for j in range(i+1,len(lis)):
if lis[j][1]==lis[i][1]:
second_lowest.append(lis[j][0])
else:
break
break

else:
continue

second_lowest.sort()
for i in second_lowest:
print(i)```
```

## Jenny's Subtrees

Jenny loves experimenting with trees. Her favorite tree has n nodes connected by n - 1 edges, and each edge is ` unit in length. She wants to cut a subtree (i.e., a connected part of the original tree) of radius r from this tree by performing the following two steps: 1. Choose a node, x , from the tree. 2. Cut a subtree consisting of all nodes which are not further than r units from node x .

## Tree Coordinates

We consider metric space to be a pair, , where is a set and such that the following conditions hold: where is the distance between points and . Let's define the product of two metric spaces, , to be such that: , where , . So, it follows logically that is also a metric space. We then define squared metric space, , to be the product of a metric space multiplied with itself: . For

## Array Pairs

Consider an array of n integers, A = [ a1, a2, . . . . an] . Find and print the total number of (i , j) pairs such that ai * aj <= max(ai, ai+1, . . . aj) where i < j. Input Format The first line contains an integer, n , denoting the number of elements in the array. The second line consists of n space-separated integers describing the respective values of a1, a2 , . . . an .

## Self Balancing Tree

An AVL tree (Georgy Adelson-Velsky and Landis' tree, named after the inventors) is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. We define balance factor for each node as : balanceFactor = height(left subtree) - height(righ

## Array and simple queries

Given two numbers N and M. N indicates the number of elements in the array A[](1-indexed) and M indicates number of queries. You need to perform two types of queries on the array A[] . You are given queries. Queries can be of two types, type 1 and type 2. Type 1 queries are represented as 1 i j : Modify the given array by removing elements from i to j and adding them to the front. Ty