Integral numbers can be even or odd.

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 just not odd.

# Task

Given a finite list of integral ( not necessarily non-negative ) numbers, determine the number that is _odder than the rest_.  
If there is no single such number, no number is odder than the rest; return `Nothing`, `null` or a similar empty value.

# Examples

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

# Hint

Do you _really_ want one? Point or tap here.

Difficulty: EASY
Tags: Ad-hoc

Starter code:
def oddest(a):
	

Solutions:
def oddest(numbers):
	most_odd = 0
	max_oddity = -1
	is_unique = True
	for num in numbers:
		oddity = 0
		print(num)
		insider = num
		while insider % 2 == 1:
			if insider == -1:
				oddity = 1 + max([abs(n) for n in numbers])
				break
			else:
				oddity += 1
				insider = (insider - 1) / 2
		if oddity > max_oddity:
			is_unique = True
			max_oddity = oddity
			most_odd = num
		elif oddity == max_oddity:
			is_unique = False
	if is_unique and max_oddity >= 0:
		return most_odd
	return None


def oddest(xs):
	os = list(map(oddness, xs))
	max_o = max(os, default=None)
	return xs[os.index(max_o)] if os.count(max_o) == 1 else None

def oddness(x):
	return float('inf') if x == -1 else ~x & -~x


from collections import defaultdict

def oddity(n):
	if n == -1:
		return float('inf')
	odd = 0
	while n % 2:
		odd += 1
		n //= 2
	return odd

def oddest(a):
	result = defaultdict(list)
	for n in a:
		result[oddity(n)].append(n)
	try:
		(x,) = result[max(result)]
		return x
	except ValueError:
		pass


from heapq import nlargest
from functools import cmp_to_key

def oddity(n1, n2):
	while True:
		(n1, m1) = divmod(n1, 2)
		(n2, m2) = divmod(n2, 2)
		if m1 != m2 or m1 == 0 == m2 or n1 == n2:
			break
	return -1 if m1 < m2 else m1 > m2

def oddest(arr):
	res = nlargest(2, arr, key=cmp_to_key(oddity))
	if res and (len(res) == 1 or oddity(res[0], res[1])):
		return res[0]


def oddest(a):
	(d, o) = ({}, a.count(-1))
	for (i, j) in enumerate(a):
		n = j
		while n != 0 and n & 1 and (n != -1):
			n = (abs(n) // 2 + int(n < 0)) * [1, -1][n < 0]
			d[i] = d.get(i, -1) + 1
	m = max(d, key=lambda x: d[x], default=0)
	return a[0] if len(a) == 1 else -1 if o == 1 else a[m] if d and list(d.values()).count(d[m]) == 1 and (o < 2) else None


from collections import defaultdict

def odd(x):
	if x == -1:
		return 10
	if not x & 1:
		return 0
	return 1 + odd(x - 1 >> 1)

def oddest(a):
	if not a:
		return
	D = defaultdict(list)
	for x in a:
		D[odd(x)].append(x)
	L = D[max(D)]
	if len(L) == 1:
		return L[0]


def oddest(a):
	f = lambda x: 1000000.0 if x == -1 else x % 2 and 1 + f(x // 2) or 0
	a = [(x, f(x)) for x in a]
	n = max((y for (x, y) in a), default=-1)
	a = [x for (x, y) in a if y == n]
	if len(a) == 1:
		return a[0]


def oddest(a):
	if all((n % 2 == 0 for n in a)):
		return a[0] if len(a) == 1 else None
	if -1 in a:
		return -1 if a.count(-1) == 1 else None
	a = [(x, x) for x in a if x % 2 != 0]
	while True:
		if len(a) == 0:
			return None
		if len(a) == 1:
			return a[0][0]
		a = list(filter(lambda n: n[1] % 2 != 0, ((n[0], (n[1] - 1) // 2 if n[1] != -1 else 1) for n in a)))


d = {}

def odd(n):
	if n == -1:
		return 10 ** 1000
	r = 0
	while n % 2:
		r += 1
		n = (n - 1) // 2
	return r

def oddest(a):
	if not a:
		return
	o = [*map(odd, a)]
	if o.count(max(o)) > 1:
		return
	return max(a, key=odd)


from collections import Counter
from math import inf

def oddest(arr):
	c = Counter(map(oddness, arr))
	return max(arr, key=oddness) if c and c[max(c)] == 1 else None

def oddness(n):
	if n == -1:
		return inf
	(m, is_odd) = divmod(n, 2)
	cnt = 0
	while is_odd:
		(m, is_odd) = divmod(m, 2)
		cnt += 1
	return cnt