A strongness of an even number is the number of times we can successively divide by 2 until we reach an odd number starting with an even number n.

For example, if n = 12, then
* 12 / 2 = 6
* 6 / 2 = 3

So we divided successively 2 times and we reached 3, so the strongness of 12 is `2`.

If n = 16 then
* 16 / 2 = 8
* 8 / 2 = 4
* 4 / 2 = 2
* 2 / 2 = 1

we divided successively 4 times and we reached 1, so the strongness of 16 is `4`


# Task

Given a closed interval `[n, m]`, return the even number that is the strongest in the interval. If multiple solutions exist return the smallest strongest even number.

Note that programs must run within the allotted server time; a naive solution will probably time out.


# Constraints
```if-not:ruby
1 <= n < m <= INT_MAX
```
```if:ruby
1 <= n < m <= 2^64
```


# Examples
```
[1, 2]    -->   2  # 1 has strongness 0, 2 has strongness 1
[5, 10]   -->   8  # 5, 7, 9 have strongness 0; 6, 10 have strongness 1; 8 has strongness 3
[48, 56]  -->  48

Difficulty: introductory

Starter code:

def strongest_even(n, m):
	

Solutions:
"""Strongest even number in an interval kata

Defines strongest_even(n, m) which returns the strongest even number in the set
of integers on the interval [n, m].

Constraints:
    1. 1 <= n < m < MAX_INT

Note:
    1. The evenness of zero is need not be defined given the constraints.
    2. In Python 3, the int type is unbounded. In Python 2, MAX_INT is
    determined by the platform.

Definition:
    A number is said to be more strongly even than another number if the
    multiplicity of 2 in its prime factorization is higher than in the prime
    factorization of the other number.
"""
from math import log2


def strongest_even(n, m):
    """Returns the strongest even number in the set of integers on interval
       [n, m].
    """

    #It can be shown that the largest power of 2 on an interval [n, m] will
    #necessarily be the strongest even number. Check first if the interval
    #contains a power of 2, by comparing the log2 of the endpoints.
    if int(log2(m)) > int(log2(n)):
        return 2**int(log2(m))

    #Modify the endpoints exclude any odd numbers. If the two endpoints are
    #equal, the original interval contains only a single even number. Return it.
    n += n % 2
    m -= m % 2
    if n == m:
        return n

    #All optimizations and edge cases are exhausted. Recurse with the
    #modified endpoints halved, and multiply the result by 2.
    return 2*strongest_even(n // 2, m // 2)


def strongest_even(n, m):
    while m & m - 1 >= n:
        m &= m - 1
    return m

def strongest_even(n, m):
    while True:
        if m & m - 1 < n: return m
        m &= m - 1

from math import log2

def strongest_even(n, m):
    b = x = 2**int(log2(m))
    
    while not n <= x <= m:
        b //= 2
        x = (m // b) * b
    
    return x

def strongest_even(n, m):
    while n <= m:
        prev = n
        n += 1 << strongness(n)
    return prev

def strongness(n):
    return n.bit_length() - len(format(n, 'b').rstrip('0'))

def strongest_even(n, m):
    x, y = bin(n)[2:], bin(m)[2:]
    if len(x) < len(y): return 1 << len(y)-1
    i = next(i for i in range(len(x)) if x[i] != y[i])
    res = x[:i] + ('1' if '1' in x[i:] else '0') + '0'*(len(x)-i-1)
    return int(res, 2)

def strongest_even(n, m):
    n = n if n % 2 == 0 else n + 1
    m = m if m % 2 == 0 else m - 1
        
    x = 2
    
    while not x * 2 > m:
        x *= 2
    
    if x < n:
        i, s, a = m, n, x
        
        while i >= n:
            if i % a/2 == 0:
                s = i
                i -= a
                a = x
                
            a = a/2 if a/2 > 1 else 2
            
        return s
    else:
        return x
       


def strongest_even(n, m):
    exponent = 1
    while (m > 2**exponent):
        exponent += 1
    
    if (n <= 2**exponent <= m):
        return 2**exponent

    while(exponent > 0):
        exponent -= 1
        factor = 1
        while((2**exponent)*factor <= m):
            if (n <= (2**exponent)*factor <= m):
                return (2**exponent)*factor
            factor += 2

def strongest_even(n, m):
    pow = 1
    while pow <= m:
        pow *= 2
    if pow/2 <= m and pow/2 >= n:
        return pow/2
    else:
        pow /= 4
        multiplier = 3
        while True:
            multiple = pow * multiplier
            while multiple <= m:
                if n <= multiple:
                    return multiple
                else:
                    multiplier += 1
                    multiple = pow * multiplier
            pow /= 2
            multiple = 3


from math import log
from math import floor

def strongest_even(n,m):
    a=2**floor(log(m)/log(2));b=1;    
    while a*b<n or a*b>m:
        a /= 2;
        b += 2;
        while a*b<=m:
            if a*b>=n:
                return a*b
            b +=2
        
    return a*b 
#strongest_even(33,47)