Some integral numbers are odd. All are more odd, or less odd, than others.

Even numbers satisfy `n = 2m` ( with `m` also integral ) and we will ( completely arbitrarily ) think of odd numbers as `n = 2m + 1`.  
Now, some odd numbers can be more odd than others: when for some `n`, `m` is more odd than for another's. Recursively. :]  
Even numbers are always less odd than odd numbers, but they also can be more, or less, odd than other even numbers, by the same mechanism.

# Task

Given a _non-empty_ finite list of _unique_ integral ( not necessarily non-negative ) numbers, determine the number that is _odder than the rest_.  
Given the constraints, there will always be exactly one such number.

# Examples

```python
oddest([1,2]) => 1
oddest([1,3]) => 3
oddest([1,5]) => 5
```

# Hint

Do you _really_ want one? Point or tap here.

Source: codewars | Difficulty: EASY
Tags: Ad-hoc

Starter code: def oddest(a):
	

Solutions:
def oddity(n):
	while True:
		(n, m) = divmod(n, 2)
		yield m

def oddest(arr):
	res = arr[0]
	for n in arr[1:]:
		if next((b > a for (a, b) in zip(oddity(res), oddity(n)) if a != b)):
			res = n
	return res


from functools import cmp_to_key

def comp(x, y):
	(rx, ry) = (x & 1, y & 1)
	while rx == ry:
		(x, y) = (x - rx >> 1, y - ry >> 1)
		(rx, ry) = (x & 1, y & 1)
	return rx > ry

def oddest(a):
	return max(a, key=cmp_to_key(comp))


oddest = lambda A: max(A, key=lambda x: bin(256 + x)[::-1])


def oddest(a):
	return max(a, key=lambda n: f'{n + 2 ** 32:b}'[::-1])


def oddest(a):
	b = list(enumerate(a))
	while len(b) > 1:
		b = [(i, v // 2) for (i, v) in b if v % 2] or [(i, v // 2) for (i, v) in b]
	return a[b[0][0]]


def oddest(a):
	res = {k: k for k in a}
	if len(a) < 2:
		return -1 if len(a) == 0 else a[0]
	while len(a) > 1:
		if any((i % 2 for i in a)):
			res = {k: v for (k, v) in list(res.items()) if v % 2}
			a = list(res.values())
		for (k, v) in list(res.items()):
			res[k] = v // 2 if v % 2 == 0 else (v - 1) // 2
		a = list(res.values())
	return k


from functools import cmp_to_key

def oddest(a):
	odder = lambda x, y: odder(x // 2, y // 2) if x % 2 == y % 2 else 1 - 2 * (x % 2)
	return min(a, key=cmp_to_key(odder))


oddest = lambda A: max(A, key=lambda x: f'{x + 256:b}'[::-1])