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()))
counter = 0
roop_flag = True
while roop_flag:
    for i in range(N):
        if a[i] % 2 != 0:
            roop_flag = False
            break
        else:
            a[i] = a[i]/2
    else:
        counter += 1

print(counter)

Solution (Python):
a=int(input())
list=list(map(int,input().split()))
flag=False
ans=30
for i in range(31):
  for j in list:
    if j % (2**i) != 0:
      if not(flag):
        flag = True
        ans = i-1
print(ans)

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

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

while k:
	for i in range(len(A)):
		if A[i] % 2 == 1:
			k = False
			break

	if k:
		ans += 1
		for i in range(len(A)):
			A[i] = A[i] / 2

print(ans)

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

while k == True:
	for i in range(len(A)):
		if A[i] % 2 == 1:
			k = False
			break

	if k == True:
		ans += 1
		for i in range(len(A)):
			A[i] = A[i] / 2

print(ans)

Solution (Python):
n = int(input())
alist = [int(_) for _ in input().split()]

result = []
for a in alist:
  each_result = 0
  while a%2 == 0:
    a = a/2
    each_result = each_result + 1
  result.append(each_result)

print(min(result))

Solution (Python):
from math import *

N = int(raw_input())
A = map(int, raw_input().split())
print [n for n, x in enumerate([len([j for j in A if j % 2**i == 0]) for i in range(int(log(max(A), 2))+2)]) if x == N][-1]

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

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

def Even(X):
    counter = 0
    for i in range(len(X)):
        if X[i] % 2 == 0:
            counter += 1
    if counter == len(X):
        return True
    else:
        return False

counter = 0
while Even(AA) == True:
    AA = [int(i / 2) for i in AA]
    counter += 1

print(counter)

Solution (Python):

input()
numbers = list(map(int, input().split()))
 
count = 0
while(True):
	if sum(list(map(lambda x: x % 2, numbers))) == 0:
		numbers = list(map(lambda x: x / 2, numbers))
		count += 1
	else:
		break
print(count)

Solution (Python):

N =int(input())

A=list(map(int,input().split()))
ans = 0
for i in range(5*10**8):
    tmp=0
    for j,k in enumerate(A):
        if k%2 ==0:
            A[j] =k/2
            tmp+=1
    if tmp ==len(A):
        ans+=1
    else:
        print(ans)
        exit()

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

count = 0
while True:
    for i, v in enumerate(A):
        if v % 2 != 0:
            print(count)
            exit()
        else:
            A[i] = v / 2
    count += 1

Solution (Python):
kazu = int(input())
numbers_list = list(map(int, input().split()))
count = 0
seisu = 0
while True:
    for index in range(kazu):
        if numbers_list[index] % 2 != 0:
            seisu = 1
            break
        else:
            numbers_list[index] = numbers_list[index] / 2
    if seisu == 1:
        break
    count += 1
print(count)

Solution (Python):
sam_num = int(input())  
num = list(map(int, input().split()))  
count = 0
flag = 0

while True:
    for i in range(sam_num):
        
        if num[i] % 2 != 0:  
            flag = 1
            break
        num[i] = num[i] / 2
        
    if flag == 1:
        break
    count = count + 1

print(count)

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

Solution (Python):


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

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

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

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

cnt = 0

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

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

N = int(input())
A = (int(x) for x in input().split())
y = min(map(counter,A))
print(y)

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

Solution (Python):
N = input()
A = list(map(int, input().split()))
count = 0
existOdd = False
while not existOdd:
    for a in A:
        if a % 2 == 1:
            existOdd = True

    if not existOdd:
        A = list(map(lambda x: x / 2, A))
        count += 1

print(count)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
  A=list(map(lambda x:x|A.pop(),A))
print(len(str(bin(A[0])))-str(bin(A[0])).rfind('1')-1)

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

for i in a:
    answer = answer | i
print(len(bin(answer & -(answer))) - 3)

Solution (Python):
_,t=open(0);n=eval(t.replace(' ','|'));print(len(bin(n&-n))-3)

Solution (Python):
n = int(input())
def reduce(x):
    cnt = 0
    while( x % 2 == 0):
        x = x//2
        cnt += 1
    return cnt
print( min( [ reduce(int(i)) for i in input().split() ] ) )

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

while flg:
    for i in range(n):
        if a[i] % 2 != 0:
            flg = False
            break
        else:
            a[i] >>= 1
        
    if flg:
        ans += 1
        
print(ans)

Solution (Python):
from functools import reduce

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

def gcd(x,y):
    l = max(x,y)
    s = min(x,y)
    while s != 0:
        l,r = s,l % s
        s = r
    return l

kai = reduce(gcd,As)

counter = 0
while kai % 2 == 0:
    kai //= 2
    counter += 1

print(counter)

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

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

print(ans)

Solution (Python):
N = int(input())
P = list(map(int,input().split()))
cnt = 0
repeat = True

while repeat:
    for i in range(N):
        if P[i] % 2 == 1:
            repeat = False
            break
        else:
            P[i] = P[i] // 2
    cnt += 1

cnt -= 1
print(cnt)

Solution (Python):
n = input()
a_str = input().split()
a = list(map(int, a_str))
count = 0
should_continue = True
while should_continue:
    
    for i, num in enumerate(a):
        
        if num%2 == 0:
            num //= 2
            a[i] = num
            
        else:
            should_continue = False
    if should_continue:
        count+=1
print(count)

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

cnt = 0

while True:
    if 1 in [i%2 for i in A]:
        break
    A = [j // 2 for j in A]
    cnt += 1
print(cnt)

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

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

Solution (Python):
import numpy as np
N = input()
s = np.array(list(map(int, input().split())))
count = 0
while True:
  _exp = 2**(count+1)
  if np.all( s%_exp == 0):
    count += 1
  else:
    break
print(count)

Solution (Python):
N = input()
A = list(map(int, input().split()))
count = 0
existOdd = False
while not existOdd:
    for a in A:
        if a % 2 == 1:
            existOdd = True

    if not existOdd:
        A = list(map(lambda x: x / 2, A))
        count += 1

print(count)

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

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

Solution (Python):
N = int(input())
a_list = list(map(int, input().split(' ')))
count_all = 0
continue_flag = True

while continue_flag:
    count = 0
    for i, a in enumerate(a_list):
        if a % 2 == 0:
            count += 1
            a_list[i] //= 2

    if count == N:
        count_all += 1
    else:
        continue_flag = False

print(count_all)

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(ans)

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

Solution (Python):
s = input()
li = input().split()
t = 0
li2 = []
for i in li:
    t  = 0
    while True:
        if int(i) % 2 == 0:
            i = int(i) / 2
            t += 1
        else:
            li2.append(t)
            break

li2.sort()
ans = li2[0]
print(ans)

Solution (Python):

n = int(input().rstrip())
values = list(map(int,input().rstrip().split()))

m = 500000000 
for i in range(len(values)):
	nowV = values[i]
	nm = 0
	for j in range(500000000):
		if nowV % 2 == 0:
			nm += 1
			nowV = nowV / 2
		else:
			break 
	m = min(m,nm)
print(m)

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

leave = False
while True:
    for i in range(N):
        if A[i]% 2 == 1:
            leave = True
    if leave == True:
        break
    n += 1
    A = list(map(lambda x : x/2, A))
    
print(n)

Solution (Python):

n = int(input())
l = input().split()
l_i = [int(j) for j in l]

min = l_i[0]
count = 0
flag = True

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

print(count)

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

n = 0
leave = False
while True:
    for i in range(N):
        if A[i]%2 == 1:
            leave = True
    if leave == True:
        break
    n+=1
    A = list(map(lambda x : x/2, A))

print(n)

Solution (Python):
N=int(input())
ans=float('inf')
for a in map(int,input().split()):
    cnt=0
    while a%2==0:
        a//=2
        cnt+=1
    ans=min(cnt,ans)
print(ans)

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
ans = []
for i in range(N):
    count = 0
    k = A[i]
    while k % 2 == 0:
        k = k // 2
        count += 1
    ans.append(count)
print(min(ans))

Solution (Python):
_=input()
Al=list(map(int,input().split()))
count=0
while all(map(lambda x:x%2==0,Al)):
    Al=list(map(lambda x:x//2,Al))
    count+=1
print(count)

Solution (Python):


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

flag = False
cnt = 0

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

print(cnt)

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

counts = []
for i in A:
    count = 0
    while i % 2 == 0 and i != 0:
        i /= 2
        count += 1
    counts.append(count)
print(min(counts))

Solution (Python):
total = int(input())
numbers = input().split()
time = 0
flag = False
while True:
  for number in numbers:
    if int(number)%2 != 0:
      flag = True
      break;
  else:
    numbers = [(int(j) / 2) for j in numbers]
    time = time + 1
  if flag:
    break
print(time)

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

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(ans)

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

flag = False
count = 0

while True:
  
  for num in A:
    if (num % 2) == 1:
      flag = True
      
  A = list(map(lambda x: int(x / 2), A))
  
  if flag:
    break
  
  count += 1
  
print(count)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
m = 0
for i in range(40):
  if all([i % 2 == 0 for i in a]):
    a = [i / 2 for i in a]
    m += 1
  else:
    break
    
print(m)

Solution (Python):
def calc(n):
    ret = 0
    while (n & 1) == 0:
        n >>= 1
        ret += 1
    return ret

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

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

i = 0
while(1):
    if all([ True if a % 2 == 0 else False for a in A]):
        i += 1
        A = [n/2 for n in A]
    else:
        break

print(i)

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

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

print(cnt)

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

for num in a:
  tmp = 0
  while num % 2 == 0:
    num /= 2
    tmp += 1
  ans = min(tmp, ans)

print(ans)

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

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

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

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

ans = 0
while True:
    if [i % 2 for i in A].count(1) > 0:
        break
    A = [j // 2 for j in A]
    ans += 1
print(ans)

Solution (Python):
import numpy as np

line_len = int(input())
num_list = []
num_list = input().rstrip().split(' ')
np_num_list = np.array(num_list).astype(int)
div = [2]*line_len
np_div = np.array(div)
counter = 0
flag = False
while True:
    for i in range(line_len):
        if np_num_list[i]%2 != 0:
            flag = True
    if flag:
        print(counter)
        break
    np_num_list =  np_num_list/np_div
    counter = counter + 1

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

i = 0
while True:
    if [_%2 for _ in A].count(1) > 0:
        break
    A = [_/2 for _ in A]
    i += 1

print(i)

Solution (Python):
n=int(input())
a=list(map(int, input().split()))
count=0 
def h(L):
  for i in range(len(L)):
    if L[i] % 2 != 0:
      return(1)
  return(0)
while h(a) == 0:
  for j in range(n):
    a[j]=a[j]/2
  count=count+1
  
print(count)

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

def hantei(L):
  for i in range(len(L)):
    if L[i] % 2 != 0:
      return(1)
  return(0)

count = 0
while hantei(A) == 0:
  for j in range(N):
    A[j] = A[j] / 2
  count = count + 1
  
print(count)

Solution (Python):
N=int(input())
A_list=list(map(int, input().split()))
 
ans=100
for i in A_list:
    cnt=0
    while i%2==0:
        i/=2 
        cnt+=1
 
    ans=min(cnt, ans)
 
print(ans)

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

ans=100
for l in A_list:
    cnt=0
    while l%2==0:
        l/=2 
        cnt+=1

    ans=min(cnt, ans)

print(ans)

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

for i in range(1, 10**9):
  tmp = [A[j]/2 if A[j]%2 == 0 else -1 for j in range(N)]
  A = tmp[:]
  if A.count(-1) != 0:
      break

print(i-1)

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

ans=100
for l in List:
    cnt=0
    while l%2==0:
        l/=2
        cnt+=1
    ans=min(ans,cnt)
print(ans)

Solution (Python):
import numpy as np
 
n = int(input())
a = np.array(list(map(int, input().split())))
ans_count = 0
 
while(1):
  count = len(np.where(a % 2 == 1)[0])
  if count > 0:
    break
  a = a / 2
  ans_count += 1
print(ans_count)

Solution (Python):
N = int(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):
input()
strs = input().split(' ')
nums = [int(i) for i in strs]

ct = 0
b_flag = False
while(1):
  for i, num in enumerate(nums):
    if num % 2 == 0:
      nums[i] = num/2
      continue
    else:
      b_flag = True
      break
  if b_flag:
    break
  ct += 1
print(ct)

Solution (Python):
input()
strs = input().split(' ')
nums = [int(i) for i in strs]

ct = 0
b_flag = False
while(1):
  for i, num in enumerate(nums):
    if num % 2 == 0:
      nums[i] = num/2
      continue
    else:
      b_flag = True
      break  
  if b_flag:
    break
  ct += 1
print(ct)

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

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

ans = 50
for i in range(n):
    c = 0
    while A[i] %2 == 0:
        A[i] = A[i]//2
        c += 1
    ans = min(ans,c)
print(ans)

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

i = 0
while True:
    l = [j for j, x in enumerate(A) if int(x) % 2 == 0]
    A = list(map(lambda x : x / 2, A))
    if len(l) == len(A):
        i += 1
    else:
        print(i)
        break

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

while 1:
  flag=0
  for i in range(n):
    if(hoge[i]%2==1):
      flag=1
    else:
      hoge[i]=hoge[i]/2

  if(flag==0):
    ans+=1
  else:
    break

print(ans)

Solution (Python):


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

def check(ar):
    b = True
    for i in range(len(ar)):
        if ar[i] % 2 != 0:
            b = False
            break
    return b

answer = 0

for i in range(1000000000):
    if check(a) == True:
        for j in range(len(a)):
            a[j] = int(a[j]/2)
        answer += 1
    else:
        break;

print(answer)

Solution (Python):
def solve(string):
    n, *a = map(int, string.split())
    ans = 0
    while all([_a % 2 == 0 for _a in a]):
        a = [_a // 2 for _a in a]
        ans += 1
    return str(ans)


if __name__ == '__main__':
    print(solve('\n'.join([input(), input()])))

Solution (Python):
def isEven(num):
    if num % 2 == 0:
        return 0
    else:
        return 1

def isAllEven(l):
    allEven = 0
    for i in l:
        allEven += isEven(i)
    
    if allEven == 0:
        return True
    else:
        return False

def countDivide(n, l):
    if isAllEven(l):
        newl = list(map(lambda x: int(x/2), l))
        n += 1
        return countDivide(n, newl)
    else:
        return n

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

print(countDivide(0, A))

Solution (Python):
a = int(input())
num = [int(a) for a in input().split()]
counter = 0
while True:
    b = list(map(lambda x: x % 2, num))
    if b.count(0) == a:
        num = list(map(lambda x: x>>1, num))
        counter += 1
    else:
        print(counter)
        break

Solution (Python):


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

counter = 0
while True:
    b = list(map(lambda x: x % 2, num))
    if b.count(0) == a:
        num = list(map(lambda x: x/2, num))
        counter += 1
    else:
        print(counter)
        break

Solution (Python):


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

counter = 0
while True:
    b = list(map(lambda x: x % 2, num))
    if b.count(0) == a:
        num = list(map(lambda x: x/2, num))
        counter += 1
    else:
        print(counter)
        break

Solution (Python):


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

counter = 0
while True:
    b = list(map(lambda x: x % 2, num))
    if sum(b) == 0:
        num = list(map(lambda x: x/2, num))
        counter += 1
    else:
        print(counter)
        break

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

count = []
for Ai in A:
  count_i = 0
  while Ai % 2 == 0:
    Ai /= 2
    count_i += 1
  count.append(count_i)

print(min(count))

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

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

from functools import reduce

def gcd_list(numbers):
    return reduce(gcd, numbers)

ct = 0
num = gcd_list(li)
while num != 1:
    num /= 2
    ct += 1
print(ct)

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

Solution (Python):
input_num = int(input())
nums = input().split()
ope_cnt = 0
def division_nums(input_num, nums, ope_cnt):
  for i in range(input_num):
    if int(nums[i]) % 2 != 0:
      return ope_cnt
    else:
      nums[i] = int(nums[i]) / 2
  ope_cnt = ope_cnt + 1
  return division_nums(input_num, nums, ope_cnt)
      
print(division_nums(input_num, nums, ope_cnt))

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

ans = a[0]
for i in range(int(n)):
    count = 0
    while(a[i] % 2 == 0):
        a[i] /= 2
        count += 1
    ans = min(ans, count)
print(ans)

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

n = int(input())
a = [int(i) for i in input().split()]
a = [calc(i) for i in a]
print(min(a))

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

count = 0
while True:
    for i in range(N):
        q, mod = divmod(An[i], 2)
        if mod != 0:
            break
        An[i] = q
    else:
        count += 1
        continue
    break

print(count)

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

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

Solution (Python):
def gu(n,a):
  ans=[0]*n
  for i in range(len(a)):
    ii=a[i]
    while True:
      if ii%2==0:
        ans[i]+=1
        ii=ii/2
      else:
        break
  return min(ans)
n=int(input())
a=list(map(int,input().split()))
print(gu(n,a))

Solution (Python):
def func(li, c):
    for i, n in enumerate(li):
      if n % 2 != 0:
        return c
      else:
        li[i] = n/2
    c+= 1
    return func(li, c)
    
input()
li = list(map(int, input().split()))
print(func(li, 0))

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

print(min([format(a[i], 'b')[::-1].find('1') for i in range(N)]))

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

temp=input_seisu.split(" ")
seisu = [int(s) for s in temp]

i = 0
exec_con=0
rerun_flg=True

while(rerun_flg == True):
    for atai in seisu:
        if atai % 2 == 0:
            seisu[i]= atai / 2
            i+=1
        
        else:
            rerun_flg=False
            break
    if N == i:
        exec_con+=1
        i=0

print("{}".format(exec_con))

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


n = int(input())
a = list(map(int, input().split()))
ans = min(map(count_of_div, a))
print(ans)

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

ans = 0
flag = True
while flag:
    for i in range(n):
        if a[i] % 2 == 1:
            flag = False
            break
        else:
            a[i] /= 2
    ans += 1
print(ans-1)

Solution (Python):
import sys
from sys import stdin
n = int(stdin.readline().rstrip())
al = [int(_) for _ in stdin.readline().rstrip().split()]
count=0
while True:
    for i,a in enumerate(al):
        if a%2 != 0:
            print(count)
            sys.exit()
        al[i]=a/2
    count+=1

Solution (Python):
import numpy as np


N= int(input())
A = np.array([int(i) for i in input().split()])
count = 0
while 1:
    if all([x % 2 == 0 for x in A]):
        count += 1
        A = A / 2
    else:
        break

print(count)

Solution (Python):
n = int(input())
a_n = list(map(int,input().split(" ")))
k = 0
t = 0
while True:
  for i in range(len(a_n)):
    if a_n[i] % 2 == 0:
      a_n[i] = a_n[i] / 2
    else:
      t = -1
      break
  if t == -1:
    break
  k += 1
print(k)

Solution (Python):

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

Solution (Python):
N=int(input())
tmp=input()
tmp=tmp.split(' ')
a=[]
for i in range(N):
  a.append(int(tmp[i]))
  
if all(x % 2 == 0 for x in a) == False:
  print(0)
else:
  count=0
  while all(x % 2 == 0 for x in a) == True:
    a=[x/2 for x in a]
    count+=1
    
  print(count)

Solution (Python):


n = int(input())

a = input().split()
count = 0
odd = False
while(odd == False):
    for i,v in enumerate(a):
        if int(v) % 2 != 0:
            odd = True
            break
        a[i] = int(v) // 2
    if odd is not True:
        count += 1

print(count)

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

Solution (Python):
import sys
def p(s):
  sys.stderr.write(str(s)+"\n")

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

ans=1000000000

for i in a:
  p(i)
  count=0
  while i%2==0:
    count+=1
    if count>ans:
      break
    i /= 2
    p("i="+str(i))
  
  ans = min(ans, count)

print(ans)

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

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()))
ans=0
flg=True

for i in range(1,32):
    for j in range(n):
        if a[j]%2==1:
            flg=False
        else:
            a[j]=int(a[j]/2)
    if flg==True:
        ans=i
print(ans)

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007



def A():
    a,b = LI()
    if not (a*b)%2:
        print("Even")
    else:
        print("Odd")
    return


def B():
    s = S()
    print(s.count("1"))
    return


def C():
    n = I()
    a = LI()
    f = 0
    for j in range(100000):
        for i in range(n):
            if a[i]%2:
                f = 1
                break
            a[i] //= 2
        if f:break
    print(j)
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    C()

Solution (Python):
N = int(input())
def calc(n):
    if n % 2:
        return 0
    else:
        return calc(n//2) + 1

A = [int(a) for a in input().split()]
mi = 9999
for a in A:
    mi = min(mi, calc(a))
print(mi)

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

def div(x):
    ans = 0
    while x%2 ==0:
        x = x/2
        ans +=1
    return ans

li = [div(x) for x in a]
print(min(li))

Solution (Python):

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

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

Solution (Python):
N = input()
a_list = list(input().split())
result = float("inf")

for a in a_list:
  b = int(a)
  count = 0
  while b%2 == 0:
    b = b/2
    count += 1
  else:
    if  result > count:
      result = count
print(result)