This solution is O(N) in time. The "in-place" solution you are mentioning is O(N/2) which boils down to O(N) too, since 1/2 is just a constant factor.

The true difference between them lies in their space complexities. This one is O(N) in space, although it is simply mutating the input. But the "in-place" is O(1) in space because it does not use any auxiliary memory.

I still prefer this solution though, as you only need to user lower() once and it is very readable overall. Also, memory has become extremely cheap nowadays and it shouldn't be that much of a problem.

I just made a fork of my translation which fixes the problems with rounding. I'm not succeeding on merging it to the original translation. Can somebody help?

The tests expect the array to be sorted by the first element (keys of the hash) in alphabetic order, but the kata description does not mention that whatsoever.

That's because f-strings are a new feature of Python version 3.6.0.
Check out this blog post for more info and considerations on f-strings.

Took me a while to realize I should be using spaces " " instead of underscores "_".

Perhaps the description could be changed to be less misleading in that sense.

If your code is timing out, it doesn't mean that your solution is inappropriate/wrong, but it surely is a sign that your code is inefficient (slow). Very often Katas will be hard because they require you to craft an efficient solution (especially when dealing with large input), although there exists a trivial solution in most cases.

I'm not sure if that was your doubt, but timeout is not a bug, rather it is a constraint to make you think of a better solution.

That would work. However, it is a solution inefficient in terms of memory, as you are creating another list having the same size of the original.
There are better ways, as seen in other people's solutions.

Actually, the correct equivalent would be if not l.

Python translation kumited!

I believe the parameter 'sperm' should have been named 'zygote'. It is very misleading and I actually got my code wrong on my first try because of that.

This is genius. Beautiful to look at.

The problem is that you are iterating through the characters of the lowercase version of your original, uncertainly cased string, and then checking how many times each of these lowercase characters appear on that original string. It's easy to see where this goes wrong.

Adding this to the beginning of your function should fix it:

word = word.lower()

Beautiful one-liner, thanks for that.