Чтобы ответить на ваш вопрос, вы можете ввести входные данные во вложенный список как

n=int(input())
arr=[[input(),float(input())] for _ in range(0,n)]

Я считаю, что это вопрос ранга хакера Вот решение

n=int(input())
arr=[[input(),float(input())] for _ in range(0,n)]
arr.sort(key=lambda x: (x[1],x[0]))
names = [i[0] for i in arr]
marks = [i[1] for i in arr]
min_val=min(marks)
while marks[0]==min_val:
    marks.remove(marks[0])
    names.remove(names[0])    
for x in range(0,len(marks)):
    if marks[x]==min(marks):
        print(names[x])

Вот мое решение для этого упражнения Hackerrank:

if __name__ == '__main__':
        students = []
        for _ in range(int(input())):
            name = input()
            score = float(input())
            new = [name, score]
            students.append(new)


def removeMinimum(oldlist):
 oldlist = sorted(oldlist, key=lambda x: x[1])
 min_ = min(students, key=lambda x: x[1])
 newlist = []

 for a in range(0, len(oldlist)):
     if min_[1] != oldlist[a][1]:
        newlist.append(oldlist[a])

 return newlist

students = removeMinimum(students);
# find the second minimum value 
min_ = min(students, key=lambda x: x[1])
# sort alphabetic order 
students = sorted(students, key=lambda x: x[0])
for a in range(0, len(students)):
     if min_[1] == students[a][1]:
      print(students[a][0])

^{An old question but adding an answer so one can get help}

Это действительно вопрос интервью от хакерранк.

Ниже представлено мое простое решение проблемы - я просто перебираю вложенный список оценок. И на каждой итерации новая оценка сравнивается с оценкой lowest и второй самой низкой оценкой (slowest), при этом поддерживается список names, у которых оценка равна второй самой низкой оценке.

Примечание: names всегда связан с оценкой slowest, и если slowest изменяется, мы также меняем names. Если новый балл равен баллу slowest - добавьте новое имя. Комментарий поможет вам в дальнейшем ...

def second_lowests(grades):
    """
    returns list of names of students with second lowest score
    """
    # intialize the `lowest` and second lowest `slowest` score and names
    grades = iter(grades)
    lname, lowest = next(grades)
    slname, slowest = next(grades)
    if slowest < lowest:
        lowest, slowest = slowest, lowest
        names = [lname]
    elif slowest == lowest: # we don't know, if lowest can be second lowest!
        names = [lname, slname]
    else:
        names = [slname]

    for name, score in grades:
        if score == slowest:
            names.append(name)
            continue
        if score == lowest:
            continue
        if score < lowest:
            if slowest == lowest:
                pass
            else:
                names = [lname]
            lowest, slowest = score, lowest
            lname = name
        elif score < slowest:
            slowest = score
            names = [name]
        elif score > slowest and slowest == lowest:
            slowest = score
            names = [name]

    if slowest == lowest: # all have same score
        return []
    names.sort()
    return names


if __name__ == '__main__':
    nested_list = []
    for _ in range(int(raw_input())):
        name = raw_input()
        score = float(raw_input())
        nested_list.append([name, score])
    assert 2 <= len(nested_list) <= 5
    print ("\n".join(second_lowests(nested_list)))

Я не знаю, лучше ли это решение, но оно проходит все тесты.

Это мое решение.

students = [[input(), float(input())] for _ in range(int(input()))]
students.sort(key=lambda x: (x[1], x[0]))
first_min_score = students[0]
second_min_score = min(students, key=lambda x: (x[1]==first_min_score[1], x[1]))
for student in students:
    if student[1] == second_min_score[1]:
        print(student[0])

if __name__ == '__main__':
    total = []
    for i in range(int(input())):
        name = input()
        score = float(input())
        name_score = list((score, name))
        total.append(name_score)
    total.sort()
    min_mark = total[0][0]
    count = 0
    for i in range(len(total)):
        if min_mark == total[i][0]:
            count = count+1
    if count >= 1:
        for j in range(count):
            total.pop(0)
    nd_min_mark = total[0][0]
    for i in range(len(total)):
        if nd_min_mark == total[i][0]:
            print(total[i][1])

вы можете использовать:

start=int(input())
for _ in range(start):
    print("enter Name: ")
    name = input()
    print("enter Score: ")
    score = float(input())
    d[name]=score
    l = sorted(d.items(),key=lambda x: x[0])
m=min(l,key=lambda item:item[1])
#print("minumul este: ")
#print(m)
l.remove(m)
print("lista este: ")
for i in l:
    if i[1]==m[1]:
        #print(rf"elementul {i[1]} a fost exclus")
        l.remove(i)
print(l)
n=min(l,key=lambda item:item[1])
#print(n)
nn=[]
for i in  l:
    if i[1]==n[1]:
        nn.append(i[0])

for i in sorted(nn):
    print(i)

# function for removing duplicate elements
def Remove(scorelist):# scorelist is sorted list with duplicate element
    uniquelist=[]     #uniquelist is list without duplicate element
    for num in scorelist:
        if num not in uniquelist:
            uniquelist.append(num)
   # print("this is unique list",uniquelist)        
    return uniquelist

if __name__ == '__main__':
    newlist = [] #list contain name and number both
    scorelist=[] #list contain number only
    finallist=[] 
    n =int(input())
    for i in range(0,n):
        name = input()
        score = float(input())
        scorelist.append(score)
        lst=[name,score]
        newlist.append(lst)

    scorelist.sort()
    uniquelist=[]
    uniquelist=Remove(scorelist) #sorted and unique list  

    seclow=uniquelist[1] 
    for i in range(len(scorelist)):
        if newlist[i][1]==seclow :
            finallist.append(newlist[i][0])
    finallist.sort()
    print(*finallist, sep = "\n") 

if __name__ == '__main__':
    python_students = []
    new_list = []
    for _ in range(int(input())):
        name = input()
        score = float(input())
        data = [name, score]
        python_students.append(data)


python_students.sort(key = lambda x: x[1])
minvalue = python_students[0][1]
secondValue = 0
for i in python_students:
    if (minvalue < i[1]):
        secondValue = i[1]
        break

for i in python_students:
    if (secondValue == i[1]):
        new_list.append(i[0])

new_list.sort()

for i in new_list:
    print(i)

if __name__ == '__main__':

    n = []
    s = []
    for _ in range(int(input())):
        name = input()
        n.append(name)
        score = float(input())
        s.append(score)            
    a=max(s)
    b=min(s)
    for i in range(len(n)):
        if s[i]<a and s[i]>b:
            a=s[i]

    for j in range(len(n)):
        if s[j]==a:
            print(n[j])

Используйте два указателя для наименьшего (f) и второго наименьшего (s) и перебирайте запись одно за другим. Это должна быть сложность O (N).

def get_second_lowest_grade_students(student_recs):
    f, s = float('inf'), float('inf')
    fl_names, sl_names = [], []

    for (score, names) in student_recs.items():
        if score < f:
            s = f
            f = score
            sl_names = fl_names
            fl_names = names
        elif score < s and score != f:
            s = score
            sl_names = names

    sl_names.sort()

    return sl_names

if __name__ == '__main__':
    student_recs = {}

    for _ in range(int(input())):
        name = input()
        score = float(input())

        if score not in student_recs:
            student_recs[score] = []

        student_recs[score].append(name)

    print("\n".join(get_second_lowest_grade_students(student_recs)))

from operator import itemgetter
if __name__ == '__main__':

    listt = [] #list will contain name and scores, to know the relation between then
    names = [] #list will contain output names
    n = int(input())
    for _ in range(n):
        name = input()
        score = float(input())
        nested_list = [name,score]
        listt.append( nested_list ) 

    listt.sort( key = itemgetter(1) ) 
    minimum = listt[0][1] #contain the minimum score
    i = 0
    for i in range(0,n):

           # if an element its highest than the minimum, its the second lowest
        if (listt[i][1] > minimum): 

            # the second lowest
            minimum=listt[i][1] 
            names.clear() # clear the names list if we before inserted names in else block
            while(listt[i][1] == minimum): # of all scores equals to the minimum

                names.append( listt[i][0] ) #Save their names 
                if i!=n-1: # if is not the last score
                    i+=1
                else:
                    break
            break # once we obtain all equals scored, break loop

        else:           # its possible that all students have same score
            if (listt[i][1] == minimum): # if all score are equal to the minimum
                names.append( listt[i][0] )

    names.sort()
    for name in names:
        print(name)

n=int(input())
stud=[]
grad=[]
for i in range(n):
    stu=input()
    stud.append(stu)
    grd=float(input())
    grad.append(grd)
dic=dict(sorted(zip(stud,grad)))

mini=(min(grad))
cnt=grad.count(mini)

for i in range(cnt):
    grad.remove(mini)
minf=min(grad)
for i,j in dic.items():
    if j==minf:
        print(i)

Эта программа предназначена не только для того, чтобы найти второе место в рейтинге, но также и для третьего или четвертого и так далее.

если название == 'основной':

names = []
scores = []
for _ in range(int(input())):
    name = input()
    score = float(input())
    names.append(name)
    scores.append(score)

## Из этого раздела создайте цикл, чтобы найти третий самый низкий или самый высокий и т. д.

print(names)
print(scores)
min_score = min(scores)
len_scores = len(scores)
print(min_score)

i = 0
while i < len_scores:
    print(i)
    if scores[i] == min_score:
        print(i)
        scores.pop(i)
        names.pop(i)
        len_scores = len_scores-1
    else:
        i = i+1

До сих пор - зацикливание на основе требований

print(names)
print(scores)
min_score = min(scores)
print(min_score)


final_names_list = []

for j in range(len(scores)):
    if scores[j] == min_score:
        print(j)
        final_name = names[j]
        final_names_list.append(final_name)

print(final_names_list)

final_names_list.sort()

for k in range(len(final_names_list)):
    print( final_names_list[k])

Вот, наверное, самое эффективное решение этой проблемы.

'''
This solution is highly efficient because it uses
heapsort and binary search. It sorts only one time
and then uses binary search to quickly find the 
boundaries of all of the values that have the same
rank. Also, since it is sorted, it breaks out of the
loop once it collects all of the values for the rank.
'''

from bisect import bisect, bisect_left
from heapq import heappush, heappop

n = 2
student_scores = []
scores_sorted = []
student_scores_sorted = []
ordinal_map = {}
seen = set()
enum = 1

if __name__ == '__main__':
    for _ in range(int(input())):
        name = input()
        score = float(input())
        heappush(student_scores, (score, name))

for i in range(len(student_scores)):
    val_to_append = heappop(student_scores)
    scores_sorted.append(val_to_append[0])
    student_scores_sorted.append(val_to_append)

    if val_to_append[0] not in seen:
        if enum > n:
            break
        seen.add(val_to_append[0])
        ordinal_map[enum] = val_to_append[0]
        enum += 1

low = bisect_left(scores_sorted, ordinal_map[n])
high = bisect(scores_sorted, ordinal_map[n])

for i in range(low, high):
    print(student_scores_sorted[i][1])

Student=[]
Grade=[]
scorel=[]
namel=[]
for i in range(int(input())):
    name = input()
    Student.append(name)
    score = float(input())
    Grade.append(score)
    scorel.append(score)
scorel.sort()
for j in range (len(Grade)):
    if scorel[-2]==scorel[0]:       
            if scorel[-1]==Grade[j]:
                namel.append(Student[j])
    else:
        if scorel[0]==scorel[1]:
            if scorel[2]==Grade[j]:
                namel.append(Student[j])

        if scorel[0]!=scorel[1]:
            if scorel[1]==Grade[j]:
                namel.append(Student[j])

namel.sort()
for k in range (len(namel)):
    print(namel[k]).

Я не знаю, хороший ли это способ кодирования, но он работает.

Используйте основные функции Python

• понимание списка (с условиями)
• сортировка списками (на месте)
• получить уникальные значения с помощью наборов (трюк 17c)

Вы можете запустить следующее как сценарий в командной строке оболочки Linux или Windows.

Он ожидает, что вы введете данные, сначала введя целое число, указывающее количество последующих записей.

Код работает для примера, приведенного в вопросе выше, а также для других случаев. Он проверяет наиболее важные граничные случаи, зависящие от данных, которые могут вызвать проблемы.

if __name__ == '__main__':

    # Note, Python evaluates expressions from left to right, which helps us
    # to do the following. After reading the integer used within the range
    # it will read [str, float] combinations as many times as the
    # range requests
    inputs = [[str(input()), float(input())] for dummy in range(int(input()))]

    # Given the inputs, find the unique score values first. Then we take
    # the second lowest from it and search for the names of the students
    # with this score.
    #
    # Additionally, we validate the inputs to check for edge cases where
    # the question cannot be answered at all. This depends on the data
    # given.
    #
    # To get the unique score values we use the trick to convert to a
    # set and back to a list
    #
    unique_scores = list(set([score for name, score in inputs]))

    # Let's deal with the edge cases. For these we return simply None.
    students = None

    if len(unique_scores) == 0:
        # It might be that no data has been provided. We could handle this earlier
        # but let's do it here, with the other cases.
        # Let's return None in this case
        #
        print('No data provided. Cannot answer your question.')
    elif len(unique_scores) == 1:
        # Suppose, you have quiete some students, but all have the same grade.
        # So there is no second lowest. Let's be strict now and return None
        # in this case too.
        #
        print('Found only one distinct score. Cannot answer your question.')
    else:
        # Finally, after all checks passed we return the names of those students,
        # which have the second lowest case.
        unique_scores.sort()
        second_lowest_score = unique_scores[1]
        students = [name for name, score in inputs if score == second_lowest_score]

    # Finally, present the result
    print(students)

Я опоздал на вечеринку? Вот мое решение. Не самый эффективный (думаю, у Томаса лучший результат), хотя он разделен на функции, которые делают только одно:

def get_second_lowest_value(sco):
    s = list(set(sco))
    if len(s) == 1:
        return s[0]
    else:
        s.sort()
        return s[1]


def get_all_indexes_of_an_element(arr, element):
    answer = []
    for i, a in enumerate(arr):
        if a == element:
            answer.append(i)
    return answer


if __name__ == '__main__':

    names = []
    scores = []
    for _ in range(int(input())):
        names.append(input())
        scores.append(float(input()))

    indexes_of_second_lowest_score = get_all_indexes_of_an_element(
        scores, get_second_lowest_value(scores)
    )

    second_lowest_names = [names[i] for i in indexes_of_second_lowest_score]

    second_lowest_names.sort()

    for p in second_lowest_names:
        print(p)

Дальнейшее уточнение ответа Томаса, чтобы сделать его еще более кратким:

if __name__ == '__main__':

    names = []
    scores = []
    for _ in range(int(input())):
        names.append(input())
        scores.append(float(input()))


    sorted_scores = sorted(list(set(scores)))
    s2 = sorted_scores[1] if len(sorted_scores) > 1 else sorted_scores[0]
    stu = sorted([n for n, s in zip(names, scores) if s == s2])

    print(stu)

Я сделал это немного сложнее:

n=int(input())
list1 = []
for j in range(0,n):
        name = input()
        score = float(input())
        list1.append([name,score])

k=min([list1[i][1] for i in range(0,n)])


for i in range(0,len(list1)-1):
    if (list1[i][1]==k):
        list1.remove(list1[i])

k=min([list1[i][1] for i in range(0,len(list1))])
list2=[]
for i in range(0,len(list1)):
    if (list1[i][1]==k):
        
        list2.append(list1[i])   
list2.sort()

for i in range(0,len(list2)):
    print(list2[i][0])

if __name__ == '__main__':n=int(input())

    names=[]
    scores=[]
    for i in range(n):
        name=input()
        names.append(name)
        score=float(input())
        scores.append(score)
    dic=dict(sorted(zip(names,scores)))

    mini=(min(scores))
    cnt=scores.count(mini)

    for i in range(cnt):
        scores.remove(mini)
    minim=min(scores)
    for i,j in dic.items():
        if j==minim:
            print(i)

if __name__ == '__main__':
student = {}
for _ in range(int(input())):
    name = input()
    score = float(input())
    #tmp=[name]
    if score in student:
        temp=[]
        temp=student[score]
        temp.append(name)
        student[score]=temp
    else:
        temp=[]
        temp.append(name)
        student[score]=temp
key=list(student.keys());
key.sort()
temp=list(student[key[1]])
temp.sort()
for i in (temp):
    print(i)         
#print(student)
#print(key)

это со всеми последующими действиями и легким для понимания кодом

res = {}
for _ in range(int(input())):
    name = input()
    score = float(input())
    res[name]=score
new_list = list(dict.fromkeys(list(res.values())))
new_list.sort()
final_list = []
for key, value in res.items():  
    if value == new_list[1]:
        final_list.append(key)
final_list.sort()
print(*final_list, sep = "\n")

Обратите внимание, что в конце нам нужно отсортировать для отображения в алфавитном порядке.

name_and_scores = []
# Store name and scores
for _ in range(int(input())):
    name_and_scores.append([input(), float(input())])

# Finding second minimum score
second_min_score  = sorted(list(set([marks for name, marks in name_and_scores])))[1]

# Printing second minimum names
print('\n'.join([name for name,marks in sorted(name_and_scores) if marks == second_min_score]))

Этот вопрос определенно из ранга Хакера. Ниже представлено простое решение.

 if __name__ == '__main__':
    student = []
    for _ in range(int(input())):
        name = input()
        score = float(input())
        student.append([score,name])
    
    # Sort list in Ascending order
    student.sort()

    # Assign the first score to a list which will be the minimum
    grade = student[0][0]
    
    # Loop through the list by excluding first item in the list and find the second lowest
    for i in range(1,len(student)):
        if grade < student[i][0]:
            grade = student[i][0]
            break
    
    # Loop through the list and print names based on the second lowest score
    for i in range(1,len(student)):
        if student[i][0] == grade:
            print(student[i][1])

простой и эффективный

if __name__ == '__main__':
    ls1=[]
    ls2=[]
    ls4=[]
    for _ in range(int(input())):
        name = input()
        score = float(input())
        ls1.append([name, score])
    for i in ls1:
        ls2.append(i[-1])
    
    ls3 = list(set(ls2))
    for j in ls1:
        if j[-1]==ls3[-2]:
            ls4.append(j[0])
    ls4.sort()       
    for k in ls4:
        print(k)         

if __name__ == '__main__':
lst=[]
for _ in range(int(input())):
    name = input()
    score = float(input())
    data=tuple((name,score))
    lst.append(data)
lst.sort(key = lambda x: (x[1],x[0]))

print(lst)

Для начинающих этот код может помочь:

if __name__ == '__main__':
    
    N = int(input())
    
    l2 = []
    
    if  2 <= N <= 5:
        for i in range(N):
            l1 = []
            name = input()
            l1.append(name)
            score = float(input())
            l1.append(score)
            
            l2.append(l1)
            
        scores = set()
        for i in l2:
            scores.add(i[1])
        
        names = []
        for i in l2:
            if i[1] == sorted(list(scores))[1]:
                names.append(i[0])
        for i in sorted(names):
            print(i)  

Вот решение поставленного выше вопроса

temp_list = []

n=int(raw_input())
if 2<=n<=5:
    for _ in range(n):
        name = raw_input()
        score = float(raw_input())
        temp_list.append((name,score))
    
    required_dict = dict(temp_list)
    scores_list = [x[1] for x in temp_list]

    second_last_score = sorted(list(set(scores_list)))[1]
    temp_list = []
    for key,val in required_dict.items():
        if val == second_last_score:
            temp_list.append(key)

    for _ in sorted(temp_list):
        print(_)
else:
    print("Please provide n >= 2 and n<=5")
    

for _ in range(int(raw_input())):
    name = raw_input()
    score = float(raw_input())
    score.sort(key=lambda x: (x[1],x[0]))
    name =[i[0] for i in score]
    marks = [i[1] for i in score]
    min_value = min(marks)
    while marks[0] == min_value:
        marks.remove(marks[0])
        name.remove([name[0]])
    for x in range(0,len(marks)):
        if marks[x]=min(marks):
            print(names[x])
    for j in range(0,n):
            name = input()
            score = float(input())
            list1.append([name,score])

    k=min([list1[i][1] for i in range(0,n)])


    for i in range(0,len(list1)-1):
        if (list1[i][1]==k):
            list1.remove(list1[i])

    k=min([list1[i][1] for i in range(0,len(list1))])
    list2=[]
    for i in range(0,len(list1)):
        if (list1[i][1]==k):
            
            list2.append(list1[i])   
    list2.sort()

    for i in range(0,len(list2)):
        print(list2[i][0])

<!-- end snippet -->

ЭТО МОЕ РЕШЕНИЕ

if __name__ == '__main__':
    students=[[input(),float(input())] for _ in range(0,int(input()))] #read the students names and marks into an array
    students.sort(key=lambda x: (x[1],x[0]),reverse=True) #sort the elements(priority to marks then, names)
    marks = [i[1] for i in students] # get marks from sorted array
for i in sorted(students[marks.index(marks[marks.index(min(marks))-1]):marks.index(marks[marks.index(min(marks))])]): #get index of lowest grades and second lowest grades then print the elements between these two points. 
    print(i[0]) #print the names from the list 

работающий

students=[[input(),float(input())] for _ in range(0,int(input()))]

Вышеупомянутая строка предназначена для получения всех входных данных в массив (студенты). Сначала мы не даем студентов. это будет получено линией int(input()).

затем запускаются циклы for, а оставшиеся входы поступают на [input(),float(input())] в указанном порядке (сначала назовите, затем отметки)

пример ввода:

5
Harry
37.21
Berry
37.21
Tina
37.2
Akriti
41
Harsh
39

внутри массива данные будут такими:

[['Harry', 37.21],
 ['Berry', 37.21],
 ['Tina', 37.2],
 ['Akriti', 41],
 ['Harsh', 39]]

Эта строка предназначена для сортировки массива по меткам и именам (первый приоритет меткам, второй приоритет именам)

students.sort(key=lambda x: (x[1],x[0]),reverse=True)

после сортировки данные внутри массива будут такими:

[['Akriti', 41],
 ['Harsh', 39],
 ['Harry', 37.21],
 ['Berry', 37.21],
 ['Tina', 37.2]]

Эта строка будет читать отсортированные оценки из массива студентов.

marks = [i[1] for i in students]

Внутри массива данные будут такими:

[41, 39, 37.21, 37.21, 37.2]

Эти строки могут немного сбивать с толку, но работа с ними проста.

for i in sorted(students[marks.index(marks[marks.index(min(marks))-1]):marks.index(marks[marks.index(min(marks))])]): #get index of lowest grades and second lowest grades then print the elements between these two points. 
    print(i[0]) #print the names from the list 

для простоты понимания, взяв одну часть из линии

(students[marks.index(marks[marks.index(min(marks))-1]):marks.index(marks[marks.index(min(marks))])])

Вышеупомянутая строка кода предназначена для поиска диапазона индекса второй самой низкой отметки. если мы дадим этому коду входные данные из приведенного выше примера, позиция индекса будет между 2-3 поэтому (позиция отметки Гарри - индекс 2, а отметка ягоды - индекс 3), приведенный ниже код действует так же, как и приведенные выше коды (если мы даем пример входных данных, упомянутый выше)

 students[2:4]

В результате эти строки будут выглядеть так:

[['Harry', 37.21], ['Berry', 37.21]]

нам нужны только имена из этого списка, и мы также хотим отсортировать имена в алфавитном порядке.

for i in sorted(2:4):
    print(i[0])

строки выше и ниже будут работать одинаково, если мы введем те же значения, что и упомянутые выше.

for i in sorted(students[marks.index(marks[marks.index(min(marks))-1]):marks.index(marks[marks.index(min(marks))])]):
    print(i[0])

И окончательный результат

Berry
Harry

    if __name__ == '__main__':
    arrStudents = []
    for _ in range(int(input())):
        name = str(input())
        score = float(input())
        arrStudents.append([name, score])
    
    name = []
    marks = []
    sortedMarks = []
    finalist = []
    for i in arrStudents:
        name.append(i[0])
        marks.append(i[1])
    sortedMarks = sorted(list(set(marks)))
    Secondmin_marks = sortedMarks[1]
    for j in arrStudents:
        if j[1] == Secondmin_marks:
            finalist.append(j[0])
    for k in sorted(finalist):
        print(k)

def minl(l):
    mx=0
    ans=[]
    for [i,j] in l:
        if j>mx:
            mx=j
    for [i,j] in l:
        if mx>j:
            mx=j
    for [i,j] in l:
        if j==mx:
            ans+=[[i,j]]        
    return ans    
    

if __name__ == '__main__':
    l=[]
    m=[]
    for _ in range(int(input())):
        name = input()
        score = float(input())
        r=[name,score]
        l.append(r)
    for i in minl(l):
       l.remove(i)
        
    for i in minl(l):
        m+=[i[0]]
    
    for i in sorted(m):
        print(i)

n = int(input())
mainlist = []
marks_list = []
for _ in range(n):
    name = input()
    marks = float(input())
    marks_list.append(marks)
    list1 = []
    list1.append(name)
    list1.append(marks)
    mainlist.append(list1) 
    
marks_list_set = sorted(marks_list)
nameslist = []
length = len(mainlist)
i = 0

while i < length:
    
    if (mainlist[i][1] == marks_list_set[1]):
        nameslist.append(mainlist[i][0])
    i += 1
nameslist=sorted(nameslist)
for _ in nameslist:
    print (_)

students_scores = []
for _ in range(int(input())):
    name = input()
    score = float(input())
    students_scores.append([name, score]) # create input array

unique_scores_set = set((x[1] for x in students_scores)) # calculate unique scores
second_lowest_score = sorted(unique_scores_set)[1] # calculate second lowest score
output = [y[0] for y in students_scores if y[1] == second_lowest_score] # create output array containing names of students with the second lowest score
output.sort() # sort the names aplphabetically in place

print (*output, sep = "\n") #print output list one line at a time

Это мой ответ довольно простой

n = int(input())
l = [[input(),float(input())] for _ in range(0,n)]
s = sorted(l,key=lambda k: (k[1],k[0]))
minvalue = min(s,key=lambda k : k[1])
while s[0][1] == minvalue[1] :
    s.remove(s[0])   
minvalue = min(s,key=lambda k : k[1])
while s and s[0][1] == minvalue[1]:
    print(s[0][0])
    s.remove(s[0])

Вот мои честные попытки решить проблему.

# Run it in Python 3

students = int(input()) # taking the inputs
parentlist = [] # for saving both the students and the marks in an array
scores = list() # seperate list for the scores
newlist = [] 
sec_low = []

# saving elements in the array
for i in range(0, students):
    name = input()
    score = float(input())
    parentlist.append([name, score])
    scores.append(score)

scores.sort() # sorting score in ascending order
res = []
[res.append(x) for x in scores if x not in res] # with the help of res checking for repetation of marks in the scores list

# taking the marks in the 1st position and comparing with the 2nd lowest in the parentlist.
for i in parentlist:
    if (res[1] == i[1]):
        newlist.append(i[0]) # appending the names of students having 2nd lowest marks to newlist

# sorting the newlist alphabetically and printing values
newlist.sort()
for i in newlist:
    print(i)

if __name__ == '__main__':
    score_list = {}
    for _ in range(int(input())):
        name = input()
        score = float(input())
        score_list[name]=score
    second_val=sorted(set(score_list.values()))[1]
    print('\n'.join(sorted ([name for name,val in score_list.items() if val==second_val])))

Объяснение: Я воспользовался словарем. Сначала я взял ввод, а затем узнал второе минимальное значение, составив список значений и затем отсортировав его, чтобы получить значение. Затем в следующей строке в операторе печати я взял ключ как name и значение как val из dict, чтобы использовать значение для проверки условия, удовлетворяющего условию, чтобы оно соответствовало второму минимальному значению, а затем имя для сортировки (если больше чем один) и присоединитесь через '\ n' к следующему и напечатайте.