### CodeFights - Cat Walk - Solution

Problem
You've been working on a particularly difficult algorithm all day, and finally decided to take a break and drink some coffee. To your horror, when you returned you found out that your cat decided to take a walk on the keyboard in your absence, and pressed a key or two. Your computer doesn't react to letters being pressed when an unauthorized action appears, but allows typing whitespace characters and moving the arrow keys, so now your masterpiece contains way too many whitespace characters.
To repair the damage, you need to start with implementing a function that will replace all multiple space characters in the given `line` of your code with single ones. In addition, all leading and trailing whitespaces should be removed.
Example
For `line = "def      m   e  gaDifficu     ltFun        ction(x):"`,
the output should be
`catWalk(line) = "def m e gaDifficu ltFun ction(x):"`.
Input/Output
• [execution time limit] 4 seconds (py)
• [input] string line
One line from your code containing way too many whitespace characters.
Guaranteed constraints:
`5 ≤ line.length ≤ 125`.
• [output] string
`line` with unnecessary whitespace characters removed.
Solution

```def catWalk(code):
return " ".join(code.strip().split())
```

### CodeFights - Simple Sort - Solution

Problem
To understand how efficient the built-in Python sorting function is, you decided to implement your own simple sorting algorithm and compare its speed to the speed of the Python sorting. Write a function that, given an array of integers `arr`, sorts its elements in ascending order.
Hint: with Python it's possible to swap several elements in a single line. To solve the task, use this knowledge to fill in both of the blanks (`...`).
Example
For `arr = [2, 4, 1, 5]`, the output should be
`simpleSort(arr) = [1, 2, 4, 5]`.
Input/Output
• [execution time limit] 4 seconds (py)
• [input] array.integer arr
Guaranteed constraints:
`1 ≤ arr.length ≤ 100`,
`-105 ≤ arr[i] ≤ 105`.
• [output] array.integer
The given array with elements sorted in ascending order.
Solution

We just have to swap the elements which are out of order. The line in bold does just that. Its called tuple unpacking.

```def simpleSort(arr):

n = len(arr)

for i in range(n):
j = 0
stop = n - i
while j < stop - 1:
if arr[j] > arr[j + 1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
j += 1
return arr

```

### CodeFights - Count Bits - Solution

Problem
Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.
Implement a function that, given an integer `n`, uses a specific method on it and returns the number of bits in its binary representation.
Note: in this task and most of the following tasks you will be given a code snippet with some part of it replaced by the ellipsis (`...`). Only this part is allowed to be changed.
Example
For `n = 50`, the output should be
`countBits(n) = 6`.
`5010 = 1100102`, a number that consists of `6` digits. Thus, the output should be `6`.
Input/Output
• [execution time limit] 4 seconds (py)
• [input] integer n
A positive integer.
Guaranteed constraints:
`1 ≤ n ≤ 109`.
• [output] integer
The number of bits in binary representation of `n`.
Solution
It is expected to only replace the ellipsis with the code that would give you the bit length of the given integer.

def countBits(n):
return n.bit_length()