gkeswani92 Most pythonic solution I could come up with :)
marksheet = [] for _ in range(0,int(input())): marksheet.append([input(), float(input())]) second_highest = sorted(list(set([marks for name, marks in marksheet])))[1] print('\n'.join([a for a,b in sorted(marksheet) if b == second_highest]))
omalsa04 I like your use of join. Btw, you could use list expansion for the read as well if you wanted:
n = int(input()) marksheet = [[input(), float(input())] for _ in range(n)]gkeswani92 That's cool. Reduces the code bya further one line :)
utsav_krishnan [deleted]
yashpalsinghdeo1 here is the solution of probelm Nested lists https://solution.programmingoneonone.com/2020/06/hackerrank-nested-lists-problem-solution-python.html
jainsoumya199 thanks!!
pankajpal Why we are trying to cram the code in 2-3 lines. Is this what pythonic is?
If you are writing a code more than 50 lines and there is bug you will have hell of headache in debugging it.
One great personaility said once:
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
mathPythonCoder I feel like people prefer "to code in fewer lines" instead "to write beautiful and clean code" here.
sim_astro I also agree with you and here is reason for code should be clear and simple to read.
Think someone (may be you) after few months/years may need to change/debug it, then you might have forget the cleaverness done in past :/
Be practicle and try to write clear (might not be in fewer lines or cleaverest) but working and easy read (by someone else) and in future easy to maintaine.
kendall_fleming Even The Zen of Python states
Readability counts
lol...
kurian_benoy Truely agree with u,but his is elegant coding
venkatraju_1284 ridiculously rich and cool
RogueSword754 true
itsbruce I don't disagree with the principle but in this specific case there's absolutely nothing wrong with using a list comprehension instead of a for loop. The comprehension is doing a simple job elegantly.
If this were production code, I'd use a generator rather than a comprehension, to avoid loading the entire data set into memory unnecessarily, but that's not a problem with the tiny data set here.
ic3balandran Java dev here learning python. I don't think pythonic means cram code in as fewest lines. In fact pythonic just means to use python features to your advantages and create CLEAR, CONCISE, MAINTANABLE CODE. And also follow the "standard" ways of doing something in the python community.
The key word here is MAINTANABLE. I've seen many python challenges were people strive for less lines and even one liners and in some occassions they even fail to do the assignment for the sake of a one liner.
xq9125 True
meet_rahulkumar8 Writing a code which machine can understand is easy. Writing a code which human can understand easily is difficult.
jerodg Once you get the hang of comprehensions you will use nothing else. They are very easy to read/understand/debug. It's no different than when you learned how to use a loop for the first time.
er_arunkumar solve this please for me:
in file handling python FI FILE HAS = A B C ; F2 FILE HAS:--- P, Q , R ;
file fif2 should be like a=p , b= q = c=r
try anyone who is intersted
solve F1F2:- A=P B=Q C= R
GoodBOi3000 This is python if your code is not small consice and small , it kind of defeats the purpose of coding in python
ManiChilzz python is type of snake. It is large is size. It is non venomous.
SHEERSENDU_GHOSH [deleted]SHEERSENDU_GHOSH r u mad or what? first learn english then come to comment on other's post.
generalom1234 lol...
abineshabinesh41 r u mad
artur_ludwik XD
er_garciaestrada [deleted]
l00psx [deleted]mailmenk85 are* you*
mkhan874 Touché
danieljmoore123 That's hilarious lol
abineshabinesh41 what
ChrisGrey funny thought though. if you can understand the larger code it's really fascinating.
jiyaBD Right bro...
sayanta2702 [deleted]sayanta2702 marksheet=[] scorelist=[] if __name__ == '__main__': for _ in range(int(input())): name = input() score = float(input()) marksheet+=[[name,score]] scorelist+=[score] b=sorted(list(set(scorelist)))[1] for a,c in sorted(marksheet): if c==b: print(a)sayanta2702 something like this?
pranav01varma This works... helped me refine my logic. Thanks @sayanta2702
chaitanya_u just tweak this code a little bit. add this : scorelist = list(dict.fromkeys(scorelist)) before taking b.
if name == 'main': marksheet=[] scorelist=[]
for _ in range(int(input())): name = input() score = float(input()) marksheet+=[[name,score]] scorelist+=[score] scorelist = list(dict.fromkeys(scorelist)) b=sorted(scorelist)[1] for a,c in sorted(marksheet): if c==b: print(a)ssouravkumar25 what is the use of dict.fromkeys here ?
dheenakcg 1.Create a dictionary, using the List items as keys. This will automatically remove any duplicates because dictionaries cannot have duplicate keys. 2.Then, convert the dictionary back into a list 3.Now we have a List without any duplicates, and it has the same order as the original List
rishabh_saraf30 the order will be different. it wont be same
kishore_123_vel1 it will create a dictionary with keys as items in the give list as argument and values as None.
suryatejapatkari its a way to remove duplicates from the list
anujchamp17 Any benefit of using dict.fromkeys? A simple use of set could have done the same, right?
scorelist = list(set(scorelist))
Also, why have we created a new scorelist when we already had score.
kiransiva76886 becasuse score represents the input value only .it is not a list, so we create a another list as name contain scorelist . all set and sorted operations done only on lists. i hope this is helpfull to you
bprasadpm agree, creating a set object by callin set() is appopriate here.
riteshs919 b=sorted(scorelist)[1] why 1 here?
rohit_ambre to get second highest score from sorted list
gtanishka8 what if the score on index 1 is still the lowest i.e., equals to the score on index 0
itsbruce It can't be. The set function reduces the list to a set of unique values.
gtanishka8 Ok, thanks!
swetamangal099 i have tried a similar code. traceback error: index value out of range
er_arunkumar same .... here
smit_9142 coz we need 2 elements to be printed as a result
naveen_neevan score_list = [] for _ in range(int(input())): name = input() score = float(input()) mark_sheet.append([name,score]) score_list.append(score) second_lowest_mark = sorted(list(dict.fromkeys(score_list)))[1] for name,marks in sorted(mark_sheet): if marks == second_lowest_mark: print(name)
that is how I did, seeing your code, @Chaitanya_u.
satyasai24 why do few cases fail when we dont use "dict.fromkeys"??
sg4187831 "dict.fromkeys" is as similar as set() both can be used to remove duplicates.
kailash_jb_20171 what is that meant[1] ouside of the bracket?
udaykumar_bejjam we need second lowset grade. after sorting second lowest will be in index 1 of sorted array.
saifulislamcuet lowest value can be twice or more...
gegsmith In the initial data, yes. But that's what creating a "set" is for. It removes repeating data.
rahulonlinecg i get always this error "could not convert string to float"
killuawpak did you use marksheet as a list? because you wrote mark_sheet([name,score])
hmmr29 it is wrong
watchoutchild In this above program where you defined marks
savithads1692 Traceback (most recent call last): File "Solution.py", line 9, in second_lowest_mark = sorted(list(dict.fromkeys(score_list)))[1] IndexError: list index out of range
i am getting above errorkiran25499 Even i am getting the same error. Did u get the solution to overcome this error?
dddtripled510201 try this............
marks_sheet=[] score_list =[] for _ in range(int(raw_input())): name = raw_input() score = float(raw_input()) marks_sheet.append([name,score]) score_list.append(score)
second_lowest_mark = sorted(list(dict.fromkeys(score_list)))[1]
for name,marks in sorted(marks_sheet): if marks == second_lowest_mark: print(name)
kiran25499 Thanks a lot, it worked.But, why is it we cannot use set instead of dict.fromkeys ?
dddtripled510201 we can also use set try this................... second_lowest_mark = sorted(set(score_list))[1]
dddtripled510201 we can also use set try this................... second_lowest_mark = sorted(set(score_list))[1]
manavmandalpune second_lowest_mark = sorted(list(dict.fromkeys(score_list)))[1]
can you please explain this??
sabuwalasmit Thank you for sharing your code. It's really helpful and clean
vickyvigneshwar2 [deleted]Simarpreetsingh4 it worked
SaiTejaNaidu for a,c in sorted(marksheet): if c==b: print(a)
bro can u say in which order the nest is sorted? because in marksheet=[name,score] when u used the sorted syntax . would the name of marksheet get sorted or marks get sorted ?Najwani_Girish in above case , it will be marks if your list is like :
marksheet = [score, name] then it will sort based on score what you write first is key
12194mhsnshikh but if different name has same score then how the result would be. it would not provide expected output if you provide all scores same.
jagadeeshg650 small correction name = raw_input() now it will take string
sayantanchakrav1 Does sorted(mark_sheet) sort the list according the name sublist alphabetically??
niravkamdar will it work if there are two students with same highest score ?
harshitrathod creating dict increases space complexity of code
venkatvenkatesh1 showing TypeError: unhashable type: 'list' what could be the reason? I used same code as above.
jagesh2091 we can use sets in place Dictionary and then save converting steps like:
scorelist = sorted(set(scorelist))[1]
This should reduce the steps and will optimise the code.
shaurabh_saha which language is this + sign doesn't works in python I was trying this and it got syntax error
itsbruce https://www.tutorialspoint.com/python/assignment_operators_example.htm
Both the variable on the left and the value on the right have to be the same kind of thing (lists, in this case).
jainsoumya199 why this [1] ???
faj00000 can u please tell me what is use of set here
huiwenji Hi, thanks for your elegent code. Could explain why you change the format of scorelist into list in b=sorted(list(set(scorelist)))[1]? I think scorelist initially set as list.
Rohit_Roku well, you can see scorelist is first converted to set 1)that will remove duplicates. 2) Then we need to convert it back to list
itsbruce It isn't necessary, though. The sorted function will work on any sequence and return the result as a list. Sets are also sequences in Python.
tony_w_feng [deleted]kr8856264 please explain this thing :---
b=sorted(list(set(scorelist)))[1]
for a,c in sorted(marksheet): if c==b: print(a)
mohitbhatt7571 i think that when you assigned marksheet+=[ [name,score] ] this line and so in the for loop for a,c in sorted(marksheet):.here 'a' is for name and 'c' is for score.So you are comparing if the score matches then you print the name
chungys02 May I know how the program interprets a for name and c for score automatically when we have not assigned each of them to anything?
itsbruce You need to learn about Python list comprehensions.
https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions
Anar_2706 It means that the if the second value in sorted scorelist is equal to value in marksheet then print the key of marksheet
killuawpak actually here they are trying to do everything in 1 line we can split tbis code as well ,
set(scorelist) will create a set of score list (we can use dict.from keys as well because we need to rule out the duplicate entries)
list(set(scorelist)) will create a list of set, you can create a list of dictionary as well
sorted will sort your list of set(scorelist)
[1] will point to the second element in the sorted list beause we want to print the 2nd smallest element in the list
and now we store it in the b variable
a and c are the names and scores we have already stored in the marksheet
so we are comparing that if c == b that is is core in the marksheet is equal to the secondlowest score that we just found out we will print a
now a is the name that is what the question is asking huh!
vivek3639 What if there are more that 1 lowest scores
ramit8339 Can anyone explain the multiple counters in for loop
pamuditha_i @ramit8339 It's used because the list elements contain 2 values inside each. Therefore two counters have been used instead of one.
HAMZA_SHAKEEL can you please explain this code to me i am new to python
pamuditha_i - @HAMZA_SHAKEEL First two lists are created as marksheet and scorelist. marksheet is used to store the values of all the inputs more like a dictionary while the scorelist recores only the scores.
- input is put into the range() to make sure there are enough inputs taken for all the inputs gievn and also because we camt be so sure about th amount of inputs.
- Then the scores, marks are stored by marksheet+=[[name,score]] scorelist+=[score]
- sorted() is a function used to sort the list items in the accending order. Check this link for more info. https://docs.python.org/3/howto/sorting.html
- b=sorted(list(set(scorelist)))[1] The second lowest score is taken out to the element b by the index[1].
- Then for a,c (a and c are used for the loop process. Nothing special with the functionality of the programme) in the range, all the names which bears the score b is printed.
And a special note must be made, this may look like its forgetting that the test cases might have more than one lowest score. That issue has been addressed by the use of set(). A set does not have duplicate items. Therefore the check is valid and accurate.
mantasha_shakee1 Thanks for ur kind explanation to beginners @pamuditha_i
himalayanram_it From your 5th point, the position [1] is taken to the second value. I assume the list is sorted by the marks from lowest to highest. So giving[1] will take the second lowest grade, am I right?
If what I'm stating is correct, how they are sorting the list from lowest to highest using the scores.
pamuditha_i [deleted]NEMMANIWARAYUSH please help what is the meaning of sorted(marksheet)
sg4187831 @NEMMANIWARAYUSH it is used to sort the list....in this case it will arrange the names in marksheet alphabetically.
adty910 this is easily understandable, unlike those mind breaking one liners. thanks a lot.
shettyprerana3 what is a,c in for loop?
dhawalhatzade5 can you plz explain variable b
utkarsh_vashisth why does it fail some of the test cases?
gpalak7055 can anybody explain me what is a and c in this ?
ankimay15 a,c represent name,score in marksheet
bhadauriaprasan1 [deleted]bhadauriaprasan1 what if the input has two minimas then your code will give the lowest rather the second lowest
itsbruce No. He turns the list into a set and then back into a list. Turning it into a set removes duplicates.
gayathiri3132000 yeah itsbruce is absolutely correct
tailedbeasts I'm new to python can you please explain me ,why you put [1] in your code ?
get_ultimateroh1 when the list is sorted in increasing order, [1] is the index of the second element which is the second lowest.
Farazahmad372 b=sorted(list(set(scorelist)))[1]
for a,c in sorted(marksheet): if c==b: print(a)can you please explain this code ?
vickyvigneshwar2 i didnt know that a,c will switch to arguments in list thanks ahmad for taking a moment to clarify
gayathiri3132000 its his pleasure
mailtosrijesh can anyone help with the explaination part. TIA
vickyvigneshwar2 [deleted]
Code_Vee can u plz explainn this
gayathiri3132000 no u have to explain
saarthak2552 In 9th line why are you typecasting scorelist with a List? What is the purpose?
b = sorted(list(set(scorelist)))[1]
rpclark The list conversion is not needed.
amanchoudharyx20 Why this [1] is written at the end of b?
praveen18_786 b=sorted(list(set(scorelist)))[1]
you dont need to convert set into list for sorting. Sorted function works on set as well and always return list irrespective of the type of iterable arugument passed
_ErrorCode_ Can you please explain the use of [1] ?
praveen18_786 By default sorting happens in ascending order with index starting from 0. Acc to question we have to pick second lowest grade, so after sorting
- first lowest grade at index 0 (first lowest value in ascending order reading left to right)
- second lowest grade at index 1 (second lowest value in ascending order reading left to right)
And if you know we can pick any specific element of list/set/whatever using indexing. That's why we using [1] to pick element located at index 1
_ErrorCode_ thank you.
Ted_Mosby Can you please tell what is role of function set() in the code? Thank You
sidsharik This is beautifully written!
Thank you brother :)
yashbhalgat9657 @sayanta2702 why did you use set which is unordered and unindexed and then use list why not directly use list?can you please explain
yashbhalgat9657 oh to remove duplicates u did that alright got it sorry to bother
prateekpranveer1 I am new to python can you tell why did you add [1] at the last of syntax b=sorted(list.....)))
singhp8889 can you explain me this logic
saeedfeizi01 hi 1) for _ in range(int(input())):
input() = 5
This loop will be repeated 5 times
2) name = input() # Harry score = float(input()) #37.21
At this point we get the name and score. This will be done 5 times.
3) k.append([name,score])
In list K we add the name and score to the list
4) mark = (sorted(list(set([m for n,m in k])))) #with loop taken n= name and m = score set : delet duplicate elements list : creat list of score sorted : Regular elements of mark
5) print("\n".join([a for a,b in sorted(k) if b == mark[1]])) # b == mark[1]] = second element of markIn list K we add the name and score to the list
pawansinghla [deleted]churchralph41 Thanks! This makes a lot more sense than that first comment with some 400 votes.
thind1008 what do you mean by for a,c in sorted(marksheet)
saumipant b=sorted(list(set(scorelist)))[1] can you plz explain this part
kiransiva76886 set means it delets the duplicate values list is keyword is converted to list and sorted is a keyword is used for sorting it's sorted the list and final value store in b
diff_here yeah..!! you're right.
hasanimamul57 could u please explain me about last for loop. what is the use of a,b.
rachuru174 b=sorted(list(set(scorelist)))[1] what does this line mean?
hasanimamul57 it will sort the list and take out number which are at index 1 i.e second least.
shetty3491 thanks
lifeslongtwist Hey, what is the [1] there for?
amrit55 what is mean of [1]
armaankhan123451 [deleted]armaankhan123451 if by using set the scorelist is already sorted why we use the sorted function again ?
amritoadhikary11 [deleted]ndh2912001 i don't understand why you use sorted() but not .sort() and plz explain me set function
arrangonsalves52 b=sorted(list(set(scorelist)))[l] please explain this? (the sorted part with the l)
er_arunkumar why m getting error 1000 times by using ur code
gopalparmar9468 does anyone can explain this b=sorted(list(set(scorelist)))[1]
er_arunkumar solve this please for me:
in file handling python FI FILE HAS = A B C ; F2 FILE HAS:--- P, Q , R ;
file fif2 should be like a=p , b= q = c=r
try anyone who is intersted
solve F1F2:- A=P B=Q C= R
harshitrathod THE ONLY ADDITION TO THIS CODE WOULD BE TO SORT THE MARKSHEET LIST ALSO AS IT WOULD HELP PRINTING THE OUTPUT IN ALPHABETICAL ORDER
suryatejapatkari but we dont get the names if alphabetical order right
overcastvaibhav1 what is the use of [1] in line9
raghavava17 if u create set of scorelist the similar marks will be eliminated and it will give only one name alwz
1711shashank what if the lowest score is present twice in that case value of b will be lowest not 2nd lowest
Wesleyong_2019 Would the code still worked if i replaced b=sorted(list(set(scorelist)))[1] with b=(list(set(scorelist))[1] Essentially i removed the sorted()
raghavava17 nope! set would eliminated the repeation of numbers and then u covert it to list to make it ordered and indexible but u will get the desirable value only when u sort the numbers, so yes u have to sort date anyway. but yes u can write it as b = sorted(set(scorelist))[1] u dont hv to convert it to a list again because sorted() function write the data in form of list
Wesleyong_2019 Hi there thanks for the clarification! But wouldn't set() already sort the list? The list is already sorted at least when i tested. In that case is there still a need to call sorted() again?
shubhambndl8 what will sorted( marksheet ) will do means it sort on first index or like names or what
yashshree_shinde I am new to python can you explain this,how its adding?
marksheet+=[[name,score]] What does this mean?
aniketydv Can you explain the use of [1] ? and the purpose of set() function?
anuragbhatt408 nice work bro
dddtripled510201 list index out of rang error
paresh_shelke43 what is 'a' and 'c' over here? i can't understand this two term in this code. pls explain!!
dddtripled510201 a for name and c for marks are defined
like for name ,marks in range(marksheet): if marks==second_lowest_marks print(name)
gackcdhcbua why did you used set(scorelist). why set()?
shahsheikh1999 your code is far more good but b = sorted(list here without list we can also write and it will not show any error .
shaurabh_saha why using set why do we need unique values??
itsbruce Because when the list of marks is reduced to unique values, the second element in the resulting sorted list is automatically the second lowest mark.
prasadkarjawkar6 for what [1] is taken at last in line9
sachindagrt88 why did you convert scorelist into a set and then again into a list? I tried it without converting its not working. Reason plz??
sidhhant11 perfect code for beginners to understand, Kudos to you!
theinvincibleari Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it. Brian Kernighan
174g1a0299 [deleted]
mougin_nicolas [deleted]
pipa0979 omalsa04 snippet is simple yet elegent, This is an industry standard code, why are you guys complaining about this ?
pankajpal I beleive it will bloat your memory in case list is huge thats first.
Second the code will be hard to debug.
itsbruce This challenge requires the whole list to be loaded into memory. Unless you are saving each student record to a file as you read it, there is no other option. And we're told there are never more than 5 students in the input.
I use generators rather than comprehensions wherever it is possible and reasonable, but this isn't one of those situations. If you are doing this with nested lists (a dict would be more efficient), the whole list has to be traversersed at least twice, depending on your sorting strategy.
Hard to debug? Comprehensions have become core to Python. They beat hand-crafted for loops for several reasons:
- More expressive (if not abused)
- Less fragile and error prone
- Can often easily be turned into generators for memory efficiency.
Learn them. Modern Python is full of them. Which of these is clearer?
validGroup = all(validUser(user) for user in group)
for user in group: if not validUser(user): validGroup = False break else validGroup = True
nick3499 [deleted]
TayyabKhan [deleted]ManiChilzz your answer is shit
tincumagic You are wrong, for this chalenge you only need to traverse the list once. You will keep two lists: 1. list of name found for the second position 2. list of names found for the currently min value. In case you find a another min value, the second position list of names becomes the min value list of names.
captainkangaroo1 +1 for tincumagic
This version only stores 2 lists. If the input scores are taken from a normal distribution, the 2 lists will be extremely short and will use virtually no memory. Runs in linear time.
lowest=[] secondLowest=[] for _ in range(int(raw_input())): name=raw_input() score=float(raw_input()) if len(lowest)==0: #initialize lowest list lowest=[ [name,score] ] elif score < lowest[0][1]: secondLowest=lowest lowest=[ [name,score] ] elif score == lowest[0][1]: lowest.append( [name,score] ) elif len(secondLowest)==0: secondLowest=[ [name,score] ] elif score < secondLowest[0][1]: secondLowest=[ [name,score] ] elif score == secondLowest[0][1]: secondLowest.append( [name,score] ) names=[item[0] for item in secondLowest] for name in sorted(names): print name
itsbruce -1 for ugly and verbose code. That is a mess.
15bit007 lol -9 to you
itsbruce Almost all of which appeared within 24 hours. Amazing - you'd almost think somebody childish created a series of accounts.
BoeingDriver LMAO!
lnie1 Hi, Bruce,
People are using different benchmarks.
your code is beautiful because it is easy to read and friendly to starters especially for python starters
tincumagic's code is beautiful because it runs in linear time. If you want to work for big IT companies, like Goolge, Facebook as a professional developer, please note this is the answer that they want. Sometimes, verbose code can be extremely effecient
itsbruce You can run in linear time without ugliness. Google and Facebook value maintainable code and have extensive coding standards devoted to that.
Start with the clean code, move to the fast code as necessary. The result will still look better than that.
The Hackerrank challenges actually offer good training in this approach. Start with the clean solution, then see which tests - if any - it fails, then see how much you have to contort the code to make it meet the challenge. Aim for the least distortion necessary, because the clean code is easier to maintain. Which will oten matter even in these challenges, when your optimisation clears one difficult test but still fails the next.
There's never an excuse for starting with something that much of a mess.
ChristopherPisz @itsbruce the code is neither ugly or a mess. It is solving an problem as efficiently as possible. That is, with one iteration. All the other solutions I see on this page are sorting the inputs after the are obtained, which has extra cost. When people are asking me these types of questions in interviews, they are looking for optimized code.
I came up with almost the exact same listing:
def GetName(pair): return pair[0] def GetGrade(pair): return pair[1] if __name__ == '__main__': lowest=[] runnersUp = [] for _ in range(int(input())): name = input() score = float(input()) pair = [name, score] if not lowest: lowest.append(pair) elif lowest[0][1] == score: lowest.append(pair) elif lowest[0][1] > score: runnersUp = list(lowest) lowest.clear() lowest.append(pair) elif not runnersUp: runnersUp.append(pair) elif runnersUp[0][1] == score: runnersUp.append(pair) elif runnersUp[0][1] > score: runnersUp.clear() runnersUp.append(pair) runnersUp = sorted(runnersUp, key=GetName) for pair in runnersUp: print(pair[0])
mararosa [deleted]
loki29464 [deleted]kansasvirtual I dont know why it fails with this: 3 jorge 20.0 jorge 20.0 juan 21.0
itsbruce You mean like this?
scores = {} top2 = [] def logScore(score): global top2 xs = [x for x in top2 if x < score] + [score] + [x for x in top2 if x > score] top2 = xs if len(xs) < 3 else xs[0:2] for _ in range(int(raw_input())): name = raw_input() score = float(raw_input()) logScore(score) scores[score] = scores.get(score,[]) + [name] for name in sorted(scores[top2[1]]): print name
I think you may have missed the point of what I was commenting on (the solution techniques presented in this thread, not on how I did it).
captainkangaroo1 Hey itsbruce, I think you missed the point from tincumagic. If you have a gazillion names in the input, your code will store all gazillion names in your "scores = {}" dict. (And BTW your code doesn't use nested lists, which is the subject of this assignment.) My solution (that you find "ugly and verbose") only stores 2 lists. If the input scores are taken from a normal distribution, my 2 lists will be extremely short and my code will use virtually no memory.
itsbruce [deleted]itsbruce "If you have a gazillion names in the input"
The challenge explicitly states there will never be more than 5. If the number were open ended, I'd optimise for that. As it is, there's no point. Pointless optimisation is a waste of time, in real work even more so than in toy challenges. Your solution does more work than mine and doesn't have to because there's no gain here.
"And BTW your code doesn't use nested lists, which is the subject of this assignment.)"
A fixed limit of 5 is also part of the assignment but you pointlessly ignored that.
Nested lists are the wrong solution for this challenge. That's typical of the author, most of whose challenges are poor quality and poor teaching material. Fortunately, there's zero requirement to use nested lists.
I find your solution ugly and verbose because all the logic is tied up in one long if/else statement. If I wanted to optimise for saving space (not necessary with a guaranteed limit of 5), i'd simply adjust the code so that when a value is pruned from top2, its names are pruned from dict and all future entries for that score are ignored. And because my code isn't a long chain of if/else, that's an easy change to make.
captainkangaroo1 show me
itsbruce scores = {} top2 = [] def logScore(score): global top2 xs = [x for x in top2 if x < score] + [score] + [x for x in top2 if x > score] if len(xs) > 2: scores.pop(xs[2], None) xs.pop() top2 = xs return score <= xs[-1] for _ in range(int(raw_input())): name = raw_input() score = float(raw_input()) if logScore(score): scores[score] = scores.get(score,[]) + [name] for name in sorted(scores[top2[1]]): print name
tincumagic -1 for incomprehensible code for the old school programmers like me. Maybe some Python experts find it readable.
itsbruce Truly it is indecipherable.
After all, a for loop that iterates over the input and feeds each parsed number to a function called "logScore". Deeply mysterious.
IF logScore returns true, the corresponding name is added to the dictionary entry for that score, otherwise not. How could that possibly be related to the challenge? The Rosetta Stone to translate this esoteric concept has not been carved.
Sheesh. It's mostly simple Python and a couple of core library functions that have obvious names. There are, to be fair, one or two things that will not be obvious to somebody completely unfamiliar with Python. The underscore is the variable equivalent of /dev/null - here, we're iterating over a range but don't actually care about the individual numbers in the range. Using -1 to index a sequence gives you the last element. List comprehensions used to filter a list (although you'd think the "< score" and "> score" might be a clue). But somebody told me this was a Python tutorial, which might mean that people with some interest in learning the language might try it.
I never had much time for the definition of "old school programmer" that says "Don't learn anything that doesn't look like C and complain if anybody else uses it". Have you considered actually learning the language?
k11h12anh I think everyone mentally processes code differently so some people might find one way is better than the other. I'm sure some will like itsbruce's code (verbose in a different way as in too many for loops) but for me I find tincumagic/captainkangaroo1's code cleaner and easier to read.
_jodo Hey Bruce!
I am new to programming and have started with python. I like your code because i can comprehend it, but i am having difficulty understanding some parts of it. If you could help clarifying the concepts it'd be great:
I dont understand this:
xs = [x for x in top2 if x < score] + [score] + [x for x in top2 if x > score]
First you mention x < score and then x > score, you consider both the cases (!) and how can you concat score in between. I'm like totally lost on this line. What is (xs[2], None) in:
scores.pop(xs[2], None)
What does (score,[]) + [name] do in:
scores[score] = scores.get(score,[]) + [name]
Thanks in advance!
itsbruce Hi. OK, first line...
[x for x in top2 if x < score]
This is a list comprehension. It creates a new list based on the contents of another sequence (top2). In this case, it returns a list containing all the elements in top2 which are less than score (preserving the original order). The other comprehension returns a list with all the elements which are greater than score. Meanwhile, [score] is a list containing the single value score.
So what I do in that line is create three lists - everything less than score, [score], everything bigger than score - and concatenate them into one list. What it does is take a list which may already contain scores sorted in order and adds a new item in the correct position within the list.
By doing it this way, I don't have to check to see if the list is empty or contains only one item or contains two items. I don't have to create the different strategies to cope with those 3 different possibilities. This simple strategy works in all of those situations. For example, if top2 is empty, the two list comprehensions will return empty results and two empty lists will be concatenated onto a list containing only score, which is what I would want to do if top2 were empty. If score is lower than any of the current scores in top2, then the first list comprehension will be empty and the second one will contain everything from top2; an empty list will have score added to the end of it and then the contents of top2 added to the end of that.
Oh, and I also don't have to deal with the situation where the new score has the same value as one of the scores already in top2. can you see why?
So this one line always does the right thing, no matter how many values are already in top2 and no matter how the new score value compares to them. So it works much better than a long sequence of if/else statements. It's also much clearer in its intent than a long chain of if/else - if you understand list comprehensions.
_jodo First, two thumbs up for for the detailed explanation, thank you! Now it makes so much sense to me! This is such a nifty way to deal with the problem since the order of the entries are maintained and you know where what is.
I understand what will happen when top2 is empty, that number of elements is irrelevant since you iterate over all the entries in top2 with score and you maintain the order of entries in top2, wether the score is higher or lower than top2, but i'm sure why it'd not add two entries of same value because the first comprehension will give an empty list, score will be score and the third comprehension will give an empty list so it should append score to top2 otherwise the first time the code is run, it wouldn't work in that case too?
itsbruce Imagine the current content of top2 is [1, 2] and logScore is passed a value of 2. The first list comprehension returns all the scores in top2 which are less than 2: [1]. The second list comprehension returns all the scores in top2 which are greater than 2: [], the empty list. So the result is
[1] + [2] + []
which means that the contents of top2 don't actually change. logScore replaces the contents of top2 with the result of that line of code, it doesn't add it to the end of top2.
itsbruce On to the second line you had an issue with:
scores.pop(xs[2], None)
So I want top2 to contain only the lowest two scores (yes, I should probably have named it bottom2), but I've just added a new value to the list, so there may now be 3 scores in there. So I check and if there are 3 then I remove the last one (which will be the highest of the three and not the one I want to keep) by doing this:
xs.pop()
pop() is a function that removes the last item from a list and returns that value. But I ignore it because I don't care what it was.
But before I do that, I also remove from the scores dictionary the key and the list of names associated with the score that I'm discarding. I know it can't be the second lowest score, so I don't need to keep that list of names around. Deleting it from the dict saves memory.
Now, there is a del function that removes a key and its value from a dictionary. But there's a chance that there may not be any entry in the dictionary for this score; if score was bigger than the existing values in the list, then it's been added to the end and is about to be removed from it without there ever having been an entry for it created in. So you have to check if the key exists in the dictionary before deleting it - if you use del to try and remove a key that doesn't exist, it raises an error.
Or you can use the dictionary version of the pop() function, which takes a key as input. Like the list version of pop(), it removes an element from the collection and returns its value. If you also provide a default value (as the optional second argument), it won't complain if the key doesn't exist. I don't care what that value is, so I provide a default value of None.
So that line removes an entry from the scores dictionary if it is there; otherwise it does nothing.
_jodo Just to clarify here,
scores.pop(xs[2], None)
Means: Python pop key position 2 from the list xs and return value None
itsbruce No, it means
- Find the third score in the list xs (which will be the highest score of the three, the one we don't want to keep)
- Delete that score and its list of names from the scores dictionary and return the value of that list. If there is no such entry in the dictionary, return None.
scores.pop is a method belonging to the dictionary class. It modifies the dictionary it belongs to, it doesn't modify the values passed to it. It always needs one parameter which is the key to fetch/remove from the dictionary. It optionally takes a second value, which is a default value to use if there is no such key in the dictionary.
I don't do anything with the returned value, I ignore it, so it could return anything and it wouldn't matter. I'm only providing a default value to stop pop from complaining if there is no such key in the dictionary. I use the pop method rather than the del function because pop can be made not to complain; I know there will be occasions where there is no such key and I'd rather use a function that doesn't mind, rather than have to make that check myself. I provide None as the default value to make it clearer that I don't care about the result (and to not waste the program's time by having it create and store a value that will never be used).
itsbruce OK, third and final line:
scores[score] = scores.get(score,[]) + [name]
So if logScore(score) returned true, score is one of the two lowest scores we've seen so far, which means we want to add the name to the list of names associated with that score (if it isn't one of the lowest two, we don't care). Which is what the line above does.
So we want to fetch the list of names associated with score in the scores dictionary. But what if this is the first time we've seen this score? In that case, there will be no entry - trying to fetch it will raise an error. However, if we provide a default value, get() will return that default value if score is not a key in the scores dictionary.
So that line fetches the existing list from the dictionary or returns an empty list if there is no entry for score in the dictionary. Then we add name to the end of that list and put the resulting list into the dictionary as the list associated with score.
_jodo Here i get a bit confused when you mention "if logScore(score) returned true, score is one of the two lowest scores we've seen so far" > i thought that the job of logscore is to only get second heighest score every time it iterates and this line adds the identified second heigest scores to the dictionary scores with their names **+ [name]
And thanks again!
itsbruce According to the problem description, it's the names of the students who got the second lowest score we're looking for. My code certainly finds the lowest two scores and since my code passes the tests, that seems to be what's wanted. Can't remember precisely what I was thinking when I called the variable top2 - the two most significant and/or the two which would be at the top if you sorted the list in descending order, I suppose.
You're wrong about what logScore does. Its responsibility is to add the score to the list of the two lowest scores if it is one of the two lowest scores we've seen so far. It returns True if the score is currently one of the two lowest, False otherwise.
The program checks the result; if the returned value is True, then score is currently one of the two lowest scores (lowest or second lowest) and we should keep a record of the name associated with it. But recording the name isn't logScore's responsibility.
To be honest, logScore probably has either too much responsibility or not enough; either a separate function should manage both the addition of names to the dictionary and their removal if a score drops out of the lowest-two-scores list, or logScore should completely manage both the top2 list and the scores dictionary. As it is, it's a little messy. My excuse was that it was a quick change made to my code at somebody else's request.
matthewzalex Hi itsbruce. I read your explanations and understood the code. I was wondering, if i use the same comprehension to sort the names, will the code be better?
I modified the if statement,
if logScore(score): scores[score] = scores.get(score,[]) + [name]to
if logScore(score): temp = scores.get(score,[]) scores[score] = [x for x in temp if x < name] + [name] + [x for x in temp if x >name]and avoided sorted() function in the end. full code:
scores = {} top2 = [] def logScore(score): global top2 xs = [x for x in top2 if x < score] + [score] + [x for x in top2 if x > score] if len(xs) > 2: scores.pop(xs[2], None) xs.pop() top2 = xs return score <= xs[-1] for _ in range(int(raw_input())): name = raw_input() score = float(raw_input()) if logScore(score): temp = scores.get(score,[]) scores[score] = [x for x in temp if x < name] + [name] + [x for x in temp if x >name] for name in scores[top2[1]]: print nameitsbruce I applaud your perception, but the first objection is that you've created a significantly less efficient solution. You sort the list of students with the grade you've just seen if that score is currently in the lowest two scores. Imagine if the first few students in the input get the highest score and there are more than 2 different scores. Your code will diligently sort that list, only to throw it away later. That's a waste of time.
Aside from that, reusing the technique from logScore on the list of names is likely to be significantly less efficient than Python's sorted function.
What I did in the logScore function is an insertion sort - one of the easiest sort functions to implement but one of the least efficient on data sets of any significant size. It isn't even the most efficient implementation of insertion sort - an efficient implementation would compare the next value to insert to the value just inserted, remembering the position of the value just inserted, so that the next iteration can work forward or backward from that point rather than starting from the beginning each time. That doesn't matter in logScore, because the data set never grows beyond 3 (being cropped back to a maximum of 2 elements after the sort).
As it happens, we're told there will never be more than 4 students with the second-lowest grade, so the difference in efficiency is unlikely to matter, but a) I don't see the point in dropping the core sort function for a more-than-usually-inefficient insertion sort here and b) I prefer any piece of code to do only one thing unless there's a clear and needed performance gain from doing more than one thing at once. Trying to do two things at once is also why you missed the fact that your proposed solution is inefficient.
matthewzalex Thank you for the clear explanation. Now i see what i did there. I never thought of insertion sort that way too! Good to have you commenting on what I did.
danielgcwik thanks bruce this worked for me in python 2
kansasvirtual It fails with this custom input: 3 jorge 20.0 jorge 20.0 juan 21.0
sim_astro Its just a challenge with title "Nested List" and not about cleaverest solution.
rikrishs Oh..........................
p_g97 [deleted]
nath_ajit01 [deleted]raviteja_pothala marksheet=[[input(),float(input())] for i in range(int(input()))] //another line and go on
gayathiri3132000 ohh
afamrk57 marklist=[[input(""),float(input(""))] for i in range(int(input("")))] print("\n".join(a for a,b in sorted(marklist) if b==sorted(list(set([b for a,b in marklist])))[1]))
make it in one line
Sukhendra523 i like to coode in lesser number of code for fun
marksheet=[[input(),float(input())] for _ in range(int(input()))] second_lowest=sorted(set(marks for name,marks in marksheet))[1] print('\n'.join([a for a,b in sorted(marksheet) if b==second_lowest]))
ericali nicely done!!!
pashnidgunde marksheet = [[input(), float(input())] for _ in range(int(input()))]
codeharrier I would be very leery of the order in which those input() calls are being done. And given the way Python tends to upend its language standards with any given revision, I'd be very, very, very leery of relying on it to never change.
itsbruce Counting on the order of items in a dictionary would be an unwise thing, which some languages deliberately randomise just to discourage the habit. Counting on the order of evaluation of items in a sequence is extremely reasonable for Python, a strictly-evaluated, imperative language.
Comprehensions and generators have long been central to idiomatic Python. The usage you're complaining about is widespread. Making the evaluation of sequences non-deterministic a) isn't something GvR is ever likely to consider given his history and expressed opinions and b) would be a code-breaking change for so much production code that the complaints would make the Python 3 hoo-ha seem a mild disagreement.
codeharrier I dunno. Someone who'd change print from a statement to a function is not going to make anyone trust the stability of the platform.
itsbruce You mean a minor change between one major version and the next (2.x to 3.x) is reason to believe that sequences aren't going to be evaluated in order from one point release to the next? Python is curated conservatively compared to most dynamic languages. I'm no great fan of Python's design but there's no evidence GvR is batshit crazy.
codeharrier A "minor" change could alter anything internal that isn't written down in a standard. And when it does affect order of execution, they'll shrug their shoulders and walk away.
And as for GvR, that change in print, which could have been averted simply by calling the new function pr() or something, will probably induce on the order of millions of man-hours of rework, re-review, and re-verification over time, not to mention all the arguments like this one. If that doesn't ring up as batshit crazy, the bar is set way too high.
itsbruce You can argue over whether it was the best move, but it was highlighted in advance and 2.x is still supported. Nobody's code was in danger. The problem has been one of persuading everybody in the community to move, not people's code crashing.
You're criticising somebody's perfectly good, entirely idiomatic code. By your argument, all Python code is vulnerable, not just that code. Unreasonable singling out that decent solution.
ManiChilzz don't you have any other work?
satadhi hi can u kindly tell me how th loop is working in your code ! i am new to this language and i am pretty confused my now. thanks for the help
yash1th he is using list comprehensions, for more
https://www.youtube.com/watch?v=3dt4OGnU5sM
visit that link
bryon_nicoson this is a helpful, well-presented introduction to python list comprehensions. thank you for posting it :)
bitb3ast I tried this method, but I get the following error. Do, I need to import some module?
Traceback (most recent call last): File "solution.py", line 4, in <module> marksheet = [[input(), float(input())] for _ in range(n)] File "<string>", line 1, in <module> NameError: name 'Harry' is not definedsteeeenos I was having the same problem. The way i fixed it is by using raw_input() for the name instead of input(). Hope this helps
styx97 This maybe a matter of your python version. In python 2 , input takes only integer inputs and raw_input takes strings, ints and floats. In python 3, there is only one input() function which is practically same as raw_input in Python2.
Long story short, the code above is in Python3, so suit yourself.
rakshanihamad change your compiler to python 3 if you are using python 2 or vice versa
Hope it will help :)
akulkapoor marksheet = [[input(), float(input())] for _ in range(int(input()))]
Reduce one more line :-)
shivamgoel977 will u please tell me why we use[1] at the end second heighest=sorted(())[1]
[deleted] because we want the second highest value of the list. if you do [0], you will get the highest which the problem has not asked.
loinger_adiel Should be second lowest grade ;)
beckwithdylan [deleted]mail2karthk07 i did it in one line, it works
marksheet = [[input(), float(input())] for _ in range(int(input()))]
karthiky7cs1212 Is there a need to convert a set to list , Also what is the result of sorted(marksheet) will it sort based on Names or marks?
jerodg or simply:
marksheet = [[input(), float(input())] for _ in range(int(input()))]
alan_cruz_tj marksheet = [[input(), float(input())] for _ in range(int(input()))]
DA_201812046 it will not work because input() return a inputed line (string)
you have to map it with split function and then only you can convert it into float
like map(MySplitFunction, input()) for _ in range(int(input()))
sank8dalvi marksheet = [[input(), float(input())] for _ in range(int(input()))]
kazi15_8649 This is help full. Thnak you
nalingoyal094 really very cool
TeslaM8799 what is the meaning of "_" after for
get_ultimateroh1 It is simply a variable.
gayathiri3132000 yeah
adithyaprasad86 yup..CoOl :-)
gayathiri3132000 okay!!
DipadityaDas marksheet = [[input(),float(input())] for _ in range(int(input())]
First_Second007 marksheet = [[input(), float(input())] for _ in range(int(input()))]
pandamanasranja1 [deleted]saeedfeizi01 It was cool
meshagy18 This further reduces memory usage and a line of code. :)
marksheet = [[input(), float(input())]for _ in range(int(input()))]
ujjwalpd008 to further reduce one line : marksheet = [[input(), float(input())] for _ in range(int(input()))]
er_arunkumar solve this please for me:
in file handling python FI FILE HAS = A B C ; F2 FILE HAS:--- P, Q , R ;
file fif2 should be like a=p , b= q = c=r
try anyone who is intersted
solve F1F2:- A=P B=Q C= R
er_arunkumar solve this please for me:
in file handling python FI FILE HAS = A B C ; F2 FILE HAS:--- P, Q , R ;
file fif2 should be like a=p , b= q = c=r
try anyone who is intersted
solve F1F2:- A=P B=Q C= R
mkhan874 while you are there, might as well
marksheet = [[input(), float(input())] for _ in range(int(input()]
Shivan111 what does [marks for name,marks in marksheet] mean can you explain that to me please ! ?
latived This is called "list comprehension" -- an awesome way to create lists. He takes only "marks" for every (name, marks) in marksheet, where marksheet is a nested list.
Example:
In [682]: marksheet
Out[682]:
[['Harry', 37.21],
['Berry', 37.21],
['Tina', 37.2],
['Akriti', 41.0],
['Harsh', 39.0]]
In [683]: [marks for name, marks in marksheet]
Out[683]: [37.21, 37.21, 37.2, 41.0, 39.0]
karan_youcan2438 Thanks a lot.. that was useful or me :)
sumitmcc i see that u explained well, but i'm still not clear. would you mind elaborating it for me? i am not clear on "marks for name, marks in marksheet" part..
niwot "list comprehension" is in the form : [ A B C]
Part A defines the element(s) put into the new list. Part B is a set of <"for" element(s) "in" collection> statements. Part C contains optional "if" statements that filter each collection element from consideration. In this case it looks like...
A B C [marks for name, marks in marksheet] there is no C [new2 for new1, new2 in parent]
The tricky part is between "for" and "in" of Part B.
B slices the parents child lists horizontaly into two new lists (name and marks), iteratively assigning name=marksheet [0] and marks=marksheet [1]
Part A says "im only interested in keeping the marks list." We throw away the new list called "name."
I suppose if the childlists each had N elements you could say, "for new1, new2, new3,,,newN in ParentList" and be able to manipulate N new lists in your part A.
Hope helpful
niwot The answer in the Editorial tab
a = [[raw_input(), float(raw_input())] for i in xrange(int(raw_input()))]
shows something about the order in which comprehensions are executed. "B" (in comment above) happens first, so xrange gets N. I suppose if there was a raw_input() call in C (the optional "if" statement), that woud happen next (left to right?). Finally the A bit is executed left to right.
I'm just making assumptions here. Please correct me if its wrong.
BhagyeshPanchal great explanation thank u
NseEtim i thought the set() function removes repitition, if thats true then set(marks for name, marks in marksheet) would not return those scores that are of the same value someone should please clearify
kevinbrewer04 Correct, that line of code is sorting all the unique marks (scores), and grabbing the second from the bottom (
[1]). It's slightly confusing because he named the variablesecond_highest, when it's really the second lowest score. The reason for usingsetis to guard against the case where more than one student is tied for the lowest score.
harshavardhanm03 What if we want to find the duplicate names? lets say I have [['A',12],['A',24],['B',22]]
How can I find the unique set based on the first element. Please let me know
achieng91 Hey nice solution man, but 1 issue though. When the no. of students is 2 and they have the same score,
second_highest = sorted(list(set([marks for name, marks in marksheet])))[1]this line of code result in IndexError as the size of list is 1.
Esser420 I just started learning python and this commetn just helped me understand it a lot better!
students = sorted([[raw_input(), float(input())] for _ in range(int(input()))])
secndLow = sorted(list(set(grade for [_, grade] in students)))[1]
print ("\n".join( name for [name, grade] in students if grade == secndLow))
manasveemittal If somebody wants to know reason of 2 different sorts on output
students
[['Dheeraj', 39.0], ['Pallavi', 36.0], ['Prashant', 32.0], ['Shivam', 40.0]]
secndLow
36.0
so basically first sort(on students) sorts by name in case there are repeated names for a the given second lowest grade
second sort just sorts the scores, and set is used for unique values of scores to be sorted
Correct me if wrong
sharath14187 what if there are two names with same scores
smobarsha456 ok. but why your comment yells it out.
Shriswissfed Thank you for posting and explaining code...learnt two new things......!!!!!!
th3ac3 Couldn't sorted(list(set([marks for name, marks in marksheet])))[1] be simplified down to sorted([marks for name, marks in marksheet])[1]
kenzcross This works the same for the initial tests however what happens when you have duplicates of the lowest value (ie 62 62 73 87 or 62 62 62 62 73). How can you determine what arbitrary index will hold the lowest value?
TL;DR Set removes the duplicates.
cbrit Why is it necessary to first turn the comprehension into a set and then back into a list? EDIT: I think I found out that it's because it removes duplicates. Thanks.
Velvet why have you used "set" in the 4th line ?
.....list(set(..)) ?
What is the purpose of set here ? Using list(..) instead of list(set(..)) should be fine I think. Where am I wrong ?
geekyneuro What if there are two top marks ? Then the second highest would be [2] ?
sushilyadav It doesn't matter because the set() function will remove all the duplicates as said by @aswathm78 and list provided by sorted() function will only contain unique marks. So, sorted(...)[1] will always contain 2nd lowest marks.
Spraynard_K [deleted]
dillonredding [deleted]newkid Great idea to use the set.
deepu_ac21 Could you explain the last line to me "[a for a,b in sorted(marksheet) if b == second_highest]))"
Bonsoirelliot what does this mean[1]?
newmocart great solution!!!
a bit improved on py2
arr = [[raw_input(), float(raw_input())] for _ in range(input())] c = sorted(set([b for a,b in arr]))[1] print '\n'.join(sorted([a for a,b in arr if b == c]))
Sort 1446 Discussions, By:
Please Login in order to post a comment