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()))
ok=True
ans=0
while ok==True:
    for i in range(N):
        if A[i]%2:ok=False
        A[i]=A[i]//2
    if ok:ans+=1
print(ans)

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
s=float('inf')
for a in l:
    c=0
    while a%2==0:
        c+=1
        a/=2
    s=min(s,c)
print(s)

Solution (Python):
N = int(input())
mini = 2**30
LL = input().split()
for i in LL:
  x = 0
  
  while int(i)%(2**x) ==0:
      x += 1
      
  
  if mini > (x-1):
    mini = (x-1)
    
print(mini)

Solution (Python):
def factorize(n):
    a=[]
    while n%2==0:
        a.append(2)
        n//=2
    f=3
    while f*f<=n:
        if n%f==0:
            a.append(f)
            n//=f
        else:
            f+=2
    if n!=1:
        a.append(n)
    return a
n = int(input())
li = list(map(int,input().split()))
lia = []
for i in range(n):
    fac = factorize(li[i])
    count = fac.count(2)
    lia.append(count)
print(min(lia))

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

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

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

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

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):
I = int(input())
L = list(map(int, input().split()))

ans = 0
while all(i % 2 == 0 for i in L):
    L = list(map(lambda el: el//2, L))
    ans += 1

print(ans, flush=True)

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

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

result = 0

def judge(nums, result):
    l = []
    index = 0
    false = 'False'
    for num in nums:
        if num % 2 == 0:
            l.append(num)
            index += 1
            if index == len(nums):
                result += 1
                return l, result
        else:
            return false, result

def divide(nums):
    l = []
    for num in nums:
        a = num / 2
        l.append(a)
    return l


j_l, result = judge(num_l, result)

while True:
    if j_l == 'False':
        print(result)
        break
    else:
        re_l = divide(j_l)
        j_l, result = judge(re_l, result)

Solution (Python):

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

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

print(count)

Solution (Python):


n = int(input())

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

def mod2(a, cnt):
    if sum([i % 2 for i in a]) == 0:
        a = [i / 2 for i in a]
        cnt += 1
        return mod2(a, cnt)
    else:
        return cnt

print(mod2(a, 0))

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

length = len(lists)
count = 0
while True:
  lists = [int(i/2) for i in lists if i%2 == 0]
  if length == len(lists):
    count += 1
  else:
    break
print(count)

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

while True:
    for i in range(N):
        ss=a[i]%2
        if ss==0:
            a[i]=a[i]/2 
        else:
            print(j)
            exit()
    j+=1

Solution (Python):
s = input()

n = int(s)

numbers = []
answer = 0
check = True

v  =input().split()

for i in range(n):
    numbers.append(int(v[i]))

while (check):
    for i in range(len(numbers)):
        if numbers[i] % 2 == 1:
            check = False
        else:
            numbers[i] /= 2
    if check:
        answer += 1

print(answer)

Solution (Python):
import numpy as np

N=int(input())
A=np.array(list(map(int,input().split())))
ans=0

while True:
  if np.all(A%2==0):
    A=A//2
    ans+=1
  else:
    print(ans)
    break

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

ans = 0;
l = len(A)
while(True):
  A = list(filter(lambda x: x%2==0, A))
  if len(A) is not l:
    break
  A = list([x//2 for x in A])
  ans += 1
  
print(ans)

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

Solution (Python):
import math

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

result = 10 ** 10
for i in A:
    count = 0
    for _ in range(result):
        if i % 2 == 0:
            i /= 2
            count += 1
        else:
            break
    result = min(result, count)

print(int(result))

Solution (Python):
a = input()
suuziretu = input().split(' ')
record_times = []
for n in range(int(a)):
    times = 0
    while True:
        if int(suuziretu[n])%2 != 0 or int(suuziretu[n]) == 0:
            record_times.append(times)
            break
        if times == 0:
            b = int(suuziretu[n])
        if b % 2 == 0:
            b = b /2
            times += 1
        else:
            record_times.append(times)
            break
print(min(record_times))

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

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

C= 0
flag = True
while flag == True:
  for i in range(N):
    if list_num[i] % 2 == 1:
      flag = False
  if flag == False:
    break
  for i in range(N):
    list_num[i] = int(list_num[i] / 2)
  C += 1
print(C)

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()))
count = 0
flag = True
while(flag):
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] = A[i]/2
        else:
            flag = False
            break
    if flag == True:
        count+=1
print(count)

Solution (Python):
def resolve():
    n = int(input())
    li = list(map(int, input().split()))

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

Solution (Python):


n = int(input())

mod2 = lambda x: x%2
div2 = lambda x: x//2

l_a = list(map(int, input().split()))
odd_flgs = list(map(mod2, l_a))

cnt = 0

while sum(odd_flgs) == 0:
    cnt += 1
    l_a = list(map(div2, l_a))
    odd_flgs = list(map(mod2, l_a))

print(cnt)

Solution (Python):
N = int(input())
num = list(map(int,input().split()))
ans = []
for i in num:
  a = format(i,('b'))[::-1].find("1")
  ans.append(a)
print(min(ans))

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

N = int(input())
BB = map(int,input().split())

ans = min(map(divis,BB))
  
print(ans)

Solution (Python):
_ = input()
num_list = list(map(int, input().split()))
 
count = 0
 
while(True):
  is_even_list = [False if num % 2 else True for num in num_list]
  if False in is_even_list:
    break
  num_list = list(map(lambda num: num / 2, num_list))
  count += 1
 
print(count)

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

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

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    n, *a = map(int, read().split())
    r = 0
    num = 2
    while True:
        c = [not (i % num) for i in a]
        if all(c):
            r += 1
            num *= 2
        else:
            break
    print(r)


if __name__ == '__main__':
    main()

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

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


def chk(A):
    if all([ai%2==0 for ai in A]):
        return True
    else:
        return False
count=0
while chk(al):
    count+=1
    for i in range(n):
        al[i]=al[i]//2
print(count)

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

Solution (Python):
_ = input()
INPUT = list(map(int, input().split()))

def check_even(l):
    return sum([i % 2 for i in INPUT]) == 0

check_even(INPUT)

count = 0
while True:
    if check_even(INPUT):
        INPUT = [i / 2 for i in INPUT]
        count+=1
    else:
        break
print(count)

Solution (Python):
def div(A):
    div_A = []
    for a in A:
        if a % 2 == 1:
            return 0
        else:
            div_A.append(a // 2)
    return div_A


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

cnt = 0
while True:
    A = div(A)
    if A == 0:
        break
    else:
        cnt += 1

print(cnt)

Solution (Python):
Array1 = int(input())
Array2 = input().split()
 
Number = 0
times = 0
 
while True:
    if int(Array2[Number ]) % 2 == 0:
        Array2[Number] = int(Array2[Number]) // 2
        Number += 1
        if Number == Array1:
            Number = 0
            times += 1
    else:
        print(times)
        break

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

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

print(ans)

Solution (Python):
input()
A=list(map(int, input().split()))
count=0
while all(a%2==0 for a in A):
    A=[i/2 for i in A]
    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=[i/2 for i in A]
    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 = list(map(lambda x: x / 2, A))
    count = count + 1

print(count)

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

    res = 1000
    for i in A:
        tmp = i
        cnt = 0
        while(tmp%2==0):
            tmp//=2
            cnt+=1
        res = min(res,cnt)
    print(res)
if __name__ == '__main__':
    main()

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

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

Solution (Python):

import sys
N = int(input())
a = list(map(int,input().split()))
cou = 0
l = len(a)
while cou >=0:
    for i in range(l):
        if a[i]%2 !=0:
            print(cou)
            sys.exit()
        a[i] /=2
    cou +=1

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

import math
from functools import reduce

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

cnt=0  
b=gcd_list(a)
for i in range(2**30):
  if b%2==0:
    cnt+=1
  b=b/2
  if b%2==1 or b==1/2:
    break

print(cnt)

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

f = True
for i in range(1, 100):
    for a in A:
        if a % 2**i != 0:
            f = False
    if not f:
        print(i-1)
        break

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

Solution (Python):
num = int(input())
data = input().split()

int_data = [int(i) for i in data]

cnt= 0

judge = True

while judge == True:
    
    for i in range(num):
        if int_data[i] % 2 == 0:
            int_data[i] = int_data[i] / 2
        else:
            judge = False
            break

    cnt += 1
    
print(cnt - 1)

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

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

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

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

Solution (Python):
n = int(input())
a = list(map(int, input().split(" ")))
l = len(a)
f = False
c = 0
while True:
    for i in range(0, l):
        if a[i] % 2 == 0:
            a[i] /= 2
        else:
            f = True
    if f is not True:
        c += 1
    else:
        break
print(str(c))

Solution (Python):
n=int(input())
nums=list(map(int,input().split()))
cnt=0
flag=0
while flag is 0:
    for i in range(n):
        num=nums[0]/2
        key=nums[0]%2
        if key==1:
            flag=1
            break
        else:
            del nums[0]
            nums.append(num)
    if flag==0:
        cnt+=1

print(cnt)

Solution (Python):
n=int(input())
nums=list(map(int,input().split()))
cnt=0
flag=0
while flag is 0:
    for i in range(n):
        num=nums[0]/2
        key=nums[0]%2
        if key==1:
            flag=1
            break
        else:
            del nums[0]
            nums.append(num)
    if flag==0:
        cnt+=1

print(cnt)

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 = map(int, input().split())

def how_many_times_divisible(N):
    ans = 0
    while N % 2 == 0:
        N = N /2
        ans += 1
    return ans

ans = min(map(how_many_times_divisible, a))
print(ans)

Solution (Python):
N = int(input())
A = input().split(' ')
A = [int(A[i]) for i in range(N)]
count = 0
while 1:
  for i in range(N):
    if A[i]%2 == 0:
      A[i] /= 2
    else:
      break
  else:
    count += 1
    continue
  break

print(count)

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

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

print(cnt)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    n = int(input())
    A = list(map(int, input().split()))

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


if __name__ == '__main__':
    main()

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

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

ans = 10**9
for i in range(n):
    cnt = 0
    while a[i]%2 == 0:
        a[i] = a[i]//2
        cnt += 1
    ans = min(ans, cnt)
print(ans)

Solution (Python):
N = int(input())
A = map(int, input().split())
c, m = 0, 100000000000000000000
for a in A:
  while a%2==0:
    a = a//2
    c += 1
  m = min(m, c)
  c = 0
print(m)

Solution (Python):
N = int(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())
ls=[int(s) for s in input().split()]
count=0
while sum([n%2 for n in ls])==0:
  count+=1
  ls=[n//2 for n in ls]
print(count)

Solution (Python):
N=input()
N=int(N)
ls=[int(s) for s in input().split()]
flag=1
ans=0
while flag==1:
  count=0
  for i in range(N):
    if ls[i]%2==0: 
      count=count+1
  if count==N:
    ans=ans+1
    for i in range(N):
      ls[i]=ls[i]//2
  else:
    flag=flag-1
print(ans)

Solution (Python):
import sys

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

while flg == 0:
  for i in range(N):
    if A[i]%2 == 0:
      A[i] = int(A[i]/2)
    elif A[i]%2 ==1 or A[i] == 1:
      print(cnt)
      sys.exit()
  cnt += 1
print(max(0,cnt-1))

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

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

Flg = True
COUNT  = 0

while(Flg):    
    for n in A:        
        if n%2 != 0:
            Flg=False
            break
        
    if Flg:
        A =  [n / 2 for n in A]
        COUNT+=1

print(COUNT)

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

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

Solution (Python):

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


cnt = 0
while len([1 for a in A if a % 2 == 0]) == len(A):
    A = [a // 2 for a in A]
    cnt += 1

print(cnt)

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

print(cnt)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
target=a
flag=True
cnt=0
while flag:
    tmp=[v%2==0 for v in target]
    if all(tmp):
        target=[v//2 for v in target]
        cnt+=1
    else:
        flag=False
print(cnt)

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:
            print(ans)
            exit()  
        
        else:
            A[i] = A[i] / 2
    ans += 1

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = 0
for _ in range(10000):
  for i in range(len(A)):
    if A[i]%2 == 1:
      print(ans)
      exit()
    else:
      A[i] //= 2
  ans += 1

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
c = 0
t = 0
while t == 0:
  A = [num/2 for num in A]
  B = [int(num) for num in A]
  if A == B:
    c += 1
  else:
    t += 1
print(c)

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

for n in range(A[-1]//2):
  for a in A:
    if a%2 == 1:
      print(ans)
      exit()
  for n in range(N):
    A[n] = A[n]/2
  ans+=1
  
print(ans)

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

res = float('inf')
for v in a:
    cnt = 0
    while v % 2 == 0:
        v //= 2
        cnt += 1
    res = min(res, cnt)

print(res)

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

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




output = 0
stop_flag = 0

while 1:
    for num in num_list:
        if((num % 2) == 1 ):
            stop_flag = 1
    if stop_flag == 0:
        output += 1
    
    num_list = list(map(lambda x: x/2,num_list))

    if stop_flag == 1:
        break
    
print(output)

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:
            a[i] //= 2
        else:
            break
    else:
        ans += 1
        continue
    break
print(ans)

Solution (Python):
def resolve():
    '''
    code here
    '''
    N = int(input())
    As = [int(item) for item in input().split()]

    cnt = 0
    is_not_found = True
    while is_not_found:
        for i in range(N):
            if As[i] % 2 == 0:
                As[i] //= 2
            else:
                is_not_found = False
                break
        else:
            cnt += 1
    print(cnt)

if __name__ == "__main__":
    resolve()

Solution (Python):
def actual(N, A):
    count = 0
    while True:
        is_all_even = all([a % 2 == 0 for a in A])

        if is_all_even:
            A = [a // 2 for a in A]
            count += 1
        else:
            return count

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

print(actual(N, A))

Solution (Python):
def check_pow_2(a,cnt):
  if a % 2 == 1:
    return cnt
  else:
    return check_pow_2(a/2,cnt) + 1

n = int(input())
a_lst = map(int, input().split())
min_ope = float("inf")
for a in a_lst:
  min_ope = min(min_ope, check_pow_2(a,0))
if min_ope == float("inf"):
  min_ope = 0
print(min_ope)

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

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

Solution (Python):

n=int(input())

a_list=[int(i) for i in input().split()]
count_list=[]

for i in range(n):
    num=a_list[i]
    count=0
    while True:
        if num%2==0:
            num//=2
            count+=1
        else:
            break
    count_list.append(count)


print(min(count_list))

Solution (Python):
N = int ( input () )
l = input().split()
s = []
for i in range (N):
    a = int ( l[i] )
    o = 0
    while True:
        b = a%2
        if b == 0:
            a = a/2
            o += 1
        else:
            s.append (o)
            break
print ( min (s) )

Solution (Python):


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

ans = len(format(10**9, "b"))-1
for ai in a:
  for i in range(len(format(ai, "b"))):
    if (ai >> i) & 1 and ans > i:
      ans = i
print(ans)

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

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


for i in range(N):
    cnt = 0
    while A[i] % 2 == 0:
        A[i] = A[i] / 2
        cnt += 1
    ans.append(cnt)
        
print(min(ans))

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
print(min([min(bin(i)[::-1].index("1"), len(bin(i))-2) for i in A]))

Solution (Python):

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

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

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

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

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

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

Solution (Python):


N = int(input())
A = input().split()

count = 0
count_a = 0
flag = 0

while flag == 0:

    for i in A:
        if int(i) % 2 == 0:
            count += 1

    if count == N:
        count_a += 1
        count = 0
        for i in range(N):
            A[i] = int(A[i]) // 2
    else:
        flag = 1

print(count_a)

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

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,*a = map(int,open(0).read().split())
c=10**9
for i in a:
  t=0
  while ~i>>t & 1:
    t+=1
  c = min(c, t)
print(c)

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

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

Solution (Python):
def main():
    N = int(input())
    next_numbers = [int(x) for x in input().split(" ")]
    count = 0
    while True:
        next_numbers = [x/2 for x in next_numbers if x % 2 == 0]
        if len(next_numbers) != N:
            print(count)
            break
        count += 1


if __name__ == '__main__':
    main()

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

check = True
num = 0
while check:
    for a_i in a:
        if a_i % (2 ** (num + 1)) != 0:
            check = False
            break
    if check:
        num += 1

print(num)

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

mc = 10**9
for a in A:
    i = 0
    while True:
        if (a>>i)&1 == 0:
            i += 1
        else:
            break
    mc = min(mc, i)
print(mc)

Solution (Python):
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()))

first_flg = 0
ans_num=0
def ans(calc_list):
    b = []
    for i in calc_list:
        if i%2 != 0:
            return 'stop'
        else:
            b.append(int(i/2))
    return b

while True:
    if 0 == first_flg:
        first_flg = 1
        output = ans(a)
    else:
        output = ans(output)

    if output == 'stop':
        break
    else:
        ans_num+=1
        
print(ans_num)

Solution (Python):

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

cnt = 0
flg = True

while flg == True:
    for i in range(len(a)):
        if a[i] % 2 == 1:
            flg = False
        a[i] /= 2

    if flg:
        cnt += 1 

print(cnt)

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

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

Solution (Python):
import numpy as np
N=int(input())
A=np.array(input().split(),dtype=np.int32)
ans=0
while (A%2==0).all():
    A//=2
    ans+=1
print(ans)

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

N=int(input())
A=map(int,input().split())
ans=10**9
for a in A:
    ans=min(ans,f(a))
print(ans)

Solution (Python):










import sys

def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


def cnt_two(n):
  if n % 2 == 1:
    return 0
  else:
    return 1 + cnt_two(n // 2)

N = iIn()
A = iInLH()

ans = INF
for i in range(N):
  cnt = cnt_two(A[i])
  ans = min(ans, cnt)
  
print(ans)

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

def func(x):
  s = 0
  while(True):
    for (i, j) in enumerate(x):
      if j % 2 == 1:
        return s
      x[i] = j / 2
    s = s + 1

print(func(x))

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

while all(i % 2 == 0 for i in a):
    a = list(map(lambda x: int(x/2), a))
    cnt += 1

print(cnt)