Problem:
 Score : 200 points    Problem Statement There are N positive integers written on a blackboard: A_1, ..., A_N .  Snuke can perform the following operation when all integers on the blackboard are even:   Replace each integer X on the blackboard by X divided by 2 .   Find the maximum possible number of operations that Snuke can perform.      Constraints  1 \leq N \leq 200  1 \leq A_i \leq 10^9         Input Input is given from Standard Input in the following format:  N  A_1  A_2 ... A_N       Output Print the maximum possible number of operations that Snuke can perform.        Sample Input 1 3
8 12 40      Sample Output 1 2  Initially, [8, 12, 40] are written on the blackboard.
Since all those integers are even, Snuke can perform the operation.  After the operation is performed once, [4, 6, 20] are written on the blackboard.
Since all those integers are again even, he can perform the operation.  After the operation is performed twice, [2, 3, 10] are written on the blackboard.
Now, there is an odd number 3 on the blackboard, so he cannot perform the operation any more.  Thus, Snuke can perform the operation at most twice.       Sample Input 2 4
5 6 8 10      Sample Output 2 0  Since there is an odd number 5 on the blackboard already in the beginning, Snuke cannot perform the operation at all.       Sample Input 3 6
382253568 723152896 37802240 379425024 404894720 471526144      Sample Output 3 8

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

flg = True
cnt = 0

for j in range(100):
    for i in range(n):
        if a[i] % 2 == 1:
            flg = False

    if flg is True:
        for i in range(n):
            a[i] = int(a[i] / 2)
        cnt += 1
    else:
        break

print(cnt)

Solution (Python):
n = int(input())

li = [int(x) for x in input().split()]

count = 0
counter = 0

while True:
  for i in range(0,n):
    if li[i] % 2 == 0:
      count+=1
  if count == n:
    counter+=1
    li = [int(li[i]/2) for i in range(0,n)]
    count = 0
  else:
    break
    
print(counter)

Solution (Python):
import math

n = int(input())
a = list(map(int, input().split()))

ans = float("inf") 

for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))

Solution (Python):
N = int(input())
A = input().split()
intA = [int(s) for s in A]

def warizan():
    for i in range(N):
        intA[i] = int(intA[i] / 2)

count=0
flg = False
while True:
    for i in range(N):
        
        if(intA[i]%2 != 0):
            flg = True
            break
    if flg:
        break
        
    warizan()
    count += 1
        
print(count)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=30
for i in range(n):
    buf=0
    a_i=a[i]
    while a_i%2==0:
        buf+=1
        a_i=a_i//2
    if buf<ans:
        ans=buf
print(ans)

Solution (Python):
s = [input() for i in range(2)]
N = int(s[0])
A = [int(i) for i in s[1].split()]

for i in range(N):
    N = 0
    while A[i] % 2 == 0:
         A[i] = A[i] / 2
         N += 1
    A[i] = N

print(min(A))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0

while True:
    for i in range(len(a)):
        if a[i] % 2 == 0:
            dist = a[i] // 2
            if dist >= 0:
                a[i] = dist
            else:
                print(ans)
                exit()
        else:
            print(ans)
            exit()
    ans += 1

Solution (Python):
n = input()
a = list(map(int, input().split()))
x = 0

while all(i%2 == 0 for i in a):
  a = [i/2 for i in a]
  x = x + 1

print(x)

Solution (Python):
N = int(input())
a = 0
nums = [int(i) for i in input().split()]
while True:
    if [i for i in nums if i %2==1]:
        break
    else:
        nums = [i//2 for i in nums]
        a+=1
        
print(a)

Solution (Python):
n = input()
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
flag = False
while True:
    for i in range(n):
        if a[i]%2 == 1:
            flag = True
            break
        a[i] //= 2
    if flag:
        break
    else:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
numbers = list(map(int, input().split()))
k = -1
dividable = True
while dividable:
  k += 1
  for i, number in enumerate(numbers):
    if number % 2 == 0:
      numbers[i] = number / 2
    else:
      dividable = False

print(k)

Solution (Python):
input();count=0
s=set(map(int, input().split(' ')))
while all(map(lambda x:x%2==0,s)):
  s=set(map(lambda x:x/2,s))
  count+=1
print(count)

Solution (Python):
s = int(input())
y = list(map(int, input().split()))
x = 0
 
while all(a%2==0 for a in y):
    y = [a/2 for a in y]
    x += 1
 
print(x)

Solution (Python):
n = int(input())

A = list(map(int, input().split()))

t = 100000000000000000000000000000000000000000

for i in A:
    s = 0
    for s in range(i):
        if i % 2 == 0:
            i = i//2
            continue
        else:
            break
    if s < t:
        t = s
print(t)

Solution (Python):
from fractions import gcd
from functools import reduce


def main():
    n = int(input())
    numbers_gcd = reduce(gcd, list(map(int, input().split())))
    answer = 0
    while numbers_gcd > 0:
        if numbers_gcd % 2:
            break
        else:
            numbers_gcd //= 2
            answer += 1
    print(answer)


if __name__ == '__main__':
    main()

Solution (Python):
import math
n = input()
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 1000
for ai in a:
    ans_i = 0
    while ai % 2 == 0:
        ai //= 2
        ans_i += 1
        if ans_i == ans:
            break
    ans = min(ans, ans_i)
print(ans)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = 10**9
for i in a:
    x = i
    cnt = 0
    while x % 2 == 0:
        cnt += 1
        x /= 2
    ans = min(ans,cnt)
print(ans)

Solution (Python):


N = input()
N = int(N)
Data = input().split(" ")
for i in range(N):
  Data[i] = int(Data[i])

LoopCount = 0
while(1):
  PerCount = 0
  tmp = [0 for i in range(N)]
  for i in range(N):
    if(Data[i] % 2 == 0):
      tmp[i] = int(Data[i]/2)
      PerCount = PerCount + 1
  if(PerCount == N):
    Data = tmp
    LoopCount = LoopCount + 1
  else:
    break
print(LoopCount)

Solution (Python):
s = int(input())
y = list(map(int, input().split()))
x = 0
 
while all(a%2==0 for a in y):
    y = [a/2 for a in y]
    x += 1
 
print(x)

Solution (Python):
def solve():
    N = int(input())
    A = list(map(int, input().split()))
    l = []

    for a in A:
        if a % 2 == 0:
            c = 0
            while a % 2 == 0:
                a //= 2
                c += 1
            l.append(c)
        else:
            l.append(0)

    return min(l)

print(solve())

Solution (Python):
def solve():
    N = int(input())
    A = list(map(int, input().split()))
    ans = 0
    while True:
        for i in range(N):
            if A[i] % 2 != 0:
                return ans // N
            A[i] //= 2
            ans += 1

    return ans

print(solve())

Solution (Python):
n = int(input())
L = list(map(int, input().split()))
K = -1
bool1 = True

while(bool1 == True):
    K +=1
    for k in range(n):
        if L[k] %2 ==0:
            L[k] = L[k]/2

        else:
            bool1 = False
            break

print(K)

Solution (Python):
n = int(input())
L = list(map(int, input().split()))
K = -1

def main():
    bool1 = True
    global n,L,K 
    K += 1

    while(bool1 == True):
        for k in range(n):
            if L[k] %2 ==0:
                L[k] = L[k]/2

            else:
                bool1 = False
                break
        if(bool1 == True):
            main()

main()
print(K)

Solution (Python):
n=int(input())
a=[int(x) for x in input().split()]
s=all([x%2==0 for x in a])
ans=0
while s:
    s=all([x%2==0 for x in a])
    if s:
        ans+=1
    for i in range(n):
        a[i]=a[i]//2
print(ans)

Solution (Python):
n = int(input())
A = [int(x) for x in input().split()]
c = 0

while all(a % 2 == 0 for a in A):
        A = [a / 2 for a in A]
        c += 1
            
print(c)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
l = []
for i in a:
    count = 0
    for j in range(1, 31):
        if i%(2**j) == 0:
            count += 1
        else:
            l.append(count)
            break
print(min(l))

Solution (Python):
def main(N,A):
    count = 0
    while True:
        for i in range(N):
            if A[i] % 2 != 0:
                return count
                break
            else:
                A[i] = A[i] // 2
        count +=1

N = int(input())
A = list(map(int,input().split()))
print(main(N,A))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
c = 0
i = 0
 
while a[i]%2 == 0:
  if a[i]%2 ==0:
    a[i]//=2
  if i==n-1:
    c+=1
    i = 0
  i+=1
print(c)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

ok = 1
ans = 0
while ok == 1:
    for i in range(n):
        if a[i] % 2 == 0:
            a[i] /= 2
            continue
        ok = 0
    if ok == 1:
        ans += 1
print(ans)

Solution (Python):
n = input()
vals = map(int, input().split())
bins = [str(bin(v)) for v in vals]
idx = -1
while True:
    if len([b for b in bins if b[idx] == "1"]) > 0:
        break
    idx -= 1
print((idx + 1) * -1)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = []
for a in A:
  i = 0
  while a % 2 ** i == 0:
    i += 1
  B.append(i - 1)
B.sort()
print(B[0])

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
c = 0

while True:

    for i in range(len(a)):
        if a[i] % 2 == 0:
            a[i] = int(a[i] / 2)
        else:
            print(c)
            exit()
    c += 1

Solution (Python):
n=int(input())
*a,=map(int,input().split())
cnt =0
while True:
	if all(i%2==0 for i in a):
		a=[j//2 for j in a]
		cnt += 1
	else:
		break
print(cnt)

Solution (Python):
import numpy as np

l = int(input())
num = list(map(int, input().split()))
n = np.array(num)
c = 0
while not any(n%2):
  c += 1
  n /= 2
print(c)

Solution (Python):
n = int(input())
existing_list = list(map(int,input().split()))

counts = 0 
while all(num%2 ==0 for num in existing_list):
    length = 0
    for a in existing_list:
        division = a/2
        existing_list[length]=division
        length +=1
    counts +=1

print(counts)

Solution (Python):
input()
data = list(map(int, input().split(' ')))
cnt = 0
while sum([i%2 for i in data])==0:
    cnt = cnt + 1
    data = [i/2 for i in data]
print(cnt)

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]


flag = True
count=0
while(flag):
    for i in range(N):
        if A[i]%2 == 1 :
            flag=False
            break
        else:
            A[i] /= 2
    if flag:
        count += 1

print(count)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
 
flag = True
count = 0
while(flag):
  for i in range(N):
    if A[i]%2:
      flag = False
      break
    else:
      A[i] /= 2
  if flag:
    count += 1
print(count)

Solution (Python):
N = int(input())
count = 0
nums = [int(x) for x in input().split()]
loop = True
while loop:
  if not all ([n % 2 == 0 for n in nums]):
    loop = False
    break
    
  for i, n in enumerate(nums):
    nums[i] = n//2
  count += 1
print(count)

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
count=0
i=0
while a[i]%2==0:
  if a[i]%2==0:
    a[i]//=2
  if i==n-1:
    count+=1
    i=0
  i+=1
print(count)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
flag = True
count = 0
while 1:
    for i in range(n):
        if a[i] % 2 != 0:
            flag = False
            break
        a[i] /= 2
    if not flag:
        break
    count += 1
print(count)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))




isnext = 0
ans = 0

while isnext == 0:
    for i in range(N):
        
        if A[i] % 2 == 0:
            A[i] = A[i] / 2
        
        if A[i] % 2 != 0:
            isnext = 1
            break
        
        if i == N-1:
            ans = ans + 1

if ans == 0:
    print(ans)
else:
    print(ans+1)

Solution (Python):
N = (int)(input())
A = []
for s in input().split():
    A.append((int)(s))

count = 0
mincount = 9999
for i in range(N):
    count = 0
    while(1):
        if not A[i]%2==0:
            break
        count = count + 1
        A[i] = A[i]/2
    if mincount>count:
        mincount = count
        
print(mincount)

Solution (Python):
ans = 10**9
n = int(input())
a = list(map(int,input().split()))
for x in a:
  tmp = 0
  while x % 2 == 0:
    tmp += 1
    x //= 2
  ans = min(ans, tmp)
print(ans)

Solution (Python):
def how_many_times_divisible(n):
	ans = 0
	while n % 2 == 0:
		n /= 2
		ans += 1
	return ans

n = int(input())
a = map(int, input().split())
ans = min(map(how_many_times_divisible, a))

print (ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

ope_count = 0
while True:
    even_count = len([a for a in A if a % 2 == 0])

    if even_count != N:
        print(ope_count)
        break

    A = [a / 2 for a in A]
    ope_count += 1

Solution (Python):

N = int(input())
A = list(map(int, input().split()))

ans = float("inf")

for i in A:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)

print(ans)

Solution (Python):
def time(n):
  ans = 0
  while n % 2 == 0:
    n /= 2
    ans += 1
  return ans
N = int(input())
LA = list(map(int, input().split()))
ans = min(map(time, LA))
print(ans)

Solution (Python):




def main():
    N = int(input())
    S = list(map(int, input().split()))
    result = 0
    count = 2
    while all([s % count == 0 for s in S]):
        count *= 2
        result += 1

    print(result)


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

cnt = 0
flg = True
while True:
    for a in A:
        if a % 2 != 0:
            flg = False
    if flg == False:
        break
    A = list(map(lambda x: x/2, A))
    cnt += 1
print(cnt)

Solution (Python):
N = int(input())
lst = [int(s) for s in input().split(" ") ]

cnt = 0
flag = 0

while flag == 0:
    for i in range(0,N):
        if lst[i]%2 == 0:
            lst[i] = lst[i]/2
        else:
            flag = 1
    cnt += 1
    

print("{}".format(cnt-1))

Solution (Python):
n = input()
A = list(map(int,input().split()))
count = 0
while all(a%2 == 0 for a in A):
    A = [a/2 for a in A]
    
    count += 1
print(count)

Solution (Python):

N = int(input())
ListA = [int(x) for x in input().split()]

count = 0

while 1 :
    exist_odd = False

    for i in range(len(ListA)) :
        if ListA[i]%2 != 0 :
            exist_odd = True
    if exist_odd :
        break

    for i in range(len(ListA)) :
        ListA[i] /= 2

    count += 1

print(count)

Solution (Python):
def shift_only(array):
    tmp = []
    counter = 0
    while True:
        flag = True
        
        for num in array:
            if num%2 != 0:
                flag = False
        if flag == False:
            break
        array = [i/2 for i in array]
        counter +=1
    print(counter)
    
n = int(input())
a = list(map(int, input().split()))
shift_only(a)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

count = 0
while all([i % 2 == 0 for i in a]):
  count+=1
  a = [i//2 for i in a]
print(count)

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

def many_int():
    return list(map(int, input().split()))

N=one_int()
A=many_int()

mins=100000000000
for i in A:
    temp=i
    count=0
    while temp%2==0:
        count+=1
        temp/=2
            
    if count < mins:
        mins = count

print(mins)

Solution (Python):
n = int(input())
a_list = list(map(int, input().split()))
counter = 0
while True:
    fl = 0
    for i in a_list:
        fl += i%2
    if not fl == 0:
        break
    else:
        counter += 1
        for i in range(n):
            a_list[i] //= 2
print(counter)

Solution (Python):
n=input()
wb = list(map(int, input().split()))
num=0
while True:

	wb2 = list(map(lambda x: x%2, wb))
	if any(wb2) == 0:
		num += 1
		wb = list(map(lambda x: x/2, wb))
	else:
		break
print(num)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = 0
while all(i%2 == 0 for i in a):
    a = [j/2 for j in a]
    ans += 1
print(ans)

Solution (Python):
input()
A=list(map(int,input().split()))
cnt=0
while all(a%2==0 for a in A):
  A=[a/2 for a in A]
  cnt+=1
print(cnt)

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
ans = 0
flg = 1
while flg:
  for i in range(n):
    if l[i]%2 < 1:
      l[i] //= 2
    else:
      flg = 0
      break
  ans += flg
print(ans)

Solution (Python):
def hd2(n):
	ans = 0
	while n % 2 == 0:
		n /= 2
		ans += 1
	return ans
n = int(input())
a = map(int, input().split())
ans = min(map(hd2, a))
print(ans)

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
A.sort()
for i in range(N):
  A[i]=list(format(A[i],'320b'))
A=list(map(list,zip(*A)))
B=['0']*N
ret=0
A.reverse()
for i in A:
  if i==B:
    ret+=1
  else:
    break
print(ret)

Solution (Python):
input()
a = list(map(int, input().split()))
ans = 0
while all(i%2 == 0 for i in a):
    a = [n/2 for n in a]
    ans += 1
print(ans)

Solution (Python):
input()
arr = [int(s) for s in input().split(" ")]
cnt = 0
while (1):
    all_even = all([i % 2 == 0 for i in arr])
    if all_even:
        arr = [i // 2 for i in arr]
        cnt += 1
    else:
        break
print(cnt)

Solution (Python):
n=int(input())
s=list(map(int,input().split()))
f=False
c=0
while True:
    for x in range(n):
        if s[x]%2==0:s[x]=s[x]//2
        else:f=True
    if f:
        print(c)
        break
    c+=1

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

min_div = 10 ** 9 
for a in A:
    div_count = 0
    while a % 2 == 0:
        a /= 2
        div_count += 1
    min_div = min(min_div, div_count)

print(min_div)

Solution (Python):
N = int(input())
A = input().split()
A = list(map(int, A))

def even_judgement(A):
  count = 0
  for a in A:
    if a%2 == 0:
      count += 1
  if count == N:
    return True
  else:
    return False

S_COUNT = 0
while even_judgement(A):
  A = list(map(lambda x: x/2, A))
  S_COUNT += 1
print(S_COUNT)

Solution (Python):
n = int(input())
al = list(map(int, input().split()))

ans = 0
while True:
    for i in range(n):
        if al[i] % 2 == 0:
            al[i] = al[i]//2
        else:
            break
    else:
        ans += 1
        continue
    break

print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt = 0

while True:
    if any([i%2 for i in a]):
        break
    else:
        a = [i/2 for i in a]
        cnt += 1

print(cnt)

Solution (Python):
import fractions
from functools import reduce

n=int(input())
a=[int(x) for x in input().split()]

buf=reduce(fractions.gcd,a)

print(format(buf,'b')[::-1].find('1'))

Solution (Python):
n =int(input())
input_line=input().split(" ")



flag="ture"
count=0
while flag=="ture":
    for i in range(n):
        if int(input_line[i]) % 2 != 0:
            flag="false"
        else:
            input_line[i]=int(input_line[i])/2
    if flag=="false":
        break
    count +=1
print(count)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
count = 0



while all(a%2==0 for a in A): 
    A = [a/2 for a in A]
    count += 1
    
print(count)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
s = 0

def count(A, n):
    for i in range(n):
        if (A[i] % 2 == 1) or (A[i] == 0):
            return False
        A[i] = A[i] // 2
    return True

while True:
    if count(A, n):
        s += 1
    else:
        break
    
print(s)

Solution (Python):
n = input()
a = list(map(int, input().split()))
cnt = 0
while all(i%2==0 for i in a):
    a = [i/2 for i in a]
    cnt += 1
print(cnt)

Solution (Python):
n = int(input())

a = list(map(int,input().split()))

def waru(a,n):
    for i in range(n):
        if a[i]%2==1:
            return False
        else:
            a[i] = a[i]//2
    return True

con = 0
while True:

    if waru(a,n):
        con += 1
    else:
        break

print(con)

Solution (Python):
import math
n = input()
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))

Solution (Python):
import math
n = input()
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
counter = 0
breaker = 0
while True:
	for i in range(n):
		if A[i]%2 == 0:
			A[i] = A[i] // 2
		else:
			breaker = 1
	if breaker == 0:
		counter += 1
	else:
		break
print(counter)

Solution (Python):
import fractions
from functools import reduce

def gcd_list(num):
  return reduce(fractions.gcd,num)
  
n = int(input())
a = list(map(int,input().split()))
count = 0

gcd = gcd_list(a)
while gcd % 2 == 0:
  gcd = gcd / 2
  count += 1
print(count)

Solution (Python):
input()
A = list(map(int,input().split()))
cnt = 0
while all(a%2==0 for a in A):
    A = [a/2 for a in A]
    cnt+=1
print(cnt)

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
ans=1000
for i in l:
  t=0
  while(i%2==0):
    i=i//2
    t+=1
  ans=min(ans,t)
print(ans)

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
ans = max(l)
for i in l:
  count = 0
  while i % 2 == 0:
    count += 1
    i //= 2
  ans = min(ans,count)
  if ans == 0:
    print(0)
    exit()
print(ans)

Solution (Python):
n = int(input())
nums = [int(x) for x in input().split()]
ops = 0
cont = 1
while cont:
	for x in range(n):
		if nums[x] % 2 == 0:
			nums[x] = nums[x]/2
		else:
			cont = 0
			break
	ops += cont
print(ops)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
def keta2(n):
    b = 0
    if n%2 == 0:
        b += 1
        while(1):
            n = n//2
            if n==0 or n==1:
                break
            if n % 2 == 0:
                b += 1
            else:
                break

    return b

ans = 1000
for i in range(N):
    b = keta2(A[i])
    ans = min(ans,b)


print(ans)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
s=[]
i=0
cnt=0
for i in range(n):
    while a[i]%2==0:
        cnt+=1
        a[i]=a[i]//2
    else:
        s.append(cnt)
        i+=1
        cnt=0
print(min(s))

Solution (Python):
input()
A = list(map(int, input().split()))
count = 0

while all(a%2==0 for a in A):
  A = [a/2 for a in A]
  count += 1
print(count)

Solution (Python):
N = int(input())
a = list(map(int,input().split()))
count = 0
flag = False

while True:
    for i in range(len(a)):
        if a[i]%2 != 0:
            flag = True
            break
        else:
            a[i] = a[i] / 2
            flag = False
    if flag:
        break
    else:
        count += 1

print(count)

Solution (Python):
N = input()
A = list(map(int,input().split()))
ans=10**9
for a in A:
    cnt = 0
    while a%2 == 0:
       cnt += 1
       a /= 2
    ans = min(ans, cnt)
print(ans)

Solution (Python):
N = int(input())
A = input().split()
A = [int(i) for i in A]

check1 = 0
count1 = 0
while check1 == 0:
    for i in range(len(A)):
        if(A[i]%2 == 0):
            A[i] = A[i]/2
        else:
            check1 = 1
            break
    count1 += 1
        
count1 -= 1
print(count1)

Solution (Python):
import sys
N = int(input())
l = list(map(int,input().split()))
cnt = 0
while(1):
    for i in range(N):
        if l[i]%2 == 1:
            print(cnt)
            sys.exit()
        else:
            l[i] = l[i] // 2
    cnt += 1

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

cnt = 0

while(1):
    for i in range(n):
        if a[i] % 2 == 1:
            print(cnt)
            exit(0)
        else:
            a[i] = a[i] // 2
    cnt += 1

Solution (Python):
N = int(input())
arr = [int(n) for n in input().split()]
n_operation = 0
possible = True
while possible:
    for i, n in enumerate(arr):
        if n % 2 == 1:
            possible = False
            break
        arr[i] /= 2
    else:
        n_operation += 1
print(n_operation)

Solution (Python):
a = int(input())
n = [int(i) for i in input().split()]
count = 0
flag = True
while flag==True:
    for i in range(len(n)):
        if n[i]%2==1:
            flag = False
    
    if flag==False:
        break
    
    count += 1
    for i,j in enumerate(n):
        n[i]=j//2
    
print(count)

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    A=LIST()
    ct=0
    flg=1
    while flg==1:
        for i in range(n):
            if A[i]%2==1:
                flg=0
            else:
                A[i]=A[i]//2
        if flg==1:
            ct+=1
    print(ct)
            
        
if __name__ == '__main__':
    do()

Solution (Python):
import sys

n=int(input())
a=list(map(int,input().split()))
count=0
for j in range(100000):
	for i in range(n):
		if a[i]%2==1:
			print(count)
			sys.exit()
		a[i]=a[i]/2
	count+=1

Solution (Python):
N = int(input())
a = list(map(int,input().split()))
count = 0
while True:
  if len([i for i in a if i % 2 == 0]) == len(a):
      a = list(map(lambda q: q // 2, a))
      count += 1
  else:
      break
print(count)

Solution (Python):
n = int(input())
list = list(map(int, input().split()))
b = -1
cont = True

while cont:
  b += 1
  for i in range(n):
    if(list[i] % 2 == 0):
      list[i] = list[i] / 2
    else:
      cont = False
     
print(b)

Solution (Python):
n = int(input())
nums = list(map(int, input().split()))

num_dvd = 0
 
can_devide = True
temp_list = []
while can_devide:
  for num in nums:
    if num % 2 == 1:
      can_devide = False
      print(num_dvd)
      break
    else:
      temp_list.append(num // 2)
  num_dvd += 1
  nums, temp_list = temp_list, []

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt = 0

while True:
    if sum([a[i]%2 for i in range(n)]) == 0:
        a = [int(n/2) for n in a]
        cnt += 1
    else:
        break
print(cnt)

Solution (Python):
n = int(input())

AS = list(map(int,input().split()))
count = 0

while True:
  for i in range(n):
    a = AS[i]
    if a %2:
      break
    AS[i] = int(a/2)
  else:
    count += 1
    continue
  break
print(count)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

count = 0
while(True):
    flag = True
    for i in range(n):
        if a[i] % 2 != 0:
            flag = False
            break

    if flag == False:
        break
    else:
        count += 1
        for i in range(n):
            a[i] = a[i] // 2

print(count)

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
B = []

for i in range(n):
    count = 0
    while A[i]%2 == 0 :
        count +=1
        A[i] = A[i]//2
    B.append(count)

print(min(B))

Solution (Python):
n = int(input())
a = [i for i in map(int, input().split())]
cnt = 0
tmp = []
for i in range(n):
    b = a[i]
    t = 0
    while b % 2 == 0:
        b //= 2
        t += 1
    tmp.append(t)
print(min(tmp))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
lst1 = list(map(int,readline().split()))
ans = 10**9
for i in lst1:
    res = 0
    while True:
        if i%2 == 0:
            i //= 2
            res += 1
        else:
            ans = min(ans,res)
            break

print(ans)

Solution (Python):
def main():
    N = int(input())
    A = list( map(int, input().split()) )
    cnt = 0
    while True:
        if sum([ A[i]%2 for i in range(N) ]) == 0 :
            A = [ int(n/2) for n in A ]
            cnt += 1
        else:
            break
    print(cnt)


    

if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
A = list(map(int, input().split()))




cnt = 0

while True:
    exist_odd = False
    for a in A:
        if a % 2 == 0:
            continue
        else:
            exist_odd = True
            break 
    if exist_odd: 
        break
    A = [a/2 for a in A]
    cnt = cnt + 1
print(cnt)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))




cnt = 0

flag=True
while flag:
    for a in A:
        if a % 2 == 0:
            continue
        else:
            flag=False
            break 
    if not flag: 
        break
    A = [a/2 for a in A]
    cnt = cnt + 1
print(cnt)

Solution (Python):
N = int(input())
ary = list(map(int, input().split()))

count = 0
while True:
    flag = True
    for i in range(len(ary)):
        v = ary[i]
        if v % 2 == 0:
            v //= 2
            ary[i] = v
        else:
            flag = False
    if flag is False:
        break
    count += 1
print(count)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
while True:
  for i in range(n):
    if a[i]%2!=0:
      print(ans)
      exit()
    a[i]//=2
  ans+=1

Solution (Python):
N = int(input())

A = list(map(int, input().split()))

count = 0
i = 0
j = 0

while i == 0:
    for a in A:
        if a % 2 == 1:
            i = 1
            break
        else:
            a = a / 2
            A[j] = a
            j += 1
    j = 0
    if i == 0:
        count += 1

print(count)

Solution (Python):
N=int(input())
A=input().split()
count=0
i=0
output=0

while True:
  for i in range(N):
    if int(A[i])%2==0:
      count+=1
      A[i]=int(A[i])/2
    if count == N:
      output+=1
  if count != N:
    count=0
    i=0
    break
  count=0

print(output)

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
count=0
flag=0
while flag==0:
    for i in range(N):
        if (A[i]%2==0):
            A[i]=int(A[i]/2)
        else:
            flag=1
            count=count-1
            break
    count = count + 1
print(count)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

ans = 9999
for i in A:
  tmp = i
  count = 0
  while tmp % 2 == 0:
    tmp = tmp // 2
    count += 1
  ans= min(ans, count)
print(ans)

Solution (Python):
N = int(input())
args = list(map(int, input().split()))

c = 0
isOdd = False
while True:
    for i in range(N):
        if args[i] % 2 == 1:
            isOdd = True
        args[i] /= 2
    if isOdd:
        break
    c += 1

print(c)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
count = 0
tmp = 0
while(1):
	tmp_2=0
	if tmp == 1:
		break
	for i in range (N):
		if A[i]%2 == 1:
			print(count)
			tmp = 1
			break
		else:
			tmp_2 += 1
	if tmp_2 == N:
		count += 1
		for i in range (N):
			A[i] = A[i]/2

Solution (Python):
import sys

N = int(input())
A = list(map(int, input().split()))

s = []
a = A
i = 0

f = list(map(lambda x: x % 2, A))
if f.count(1):
    print(i)
    sys.exit()

while not s.count(1):
    a = list(map(lambda x: x // 2, a))
    s = list(map(lambda x: x % 2, a))
    i += 1

print(i)