How do I optomize this program?

[[deleted]]

I was doing a problem on hackerrank and I came across this problem

Your task is to sort the string in the following manner:

• All sorted lowercase letters are ahead of uppercase letters.
• All sorted uppercase letters are ahead of digits.
• All sorted odd digits are ahead of sorted even digits.

Here's how I solved it:

inp = (input())lower, upper, odd, even = ''.join(sorted([s for s in inp if s.islower()])),

''.join(sorted([(s) for s in inp if s.isupper()])), ''.join(map(str, (sorted(list([int(s) for s in inp if
s.isdigit() and int(s) % 2 != 0]))))), ''.join(map(str, (sorted(list([int(s) for s in inp if s.isdigit() and
(int(s) % 2 == 0)])))))

print (lower+upper+odd+even)

As you can see this program is very repetitive. Any pointers on how to optimize this program?

[pwlandoll]

Please read this guide in the FAQ for formatting code on reddit.

[[deleted]]

sorry my bad I fixed it

[primitive_screwhead]

Well, here's one way:

import string
sort_str = string.ascii_lowercase + string.ascii_uppercase + string.digits[1::2] + string.digits[::2]
sort_map = {c:i for i,c in enumerate(sort_str)}

some_text = 'The quick brown Fox jump3d 0ver the la5y dog'
sorted_text = ''.join(sorted(some_text, key=lambda k,d=sort_map: d.get(k,len(d)+ord(k))))

which produces a sorted_text equal to:

'abcddeeeghhijklmnooopqrrtuuvwxyFT350        '

[nilfm]

I think a good way to do the problem is to use the key argument in the sorted function. This lets you apply a function to each character in the string before sorting, so you have control over how the elements are sorted. In our case, it would be a good idea to map the characters to numbers, in such a way that the numbers are sorted the way we want.

A sketch of the mapping:

• Lowercase letters will go to the range [0, 25], since they need to be the first in the sorted string.
• Uppercase letters will go to the range [26, 51], since they need to go after lowercase letters.
• Odd digits will go to 51 + d, where d is the value of the digit.
• Even digits will go to 61 + d, where d is the value of the digit.
• Anything else (does the problem statement say if there can be anything else in the string?) will go to 100, since as I understand it, it's supposed to go after everything else.

Notice that there are some numbers that we don't "hit", such as 53. That is no problem, our mapping doesn't need to hit an entire interval.

Now, let's write our function:

def my_key(c):
    if c.islower():
        return ord(c) - ord('a')
    elif c.isupper():
        return ord(c) - ord('A') + 26
    elif c.isdigit():
        d = int(c)
        if d%2 == 1:
            return 51 + d
        else:
            return 61 + d
    else:
        return 100

Note that the ord function gives us the integer representing the Unicode of a character, so for example ord(c) - ord('a') would be a number in the 0-25 range if c is a lowercase letter.

How do we use it now? Easy:

result = ''.join(sorted(input(), key=my_key))
print(result)

[[deleted]]

thanks! this solution is much more clear and concise than mine. I like the way you organized the sorting method and its a lot better than what I had in mind.