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: introductory

Starter code:

def oddest(a):
	

Solutions:
def oddest(numbers):
    most_odd   = 0      # The current most odd number in the list
    max_oddity = -1     # The current greatest oddity rate, starts at -1 so that even an even number can be the unique most odd
    is_unique  = True   # If the current most odd number is really the most, so if there is no unique oddest number, it will return None
    for num in numbers:  # Loop through all the numbers
        oddity  = 0      # The oddity rate starts at 0
        print(num)
        insider = num    # The coefficient of the number 2, so in 2n + 1, the insider is n
        while insider % 2 == 1:  # While that coefficient is odd
            if insider == -1:
                oddity = 1 + max([abs(n) for n in numbers]) # Since the oddity rate of a number is NEVER greater than the absolute value of the number, this garantees that the current number is the most odd one
                break
            else:
                oddity  += 1               # Add the oddity rate of the total number
                insider = (insider-1)/2    # So if in 2n + 1, n is odd, represent it as 2(2m + 1) + 1, and set the value to m
        if oddity > max_oddity:  # If the current number's oddity rate is greater than the current max oddity,
            is_unique = True     # Set it to unique
            max_oddity = oddity  # Set the max oddity to the current oddity
            most_odd   = num     # Set the most odd number to the current number
        elif oddity == max_oddity:# Otherwise, if it's the same rate
            is_unique = False    # It's not unique
    if is_unique and max_oddity >= 0:  # If the current most odd number is REALLY the most odd number and the list isn't empty
        return most_odd # Return it
    return None # Otherwise, 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 # Infinite recursive, that's the oddest you can get
    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: 1e6 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