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]
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.
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]
danieljmoore123 That's hilarious lol
abineshabinesh41 what
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
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.
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!
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.
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])
watchoutchild In this above program where you defined marks
bbt10993 u need to intialize mark_sheet=[] in the top
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 ?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
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]
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.....)))
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
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..........................
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
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]
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 ?
geekysalsero 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]))
prakashyadav008 c = sorted(set([b for a,b in arr]))[1]
what does [1]in this line mean
tao_zhang get the second element in the sorted collection
Max_Vignesh It gets the second element from the array.
Thanks & Regards
tao_zhang Interesting, even without creating the list before sorting, after sorting
print(type(sorted(set([b for a, b in sheet]))))
result:
class 'list'
omavinashkalal can you explain me following code : arr = [[raw_input(), float(raw_input())] for _ in range(input())] c = sorted(set([b for a,b in arr]))[1]
NseEtim that is list comprehension the varriable "arr" takes two inputs, but the second input is placed inside the float function, so the input is converted to a floating point value,which means it cant take strings,then "for _ in range(input())", the "_" can be replaced with anything, its just that if you are writing code where you wont need to use that particular variable for anything, you could call it _, its just a community rule of thum thingy,so the third input is taken at the point of the range, its just a way of reducing the amount of code one has to write, so instead of doing something like,
a = raw_input() b = float(raw_input()) d = input() arr = [a, b] for _ in range(d) :# you can use i or any variable name in place of '_' c = sorted(set([b for a, b in arr]))[1]# the 1 in braces means the order in which the sorting should be done, if you use -1 it will be in reverse order
you just use the short version you have there
starcoder thanks gkeswani92 for this solution bt since i am just new in python world so can you plz explain each line of code
satadhi [marks for name, marks in marksheet] how this is working ? can you kindly tell me, i am new to this language .
amit_badve what if bottom 2 students have same marks? we will need a loop to find out second min person from sorted list.
tao_zhang [deleted]yash1th is there any reason why you created a list in the statement?
sorted(list(set....)
as even if you leave it as a set, it will create a set and then sort it, right?
rchidb Here is a variance of your implementation that sorts the the nested list using its 2nd element directly to avoid using Set(). It may save some time in the best case scenario. Comments welcomed.
N = int(raw_input()) students = [] for i in xrange(N): grade = [raw_input(), float(raw_input())] students.append(grade) students = sorted(students, key=lambda x: x[1]) second_highest = students[0][1] for name, grade in students: if grade > second_highest: second_highest = grade break print('\n'.join([name for name, grade in sorted(students) if grade == second_highest]))
neil_a_ramsay Very similar to mine and much more legible than the obfuscated skinny code that the experts are posting above!
kurian_benoy for name, grade in students: if grade > second_highest: second_highest = grade break
I am new to python. Can you please explain what does grade> SECOND_highest means?
enilaydagdemir [deleted]karthickroshan91 hi...
mitkatwala95 students = sorted(students, key=lambda x: x[1])
Can someone please explain me how does this line work? Bit confused on the lambda x: x[1] thing!
valibraimi lambda x:x[1]
Is an anonymous function that will select the second element from lists that are processed in the nested list. also it is equivalent to
def select_second_element(x): return x[1]
XRohan Great thinking. salute to you sir.
Krrish_bro [deleted]
R3zu4C [deleted]mohamed_laleg you assume second_highest is always [0][1], but what if this isn't the case? or am i missing something..
kiranreddyrebel [deleted]kiranreddyrebel [0][1] means first list item's 2nd value i.e grade is kept in one variable so that now we can choose 2nd lowest grade except first lowest grade..
u now understood bro ?
actually it took sometime to catch me also .. (^_^)
enilaydagdemir Can you explain what this "join" part of the code does?
landonkoo0207 This is not my code, but I can comment on that.
It is to print the results as strings in separate lines.
Without it, the results would be like ['Harry', 'Berry'].
'\n' part is to print each name in a new line. This is just the way of python to print a list as strings :)
karthickroshan91 can you breifly explain about python codes
kurian_benoy second_highest = sorted(list(set([marks for name, marks in marksheet])))[1]
What is meaning of [1] at end of snippet?
enilaydagdemir I think it means taking the second last element from the list.
generalom1234 Not second last but it determines the order of sorting which is to be in done for every 2nd element... I guess...
Rick356 It will display the element at 1 position
vikas_p_manav [deleted]
paritosh17 can please please explain me this " second_highest = sorted(list(set([marks for name, marks in marksheet])))[1] " ??
jonobjornstad excellent solution once again!
SebastianNielsen in the line were you define "second_highest": Why do you say: "list( blah blah.. )" The list comprehension will always return a list anyway, or am I wrong?
ameybh to use the sort
tarathedev An alternative to using join is the unpacking operator and setting sep='\n' for print.
eyshikaengineer Can you please explain how your code takes second highest value, also what is the use of set()
Lucasjuv [deleted]pshaikh sorted(list(set([marks for name, marks in marksheet])))[1]
In above statement how does this work?
set([marks for name, marks in marksheet])
How is "marks for name" and "marks in marksheet" interpreted?
[deleted] Wow! Elegant.
oksuzgonulh Great solution. Because this is what happens if it is not pythonic at all!
if __name__ == '__main__': final = [] n = int(input()) for _ in range(n): name = input() score = float(input()) final.append([score,name]) final.sort() k = 0 for x in range(n): if final[x][0] > final[0][0]: k = x break for x in range(n): if final[k][0] == final[x][0]: print(final[x][1])
I have k = 0 for the case all students have the same grade, so the solution is all of them.
ankitathummar final = [] n = int(raw_input()) for i in range(n): score = raw_input() name = float(raw_input()) l = [name,score] final.append(l) final.sort() needed = final[1] c = final.count(needed[0]) if(c == 1): print needed[1] else: for i in range(n): if(final[i][0] == needed[0]): print final[i][1]
I have use same logic as your code. You said it in not pythonic. But this is what logic came into my mind as I am new to python. Though it is failing for TC 2 & 3. What should I do for more cool work as everyone have done for this statement problem.
hivex201 I think there is something wrong with the compiler. I made some changes to your code to run the rest of the test cases and made some changes:
final = [] n = int(input()) for _ in range(n): name = input() score = float(input()) l = [name, score] final.append(l) final.sort() need = final[1] for i in range(n): if(final[i][1] == need[1]): print(final[i][0])
When I ran it on a offline IDLE compiler all outputs are correct but when I ran it on HackerRank, it shows scores instead of names.
sdovejero [deleted]
saransh_arora123 Can you please explain me how are the last two lines working ?
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]))
ameybh will you please explain the join part to me?
nandi_abir [marks for name, marks in marksheet] how does this give me a list of marks .... name is not defined separately ... what does it do???
kevinbrewer04 marksheet is a 2D array, something like
[["Sally", 20.3], ["John", 19.5], ["Susan", 21.2]].So
name, markseffectively destructures each element in the 2D array. For every element,namegets bound to the first item, e.g."Sally", andmarksgets bound to the second item, e.g.20.3. So we iterate through the 2D array, and for each element, we return only the second item in the subarray, and we end up with a 1D array like this:[20.3, 19.5, 21.2].The code is slightly misleading because as the list comprehension iterates over the 2D array
marksheet, it's only looking at 1markat a time. So perhaps, it should have been written[mark for name, mark in marksheet].Does that make sense?
ottawabiju Thanks, how to get the name list (remove sorting), instead of mark pls.
arunangshubsws Who told you that this code is pythonic?? read PEP 8 and PEP 20 again! I dont care if you cram your code into 5 or 4 lines but please refrain from saying that cramming codes is pythonic! It goes directly against the core principles of python programming!
sristi_gupta92 second_highest = sorted(list(set([marks for name, marks in marksheet])))[1]
can you explain this line , i didn't understand why a list has to be created to be sorted, we can place a collection in sorted method.
seejoy [deleted]bubun71 what is that [1]
vishalit10 sorted(list(set([marks for name, marks in marksheet]))) it will provide a list, and of that list object at index 1 will be carried and valuue transfer to second_highest. index start with zero
vishalit10 [marks for name, marks in marksheet] how it will work??
itsbruce The most pythonic thing would be not to use a sorted set when a dict or defaultdict is a significantly better choice.
- Create defaultdict(list) grades
- Read in each name and grade, grades[grade].append(name)
- Sort the keys and take the second lowest.
- Sort the list at that key and print each element
I'm not inclined to use an inappropriate solution when nothing compels me to.
humichina Based on your code, I got this solution. Learned a lot. (py3)
student_marks = [[input(), float(input())] for _ in range(int(input()))] snd_mark = sorted(list(set([mark for stu, mark in student_marks])))[1] print(*sorted([stu for stu, mark in student_marks if mark == snd_mark]), sep = '\n')
RahulBhusare Can you please explain me this code?
bONSPARROW even more compact. is it pythonic?
students = [[input(),float(input())] for _ in range(int(input()))]
print(*(sorted([x[0] for x in students if x[1] == sorted({x[1] for x in students})[1]])),sep='\n')
itsbruce Pythonic aimes for the ideal mix of the explicit and the expressive, so no. Your compactness is at the expense of efficiency as well as clear meaning - you sort the list, then traverse the unsorted list. You traverse the entire list twice. You do more sorting than you need, because you're sorting alphabetically the names of students whom you will discard. That can be improved significantly.
I've said elsewhere that using nested lists for this is an inappropriate solution (dicts much better). But if you want to use nested lists then
- Sort the list by score only.
- Drop from the front of the list all elements with the same score as the first element
- take all the elements from the new sequence with the same score as the first element of the new sequence, discarding the scores and ignoring the rest of the new sequence
- Sort what you have left.
If you want to be efficient and compact to the point of unreadability, here's how your code could be changed to do that...
from itertools import dropwhile, takewhile, tee students = ([input(),float(input())] for _ in range(int(input()))) print(*(x for s1 in [sorted(students,key=lambda y: y[1])] for lowest in [s1[0][1]] for (s2, s2b) in [tee(dropwhile(lambda y: y[1] == lowest, s1))] for next_lowest in [next(s2b)[1]]for x in sorted(y[0] for y in takewhile(lambda y: y[1] == next_lowest, s2))), sep="\n")
For larger data sets with a spread of scores, that's going to be much more efficient than your solution (partly because I use generators and iterators, partly because I do as little traversal as possible). But neither of them are pythonic. Line noise is not pythonic.
petersonpeter elegant!
nath_ajit01 Nice. You could also unpack the list like this when printing in python3
print(*[a for a,b in sorted(marksheet) if b == second_highest], sep="\n")
iamalokit what's the use of set() in the above code. Please explain. ThankYou
nath_ajit01 a set is an iterable with unique elements. So when you do something like,
list(set(some_list))
You get a list with just unique elements
sycramore I am curious about taking position 1 in second_highest. I would prefer something like counting how often the minimum arises and then take the count + 1. That might help if you have more than one person with the lowest grade.
nihl01 Short code does not equals efficient code.
In this code there's a loop of O(n) to read the input, then another loop of O(n) to get the marks, then set() (I'm not sure but I think) is O(n), the sorted marks is O(nlgn) (here n being the size of the set), then another sorted() by names O(nlgn) and a O(n) loop to get the names with the second highest and print them.
A solution: In the same loop that reads the input you could find out the 2nd lowest.
And instead of using a list to store the data use a dict of lists, where the key is the mark, and append to it the names.
After reading all the input you know the 2nd lowest mark, asking the dict for the data of that key will get you the list of names, sort them and print them.
MatricksDecoder You can actually be more pythonic and get rid of the for loop completely and only use list comprehensions all the way n = int(input()) students = [[input(), float(input())] for i in range(n)] second_lowest_score = sorted(list(set([i[1] for i in students])))[1] print(*sorted([i[0] for i in students if i[1]==second_lowest_score]), sep="\n")
saif_bhatkar Super I followed ur way and tried to perform this same operation on list of dict();
marksheet=[]
for _ in range(0,int(raw_input())): d = dict() d['name'],d['score'] = raw_input(),float(raw_input()) marksheet.append(d)
second_lowest = sorted(list(set([score['score'] for score in marksheet])))[1]
print '\n'.join(sorted([a['name'] for a in marksheet if a['score']== second_lowest]))
DebasishOpu Such a beautiful code <3
tongjin what does [marks for name, marks in marksheet] mean? Any rules for that? Thx
kozuch_tomasz1 Such code pieces are too hard for debbuging and maintaining, here is my edit of your code for minimal readability:
marksheet = [] noStudents = int(input()) for _ in range(noStudents): name = input() score = float(input()) marksheet.extend([[name, score]]) uniqueOrderedMarks = sorted(list(set([marks for _, marks in marksheet]))) second_highest = uniqueOrderedMarks[1] print('\n'.join([name for [name, score] in sorted(marksheet) if score == second_highest]))mrchethan print('\n'.join([a for a,b in sorted(marksheet) if b == second_highest])) can you explain this line pleas?
pradippatel7792 Lets first break whole code into pieces.
students = [[raw_input(), float(raw_input())] for _ in range(input())]
it creates nested lists.
students = [['Harry', 37.21], ['Berry', 37.21], ['Tina', 37.2], ['Akriti', 41.0], ['Harsh', 39.0]]
second_lowest = sorted(set([grade for name, grade in students]))[1]
First it removes repeated values and sort by their values. so sorted list becomes [37.2, 37.21, 39.0, 41.0].
then it copies 2nd element as second lowest value which is 37.21 to compare whether it has more than one student or not.
print '\n'.join(sorted([name for name, grade in students if grade == second_lowest]))
it is called list comprehensions. syntax is : [ expression for item in list if conditional ]
First it compares every values with second lowest value if it is true then it copies new name object which is Harry and Berry in new list then it sorts by name.
'\n'.join prints each object from new list with new line.
For more information, you can refer below link.
atulksingh4 Great work!
bhaskargoswamy_1 kindly explain what is "second_highest = sorted(list(set([marks for name, marks in marksheet])))[1]"[The Bolted and Italic Section] is used for. As I am new to coding, i can't find what's the role of this expression... Thanks in Advance..!!!
PsychicCoder line 3rd of your code shows error
JJJason second_highest = sorted(list(set([marks for name, marks in marksheet])))[1]
You do not need a list() here, because sorted() will return a sorted list.
Sort 1015 Discussions, By:
Please Login in order to post a comment