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):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''

def main2():
    stdin = open('/dev/stdin')
    stdin.readline()
    ans = 100
    for c in map(int, stdin.readline().split()):
        count = 0
        while c & 1 == 0:
            count += 1
            c >>= 1
        ans = min(ans, count)
    print(ans)

'''

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

operation = 0

while(True):
    odd_flag = False
    for i in range(0,n):
        if a[i] % 2 != 0:
            odd_flag = True
        else:
            a[i] = a[i] / 2
    if odd_flag == True:
        break
    operation += 1
print(operation)

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

ans = float('inf')
for i in b:
  ans = min(ans,len(bin(i)) - bin(i).rfind('1') - 1)
print(round(ans))

Solution (Python):

def main():
	N = int(input().strip())
	alist = list(map(int,input().strip().split()))

	countmin = 10000
	for i in range(len(alist)):
		ai = alist[i]
		count = 0
		while ai%2==0:
			ai = ai/2
			count = count+1

		if count<countmin:
			countmin = count

	print(countmin)

if __name__ == "__main__":
    main()

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

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()))
count = [0]*n

for i in range(n):
    while a[i] % 2 == 0 and a[i] != 0:
        count[i] += 1
        a[i] /= 2

print(min(count))

Solution (Python):
N = int(input())
list = list(map(int,input().split()))
list2 = []
count = 0
for i in list:
    count = 0
    while i % 2 ==0:
        count += 1
        i = i / 2
    j = count
    list2.append(j)

print(min(list2))

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

Solution (Python):

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

iteral = 0
odd = 0
while True:
    for i in range(N):
        if A[i] % 2 != 0:
            odd += 1
        A[i] /= 2

    if odd != 0:
        break

    iteral += 1

print(iteral)

Solution (Python):
n = input()
l = input().split()
m = []
for a in l:
    a = int(a)
    c = 0
    while a % 2 == 0:
        a = a / 2
        c = c + 1
    m.append(c)
d = m[0]
for b in m:
    if b < d:
        d = b
    else:
        pass
print(d)

Solution (Python):
n = input()
l = input().split()
m = []
for a in l:
    a = int(a)
    c = 0
    while a % 2 == 0:
        a = a / 2
        c = c + 1
    m.append(c)
d = m[0]
for b in m:
    if b < d:
        d = b
    else:
        pass
print(d)

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

Solution (Python):


def main():

    N = int(input())
    numsList = [i for i in map(int,input().split())]
    for i in numsList:
        if i%2 != 0:
            print(0)
            exit()

    flag = True
    ans = 0

    while(flag):
        numsList = [ i//2 for i in numsList]        
        for target in numsList:
            if target%2 != 0:
                flag = False
                break
        ans += 1
    
    print(ans)




if __name__== "__main__":
    main()

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

n=int(input())
a=map(int,input().split())
print(min(map(how_many_times,a)))

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

while(True):
    for num in nums:
        flag = flag and (num%2==0)
    if flag:
        count += 1
        nums = list(map(lambda x:x//2, nums))
    else:
        break

print(count)

Solution (Python):


cnt = input()
nums = list(map(int, input().split()))


def evens(arr):
    ans = [0 for i in arr if i % 2 == 1]
    return len(ans) == 0


cnt = 0
while evens(nums):
    for i, obj in enumerate(nums):
        nums[i] = obj / 2
    cnt += 1
print(cnt)

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

for n in range(N):
    d = 0
    a = a_arr[n-1]
    while a%2 == 0:
        d+=1
        a/=2
    div_nums.append(d)

print(min(div_nums))

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

while True:
    for i in range(N):
        if A[i] % 2 != 0:
            print(counter)
            exit()
        A[i] = A[i] // 2
    counter += 1

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

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

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

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

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

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

Solution (Python):
import math

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

count=0

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


    
print(count)

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

cnt = 0
while True:
    if n == sum(1 if x % 2 == 0 else 0 for x in a):
        a = list(map(lambda x: x//2, a))
        cnt += 1
    else:
        break
print(cnt)

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

Solution (Python):
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):
import numpy as np

N = int(input())
a = np.array(list(map(int,input().split())))
count = 0
flag = 0
while True:
    for i in range(N):
        if a[i]%2 == 1:
            flag = 1
            continue;
    if flag == 1:
        break;
    else:
        count += 1
        a = a/2
print(count)

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

Solution (Python):
s = [list(map(int,input().split())) for i in range(2)]
nums = s[0][0]

a = 0
check = True
while check:
  for i in range(nums):
    if s[1][i] % 2 != 0:
      check = False
      break
  if check:
    for l in range(len(s[1])):
      s[1][l] /= 2
    a += 1
print(a)

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

Solution (Python):

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


counter = 0
while sum([e < 2 for e in A]) == 0:
    if sum([e % 2 for e in A]) == 0:
        counter += 1
        A = [e // 2 for e in A]
    else:
        break
    

print(counter)

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

Solution (Python):
n = int(input())
x1 = input().split()
x2 = [int(i) for i in x1]

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

print(y)

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

Solution (Python):
def checkEven(lst):
    for i in range(len(lst)):
        if lst[i]%2 != 0:
            ans = False
            break
    else:
        ans = True
    return(ans)

n = int(input())
lst = list(map(int, input().split()))
cnt = 0
while checkEven(lst) == True:
    cnt += 1
    lst = [lst[i]*0.5 for i in range(n)]
print(cnt)

Solution (Python):
n = int(input())
a = input().split()
odd = 0
count = 0
while odd == 0:
    for k in range(n):
        if int(a[k]) % 2 ==1:
            odd = 1
        else: 
            a[k] = int(a[k]) / 2
    count+=1

count-=1
    
print(count)

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

counts = []
for i in range(n):
    num = nums[i]
    count = 0
    while True:
        k = num % 2
        if k == 0:
            count += 1
            num //= 2
        else:
            break
    counts.append(count)
print(min(counts))

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

count = 0
while True:
    exist_odd = False
    for a in A:
        if a % 2 == 1:
            exist_odd = True

    if exist_odd:
        break
    else:
        A = [a // 2 for a in A]
        count += 1

print(count)

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

Solution (Python):
from collections import defaultdict, Counter
from heapq import heapify, heappop, heappush
from sys import stdin

def main():
    N = int(input())
    A = [int(x) for x in input().split()]
    cnt = 0
    while True:
        loop = True
        for i in range(N):
            if A[i] % 2 == 1:
                loop = False
                break
            A[i] /= 2
        if not loop:
            break
        cnt += 1
    print(cnt)

input = lambda: stdin.readline().rstrip()
main()

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

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

i=0
while sum(a)%2==0:
    end=False

    for x in a:
        if x%2!=0:
            end=True
            break

    if end: 
        break
        
    a=list(map(lambda x: x/2, a))
    i+=1

print(i)

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

count = 0
while not any([i % 2 for i in l]):
    count += 1
    l = tuple(map(lambda x: x / 2, l))
print(count)

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

def even_check(A):
    cnt = 0
    for i in range(N):
        if A[i]%2 == 0:
            cnt += 1
    if cnt == N:
        return True

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

print(total_cnt)

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

Solution (Python):
def mission(a, n):
    fail = False
    b = []
    for x in range(n):
        if a[x] % 2 == 1:
            fail = True
        b.append(a[x] / 2)
    if fail:
        return 0
    else:
        return 1 + mission(b, n)



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

Solution (Python):
import numpy as np
n = input()
ans = 100000000
arr = list(map(int,input().split()))
for a in arr:
    ind = 1
    while (True):
        if a%(2**ind) == 0:
            ind += 1
        else:
            break
    ind -= 1
    if ind < ans:
        ans = ind

print(ans)

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

k=0
flag=False
while True:
    for aa in a:
        if int(aa) % 2**k != 0:
            flag = True
            break


    if flag:
        break
    k += 1

print(k-1)

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

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

Solution (Python):

N = int(input())
x = [0] * N
x=map (int, input().split(' '))


def check(x, count):
    n=[]
    for d in x:
        if d%2 != 0:
            print(count)
            return False
        n.append(d/2)
    count+=1 
    check(n, count)
    
    

check(x, 0)

Solution (Python):
n = input()
a = list(map(int, input().split()))
 
counter = 0
while sum(list(map(lambda x: x % 2, a))) == 0:
    a = list(map(lambda x: x / 2, a))
    counter += 1
 
print(counter)

Solution (Python):
def count_factors(num, fact):
  if num % fact != 0:
    return 0
  return 1 + count_factors(num // fact, fact)

input()
nums = [int(tok) for tok in input().split()]
print(min(map((lambda n : count_factors(n, 2)), nums)))

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

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

ans=0
flag=0
while True:
    for i,a in enumerate(A):
        if a%2:
            flag=1
            break
        A[i]=int(a/2)
    if flag:
        break
    ans+=1
print(str(ans))