stefan_pochmann Four decent solutions:
print(*sorted(input(), key=lambda c: (-ord(c) >> 5, c in '02468', c)), sep='') print(*sorted(input(), key=lambda c: (c.isdigit() - c.islower(), c in '02468', c)), sep='') order = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1357902468' print(*sorted(input(), key=order.index), sep='') import string print(*sorted(input(), key=(string.ascii_letters + '1357902468').index), sep='')
hellosputnik Nice solutions! I really like the second solution using Boolean properties.
haotie hi, stefan, could you explain more about the
(-ord(c) >> 5, appreciate it :)
conkosidowski I'm just trying to piece this all together by myself and I could be entirely wrong, but here I go.
- "key" is setting values for each element so as to use them for comparison and subsequently sorting later on.
- Each parameter in our lambda function contributes to the value of key - the order in which the parameters are aranged has to do with this but I don't know how (help please :D)
- ord(c) finds the unicode point of the character we're looking at
- We use >> to shift the ordinal value to less than 2 bits (so between 0 and 3 in decimal)
- We set the result of this to a negative because we sort in ascending order
Basically -ord(c) >> 5 sets the values to -3 if it's a lowercase character, -2 if it's an uppercase character and -1 if it's a digit. This segregates each section of our string into uU12. From here we need to sort the numbers, so we use c in '02468' to do so. And then we use c at the end to sort the contents of each group by value.
At least that's how I think it all works. I'll wait for someone to correct me :)
daniop I think you have it dead on, for anybody who still doesn't understand how the ord(c) >> 5 part works, this is the binary representation of characters and digits:
>>> bin(ord('0')) '0b0110000' >>> bin(ord('9')) '0b0111001' >>> bin(ord('A')) '0b1000001' >>> bin(ord('Z')) '0b1011010' >>> bin(ord('a')) '0b1100001' >>> bin(ord('z')) '0b1111010'
The first 2 binary digits will separate the characters into digits, lower case, upper case. So right shifting the value of ord(c) will just give those digits, e.g.
>>> bin(ord('a') >> 5) '0b11' which as conkosidowski says is 3 when represented as int.
relte_schutte faaaark o_0
Crystal_star nice explanation... went straight into my brain. thankz
Ehouarn Nice one when passing the symbols!
RryLee Cool, man!
geekoala Great solution!
dmshantanu What is *sorted ?
thongola print(*[1, 2, 3], sep='')123duckyducky That's awesome. I had to hit my head against the wall 'til I could find where reduce got moved to in Python3.
rajesh_moturu functools
letientai299 Nice. I forgot that
printhas thesepparam.
congge Impressive answer!
kalcho Hi Stefan,
can you please explain second solution?
arunram860 you are awesome.
kas111ph can you explain this print(*sorted(input(), key=lambda c: (-ord(c) >> 5, c in '02468', c)), sep='')
arunram860 here input() value shifted 5 digit using ord function
ocslegna This is amazing.
DavidGladsonGM Learnt a lot from this comment thank you so much :)
aditya_trivedi75 what " c in '02468'" does here??
cnrprfnl I like the 3rd solution. its looking smart :)
Todaizhy you are god
edwardjiang0105 Can anyone help me out with"key=lambda c: (c.isdigit() - c.islower(), c in '02468', c))"?
What does those comma and the Boolean calculation means?
daniop It makes a sortable tuple:
>>> x = 's' >>> (x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x) (False, False, False, True, 's') >>> x = 'G' >>> (x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x) (False, False, True, False, 'G') >>> (False, False, False, True, 's') < (False, False, True, False, 'G') True >>> x = '1' >>> (x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x) (True, False, False, False, '1') >>> (False, False, True, False, 'G') < (True, False, False, False, '1') True
PapaThor Excellent examples. For #2, I prefer:
print(*sorted(input(), key=lambda c: (c.isdigit(), c.isupper(), c in '02468', c)), sep='')
There is one more element in the tuple but same number of function calls and a little more readable IMO.
Fun stuff!!!
burakcank Third one is exactly same as mine.
myList = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1357902468" print(*sorted(input(), key = myList.index), sep ="")
ashwanidohray Damn cool idea,amazing
MishraRakesh Third solution is cool
walter_deinzer Hmm, the idea to define a constant for sorting seems a good idea as it gives the change to add non A-Z/a-z characters, like É, é, ç, ...
Gr4d4m ugly oneliner
print(*(sorted(input(), key=lambda x: (x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x))), sep='')
rsurana Simply Awesome!
Could you please explain in what sequence checks/conditions should be added in general in lambda?
angel1a How does the key argument work?
xRahul Can anyone shed light on this method?! I can't find anything concrete on the web!
scoobyzhang Key argument is a function which takes in the value and returns how important the value is.
For example, if key is
lambda x = -x
Then, the larger the value is, the less the importance gets. In this case, you can sort the array in reverse order.
Gr4d4m's key will turn each character in the string into a tuple, and then let the the sorted function compares each character according to the tuple instead of the character itself.
xRahul I'm pretty sure I've figured it out.. here is each part in key explained-
`
1. if isdigit, give higher priority. so alphas come before digits now
2. if isevendigit, give higher priority. so, among the digits, now even have higher priority. While the 1st part in key is maintainedEx- Sorting1234 => Sorting1234
3. next priority goes to upper case keeping both previous keys maintained. so uppercase can't go after the numbers as that key has higher priority.Ex- Sorting1234 => Sorting1324
4. next priority is given to lowercase characters, but that isn't required as it's the only ones left in alphanumeric characters. We will get the same output either wayEx - Sorting1234 => ortingS1324
5. now sort according to the characters, but keeping all the previous keys in mind, all the characters will be sorted in place, keeping their order as defined in previous keysEx - Sorting1234 => ortingS1324Ex - Sorting1234 => ginortS1324
trubul could you explain why higher priorities go at the end of a string, not start?
mshk_iit_kgp sorting is done from lower priority to higher priority.
acmaan Why is there a need for x.islower()?
Jaitnium Great explanation
lihu723 Nice answer!
athai the asterick isn't working for me for unpacking, anybody know how to get this solution working in Python 2?
amysj you need import print_function, to use print with 'sep' ~ such as
from future import print_functionprint(*(sorted(raw_input(), key=lambda x: ( x.isdigit() and int(x)%2==0, x.isdigit(), x.isupper(), x.islower(), x))), sep='')
athai Thanks!
kas111ph can u please tell what does '*' do in print?? please explain
danishmnazer - is used when the number of objects is not known.
Tzalumen The * operator unpacks lists and iterables into the arguments of the function, so print(*range(4)) will be unpacked into print(0,1,2,3) with an output of 0 1 2 3
sharadboni from _future_
dengjianbo1 Clean Awesome!
acybercoder [deleted]Deb89 Why do we add x at the end (the last argument of lambda)?
sharadboni that is incase all the values(booleans) are same, sorting will be done on the basis of character/digit
vlgayathri Awesome
parasvillis655 can you please help me why to use asterik here...
arsho Found an interesting bug(or feature?):
When I tried to solve the problem using the following code it gives me Wrong answer
Code (Python 3), Verdict: Wrong Answer
s = input() s_sorted = sorted(s,key = lambda x:(x.isdigit() and int(x)%2==0, x.isdigit(),x.isupper(),x.islower(),x)) print(*(s_sorted),sep = '')
Like the problem said:
 a) Using join, for or while anywhere in your code, even as substrings, will result in a score of 0. b) You can only use sorted function in your code. A 0 score will be awarded for using sorted more than once.
But in the above code I did not use join, for or while. Also I did not use sorted() more than once!
What I realized later that it is counting the variable s_sorted as sorted() function. So, I removed _sorted and it got Accepted.
Code (Python 3), Verdict: Accepted
s = input() s = sorted(s,key = lambda x:(x.isdigit() and int(x)%2==0, x.isdigit(),x.isupper(),x.islower(),x)) print(*(s),sep = '')
Funny, right? :D
giovanni_trappo1 Why do you guys put that x at the end of the key sorted?
daniop it's so that the string is sorted by the character content, otherwise it would only sort on the digit, upper and lower case properties, and e.g. "abcd" could be sorted in any order, not as "abcd"
chriscallan Just another example of how hacky it is to restrict people from using language features for silly/arbitrary reasons. Perhaps the author should come up with a challenge that doesn't lend itself to the use of standard functions?
daniop I think the idea here is to use more performant methods than for loops and multiple sorts. I guess it's hard to set performance targets with hackerrank, so they have done it by searching the input with strings.
It is a bit of a pain to work with though.
SebastianNielsen It's not a bug, it's beacause you got 'sorted' in one of your variable names. He also explained that if you just use it more than once in your code. Even though it for instance only is a variable name. It will count as if you used it more than once, and give you a score of 0.
Dude, read the text lol.
s_c_z Did not realize key=lambda x:(...) could use multiple functions as keys.
Thanks.
daniop The lambda function returns a tuple of values using the standard (,) python tuple syntax - not multiple functions as parameters.
s_c_z Yes, I realize it is standard tuple syntax. I guess the correct language would be multiple "expressions". From Glossary > Lambda: "An anonymous inline function consisting of a single expression which is evaluated when the function is called. The syntax to create a lambda function is lambda [arguments]: expression."
My point was that docs.python.org do not make it obvious that multiple expressions can be used. (Or, perhaps a single expression which happens to be a tuple.) Believe me, I scoured the docs for that info; if it is there, my not finding it is not because of lack of effort.
Any advice about where to look when docs.python.org is lacking? (Other than general internet search, e.g., "python key lambda multiple tuple" which did not help either.)
daniop The lambda in the code is just a single expression - one that returns a tuple. So the docs have it covered really, it is just a single expression.
For example:
lambda x: x * 2 // a simple expression that is an integer
lambda x: (1, 4 * x, 42) // a single expression that is a tuple
lambda x: [x, x * x, 2 * x] // a single expression that is a list
lambda x: (x, x * x, 2 * x) // a single expression that is a tuple
There's a lot in python like this, combining simple language features to make it seem like there's something more complicated going on!
s_c_z I appreciate your responses. Semantics aside, my issue is that I searched for how a single "key=" argument could sort over multiple criteria. Coders who knew that a lambda expression could be a tuple had an easy time with this challenge. I did not know that and, despite searching docs.python.org, I still do not see documentation that explains this syntax/usage. My bottom line is that the docs could be better, and I wonder if there are other definitive resources to refer to. If it's in the docs, but I am missing it, please point me in the right direction. Thanks.
brotatotes Python 2:
made use of string library.
from string import ascii_lowercase, ascii_uppercase
sortkey = ascii_lowercase + ascii_uppercase + "1357902468"print reduce(lambda x,y: x+y, sorted(raw_input(),key=sortkey.index))
tricerabottoms I like the use of ascii_* imports. Once you have that key though, you don't need sorted() at all:
from string import ascii_lowercase, ascii_uppercase sortkey = ascii_lowercase + ascii_uppercase + "1357902468" x = input() print(*map(lambda y: y * x.count(y), sortkey), sep='')
touihri_rania Here is another solution like the concept of Boolean properties but based on assigned priorities (with int) and within a function :
def getKey(x): if x.islower(): return(1,x) elif x.isupper(): return(2,x) elif x.isdigit() : if int(x)%2==1: return(3,x) else : return(4,x) print(*sorted(input(),key=getKey),sep='')
nik_roby I really like this version. It is very clear what is being sorted.
sharmavibhor013 really liked this version
mchougule297 ty this one clear solution.
feizhu2 My solution used python 2：
print reduce(lambda x,y: x+y, sorted(raw_input(), key=lambda x: (x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x)))
pkk__ print(*sorted(input(), key = lambda x: ( 0 if str(x).islower() else 1 if str(x).isupper() else 2 if int(x)%2 != 0 else 3,x)), sep = '')
qu4ku sue me.
s = input() uppercase = '' lowercase = '' odd = '' even = '' def fu(ch): global uppercase global lowercase global odd global even if ch.isdigit(): if int(ch)%2==0: even+=ch else: odd+=ch elif ch.isupper(): uppercase+=ch else: lowercase+=ch list(map(fu, sorted(s))) print(lowercase+uppercase+odd+even,end='')
haotie one solution using filter()
s = sorted(input()) num= list(filter(str.isnumeric, s )) odd =list(filter(lambda x: int(x) % 2 != 0, num)) even = list(filter(lambda x: int(x) % 2 == 0, num)) lower = list(filter(str.islower, s)) upper = list(filter(str.isupper, s)) print(*(lower + upper + odd + even), sep='')
edogawaconan4x My code . It passed the test but I think it would take too much time to run if the data input is large
import re patterns = [ r'[a-z]', r'[A-Z]' , r'[13579]' ,r'[02468]'] data = input() t = [ r for pattern in patterns for r in sorted(re.findall( pattern, data )) ] print("".join(t))
Sort 170 Discussions, By:
Please Login in order to post a comment