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.

Difficulty: introductory

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])