Your task is to form an integer array nums from an initial array of zeros arr that is the same size as nums.
Return the minimum number of function calls to make nums from arr.
The answer is guaranteed to fit in a 32-bit signed integer.
 
Example 1:
Input: nums = [1,5]
Output: 5
Explanation: Increment by 1 (second element): [0, 0] to get [0, 1] (1 operation).
Double all the elements: [0, 1] -> [0, 2] -> [0, 4] (2 operations).
Increment by 1 (both elements)  [0, 4] -> [1, 4] -> [1, 5] (2 operations).
Total of operations: 1 + 2 + 2 = 5.

Example 2:
Input: nums = [2,2]
Output: 3
Explanation: Increment by 1 (both elements) [0, 0] -> [0, 1] -> [1, 1] (2 operations).
Double all the elements: [1, 1] -> [2, 2] (1 operation).
Total of operations: 2 + 1 = 3.

Example 3:
Input: nums = [4,2,5]
Output: 6
Explanation: (initial)[0,0,0] -> [1,0,0] -> [1,0,1] -> [2,0,2] -> [2,1,2] -> [4,2,4] -> [4,2,5](nums).

Example 4:
Input: nums = [3,2,2,4]
Output: 7

Example 5:
Input: nums = [2,4,8,16]
Output: 8

 
Constraints:

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

Difficulty: interview

Starter code:

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        

Solutions:
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(x).count('1') for x in nums)+len(bin(max(nums)))-3


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        add_count = sum(bin(v).count('1') for v in nums)
        mul_count = len(bin(max(nums))) - 3
        
        return add_count + mul_count
    
    def minOperations_my(self, nums: List[int]) -> int:
        add_sum = mul_maxi = 0
        for value in nums:
            c1 = c2 = 0
            while value > 1:
                if value & 1:
                    c1 += 1
                c2 += 1
                value >>= 1
            
            add_sum += c1 + value
            mul_maxi = max(mul_maxi, c2)
        
        return add_sum + mul_maxi


class Solution:
    def minOperations(self, nums: List[int]) -> int:
#         The number of operation 0 equals to the total number of bits \"1\".
#         The number of operation 1 equals to maximum bit length - 1.
        
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3
        
        # notfinish = True
        # count = 0
        # while notfinish:
        #     notfinish = False 
        #     for i,n in enumerate(nums):
        #         if n%2:
        #             nums[i] = (nums[i]-1)//2
        #             count += 1
        #             if nums[i]>0:
        #                 notfinish = True
        #         elif nums[i]>0:
        #             nums[i] = nums[i]//2
        #             notfinish = True
        #     if notfinish:
        #         count += 1
        #     print(nums,count)
        # return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        #make every element 1
        m = [bin(x)[2:].zfill(32) for x in nums]
        ret = 0
        #print(m)
        for i in range(32):
            #looking at the first digit. how many of you have it set to 1?
            cnts = sum([1 if x[i] == '1' else 0 for x in m])
            #print(\"%d: %d\" % (i, cnts))
            ret += cnts
            if ret > 0:
                ret += 1
                pass
            pass
        return ret - 1
        #first, remove 


class Solution:
    def minOperations(self, a: List[int]) -> int:
        ans=0
        mx=0
        for x in a:
            cnt=0
            while x:
                if x%2:
                    ans+=1
                cnt+=1
                x//=2
            mx=max(mx,cnt)
        # print(ans,mx)
        return max(ans+mx-1,0)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def highestBit(x):
            i = 0
            while x:
                i += 1
                x = x >> 1
            return i
        def numberOfBits(x):
            i = 0
            while x:
                i += 1
                x = x & (x-1)
            return i
        doublings = max(map(highestBit,nums))
        print(doublings)
        adds = sum(map(numberOfBits,nums))
        print(adds)
        return doublings-1 + adds

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        max_num = 0
        
        for n in nums:
            max_num = max(max_num, n)
            while n > 0:
                # drop lowest bit
                n = n & (n - 1)
                ops += 1
        
        while max_num > 1:
            max_num >>= 1
            ops += 1
        
        return ops


class Solution:
    def minOperations_1(self, nums: List[int]) -> int:
        '''        
        Instead of trying to go from 0 array to nums,
        go from nums to 0 array, decrement index by 1
        divide all elements by 2 if divisible by 2
        
        Nevermind this isn't DP, do greedy, divide by
        2 as much as possible then decrement indexes by 1
        
        Repeat until everything is divisble by 2 again
        
        Runtime?
        
        O(3n) inner loop, 32 times outer loop because
        divison by 2 happens frequently which shifts
        '''
        ops = 0
        while not all(n == 0 for n in nums):
            for i, n in enumerate(nums):
                if n % 2 != 0:
                    nums[i] = n - 1
                    ops += 1
            
            if all(n == 0 for n in nums):
                break
            
            nums = [n // 2 for n in nums]
            ops += 1
        
        return ops
    
    def minOperations_2(self, nums: List[int]) -> int:
        '''
        More efficient way to do this:
        
        Loop through the numbers individually, count
        the number of times you have to subtract 1 and divide
        by 2. Add 1's to total but only take the maximum number
        of times to divide by 2 since division affects everything
        and so only the largest number of divisions gets taken
        into account
        
             24 2 5 
        
        ones  2 1 2
        
        twos  4 1 2
        
        5 + max(twos) = 9
        '''
        op_1 = 0
        op_2 = 0
        for n in nums:
            op_2_cur = 0
            while n > 0:
                if n % 2 != 0:
                    op_1 += 1
                    n -= 1
                else:
                    op_2_cur += 1
                    n = n // 2
            
            op_2 = max(op_2, op_2_cur)
        
        return op_1 + op_2
    
    
    def minOperations(self, nums: List[int]) -> int:
        '''
        Bit Manipulation Solution (Most Efficient)
        
        Multiplying by 2 is equivalent to bit shift to left by 1
        Likewise divide by 2 is equivalent to bit shift to right by 1
        
        Using this knowledge, the highest leftmost bit will determine
        how many divide by 2 operations we have to perform
        
        24
        
        11000 => 4 operations
        
        The number of 1's in the number determine the number of 1 operations
        to perform
        
        24
        11000 => 2 operations
        
        We loop from bit to bit to avoid the max comparison operation
        
        O(32n) Time, O(1) Space
        
        -----------------------------------------
        
        (n & (1 << i)) != 0
        
        Gets bit at index i in the number

        Ex. Get index 4

          4 3 2 1 0

          1 1 0 0 0
        & 1 0 0 0 0
        -----------
          1 0 0 0 0

        Final result not 0 so index 4 must've been a 1
        
          4 3 2 1 0

          0 1 0 0 0
        & 1 0 0 0 0
        -----------
          0 0 0 0 0
          
        If index 4 was 0 then result would be all 0's
        '''
        op1 = 0
        op2 = 0
        for i in range(31):
            for n in nums:
                if (n & (1 << i)) != 0:
                    op1 += 1
                    op2 = i
        
        return op1 + op2
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        addOneOperations = 0 # +1 operations
        highestSetBit = 0 # *2 operations
        for bit in range(31):
            for num in nums:
                if num & (1 << bit) != 0:
                    addOneOperations += 1
                    highestSetBit = bit
        return addOneOperations + highestSetBit


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if nums == [0]: return 0
        count = 0
        max_bits = 0
        for n in nums:
            bits = 0 
            while n:
                count += n & 1
                bits += 1
                n >>= 1
            max_bits = max(max_bits, bits)
        return count + max_bits - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        add_sum = mul_maxi = 0
        for value in nums:
            c1 = c2 = 0
            while value > 1:
                if value & 1:
                    c1 += 1
                c2 += 1
                value >>= 1
            
            add_sum += c1 + value
            mul_maxi = max(mul_maxi, c2)
        
        return add_sum + mul_maxi


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        hb = 0
        ans = 0
        for n in nums:
            for i in range(32):
                if n&(1<<i):
                    ans+=1
                    if i>hb:
                        hb = i
        return ans+hb

import collections

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        sum = 0
        for num in nums:
            sum += collections.Counter(bin(num))['1']
            
        sum += len(bin(max(nums))) - 3
        return sum


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def n1b(x):
            ans = 0
            while x:
                x &= (x-1)
                ans += 1
            return ans
        
        def hi(x):
            ans = 0
            while x:
                x >>= 1
                ans += 1
            return ans
        
        maxshift = 0
        tog = 0
        for n in nums:
            maxshift = max(maxshift, hi(n))
            tog += n1b(n)
        
        maxshift = max(0, maxshift-1)
        return maxshift + tog

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        x = [0]*len(nums)
        counts = 0
        while(1):
            counts += sum(n%2 for n in nums)
            nums = [n//2 for n in nums]
            if (nums == x):
                return counts
            counts += 1
            
                    
                    
        
        
        
        
        
        
        def div(l):
            for i in range(len(l)):
                    if (sum(l)==0):
                        return None
                    l[i] *= 2
            return l
        
        
        def mi(l):
            for i in range(len(l)):
                    l[i] += 1
            return l
        
        
        q = deque()
        
        q.append([0]*len(nums))
        d = 0;
        while q:
            d+=1
            for i in range(len(q)):
                x  = q.popleft()
                j = x.copy()
                print(x)
                if (x == nums):
                    return d;
                y=  div(j)
                if (y != None):
                    q.append(y)
                q.append(mi(x))
            
            
            
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        a = m = 0
        for i in nums:
            a += bin(i).count('1')
            m = max(m, len(bin(i)) - 3)
        return a + m

import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_half_ops = 0

        def find_odd_ops_req(num):
          nonlocal max_half_ops
          result = 0
          half_ops = 0
          while(num):
            result += num & 1
            half_ops += 1
            num = num >> 1
          max_half_ops = max(max_half_ops, half_ops - 1)
          return result
          
        result = 0
        for num in nums:
          result += find_odd_ops_req(num)
        return result + max_half_ops


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if nums == [0]:
            return 0
        count = 0
        max_bits = 0
        for n in nums:
            bits = 0
            while n:
                count += n & 1
                bits += 1
                n >>= 1
            max_bits = max(max_bits, bits)
        return count + max_bits - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n_add, n_mul = 0, 0
        for num in nums:
            c_mul = 0
            while num > 1:
                n_add += num % 2
                num //= 2
                c_mul += 1
            if num == 1:
                n_add += 1
            n_mul = max(n_mul, c_mul)
        return n_add + n_mul
                
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        return sum(bin(x).count('1') for x in nums) + len(bin(max(nums))) - 3
        
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op_0, op_1 = 0, 1
        for num in nums:
            b_len = 0
            while num:
                op_0 += num & 1
                num >>= 1
                b_len += 1
            op_1 = max(op_1, b_len)
        return op_0 + op_1 - 1
    
                
                


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # 4,2,5->2,1,2->2,0,2->1,0,1
        # 1,5->1,4->1,2->1,1
        # 2,4,8,16->1,2,4,4->
        count = max([int(math.log(x)/math.log(2)) for x in nums if x > 0])
        for n in nums:
            while (n):
                if n % 2:
                    count += 1
                    n -= 1
                else:
                    n //= 2
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxTwos = 0
        ones = 0
        for num in nums:
            count, left = self.getCount(num)
            maxTwos = max(maxTwos, count)
            ones += left
        return ones + maxTwos
    
    def getCount(self, num):
        count = 0
        odd = num % 2
        if num % 2 == 1:
            num -= 1
        while num > 1:
            odd += num % 2
            num //= 2
            count += 1
        return count, num + odd

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans, largest = 0, 0
        for num in nums:
            largest = max(largest, num)
            while num > 0:
                if num % 2 == 1:
                    num -= 1
                    ans += 1
                if num > 0:
                    num = num // 2
        while largest > 1:
            ans += 1
            largest = largest // 2
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2: # odd number, just delete 1 so that it's now a multiple of 2
                    n -= 1
                    ones += 1
                else: # multiple of 2, so just divide by 2 
                    n //= 2
                    mul += 1
            twos = max(twos, mul)
        return ones + twos

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2:
                    n -= 1
                    ones += 1
                else:
                    n //= 2
                    mul += 1
            twos = max(twos, mul)
        return ones + twos

class Solution:
  def minOperations(self, nums: List[int]) -> int:
    # TC: O(NlogM), SC: O(1), n = len(nums), m = max(nums)
    def numOperations(x):
      # TC: O(logX)
      n1, n2 = 0, 0
      while x:
        if x & 1:
          n1 += 1
          x -= 1
        else:
          n2 += 1
          x //= 2
      return n1, n2
    # operation -1 is self, //2 is shared.
    n1, n2 = 0, 0
    for x in nums:
      x1, x2 = numOperations(x)
      n1 += x1
      n2 = max(n2, x2)
    return n1 + n2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones = 0
        twoes = 0
        
        for i in nums:
            c = 0
            while i:
                if i%2:
                    i-=1
                    ones+=1
                else:
                    i //=2
                    c+=1
            twoes = max(twoes,c)
            
        return ones+twoes
                
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def operate(n):
            max_ = 0
            ans = 0
            k = 0
            while n>0:
                k += 1
                ans += n%2
                n = n//2
            max_ = max(max_,k-1)
            return max_, ans
        
        ans = 0
        max_ = 0
        for n in nums:
            m, o = operate(n)
            #print(m,n,o)
            max_ = max(max_,m)
            ans += o
            
        return ans+max_

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxTwos = 0
        totalOnes = 0
        for num in nums:
            twos, ones = self.getCount(num)
            maxTwos = max(maxTwos, twos)
            totalOnes += ones
        return totalOnes + maxTwos
    
    def getCount(self, num):
        twos = 0
        ones = 0
        while num > 1:
            ones += num % 2
            num //= 2
            twos += 1
        return twos, ones + num
    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # number of operation 1 (multiply by 2) is the length of bin(num)
        # number of operation 0 (increment by 1) is the number of 1 in bin(num)
        return sum(bin(num).count('1') for num in nums) + len(bin(max(nums))) - 3 # why 3, bin() function return a string leading by 0b10= => 4

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        totOddRem = 0
        max2Power = 0
        for x in nums:
            pow2 = 0
            while True:
                totOddRem += x & 1
                if x > 1:
                    pow2 += 1
                    x >>= 1
                else:
                    break
            if pow2 > max2Power:
                max2Power = pow2
        return totOddRem + max2Power

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            ans += sum(n % 2 for n in nums)
            if any(n > 1 for n in nums):
                ans += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return ans
                
                
                    
        
                
            
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxLmove, bitCount = 0,0
        for num in nums:
            if num == 0:
                continue
            Lmove = 0
            while num != 0:
                if num&1:
                    bitCount += 1
                num = num >> 1
                if num != 0:
                    Lmove += 1
            maxLmove = max(maxLmove, Lmove)
        return maxLmove + bitCount

class Solution:
    # mine
    def minOperations0(self, nums: List[int]) -> int:        
        l = len(nums)
        ans = 0
        
        def turnEven():
            nonlocal ans
            for i in range(l):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ans += 1
                    
        def countZero():
            count = 0
            for n in nums:
                if n == 0:
                    count += 1
            return count                    
                
        while True:
            turnEven()
            if countZero() == l:
                return ans
            for i in range(l):
                nums[i] //= 2
            ans += 1
                
    # copied https://leetcode.com/problems/minimum-numbers-of-function-calls-to-make-target-array/discuss/805740/JavaC%2B%2BPython-Bit-Counts
    # 其实思路跟上面是一样的
    def minOperations(self, nums: List[int]) -> int: 
            res = 0
            maxLen = 1
            for n in nums:
                bits = 0
                while n > 0:
                    res += n & 1
                    bits += 1
                    n >>= 1
                maxLen = max(maxLen, bits)
            return res + maxLen - 1
                


class Solution:
  def minOperations(self, nums: List[int]) -> int:
    # TC: O(NlogM), SC: O(1), n = len(nums), m = max(nums)
    def numOperations(x):
      # TC: O(logX)
      n1, n2 = 0, 0
      while x:
        if x & 1:
          n1 += 1
          x -= 1
        else:
          n2 += 1
          x >>= 1
      return n1, n2
    # operation -1 is self, //2 is shared.
    n1, n2 = 0, 0
    for x in nums:
      x1, x2 = numOperations(x)
      n1 += x1
      n2 = max(n2, x2)
    return n1 + n2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        totOddRem = 0
        max2Power = 0
        
        for x in nums:
            pow2 = 0
            while True:
                totOddRem += x & 1
                if x > 1:
                    pow2 += 1
                    x >>= 1
                else:
                    break
                
            max2Power = max(max2Power, pow2)
                
        
        
        
        
        return totOddRem + max2Power

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        maxi = 0
        for num in nums:
            res += 1 if num > 0 else 0
            div = 0
            while num > 1:
                res += 1 if num%2 else 0
                num //= 2
                div += 1
            maxi = max(div, maxi)
        return res+maxi



def val(n):
    c = 0
    while(n>1):
        if n%2 == 1:
            c +=1
            n -=1
        else:
            n = n//2
            # c += 1
    return c

def ma(n):
    c = 0
    while(n>1):
        if n%2 == 1:
            # c +=1
            n -=1
        else:
            n = n//2
            c += 1
    return c

class Solution:
    def minOperations(self, n: List[int]) -> int:
        c = ma(max(n))
        
        for i in range(len(n)):
            if n[i]>0:
                c += val(n[i])+1
        
        return c

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2:
                    n-=1
                    ones+=1
                else:
                    n//=2
                    mul+=1
            twos = max(twos, mul)
        return ones + twos

        
# class Solution:
#     def minOperations(self, nums: List[int]) -> int:
#         twos = 0
#         ones = 0
#         for n in nums:
#             mul = 0
#             while n:
#                 if n%2: # odd number, just delete 1 so that it's now a multiple of 2
#                     n -= 1
#                     ones += 1
#                 else: # multiple of 2, so just divide by 2 
#                     n //= 2
#                     mul += 1
#             twos = max(twos, mul)
#         return ones + twos


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        #m = max(nums)
        highest_bit = 0
        addone = 0
        for num in nums:
            tmp = -1
            while num > 0:
                addone += num & 1
                num >>= 1
                tmp += 1
            highest_bit = max(highest_bit, tmp)
        return highest_bit + addone


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # find number of set bits in all numbers
        # find offset of highest number
        if max(nums) == 0: return 0
        return sum(map(lambda x: bin(x).count('1'), nums)) + int(log2(max(nums)))

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op0 = 0
        op1 = 0
        for n in nums:
            l = 0
            while n > 0:
                l += 1
                if n % 2 == 1: op0 += 1
                n //= 2
            op1 = max(op1, l-1)
        return op0 + op1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            ans += sum(num % 2 for num in nums)
            if any(num > 1 for num in nums):
                ans += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return ans
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        two,one = 0,0
        for n in nums:
            mul = 0
            while n :
                if  n%2 :
                    one += 1
                    n -= 1
                else:
                    mul += 1
                    n //= 2 
            two = max(two,mul)
        return one+two

    # @lru_cache(None)
    # def minOperations(self, nums: List[int]) -> int:
    #     return 0
    #     return self.helper(nums,-1,-1)
    # def helper(self, nums: List[int],op ,idx ) -> int:
    #     if op == 0:
    #         nums[idx] += 1
    #     elif op == 1:
    #         for i in range(len(nums)):
    #             nums[i] *= 2
    #     print(min([min(self.helper(nums,0,i),self.helper(nums,1,-1)) for i in range(len(nums))]))
    #     # return min([min(self.minOperations(nums,0,i),self.minOperations(nums,1,-1)) for i in range(len(nums))])
    #     return 0



class Solution:
    def minOperations(self, nums: List[int]) -> int:
        mx = 1
        ops = 0
        for nm in nums:
            bt = 0
            while nm > 0:
                ops += (nm & 1)
                bt +=1
                nm = (nm >> 1)
            mx = max(mx, bt)
        return ops + mx - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2:
                    n-=1
                    ones+=1
                else:
                    n//=2
                    mul +=1
            twos = max(twos, mul)
        return ones+twos
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def ops(num):
            plus = 0
            mult = 0
            while num:
                if num % 2:
                    plus += 1
                    num -= 1
                else:
                    num //= 2
                    mult +=1
            return plus, mult
    
        plus = 0
        mult = 0
        for num in nums:
            plus_, mult_ = ops(num)
            plus += plus_
            mult = max(mult, mult_)
        return plus + mult
                
           
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        total = 0
        currentMax = 0
        for n in nums:
            if n == 0:
                continue 
            total += 1
            count = 0
            while n > 1:
                if n % 2 == 1:
                    n -= 1
                    total += 1
                n = n //2
                count += 1
            
            currentMax = max(count, currentMax)
        return total + currentMax
            
                
        
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def calculate(num):
            temp1=0
            temp2=0
            while num:
                if num%2:
                    temp1+=1
                    num-=1
                else:
                    temp2+=1
                    num>>=1
            
            return temp1,temp2
                
        
        
        
        
        ones,twos=0,0
        for val in nums:
            if val:
                a,b=calculate(val)
                ones+=a
                twos=max(twos,b)
        print(ones)
        return ones+twos


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            ans += sum(n % 2 for n in nums)
            if any(n > 1 for n in nums):
                ans += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return ans     


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        total = 0
        currentMax = 0
        for n in nums:
            if n == 0:
                continue 
            total += 1
            count = 0
            if n % 2 == 1 and n > 1:
                total += 1
                n -= 1
            while n > 1:
                if n % 2 == 1:
                    n -= 1
                    total += 1
                n = n //2
                count += 1
                #print(f\"count{count} n{n}\")
            
            currentMax = max(count, currentMax)
        #print(f\"currentMax : {currentMax} total {total}\")
        return total + currentMax
            
                
        
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            ans += sum(n % 2 for n in nums) #Count of the +1 ops
            if any(n > 1 for n in nums): #Count of the mul by 2 ops
                ans += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return ans

class Solution:
    
    def calc(self, num):
        m=0
        a=0
        while num>0:
            if num&1:
                a+=1
                num-=1
            else:
                num=num>>1
                m+=1
        return a,m
    def minOperations(self, nums: List[int]) -> int:
        adds=0
        mults=0
        for i in range(len(nums)):
            a,m = self.calc(nums[i])
            if mults<m:
                mults=m
            adds+=a
        
        return mults+adds

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cache = defaultdict(int)
        for i in nums:
            for ind, j in enumerate(bin(i)[2:][::-1]):
                if j == '1':
                    cache[ind] += 1
        return sum(cache.values()) + max(cache.keys())
        # result = 0
        # max_digit = max(cache.keys())
        # for i in range(max_digit + 1):
        #     result += cache[i] + 1
        # return result - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op = 0
        s = sum(nums)
        while (s):
            odd_ct = len([0 for n in nums if (n & 1)])
            op += odd_ct
            s -= odd_ct
            if s != 0:
                nums = [n//2 for n in nums]
                op += 1
                s /= 2
        return op

from collections import Counter

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_doubles = 0
        increments = 0

        counts = Counter(nums)
        for n, c in counts.items():
            if n == 0:
                continue
            doubles = 0
            while n:
                if n % 2 == 1: # odd
                    increments += c
                    n -= 1
                else:
                    doubles += 1
                    n //= 2
            max_doubles = max(max_doubles, doubles)

        return increments + max_doubles

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        div_arr,sub_arr=[],[]
        
        for n in nums:
            div=0
            sub=0
               
            while n:
                
                if n%2==1:
                    n-=1
                    sub+=1
                else:
                    n=n//2
                    div+=1
                    
            sub_arr.append(sub)
            div_arr.append(div)
            
            
        #print(sub_arr,div_arr)
        
        return max(div_arr) + sum(sub_arr) 


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        
        while any(n > 0 for n in nums):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    count += 1
            if all(n == 0 for n in nums):
                break
            nums = [n // 2 for n in nums]
            count += 1
        
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def countBit(num) :
            count, highbit = 0, 0
            while num > 0:
                highbit += 1
                if num % 2 == 1:
                    count +=  1
                num //= 2
            return count, highbit
                
            
        nums = sorted(nums)
        last={}
        sum = 0
        maxDouble = 0
        for num in nums:
            if num == 0 :
                continue
            elif num in last:
                sum += last[num]
            else:
                count, highbit = countBit(num)
                maxDouble = max(maxDouble, highbit)
                sum += count
                last = {num: count}
        
        print (sum, maxDouble)
        if maxDouble == 0:
            return 0
        return sum + maxDouble - 1

import math

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones,co,twos = 0,0,0
        for xx in nums:
            x,c = 0,0
            while xx > 1:
                co += xx&1
                xx //= 2
                c += 1
            x = int(floor(math.log(max(xx,1),2)))
            twos = max(twos,x+c)
            ones += max((xx-2**x),0)
            if xx >= 1:
                ones += 1
        return ones + twos + co
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums); res = 0
        while any(v > 0 for v in nums):
            for i, v in enumerate(nums):
                if v & 1:
                    res += 1
                nums[i] >>= 1
            res += 1
        return res - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        multi_max = 0
        answer = 0
        for num in nums:
            cur_multi = 0
            while(num):
                if num % 2 == 1:
                    answer += 1
                    num -= 1
                else:
                    cur_multi += 1
                    num //= 2
            multi_max = max(multi_max, cur_multi)
        return answer + multi_max
        # answer = 0
        # max_num = 0
        # for num in nums:
        #     small = int(math.log(num, 2))
        #     max_num = max(small, max_num)
        #     answer += num - 2**small + 1
        # print(max_num)
        # return answer + max_num


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if not nums:
            return 0
        ans, nxt = 0, []
        for num in nums:
            if num & 1:
                num -= 1
                ans += 1
            if num:
                nxt.append(num // 2)
        if nxt:
            ans += 1
        # print(ans, nxt)
        return ans + self.minOperations(nxt)
    
                
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n_add = 0
        n_mul = 0
        for n in nums:
            mul = 0
            while n > 0:
                if n % 2:
                    n -= 1
                    n_add += 1
                else:
                    mul += 1
                    n //= 2
            n_mul = max(n_mul, mul)
        return n_add + n_mul

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        count = 0
        res = 0
        double = 0
        
        for i in nums:
            count = 0
            while i:
                if i%2 == 1:
                    i-=1
                    res+=1
                else:
                    i//=2
                    count+=1
            double= max(double, count)
        
        return res+double

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones=0
        maxlen=0
        binlen=0
        for num in nums:
            binlen=0
            while num!=0:
                if num%2!=0:
                    ones+=1
                    num-=1
                    
                if num!=0:
                    num//=2
                    binlen+=1
            maxlen=max(maxlen,binlen)
            
        return maxlen+ones
        
        
#         op=0
#         sum1=sum(nums)
#         while sum1!=0:
#             for i in range(len(nums)):
#                 if nums[i]%2!=0:
#                     nums[i]-=1
#                     sum1-=1
#                     op+=1
                    
#             if sum1==0:
#                 return op
            
#             for i in range(len(nums)):
#                 nums[i]//=2
#             op+=1
#             sum1/=2
            
#         return op


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        num = max(nums)
        res = 0

        for i in range(n):
            if nums[i] == 0:
                continue
                
            res += 1
            num = nums[i]
            while num > 1:
                res += num % 2
                num //= 2
    
        c = 0
        num = max(nums)
        while num > 1:
            num //= 2
            res += 1
        return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def calc(num):
            tmp = 1
            ans = [0, 0]
            count = 0
            while tmp <= num:
                if (tmp&num) != 0:
                    ans[0] += 1
                count += 1
                tmp <<= 1
            ans[1] = count-1
            return ans
        result = 0
        tt = 0
        for num in nums:
            r = calc(num)
            result += r[0]
            tt = max(tt, r[1])
        result += tt
        return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        maxt = 0
        for i in nums:
            if i == 0: continue
            t = 0
            while i > 0:
                if i & 1:
                    i -= 1
                    ans += 1
                else:
                    i >>= 1
                    t += 1
            maxt = max(maxt, t)
        ans += maxt
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0
        max_len = 0
        for num in nums:
            b = bin(num)
            result += b.count('1')
            max_len = max(max_len, len(b))
        return result + max_len - 3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        doubles = 0
        incs = 0
        
        for num in nums:
            numDoubles = 0
            while num > 0:
                if num%2 == 0:
                    num //= 2
                    numDoubles += 1
                else:
                    num -= 1
                    incs += 1
            doubles = max(doubles, numDoubles)
        
    
        return doubles + incs

class Solution:
    def minOpsSingle(self, x):
        n_inc = 0
        n_db = 0
        assert(x >= 0)
        while x > 0:
            if x % 2 == 0:
                x = x // 2
                n_db += 1
            else:
                x -= 1
                n_inc += 1
        return (n_inc, n_db)
    
    def minOperations(self, nums: List[int]) -> int:
        tot_inc = 0
        tot_db = 0
        for n in nums:
            x,y = self.minOpsSingle(n)
            tot_inc += x
            tot_db = max(tot_db, y)
        return tot_inc + tot_db

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while not all(ele < 2 for ele in nums):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    count += 1
                    
                nums[i] //= 2
            count += 1
            
        count += sum(ele == 1 for ele in nums)
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # this is a bit operation question
        # trick is to realize that largest number is number of * 2 operations
        
        multiply = 0 
        add = 0 
        
        for num in nums:
            mask = 1
            for i in range(32):
                if mask << i & num:
                    multiply = max(i, multiply)
                    add += 1 
                    
        return multiply + add 

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # this is a bit operation question
        # trick is to realize that largest number is number of * 2 operations
        
        multiply = 0 
        add = 0 
        
        for num in nums:
            mask = 1
            for i in range(31):
                if mask << i & num:
                    multiply = max(i, multiply)
                    add += 1 
                    
        return multiply + add 

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        ans = 0
        while True:
            zeros = 0
            ans += 1
            for i, num in enumerate(nums):
                nums[i] = num // 2
                ans += num % 2
                if not nums[i]:
                    zeros += 1
            if zeros == n:
                break
        return ans - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def calcOps(num):
            one = 0
            two = 0
            while num > 0:
                if num%2 == 0:
                    num//=2
                    two+=1
                else:
                    num-=1
                    one+=1
            return [one, two]
        
        one = 0
        two = 0
        for x in nums:
            ops = calcOps(x)
            one += ops[0]
            two = max(two, ops[1])
        return one+two

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        move = 0
        while max(nums) > 0:
            for i,num in enumerate(nums):
                if num%2 == 1:
                    move += 1
                nums[i] = num//2
            if max(nums) > 0:
                move += 1
        return move


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while any(x != 0 for x in nums):
            for i, x in enumerate(nums):
                if x % 2 != 0:
                    nums[i] -= 1
                    res += 1
            if sum(nums) == 0: break
            nums = [x // 2 for x in nums]
            res += 1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def all_zeros(nums):
            for num in nums:
                if num != 0:
                    return False
            return True
        
        def to_all_evens(nums):
            cnt = 0
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    cnt += 1
                    nums[i] -= 1
            return cnt
            
        op_cnt = 0
        while not all_zeros(nums):
            op_cnt += to_all_evens(nums)
            if not all_zeros(nums):
                nums = [x // 2 for x in nums]
                op_cnt += 1
        return op_cnt

class Solution:
    def minOperations(self, a: List[int]) -> int:        
        ans, max_len = 0, 0
        for i, x in enumerate(a):
            b = bin(x)
            ans += b.count('1')         
            max_len = max(max_len, len(b)-2)
        return ans + max_len - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # Greedy
        res = 0
        max_len = 0
        for x in nums:
            bit = 0
            while x > 0:
                if x % 2 == 1:
                    res += 1
                x >>= 1
                bit += 1
            
            max_len = max(max_len, bit)

        return res + max_len - 1
        
        
        
        # TLE
#         n = len(nums)
#         arr = [0] * n
#         self.memo = {}
#         self.helper(nums)
#         # print(self.memo)
#         return self.memo[tuple(nums)]
    
#     def helper(self, nums):
#         if sum(nums) == 0:
#             return 0
#         if tuple(nums) in self.memo:
#             return self.memo[tuple(nums)]
        
#         need = sys.maxsize
#         for i in range(len(nums)):
#             if nums[i] - 1 >= 0:
#                 nums[i] -= 1
#                 need = min(need, self.helper(nums))
#                 nums[i] += 1
                
        
#         all_even = True
#         for x in nums:
#             if x % 2 != 0:
#                 all_even = False
#         if all_even:
#             temp = [x // 2 for x in nums]
#             need = min(need, self.helper(temp))
            
#         res = 1 + need
#         self.memo[tuple(nums)] = res
#         return res


class Solution:
        
    def minOperations(self, nums: List[int]) -> int:
        
        # we need to find out the maximum number of multiplications we need to do
        # how many mul will be required for largest number
        # all other muls can be arranged during the course
        # for ones, just need to make all odd numbers even
        # in every iteration
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2:
                    n -=1
                    ones+=1
                else:
                    n = int(n/2)
                    mul +=1
            twos = max(twos,mul)
        
        return ones + twos
        
              
                    
        


class Solution: 
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0
        max_val, max_index = -1, len(nums)
        for i in range(len(nums)):
            if nums[i] > max_val:
                max_val = nums[i]
                max_index = i

        while(max_val != 0):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    cnt += 1
            max_val = nums[max_index]
            if max_val == 0:
                break
            for i in range(len(nums)):
                nums[i] = nums[i] // 2
            cnt += 1
            max_val = nums[max_index]
        return cnt 
            
                
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt1 = 0 
        maxcnt0 = 0
        for n in nums:
            cnt0 = 0
            while n > 0:
                if n % 2 == 1:
                    n -= 1
                    cnt1 += 1
                else:
                    n //= 2
                    cnt0 += 1
            maxcnt0 = max(cnt0, maxcnt0)

        return maxcnt0 + cnt1

import math

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        arr = nums.copy()
        count = result = 0
        
        while any(arr):
            
            for i, n in enumerate(arr):
                if n & 1:
                    count += 1
                    arr[i] -= 1
                    
            result += count
            arr = [x >> 1 for x in arr]
            count = 0
        
        return result + int(math.log2(max(nums)))

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        c = 0
        while True:
            c0 = 0
            for i in range(len(nums)):
                
                if nums[i]%2 == 1:
                    c+=1
                    nums[i] = (nums[i]-1)//2
                    
                else:
                    nums[i] = nums[i]//2
                    
                if nums[i]==0:
                    c0+=1
                
            if c0==len(nums):
                return c
            else:
                c+=1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def iter_count(x):
            shift_count = sub_count = 0
            
            while x > 0:
                if x&1: 
                    x -= 1
                    sub_count += 1
                else:   
                    x >>= 1
                    shift_count += 1

            return (shift_count, sub_count)
        
        max_shift_count = 0
        total_subs = 0
        
        for x in nums:
            i, j = iter_count(x)
            max_shift_count = max(max_shift_count, i)
            total_subs += j
        
        return max_shift_count + total_subs

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count_of_one_steps = 0
        count_of_half_steps = 0
        for i in nums:
            one_steps = 0
            half_steps = 0
            while i != 0:
                if i %2 == 0:
                    half_steps += 1
                    i //= 2
                else:
                    one_steps += 1
                    i -= 1
            #print(i, one_steps, half_steps)
            count_of_one_steps += one_steps
            count_of_half_steps = max(count_of_half_steps, half_steps)
        return count_of_one_steps + count_of_half_steps     

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def countcall(x,c):
            c0 = 0
            for i in range(len(x)):
                if x[i]%2==1:
                    c+=1
                    x[i] = (x[i]-1)//2
                else:
                    x[i] = x[i]//2
                    
                if x[i]==0:
                    c0+=1
                    
            if c0==len(x):
                return c
            else:
                c+=1
                return countcall(x,c)
        
                
        return countcall(nums,0)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while True:
            for i, x in enumerate(nums):
                if x % 2 != 0:
                    nums[i] -= 1
                    res += 1
            if sum(nums) == 0: break
            nums = [x // 2 for x in nums]
            res += 1
            if sum(nums) == 0: break

        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        x, y = 0, 0
        for num in nums:
            num = format(num, 'b')
            x += num.count('1')
            y = max(y, len(num) - 1)
        
        return x + y

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        '''
        nums = [1,5]
        
        1 -> 1

        5 -> 
             ^^^
        3 + 3 - 1 = 5
        '''
        if nums == [0]:
            return 0
        count = 0
        max_bits = 0
        for n in nums:
            bits = 0
            while n:
                count += n & 1
                bits += 1
                n >>= 1
            max_bits = max(max_bits, bits)
        return count + max_bits - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def check(n):
            N_minus_one = 0
            N_div2 = 0
            while n>0:
                if n%2==0:
                    n = n//2
                    N_div2 += 1
                else:
                    n -= 1
                    N_minus_one += 1
            return N_minus_one,  N_div2
                
        
        N = len(nums)
        minus_one = []
        div2 = []
        for n in nums:
            N_minus_one, N_div2 = check(n)
            minus_one.append(N_minus_one)
            div2.append(N_div2)
            
        res = sum(minus_one)
        res += max(div2)
        print (minus_one)
        print (div2)
        return res
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # After having implemented minOperations_dumb_solution(), we realize that 
        # the number of op 1 we'll need to do is just the number of times we need
        # to divide the max even number we ever encounter to get it down to zero. 
        # Because, a division would reduce everyone by 2 and when the smaller even
        # numbers we see gets down to zero, it will no longer be affected. We only care
        # about dividing the biggest even number down to zero.
        cost = 0
        max_nb_op_1 = 0
        for i in range(len(nums)):
            nb_op_0 = nb_op_1 = 0
            x = nums[i]
            while x > 0:
                if x % 2 != 0:
                    nb_op_0 += x % 2
                    x -= x % 2
                if x > 0:
                    nb_op_1 += 1
                    x = x // 2
            cost += nb_op_0
            max_nb_op_1 = max(max_nb_op_1, nb_op_1)
        cost += max_nb_op_1
        return cost
        
                
                    
        
    def minOperations_dumb_solution(self, nums: List[int]) -> int:

        # Key insight is if nums[i] is odd, there's no way we could have arrived at nums[i]
        # via op 1, i.e. by multiplying by 2 some previous value. So the only way we could
        # have gotten here is by using op 0, nums[i] % 2 times. That is we need to skim off
        # the remainder part that makes it non-even before we can consider using op 1.
        cost = 0
        while True:
            all_zeros = True
            all_evens = True
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                
                all_zeros = False
                if nums[i] % 2 != 0:
                    cost += nums[i] % 2
                    nums[i] = nums[i] - (nums[i] % 2)
                    all_evens = False
            
            if all_zeros:
                break
            while all_evens:
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                    if nums[i] % 2 != 0:
                        all_evens = False
                cost += 1
                
        return cost
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        one = 0
        two = 0
        for n in nums:
            r = self.onetwo(n)
            one += r[0]
            two = max(two, r[1])
        return one + two
    def onetwo(self, n):
        one = 0
        two = 0
        while n != 0:
            if n%2 == 0:
                two += 1
                n >>= 1
            else:
                one += 1
                n -= 1
        return (one, two)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # Backwards!!!!
        # Change nums to arr
        
        step = 0
        
        while True:
            for i in range(len(nums)):
                if nums[i]%2 != 0:
                    nums[i] = nums[i] - 1
                    step += 1
                nums[i] = nums[i]//2
            if sum(nums) == 0:
                return step
            step += 1
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones = 0
        doubles = 0
        while(sum(nums)!=0):
            for i in range(len(nums)):
                if(nums[i]%2!=0):
                    nums[i]-=1
                    ones+=1
                    
            if(sum(nums)!=0):
                for i in range(len(nums)):
                    nums[i] = nums[i]//2
                doubles+=1
                
        return ones+doubles
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while any(nums):
            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    count += 1
            if any(nums):
                for i in range(len(nums)):
                    nums[i] //= 2
                count += 1
        return count


class Solution:
    def getPow(self, n: int) -> Tuple[int, int]:
        if n == 0:
            return (0, -1)
        if n == 1:
            return (1, 0)
        
        inc = 0
        mul = 0
        i = n
        while i != 0:
            if i % 2 == 1:
                inc += 1
                i = i - 1
            else:
                i = i // 2
                mul += 1
        return (inc, mul)

    def minOperations(self, nums: List[int]) -> int:
        pows = [self.getPow(n) for n in nums]
        
        num_incs = 0
        num_mults = 0
        
        max_pow = 0
        
        for i in range(0, len(nums)):
            if nums[i] == 0:
                continue
            if nums[i] == 1:
                num_incs += 1
            else:
                inc = pows[i][0]
                power = pows[i][1]
                num_incs += inc
                if power > max_pow:
                    max_pow = power
                    
        num_incs += max_pow
        return num_incs
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(x).count('1') for x in nums) + len(bin(max(nums))) - 3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0
        if self.check(nums):
            return cnt
        while not self.check(nums):
            for i in range(len(nums)):
                cnt += nums[i] % 2
            cnt += 1
            self.divide2(nums)
        return cnt - 1
    
    def check(self, nums):
        for i in range(len(nums)):
            if nums[i] != 0:
                return False
        return True
    
    def divide2(self, nums):
        for i in range(len(nums)):
            nums[i] //= 2

class Solution: 
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0
        max_val, max_index = -1, len(nums)
        for i in range(len(nums)):
            if nums[i] > max_val:
                max_val = nums[i]
                max_index = i

        while(max_val != 0):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    cnt += 1
            max_val = nums[max_index]
            # print(nums, max_val)
            if max_val == 0:
                break
            for i in range(len(nums)):
                nums[i] = nums[i] // 2
            cnt += 1
            max_val = nums[max_index]
            # print(nums, max_val)
        return cnt 
            
                
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def fun_call(num,mem):
            if not mem.get(num) is None:
                return mem[num]
            add=0
            mul=0
            old_num=num
            while(num>0):
                if num%2==0:
                    num//=2
                    mul+=1
                else:
                    num-=1
                    add+=1
            mem[old_num]=(add,mul)
            return mem[old_num]
        
        res=0
        mul_max=0
        mem={0:(0,0)}
        for i in range(len(nums)):
            add,mul=fun_call(nums[i],mem)
            res+=add
            mul_max=max(mul_max,mul)
        res+=mul_max
        return res
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        '''
        nums = [1,5]
        1
        5 -> 101
        3 + 3 - 1 = 5
        '''
        if nums == [0]:
            return 0
        count = 0
        max_bits = 0
        for n in nums:
            bits = 0
            while n:
                count += n & 1
                bits += 1
                n >>= 1
            max_bits = max(max_bits, bits)
        return count + max_bits - 1


class Solution:
    def toZero(self,n):
        extra = 0
        pwr2 = 0
        while n > 0:
            if n%2:
                n-=1
                extra += 1
            else:
                n = n/2
                pwr2 += 1
        return [extra,pwr2]
    def minOperations(self, nums: List[int]) -> int:
        maxPwr2 = 0
        extras = 0
        for n in nums:
            a = self.toZero(n)
            maxPwr2 = max(maxPwr2,a[1])
            extras += a[0]
        return extras+maxPwr2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        n = len(nums)
        while any(nums):
            for i in range(n):
                if nums[i] % 2:
                    nums[i] -= 1
                    count += 1
            if any(nums):
                for i in range(n):
                    nums[i] //= 2
                count += 1
        return count
                    
                
           
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        mask = 2 ** 32 - 2
        for _ in range(32):
            end = True
            for i, x in enumerate(nums):
                res += x & 1
                nums[i] >>= 1
                if nums[i]:
                    end = False
            if end:
                break
            res += 1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # rearrange the list into even number only
        # then perform divided by 2 operation 
        # recursively do this and return when it becomes [0...]
        count = 0
        for i in range(len(nums)):
            if nums[i]%2!=0 and nums[i]>0:
                count+=1
                nums[i]-=1
        if nums==[0]*len(nums):
            return count
        nums = [i//2 for i in nums]
        return count + self.minOperations(nums)+1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            for i, num in enumerate(nums):
                if num % 2:
                    nums[i] -= 1
                    count += 1
            
            if sum(nums) == 0:
                return count
            
            for i in range(len(nums)):
                nums[i] //= 2
            count += 1

import math 


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        plus_one = times_two = 0
        for idx, num in enumerate(nums):
            two = 0 
            while num:
                if num == 1:
                    plus_one += 1 
                    break
                if num%2:
                    plus_one += 1
                    num -= 1
                num = num // 2
                two += 1
            times_two = max(times_two, two)
        return plus_one + times_two
        
#         1 * 2
#         1 * 2 * 2
#         1 * 2 * 2 * 2
#         1 * 2 * 2 * 2 * 2
        
#         2^x = 16
#         xln(2) = ln(16)
        
#         x = ln(n) / ln(2)
        
        
#         18 
        
#         0 -> 1
#         1 -> 2 
#         2 -> 4
#         4 -> 8
#         8 -> 9
#         9 -> 18 


class Solution:
    def minOperations(self, nums) -> int:
        res = 0
        N = len(nums)
        while True:
            for i, v in enumerate(nums):
                if v & 1:
                    res += 1
                    nums[i] -= 1
            if nums == [0] * N:
                return res
            for i in range(N):
                nums[i] //= 2
            res += 1
        return res
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        moves, ndone = 0, len(nums)-nums.count(0)
        while ndone:
            for i,num in enumerate(nums):
                if num%2==1:
                    moves+=1
                    nums[i]-=1
                    if nums[i]==0:
                        ndone-=1
            if ndone:
                nums = [num//2 for num in nums]
                moves+=1
        return moves
    


def get_num_ops(num):
     assert num >= 0
     d_ops, s_ops = 0, 0
     while num != 0:
         if num%2 == 1:
             num = num - 1
             s_ops += 1
         else:
             num = num//2
             d_ops += 1
     return d_ops, s_ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        num_ops = 0
        doubling_ops = []
        for num in nums:
            d, s = get_num_ops(num)
            doubling_ops.append(d)
            num_ops += d + s
            print(num_ops)
        
        doubling_ops = sorted(doubling_ops)
        change = [doubling_ops[0]]
        for i in range(1, len(doubling_ops)):
            change.append(doubling_ops[i] - doubling_ops[i-1])
        
        for i, c in enumerate(change):
            num_ops = num_ops - c * (len(change) -i - 1)
                                                         
        return num_ops


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        maxi=0
        for j in nums:
            e=0
            if(j==0):
                continue
            if(j==1):
                count=count+1
            if(j>1):
                while(j):
                    if(j%2==0):
                        e=e+1
                        j=j//2
                    else:
                        j=j-1
                        count=count+1
            if(e>maxi):
                maxi=e
                        
        count=count+maxi
        return count
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def count(n):
            a = b = 0
            while n:
                if n & 1:
                    n -= 1
                    b += 1
                else:
                    n >>= 1
                    a += 1
            return (a, b)
        maxA = sumB = 0
        for n in nums:
            a, b = count(n)
            maxA = max(maxA, a)
            sumB += b
        return maxA + sumB
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
             
        number_of_moves=0
        while(True):
            for pos,num in enumerate(nums):
                if num%2 == 1:
                    nums[pos]-=1
                    number_of_moves += 1
            if not any(nums):
                break
            nums = list([x//2 for x in nums])            
            number_of_moves +=1
            
        return number_of_moves
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op=0
        sum1=sum(nums)
        while sum1!=0:
            for i in range(len(nums)):
                if nums[i]%2!=0:
                    nums[i]-=1
                    sum1-=1
                    op+=1
                    
            if sum1==0:
                return op
            
            for i in range(len(nums)):
                nums[i]//=2
            op+=1
            sum1/=2
            
        return op


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        d = {}
        odd = 0
        mx_even = 0
        for i,val in enumerate(nums):
            even = 0
            while(val):
                if val%2==0:
                    while(val>0 and val%2==0):
                        val = val//2
                        even += 1
                else:
                    val -= 1
                    odd += 1
            mx_even = max(even,mx_even)
        return odd + mx_even
                        
                        
            
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        while any(nums):
            for i in range(n):
                if nums[i]%2==1: 
                    nums[i]=nums[i]-1
                    ans += 1
            if any(nums):
                nums = [o/2 for o in nums]
                ans += 1
        return ans

from math import log

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        vposes = set(range(len(nums)))
        while vposes:
            rm = set()
            for i in vposes:
                if nums[i] % 2:
                    nums[i] -= 1
                    res += 1
                if not nums[i]:
                    rm.add(i)
            vposes.symmetric_difference_update(rm)        
            chg = False
            for i in vposes:
                chg = True
                nums[i] //= 2
            res += chg    
        return res    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        max_div = 0
        
        for n in nums:
            divs = 0
            while n > 0:
                if n % 2:
                    n -= 1
                    ops += 1
                else:
                    n /= 2
                    divs += 1
            
            max_div = max(max_div, divs)
        
        return ops + max_div


class Solution:
    def minOperations(self, a: List[int]) -> int:
        # def cnt_op(x):
        #     if x == 0: return 0
        #     if x % 2 == 0: return 1 + cnt_op(x // 2)
        #     return 1 + cnt_op(x - 1)
            
        ans = 0     
        zero_cnt = 0
        while zero_cnt < len(a):
            zero_cnt = 0
            for i, x in enumerate(a):
                if x % 2 == 1: 
                    ans += 1
                    a[i] = (x - 1) // 2
                else:
                    a[i] = x // 2
                zero_cnt += a[i] == 0
            ans += zero_cnt < len(a)                
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        steps = 0
        while True:
            for idx in range(0, len(nums)):
                if nums[idx] % 2 == 1:
                    nums[idx] -= 1
                    steps += 1
            if sum(nums) == 0:
                break
            nums = [int(x / 2) for x in nums]
            steps += 1
                    
        return steps
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        not_zero = set(list(range(n)))
        while True:
            if len(not_zero) == 0:
                return ans
            zeros = []
            for i in not_zero:
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ans += 1
                if nums[i] == 0:
                    zeros.append(i)
                nums[i] = nums[i] // 2
            for j in zeros:
                not_zero.remove(j)
            if len(not_zero) > 0:
                ans += 1
            # print(not_zero, nums, ans)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def get_add_mul_times(num: int):
            a, b = 0, 0
            while num > 0:
                if num >> 1 << 1 != num:
                    a += 1
                    num -= 1
                else:
                    b += 1
                    num //= 2
            return a, b
        N = len(nums)
        add, mul = [0] * N, [0] * N
        for ii in range(N):
            a, b = get_add_mul_times(nums[ii])
            add[ii] = a
            mul[ii] = b
        return max(mul) + sum(add)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        steps = 0
        while sum(nums) > 0:
            for idx in range(0, len(nums)):
                if nums[idx] % 2 == 1:
                    nums[idx] -= 1
                    steps += 1
            if sum(nums) == 0:
                break
            nums = [int(x / 2) for x in nums]
            steps += 1
                    
        return steps
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
#         # bit operation
#         # The number of operation 0 equals to the total number of bits \"1\".
#         # The number of operation 1 equals to maximum bit length - 1.
        
#         # operation 0: turning 1 to 0. make 1 bit to 0 bit. need 1 operation individually
#         # thus count number of 1 bits for each number and add them up
        
#         # operation 2: divide number by 2 -> shift 1 bit to right. this can be share with all numbers
#         # 1 step operation to shift all numbers to right by 1 bit.
#         # Thus find the number with max length of bit (max number in the array), count how many bits.
#         return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))[2:]) - 1
    
    
        # sum of the addition operations and the maximum number of multiply operations in any element.
        # O(32N) = O(N)
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2 == 1: # odd number, just delete 1 so that it's now a multiple of 2
                    n -= 1
                    ones += 1
                else: # multiple of 2, so just divide by 2 
                    n //= 2
                    mul += 1
            twos = max(twos, mul)
            
        return ones + twos


import numpy as np
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        #return sum(bin(a).count('1') for a in nums) + len(bin(max(nums)))-3
        
        #\"\"\"
        # poor performance on very large lenght of list.
        count = 0
        if not any(nums):
            return count
        for i in range(len(nums)):
            if nums[i]%2 != 0:
                nums[i] -= 1
                count += 1
        #b = False
        if any(nums):
            count += 1
            for i in range(len(nums)):
                nums[i] = nums[i]//2
        return count+self.minOperations(nums)
        #\"\"\"


bin = '{:0b}'.format

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxBitLen = 0
        bitCount = 0
        for num in nums:
            b = bin(num)
            maxBitLen = max(maxBitLen, len(b))
            bitCount += b.count('1')
        return maxBitLen + bitCount - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        @lru_cache(None)
        def helper(num):
            if num < 2:
                return num,0
            a,b = helper(num//2)    
            return a+num%2,b+1
            
            
        a = b = 0
        for num in nums:
            tmpa,tmpb = helper(num)
            a += tmpa
            b = max(b,tmpb)
        return a + b
        
        

        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def helper(num):
            if num in self.dic: return self.dic[num]
            n = num
            count,even = 0,0
            while n != 0:
                if n % 2 == 1:
                    n -= 1
                else:
                    n //= 2
                    even += 1
                count += 1
            self.dic[num] = (count,even)
            return count,even
        
        ans,maxb,self.dic = 0,0,{}
        for num in nums:
            a,b = helper(num)
            ans += a - b
            maxb = max(maxb,b)
        return ans + maxb

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        steps = 0
        maxIdx, maxNum = None, -math.inf 
        
        for idx, num in enumerate(nums):
            if num > maxNum:
                maxNum = num
                maxIdx = idx
                
        nums[maxIdx], nums[-1] = nums[-1], nums[maxIdx]
        
        def divideBy2(nums):
            nums = [num // 2 for num in nums]
            return nums
        
        while nums[-1] > 0:
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    steps += 1
                    
            if nums[-1] == 0:
                return steps
            
            nums = divideBy2(nums)
            steps += 1
            
        return steps

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        add = 0
        double = 0
        ans = 0
        for i in range(len(nums)):
            x = nums[i]
            if x == 0:
                continue
            add += 1
            curr = 0
            while x != 1:
                if x % 2 != 0:
                    x -= 1
                    add += 1
                while x % 2!= 1:
                    x /= 2
                    curr += 1
            double = max(double, curr)
        ans = double + add
        return ans

class Solution:        
    def minOperations(self, nums: List[int]) -> int:
        op_count = 0
        
        while not all([v==0 for v in nums]):
            for i in range(len(nums)):
                odd = nums[i] % 2
                if odd:
                    nums[i] -= 1
                    op_count += 1
                nums[i] //= 2
            
            op_count += 1
                
        return max(0, op_count - 1)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        all_zero = False
        while not all_zero:
            all_zero = True
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    ans += 1
                    nums[i] -= 1
                nums[i] //= 2
                if nums[i] != 0: all_zero = False
            if not all_zero: ans += 1
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        _max = 0
        for i in nums:
            bit = 0
            while i>0:
                res += i&1
                i >>= 1
                bit += 1
            _max = max(bit,_max)
        return res+_max-1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        while sum(nums):
            for i in range(n):
                if nums[i]%2==1: 
                    nums[i]=nums[i]-1
                    ans += 1
            if sum(nums):
                nums = [o/2 for o in nums]
                ans += 1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        res = 0
        max_len = 0
        for num in nums:
            bits = 0
            while num > 0:
                res += num%2
                num >>= 1
                bits += 1
            max_len = max(bits-1, max_len)
        return res + max_len
            
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        n = len(nums)
        while 1:
            all0 = True
            has_div = False
            for i in range(n):
                if nums[i] == 0:
                    continue
                all0 = False
                if nums[i] & 1:
                    res += 1
                    if nums[i] > 1:
                        has_div = True
                    nums[i] = (nums[i] - 1) // 2
                else:
                    has_div = True
                    nums[i] //= 2
            if all0:
                break
            if has_div:
                res += 1
        return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            Zero = True
            for i in range(len(nums)):
                if nums[i]&1:
                    nums[i]-=1
                    count += 1
                if nums[i]:
                    Zero = False
            if Zero:
                return count
            count += 1
            for i in range(len(nums)):
                nums[i]>>=1
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        check =0
        if not nums:
            return(0)
        while check !=len(nums):
            x,check, nums = self.odd(nums)
            count+=x
            if check == len(nums):
                return(count)
            nums=self.div(nums)
            count+=1
            
            
            
            
    def div(self,nums):
        for i in range(len(nums)):
            nums[i]=nums[i]//2
        return(nums)
        
        
    def odd(self,nums):
        a=0
        b=0
        
        for i in range(len(nums)):
            if nums[i] & 1 == 1:
                a+=1
                nums[i]-=1
            if nums[i] == 0:
                b+=1
        return(a,b,nums)
                


class Solution:
  def minOperations(self, nums: List[int]) -> int:
    maxDivideCount = 0
    minusCount = 0
    for num in nums:
      divideCount = 0
      while num != 0:
        if num % 2 == 0:
          num //= 2
          divideCount += 1
        else:
          num -= 1
          minusCount += 1
      maxDivideCount = max(divideCount, maxDivideCount)
    return maxDivideCount + minusCount
    
#     while self.isAllZero(nums) is False:
#       if self.isAllEven(nums):
#         nums = [a // 2 for a in nums]
#         count += 1
#         continue
#       for i in range(len(nums) - 1):
#         if nums[i] != 0 and nums[i] % 2 == 1:
#           nums[i] -= 1
#           count += 1
        
#     return count
      
#   def isAllZero(self, nums: List[int]) -> bool:
#     for n in nums:
#       if n != 0:
#         return False
#     return True
  
#   def isAllEven(self, nums: List[int]) -> bool:
#     for n in nums:
#       if n % 2 != 0:
#         return False
#     return True
    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        oneCnt = 0
        pwrCnt = 0
        for num in nums:
            if num == 0:
                continue
            exp = 0
            while num > 0:
                if num % 2 == 0:
                    num /= 2
                    exp += 1
                else:
                    num -= 1
                    oneCnt += 1
            pwrCnt = max(pwrCnt, exp)
        return oneCnt + pwrCnt
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if sum(nums) == 0:
            return 0
        
        steps = 0
        n_zeros = 0
        
        for i, num in enumerate(nums):
            if num % 2 != 0:
                nums[i] -= 1
                steps += 1
            
            if nums[i] == 0:
                n_zeros += 1
            
            nums[i] = nums[i] // 2
        
        if n_zeros != len(nums):
            steps += 1
        
        return steps + self.minOperations(nums)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            for i, x in enumerate(nums):
                if x % 2 == 1:
                    nums[i] -= 1
                    ans += 1
            if any(nums):
                for i, x in enumerate(nums):
                    nums[i] //= 2
                ans += 1
        return ans
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:

        @lru_cache(None)
        def helper(num):
            if num < 2:
                return num,0
            if num%2==0:
                a,b = helper(num//2)
                return a,b+1
            else:
                a,b = helper((num-1)//2)
                return a+1,b+1
            
        a = b = 0
        for num in nums:
            tmpa,tmpb = helper(num)
            a += tmpa
            b = max(b,tmpb)
        return a + b
        
        

        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_dev = 0
        steps = 0
        
        for i in nums:
            dev = 0
            while i != 0:
                if i % 2 == 0:
                    i = i / 2
                    dev = dev + 1
                else:
                    i = i - 1
                    steps = steps + 1
            
            if dev > max_dev:
                max_dev = dev
                
        
        return steps + max_dev

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        one = 0
        two = 0
        for n in nums:
            r = self.onetwo(n)
            one += r[0]
            two = max(two, r[1])
        return one + two
    def onetwo(self, n):
        one = 0
        two = 0
        while n != 0:
            if n%2 == 0:
                two += 1
                n /= 2
            else:
                one += 1
                n -= 1
        return (one, two)

class Solution:
    def minOperations(self, nums: List[int]) -> int:


        res = 0
        t = 0
        
        for ele in nums:
            ele = str(bin(ele))[2:]
            res += ele.count('1')
            t = max(t, len(ele) - 1)
        
        return res + t


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        
        one = 0
        two_req = 0
        
        for i in nums:
            two = 0
            i_copy = i
            while i_copy > 0:
                # print(i_copy)
                if i_copy % 2 == 0:
                    i_copy = i_copy // 2
                    two += 1
                else:
                    i_copy -= 1
                    one += 1

            two_req = max(two_req, two)

        res = two_req + one
        # print(ctr, odd_ctr, non_zero)
        return res

from math import log
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt = int(log(max(nums))/log(2))
        for n in nums:
            while n>0:
                if n%2==1:
                    n-=1
                    cnt+=1
                else:
                    n = n//2
        return cnt


from functools import lru_cache

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        divideByTwos = 0
        decrements = 0
        
        for num in nums:
            if num == 0:
                continue
                
            divides, dec = self.reductions(num)
            divideByTwos = max(divideByTwos, divides)
            decrements += dec
                
        return divideByTwos + decrements
    
    @lru_cache(maxsize=None)
    def reductions(self, num: int) -> (int, int):
        decrements = 0
        divides = 0
        
        while num > 1:
            if num % 2 == 0:
                num /= 2
                divides+=1
            else:
                num -= 1
                decrements +=1
                
        return divides, decrements + 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        
        while not(self.is_end(nums)):
            ops += self.perform_decrement(nums)
            if self.is_end(nums): return ops
            ops += self.perform_division(nums)
        return ops
        #jesli nieparzytte to odejmij 1
        #jesli wszystkie parzyste to podziel
        
    def is_end(self, nums):
        return all(i == 0 for i in nums)
    
    def perform_decrement(self, nums):
        ops = 0
        for i in range(len(nums)):
            if nums[i] % 2 == 1:
                nums[i] -= 1
                ops += 1
        return ops

    def perform_division(self, nums):
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[i] //= 2
        return 1
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        @lru_cache(None)
        def get(n):
            add = 0
            mul = 0
            while n:
                if n & 1:
                    add += 1
                    n -= 1
                else:
                    mul += 1
                    n = n >> 1
            return add, mul
        cadd = 0
        mmul = 0
        for n in nums:
            add, mul = get(n)
            cadd += add
            mmul = max(mul, mmul)
        return cadd + mmul

class Solution:
    # naive is BFS, but too costly.
    # Start from nums by greedily trace back, whenever there is an odd number, take one action to make it even by reduce 1. If everything is even, half them by taking one action.
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            for i in range(len(nums)):  # take 1 action each to make elem from odd to even
                if nums[i] % 2:
                    nums[i] -= 1
                    count += 1
            all_zero = True
            for i in range(len(nums)):  # take one action to half all elem
                if nums[i] != 0:
                    all_zero = False
                nums[i] //= 2
            if all_zero:
                return count
            count += 1
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ## there's definitely a dfs approach, but it seems
        # expensive...need as many recursive calls per level
        # as the length of the list +1 for op 1
        # start is [0,0]
        # can we extract the solution from the binary rep of all the nums?
        #pad to 32 bit or 
        N = len(nums);
        ansr = 0;
        while(any(nums)):
            divideByTwo = False;
            for i in range(N):
                if(nums[i] == 1):
                    ansr+=1;
                    nums[i] = 0;
                elif(nums[i]==0):
                    continue;
                else:
                    divideByTwo = True
                    if(nums[i]%2 == 1):
                        ansr+=1
                    nums[i] = nums[i]//2
            if(divideByTwo):
                ansr+=1;
        return ansr;
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        
        while True:
            for i in range(n):
                if nums[i] % 2 == 1:
                    ans += 1
                    nums[i] -= 1
                    
            stop = True
            for i in range(n):
                if nums[i] != 0:
                    nums[i] //= 2
                    stop = False
            
            if stop:
                break
            else:
                ans += 1
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        max_divide = 0
        res = 0
        for num in nums:
            cnt_divide = 0
            while num:
                if num%2==1:
                    res += 1
                    num-=1
                else:
                    num //=2
                    cnt_divide += 1
            max_divide = max(max_divide, cnt_divide)
            
        return res + max_divide
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        nums.sort()
        while nums[-1] != 0:            
            if nums[-1] >= 2:
                ans += 1
            for i, num in enumerate(nums):
                ans += num % 2
                nums[i] = num // 2
            
        return ans

import math
class Solution:
    def rec(self,nums):
        if not nums:
            return 0
        if len(nums)==1:
            if nums[0]<=2:return nums[0]
            
            if nums[0]%2==0:
                nums[0]=nums[0]//2
                return 1+self.rec(nums)
            else:
                nums[0]=(nums[0]-1)//2
                return 2+self.rec(nums)
            
            
            
        op=0
        new=[]
        for i in range(len(nums)):
            if nums[i]!=0:
                if nums[i]%2!=0:
                    nums[i]-=1
                    op+=1
                    if nums[i]!=0:
                        new.append(nums[i]//2)
                        
                else:
                    new.append(nums[i]//2)
        if len(new)>0:
            op+=1
        return op+self.rec(new)
        
        
    def minOperations(self, nums: List[int]) -> int:
        return self.rec(nums)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        N = len(nums)
        res = 0
        while sum(nums) != 0:
            all_even = True
            for i in range(N):
                if nums[i] & 1:
                    all_even = False
                    res += 1
                    nums[i] -= 1
            if all_even:
                res += 1
                nums = [n // 2 for n in nums]
        return res

def ones(x):
    return 0 if x == 0 else 1 + ones(x & (x - 1))
def twos(x):
    cc = 0
    while x > 1:
        x //= 2
        cc += 1
    return cc

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        o = 0
        t = 0
        for x in nums:
            o += ones(x)
            t = max(t, twos(x))
        return o + t

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        add_count = 0
        mut_count = 0
        
        def get_add_mut_count(n):
            add = mut = 0
            while n:
                if n % 2:
                    # n is odd and delete it by one which require one action as add
                    n -= 1
                    add += 1
                else:
                    n /= 2
                    mut += 1
                    
            return (add, mut)
        
        for n in nums:
            a, m = get_add_mut_count(n)
            add_count += a
            mut_count = max(mut_count, m)
        
        return add_count + mut_count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        while True:
            zeros=0
            for i in range(len(nums)):
                if nums[i]%2==0:
                    continue
                else:
                    nums[i]-=1
                    count+=1
            for j in range(len(nums)):
                if nums[j]==0:
                    zeros+=1
                nums[j]=nums[j]//2
            if zeros==len(nums):
                return count
            count+=1
            
            

            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums.sort()
        nums = nums[::-1]
        ops = 0
        
        n = len(nums)
        
        while nums:
            # print(nums)
            while nums[-1]==0:
                nums.pop()
                if not nums:
                    break
                n-=1
            if not nums:
                break
                
            oc = 0

            for i in range(n):
                if nums[i]%2!=0:
                    oc = 1
                    break
                    
            if oc==1:
                for i in range(n):
                    if nums[i]%2!=0:
                        ops+=1
                        nums[i]-=1
            else:
                ops+=1
                for i in range(n):
                    nums[i] = nums[i]//2
        return ops
            
        
        
        
        
        
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        valid = {0: 0}
        for i in range(31):
            valid[2 ** i] = i
        
        ans = 0
        for i in range(len(nums)):
            if nums[i] > 0:
                ans += 1

        max_val = float('-inf')
        need_step = [0] * len(nums)
        max_multiply_step = 0
        for i in range(len(nums)):
            one_step, multiply_step = 0, 0
            while nums[i] not in valid:
                if nums[i] & 1:
                    one_step += 1
                    nums[i] -= 1
                else:
                    multiply_step += 1
                    nums[i] //= 2
            
            max_multiply_step = max(max_multiply_step, multiply_step + valid[nums[i]])
            ans += one_step
        
        ans += max_multiply_step

        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        count=0
        while sum(nums)>0:
            for i in range(len(nums)):
                count += nums[i] % 2
                nums[i] = nums[i] // 2
                
            if sum(nums)>0: count += 1
                
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        if len(nums) == 1:
            v = nums[0]
            while v:
                if v%2:
                    ans += 1
                    v -= 1
                if v:
                    v //= 2
                    ans += 1
            return ans
        c = collections.Counter()
        for i,v in enumerate(nums):
            if v%2:
                nums[i] -= 1
                ans += 1
            c[nums[i]]+=1
        two = 0
        for v in sorted(c.keys()):
            temp = 0
            t = 0
            u = v
            while v:
                if v%2:
                    t += 1
                    v -= 1
                if v:
                    v //= 2
                    temp += 1
            ans += t*c[u] + (temp-two)
            two += (temp-two)
                
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeroIndexes = set()
        result = 0
        isEven = False
        while len(zeroIndexes) != len(nums):
            if isEven:
                for i in range(len(nums)):
                    nums[i] >>= 1
                result += 1
                isEven = False
            else:
                for i in range(len(nums)):
                    if i not in zeroIndexes:
                        if nums[i] & 1:
                            nums[i] -= 1
                            result += 1
                        if nums[i] == 0:
                            zeroIndexes.add(i)
                isEven = True
        return result


import math

class Solution:
    def minOperations(self, nums: List[int]) -> int:
#         res = 0
#         maxPow = 0
#         for i in range(len(nums)):
#             if nums[i] > 0:
#                 power = round(math.log(nums[i])/math.log(2))
#                 print(power, pow(2, power))
#                 if maxPow < power:
#                     maxPow = power
#                 res += 1 + nums[i] - pow(2, power)

#         res += maxPow
#         return res
        res = 0
        while True:
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    res += 1
                    nums[i] -= 1
                    
            numZeros = 0
            for i in range(len(nums)):
                if nums[i] == 0:
                    numZeros += 1
                    
            if numZeros == len(nums):
                break
            
            for i in range(len(nums)):
                nums[i] //= 2
            res += 1
            
        return res
            
            
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while sum(nums) != 0:
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    res += 1
            if sum(nums) != 0:
                for i in range(len(nums)):
                    nums[i]  /= 2
                res += 1
            # print(nums)
        return res


# from collections import deque
# class Solution:
#     def minOperations(self, nums: List[int]) -> int:
#         step = 0
#         while len(nums):
#             for i, val in enumerate(nums):
#                 if val % 2:
#                     nums[i] -= 1
#                     step += 1
#             nums = self.trim(nums)
#             if len(nums):
#                 step += 1
#                 for i, val in enumerate(nums):
#                     if val:
#                         nums[i] /= 2
#             nums = self.trim(nums)
#         return step

#     def trim(self, nums):
#         return [e for e in nums if e]

from collections import deque
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        step = 0
        while sum(nums):
            for i, val in enumerate(nums):
                if val % 2:
                    nums[i] -= 1
                    step += 1
            if sum(nums):
                step += 1
                for i, val in enumerate(nums):
                    if val:
                        nums[i] /= 2
        return step



class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans=0
        while True:
            count=0
            flag=0
            for i in range(len(nums)):
                if nums[i]&1:
                    count+=1
                    nums[i]-=1
            for i in range(len(nums)):    
                if nums[i]!=0:
                    nums[i]=nums[i]//2  
                    flag=1
            ans+=count
            if flag:
                ans+=1
            count=0
            if nums.count(0)==len(nums):
                return ans
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        counter = 0
        while 1:
            temp_counter = 0
            bigger_than_zero = 0
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    temp_counter += 1
                    nums[i] -= 1
                if nums[i] > 0:
                    bigger_than_zero += 1
            counter += temp_counter
            if bigger_than_zero == 0 :
                return counter
            for i in range(len(nums)):
                nums[i] //= 2
            counter += 1
        return counter


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums.sort(reverse=True)
        # zero_ind = -1
        step = 0
        while any(( n > 0 for n in nums)):
            # print('nums', nums)
            if all((n % 2 == 0 for n in nums)):
                nums = [n // 2 for n in nums]
                step += 1
            else:
                # find odd element
                remain_idx = []
                for i, v in enumerate(nums):
                    if v % 2 == 1:
                        nums[i] = nums[i] - 1
                        # if nums[i] == 0:
                        #     zero_ind = max(zero_ind, i)
                        step += 1
                # nums = [ nums[ri] for ri in remain_idx]
        return step

class Solution:
    def minOperations(self, nums: List[int]) -> int:

        m = 0
        f = 0 
        for x in nums:
            
            if x == 0:
                continue
            
            c = 0
            mm = 0
            baz = x
            while x > 1:
                if x % 2 == 0:
                    x = x // 2
                    mm += 1
                else:
                    x -= 1
                    c += 1
            print((baz,c))
            f += 1 + c
            m = max(m,mm)
            print(m)
            
        f += m
        return f


class Solution:
    def minOperations(self, nums: List[int]) -> int:

        @lru_cache(None)
        def helper(num):
            if num < 2:
                return num,0
            if num%2==0:
                a,b = helper(num//2)
                return a,b+1
            else:
                a,b = helper((num-1)//2)
                return a+1,b+1
            
        a = b = 0
        for num in nums:
            tmpa,tmpb = helper(num)
            print((num,tmpa,tmpb))
            a += tmpa
            b = max(b,tmpb)
        return a + b
        
        

        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        Count = 0

        
        while True:
            
            for i in range(len(nums)):
                if nums[i]%2 == 1: 
                    Count += 1
                    nums[i]  = (nums[i] - 1)//2
                else: nums[i] = nums[i]//2
            
            if sum(nums) == 0: return Count
            Count += 1
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ret = 0
        while nums.count(0)!=len(nums):
            for i in range(0,len(nums)):
                if nums[i]%2!=0:
                    nums[i] = nums[i]-1
                    ret = ret+1
            nums[:] = [i/2 for i in nums]
            ret = ret+1
        return (0 if ret==0 else ret-1)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while not all(n == 0 for n in nums):
            div = 0
            for i, n in enumerate(nums):
                if n & 1:
                    ans += 1
                    n -= 1
                if n > 0:
                    div = 1
                    n //= 2
                nums[i] = n
            ans += div
        return ans

from collections import deque
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        step = 0
        while sum(nums):
            for i, val in enumerate(nums):
                if val % 2:
                    nums[i] -= 1
                    step += 1
            if sum(nums):
                step += 1
                for i, val in enumerate(nums):
                    if val:
                        nums[i] /= 2
        return step

        
        
#         step = 0
#         l = deque()
#         l.append([0] * len(nums))
#         while l:
#             l_len = len(l)
#             for i in range(l_len):
#                 cur_list = l.popleft()
#                 if str(cur_list) == str(nums):
#                     return step
#                 for j in range(len(nums)):
#                     add_next, valid = self.add(cur_list, nums, j)
#                     if valid:
#                         l.append(add_next)
#                 mul_next, valid = self.multiply(cur_list, nums)
#                 if valid:
#                     l.append(mul_next)
#             step += 1
#         return step
                
       
        
#     def add(self, cur: List[int], target: List[int], idx: int):
#         if cur[idx] + 1 > target[idx]:
#             return [], False
#         else:
#             new_list = cur.copy()
#             new_list[idx] += 1
#             return new_list, True
    
#     def multiply(self, cur: List[int], target: List[int]):
#         new_list = cur.copy()
#         for i in range(len(new_list)):
#             new_list[i] *= 2
#             if new_list[i] > target[i]:
#                 return [], False
#         return new_list, True


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def dfs(n):
            if(sum(nums) == 0):
                return n
            subs = 0
            zeros = 0
            for i in range(len(nums)):
                if(nums[i]%2):
                    nums[i]-=1
                    subs+=1
                if(nums[i]==0):
                    zeros += 1
                nums[i] /= 2
            if(zeros == len(nums)):
                return subs+n
            return dfs(1+subs+n)
        return dfs(0)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def count(num):
            div = 0
            minus = 0
            while num:
                if num%2==0:
                    num = num//2
                    div+=1
                else:
                    num=num-1
                    minus+=1
            return div,minus
        m=[]
        d=[]
        for i in nums:
            div,minus = count(i)
            d.append(div)
            m.append(minus)
        return max(d)+sum(m)
            
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        ans = 0
        m = 0
        
        def get(val):
            ret = 0
            give = 0
            while(val != 0):
                if(val & 1):
                    val -= 1
                    ret += 1
                else:
                    val = val//2
                    give += 1
                
            return ret, give
    
        for i in range(n):
            if(nums[i] == 0): continue
            val, mult = get(nums[i])
            m = max(m,mult)
            ans += val
        ans += m
        return ans

class Solution:
    '''
    [3,2,2,4] 1 -> [2,2,2,4] 1 -> [1,1,1,2] 3 -> [0,0,0,2] 1 -> [0,0,0,1] 1 -> [0,0,0,0]
    '''
    def minOperations(self, nums: List[int]) -> int:
        if nums == [0]:
            return 0
        
        copy = list(nums)
        ans = 0
        while any([el != 0 for el in copy]):
            numOdd = 0
            for i in range(len(copy)):
                if copy[i] % 2 != 0:
                    numOdd += 1
                    copy[i] -= 1

            for i in range(len(copy)):
                copy[i] /= 2
                
            ans += numOdd + 1
        return ans-1
                
        
        
            
                
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        cnt = 0
        while True:
            for i in range(len(nums)):
                if nums[i] != 0:
                    if nums[i]&1 != 0:
                        nums[i] -= 1
                        cnt += 1
                    nums[i] = nums[i] >> 1
            if sum(nums) == 0:  # Notice how to calculate array sum in python....
                return cnt
            cnt += 1
        return cnt
        
        
        '''
        # Backwards!!!!
        # Some problems is hard to solve forward, but can be easy if solved backwards!!!!
        # Change nums to arr
        
        step = 0
        
        while True:
            for i in range(len(nums)):
                if nums[i]%2 != 0:
                    nums[i] = nums[i] - 1
                    step += 1
                nums[i] = nums[i]//2
            if sum(nums) == 0:
                return step
            step += 1
        '''


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = m = 0
        for x in nums:
            s = bin(x)[2:]
            m = max(len(s) - 1, m)
            n += len(s.replace('0', ''))
        return m + n

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = max_mult = 0
        for num in nums:
            count = 0
            while num != 0:
                if num % 2:
                    res += 1
                    num -= 1
                else:
                    count += 1
                    num //= 2
            max_mult = max(max_mult, count)

        return res + max_mult

                
           
            


from collections import Counter, defaultdict, OrderedDict, deque
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from typing import List
import itertools
import math
import heapq
import string
true = True
false = False
MIN, MAX, MOD = -0x3f3f3f3f, 0x3f3f3f3f, 1000000007


#
# @lc app=leetcode id=1558 lang=python3
#
# [1558] Minimum Numbers of Function Calls to Make Target Array
#
# https://leetcode.com/problems/minimum-numbers-of-function-calls-to-make-target-array/description/
#
# algorithms
# Medium (57.56%)
# Total Accepted:    4.1K
# Total Submissions: 7.1K
# Testcase Example:  '[1,5]'
#
#
#
# Your task is to form an integer array nums from an initial array of zeros arr
# that is the same size as nums.
#
# Return the minimum number of function calls to make nums from arr.
#
# The answer is guaranteed to fit in a 32-bit signed integer.
#
#
# Example 1:
#
#
# Input: nums = [1,5]
# Output: 5
# Explanation: Increment by 1 (second element): [0, 0] to get [0, 1] (1
# operation).
# Double all the elements: [0, 1] -> [0, 2] -> [0, 4] (2 operations).
# Increment by 1 (both elements)  [0, 4] -> [1, 4] -> [1, 5] (2 operations).
# Total of operations: 1 + 2 + 2 = 5.
#
#
# Example 2:
#
#
# Input: nums = [2,2]
# Output: 3
# Explanation: Increment by 1 (both elements) [0, 0] -> [0, 1] -> [1, 1] (2
# operations).
# Double all the elements: [1, 1] -> [2, 2] (1 operation).
# Total of operations: 2 + 1 = 3.
#
#
# Example 3:
#
#
# Input: nums = [4,2,5]
# Output: 6
# Explanation: (initial)[0,0,0] -> [1,0,0] -> [1,0,1] -> [2,0,2] -> [2,1,2] ->
# [4,2,4] -> [4,2,5](nums).
#
#
# Example 4:
#
#
# Input: nums = [3,2,2,4]
# Output: 7
#
#
# Example 5:
#
#
# Input: nums = [2,4,8,16]
# Output: 8
#
#
#
# Constraints:
#
#
# 1 <= nums.length <= 10^5
# 0 <= nums[i] <= 10^9
#
#
#
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0
        cc = Counter(nums)
        while True:
            dup = defaultdict(int)
            do_even = False
            for n in cc:
                if n == 0: continue
                if n % 2:
                    cnt += cc[n]
                    if n - 1 > 0:
                        do_even = True
                        dup[n // 2] += cc[n]
                else:
                    do_even = True
                    dup[n // 2] += cc[n]
            if do_even: cnt += 1
            if not dup: return cnt
            cc = dup

        return cnt


sol = Solution()

nums = [1, 5]
nums = [2, 2]
nums = [4, 2, 5]
# nums = [3, 2, 2, 4]
# nums = [2, 4, 8, 16]


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        nz = 0
        for num in nums:
            if num>0:
                nz+=1
       # print(nz)
        while nz>0:
           # print(nums, res)
            div2 = False
            for i in range(len(nums)):
                if nums[i]%2==1:
                    nums[i]-=1
                    res+=1
                    if nums[i]==0:
                        nz-=1
                if nums[i]>0:
                    div2 = True
                    nums[i]//=2
                    if nums[i]==0:
                        nz-=1
            #print('after', nums, nz)
            if div2:
                res+=1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        '''Reverse thinking, from result number back to zeros'''
        '''Time:O(n*n/2)->O(n^2), Space:O(1)'''
#         result = 0
#         zeros = 0
#         for n in nums:
#             if n==0:
#                 zeros+=1
                
#         #when all numbers are even, /2
#         #when there is any odd number, -1
#         while zeros<len(nums):
#             for i in range(len(nums)):
#                 if nums[i]%2!=0:
#                     nums[i]-=1
#                     result+=1
#                     if nums[i]==0:
#                         zeros+=1
#                     # print('odd')
#             if zeros==len(nums):
#                 break
                
#             flag=0
#             for j in range(len(nums)): 
#                 if j==0:
#                     flag=1
#                 nums[j]/=2  
#                 if flag==1:
#                     result += 1
#                     flag=0
#                     # print('even')
                    
#         return result

        '''Time:O(n), Space:O(1)'''
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2:
                    n -= 1
                    ones += 1
                else:
                    n //= 2
                    mul += 1
            twos = max(twos, mul)
        return ones + twos

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        goal = [0]*len(nums)
        if nums == goal:
            return 0 
        calls = 0 
        div_needed = False
        for i in range(len(nums)):
            if nums[i] % 2 == 1:
                nums[i] -= 1
                calls += 1
            if nums[i] > 0:
                div_needed = True
        if div_needed:
            nums = [n/2 for n in nums]
            calls += 1
        return calls + self.minOperations(nums)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        cnt=0
        
        while nums.count(0)<len(nums):            
            for i in range(len(nums)):
                if nums[i]%2!=0:
                    nums[i]-=1
                    cnt+=1
                    
            if nums.count(0)!=len(nums):
                for i in range(len(nums)):
                    nums[i]=nums[i]/2
                cnt+=1
            else:
                return cnt

            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans=0
        
        while sum(nums)!=0:
            count_odd=0
            for i,num in enumerate(nums):
                if num%2!=0:
                    count_odd+=1
                    ans+=1
                    nums[i]=nums[i]-1
            
            if count_odd==0:
                nums=[n//2 for n in nums]
                ans+=1
            #print(nums)
        
        return ans

class Solution:
    def minOperations(self, a: List[int]) -> int:
        
        ans = 0
        
        while True:
            a.sort(reverse = True)
            for i in range(len(a)):
                if a[i]%2:
                    ans += 1
                    a[i] -= 1
            for i in a:
                if i != 0:
                    break
            else:
                break
            for i in range(len(a)):
                if a[i]%2 == 0:
                    a[i] //= 2
            ans += 1
            
        return ans

class Solution:
    def minOperations(self, A: List[int]) -> int:
        return sum(bin(a).count('1') for a in A) + len(bin(max(A))) - 3


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        done = False
        while not done:
            # Make nums all even numbers
            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    ops += 1
            # Divide nums by 2
            done = True
            for i in range(len(nums)):
                if nums[i] != 0:
                    done = False
                    nums[i] /= 2
            if not done:
                ops += 1
        return ops
            
                    
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxDoubles = 0
        incrs = 0
        
        for num in nums:
            doubles = 0
            while num > 0:
                if num % 2 == 1:
                    incrs += 1
                    num -= 1
                else:
                    doubles += 1
                    num >>= 1
            maxDoubles = max(maxDoubles, doubles)
        return incrs + maxDoubles


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res=0
        sum1=1
        while sum1!=0:
            sum1 = 0
            for ii,i in enumerate(nums):
                if i%2!=0:
                    nums[ii]-=1
                    res+=1
                nums[ii] = nums[ii]//2
                sum1+=nums[ii]
            res+=1
        return res-1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        actions = 0 
        
        n = len(nums)
        while True:
            odd_flag = False 
            
            for i in range(n):
                if nums[i] % 2 == 1:
                    actions += 1
                    nums[i] -= 1
                    odd_flag = True
            if all(num == 0 for num in nums):
                break
                    
            if odd_flag:
                continue

            for i in range(n):
                nums[i] //= 2
            actions += 1         
            if all(num == 0 for num in nums):
                break
        return actions

class Solution:    
    def minOperations(self, nums: List[int]) -> int:
        count = 0
            
        while True:
            next_nums = [0] * len(nums)                        
            all_zeros = True
            for i, x in enumerate(nums):                
                if x == 0:                    
                    continue
                            
                if x % 2 != 0:
                    count += 1                
                
                next_num =  x // 2
                next_nums[i] = next_num
                
                all_zeros &= next_num == 0
                                
            if all_zeros:
                break
            
            count += 1
            nums = next_nums
        
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        L = lambda x:len(x)
        op = 0
        while sum(nums):
            isodd = False
            for i in range(L(nums)):
                 if nums[i] & 1:
                    nums[i] -= 1
                    isodd = True
                    op += 1
                
            if not isodd:
                for i in range(L(nums)):
                    nums[i] >>= 1
                op += 1
            #print(nums, op)
        return op
                    


class Solution:
    def minOperations(self, nums):
        ans = 0
        maxtimes = 0
        for num in nums:
            plus, times = 0, 0
            #print(num)
            while num!=0:
                plus = plus+num%2
                if num//2!=0:
                    times += 1
                num = num//2

            maxtimes = max(maxtimes, times)
            #print(num, plus, times)
            ans = ans+plus  

        ans += maxtimes
        return(ans)

x = Solution()
print(x.minOperations([1,5]))

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        nz = 0
        for num in nums:
            if num>0:
                nz+=1
       # print(nz)
        while nz>0:
           # print(nums, res)
            div2 = False
            for i in range(len(nums)):
                if nums[i]%2==1:
                    nums[i]-=1
                    res+=1
                if nums[i]>0:
                    div2 = True
                    nums[i]//=2
            nz = 0
            for num in nums:
                if num>0:
                    nz+=1
            #print('after', nums, nz)
            if div2:
                res+=1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if max(nums) == 0:
            return 0
        operations = 0
        for i in range(len(nums)):
            if nums[i] % 2 == 1:
                nums[i] = nums[i] - 1
                operations += 1
        if operations > 0:
            return operations + self.minOperations(nums)
        for i in range(len(nums)):
            nums[i] = nums[i]//2
        operations += 1
        return operations + self.minOperations(nums)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while any(nums):
            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    count += 1
            if any(nums):
                for i in range(len(nums)):
                    nums[i] //= 2
                count += 1
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_ = max(nums)
        multiplication = len(bin(max_)[2:]) - 1
        additions = 0
        for n in nums:
            additions += bin(n)[2:].count('1')
        return additions+multiplication

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        flag = True
        n = len(nums)
        while flag:
            flag = False
            for i in range(n):
                if nums[i]%2==1:
                    nums[i] -= 1
                    ans += 1
                if nums[i] != 0:
                    flag = True
            if flag:    
                for i in range(n):
                    nums[i] /= 2
                ans += 1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        c = 0
        while True:
            sol = True
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    nums[i] -= 1
                    c += 1
                if nums[i] != 0:
                    sol = False
            if sol:
                break
            
        
            c += 1
            nums = [x // 2 for x in nums ]
        return c

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any([True if num > 0 else False for num in nums]):
            for idx, num in enumerate(nums):
                if num % 2 == 1:
                    ans += 1
                    nums[idx] -= 1
            flag = 0
            for idx, num in enumerate(nums):
                if num != 0:
                    flag = True
                    nums[idx] = num // 2
            if flag: 
                ans += 1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        N = len(nums)
        
        allzeros = False
        while not allzeros:
            allzeros = True
            for i in range(N):
                if nums[i] % 2 > 0:
                    ans += 1
                    nums[i] -= 1
                if nums[i] != 0:
                    allzeros = False    
                    nums[i] = nums[i] // 2
                
            if not allzeros:
                ans += 1
            # print(ans, nums)
        
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        N = len(nums)
        c = 0

        while any(nums):
            for i in range(N):
                if nums[i] & 1:
                    nums[i] -= 1
                    c += 1

            m = max(nums)
            for i in range(N):
                nums[i] >>= 1
            c += 1
        return c - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        mul = [0 for i in range(len(nums))]
        inc = [0 for i in range(len(nums))]
        for i in range(len(nums)):
            while nums[i]!=0:
                if nums[i]%2 == 1:
                    inc[i] += 1
                    nums[i] = nums[i]-1
                else:
                    mul[i] +=1
                    nums[i] //= 2
        return max(mul)+sum(inc)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums.sort()
        counter = 0
        while nums[-1]:
            for i, num in enumerate(nums):
                counter += num%2
                nums[i] = num//2 * 2
            if nums[-1]:
                nums = [num//2 for num in nums]
                counter += 1
        return counter

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def get_op(n):
            op_0 = 0
            op_1 = 0
            while n != 0:
                if n % 2 == 0:
                    op_1 += 1
                    n = n // 2
                else:
                    op_0 += 1
                    n -= 1
            return op_0, op_1
        
        ans = 0
        op_1 = 0
        for n in nums:
            tmp_0, tmp_1 = get_op(n)
            ans += tmp_0
            op_1 = max(op_1, tmp_1)
        return ans + op_1

from functools import lru_cache
class Solution:
    def minOperations(self, nums) -> int:
        @lru_cache(None)
        def minOpt(num):
            if num == 0:
                return 0, 0
            if num % 2 == 1:
                m, a = minOpt(num -1)
                return m, a + 1
            else:
                m, a = minOpt(num //2 )
                return m + 1, a

        multiply, add = 0, 0
        for num in nums:
            m, a = minOpt(num)
            multiply = max(m, multiply)
            add += a
        return multiply + add

import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        t = 0
        h = nums[0]
        for n in nums:
            if n > h:
                h = n
            while n:
                n &= n - 1
                t += 1
        if h > 0:
            return t + math.floor(math.log(h, 2))
        return t

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones=0
        two=0
        
        for i in nums:
            mul=0
            while i:
                if i%2==1:
                    i=i-1
                    ones+=1
                else:
                    i=i//2
                    mul+=1
            two=max(two,mul)
        return ones+two


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        inc, mult = 0, 0
        
        
        for i in nums:
            if i:
                a, b = self.getRes(i)
                inc += a
                mult = max(mult, b)
            
        return inc + mult
    
    def getRes(self, n):
        inc, mult = 0, 0
        
        while n:
            if n % 2 == 1:
                n -= 1
                inc += 1
            else:
                n //= 2
                mult += 1
        
        return inc, mult

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op=0
        while(len(nums)>0):
            for i in range(len(nums)):
                if(nums[i]%2)==1:
                    nums[i]-=1
                    op+=1            
            nums = list(filter(lambda x: x != 0, nums))            
            if(len(nums)>0):    
                nums[:] = [int(x/2) for x in nums]                
                op+=1        
        return op

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        o=0
        m=0
        a=0
        for i in nums:
            m=0
            while(i):
                if(i%2==0):
                    m+=1
                    i//=2
                else:
                    o+=1
                    i-=1
            a=max(m,a)
        return o+a

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans=0
        
        while sum(nums)!=0:
            count_odd=0
            for i,num in enumerate(nums):
                if num%2!=0:
                    count_odd+=1
                    ans+=1
                    nums[i]=nums[i]-1
            
            if count_odd==0:
                for i in range(len(nums)):
                    nums[i]=nums[i]//2
                ans+=1
           
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        lst = list(map(find_op, nums))
        mul = max(lst, key=lambda x: x[0])
        mul = mul[0]
        add = sum([item[1] for item in lst])
        return add + mul
        
def find_op(n):
    mul, add = 0, 0
    while n > 0:
        if n % 2 == 1:
            add += 1
        n //= 2
        mul += 1
    if mul > 0:
        mul -= 1
    return mul, add

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        
        count_zeros=0
        
        for i in nums:
            if i==0:
                count_zeros+=1
        operations=0
        
        while(count_zeros!=len(nums)):
            
            odd_max=-1
            
            
            for i in range(0,len(nums)):
                if nums[i]%2==1:
                    operations+=1 
                    nums[i]-=1
                    odd_max=i
                    if nums[i]==0:
                        count_zeros+=1
                    
            
            if odd_max==-1:
                operations+=1
                for i in range(0,len(nums)):
                    nums[i]=nums[i]//2
            
            
        return operations
                        
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))[2:]) - 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        for i in range(len(nums)):
            if nums[i]%2:
                nums[i] -= 1
                res += 1
        if any(nums):
            nums = [i//2 for i in nums]
            return res + 1 + self.minOperations(nums)
        else:
            return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        arr = nums[:]
        res = 0
        while any(arr):
            odd = sum([x % 2 == 1 for x in arr])
            if odd:
                arr = [x - x % 2 for x in arr]
                res += odd
            else:
                arr = [x // 2 for x in arr]
                res += 1
        return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # print()
                
        res = 0
        while any(nums):
            ones = sum(num & 1 for num in nums)
            res += ones
            nums = [num >> 1 for num in nums]
            res += 1
            # print(ones, nums, res)
            
        return res - 1
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op=0
        a=[0]*len(nums)
        # print(a)
        # def modify(arr:List[int],op:int)-> None:
        while(nums!=a):
            # print(nums)
            for i in range(len(nums)):
                if nums[i]%2==0:
                    nums[i]=nums[i]//2
                else:
                    op+=1
                    nums[i]-=1
                    nums[i]=nums[i]//2
            op+=1
            # modify(nums,op)
        return (op-1)
            


class Solution:
    def minOperations(self,nums):
        ret = []
        overall = 0
        for i in nums:
            temp = 0
            if i == 0:
                overall -= 1
            if i % 2 == 1 and i != 1:
                overall += 1
                i -= 1
            while i > 1:
                if i % 2 == 1:
                    overall += 1
                    i -= 1
                else:
                    temp += 1
                    i /= 2
            ret.append(temp)
        return (overall + max(ret) + len(ret))

class Solution:
    
    def getOdd(self, nums):
        for i, n in enumerate(nums):
            if n % 2 == 1:
                return i
        return None
    
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while nums.count(0) != len(nums):
            odd = self.getOdd(nums)
            if odd is None:
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                res += 1
            else:
                for i in range(len(nums)):
                    if nums[i] % 2 == 1:
                        nums[i] = nums[i] - 1
                        res += 1

        return res
            


class Solution:
  def minOperations(self, nums) -> int:
    a = list(sorted(nums))

    moves = 0
    while True:
      # make all even
      for i in range(len(a)):
        if a[i] % 2 == 1:
          moves += 1
          a[i] -= 1

      # check if done
      remaining = 0
      for i in range(len(a)):
        if a[i] > 0:
          remaining += 1
      if remaining == 0:
        break

      # divide by 2
      moves += 1
      for i in range(len(a)):
        a[i] = a[i] // 2

    return moves



class Solution:
    def minOperations(self, A):
        
        steps, n = 0, len(A)
        while True:
            zeros = 0
            for i in range(n):
                if A[i] % 2 > 0:
                    A[i] -= 1
                    steps += 1
                if A[i] == 0:
                    zeros += 1
            if zeros == n:
                break
            for i in range(n):
                A[i] >>= 1
            steps += 1
        return steps
                
                
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeros, ops = 0, 0
        while zeros != len(nums):
            odds, evens, zeros = 0, 0, 0
            for i in range(0, len(nums)):
                #print(nums)
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    odds += 1
                
                if nums[i] == 0:
                    zeros += 1
                else:
                    evens += 1
                    nums[i] //= 2
            ops += odds
            ops += 1 if evens else 0
        return ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op1 = op2 = 0
        for num in nums:
            count1 = count2 = 0
            while num:
                if num & 1:
                    count1 += num & 1
                    num -= 1
                if num:
                    count2 += 1
                num >>= 1
            op1 += count1
            op2 = max(op2, count2)
        return op1 + op2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res, val = 0, sum(nums)
        while val:
            val0 = val
            for i, x in enumerate(nums):
                if x % 2:
                    nums[i] -= 1
                    val -= 1
            res += val0 - val
            if val == val0:
                for i in range(len(nums)):
                    nums[i] //= 2
                val //= 2
                res += 1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        minops = 0
        while sum(nums)>0:
            for i,num in enumerate(nums):
                if num&1: 
                    nums[i] -= 1
                    minops += 1
            nums = [num>>1 for num in nums]
            minops += 1
        return minops-1


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        maxn=0
        res=0
        for i in range(len(nums)):
            if(nums[i]>0):
                #res+=1
                if( nums[i]>0  ):
                    count=0
                    n=nums[i]
                    while(n>0):
                        if(n%2>0):
                            res+=1
                            n=n-1
                        else:
                            count+=1
                            n=n//2
                    if(count>maxn):
                        maxn=count
        return(res+maxn)        
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        odds: List[int] = [n for n in nums if n % 2 == 1]
        evens: Set[int] = [n for n in nums if n != 0 and n % 2 == 0]
        new: List[int] = []
            
        n: int = 0
        n_ops: int = 0

        while len(odds) > 0 or len(evens) > 0:
            if len(odds) > 0:
                n = odds.pop() - 1
                if n > 0:
                    evens.append(n)
            else:
                new = [n // 2 for n in evens]
                odds = [n for n in new if n % 2 == 1]
                evens = [n for n in new if n % 2 == 0]
            
            n_ops += 1
            
        return n_ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def minSteps(num):
            if num == 1:
                return 1            
            if num in memo:
                return memo[num]
            # count only odd numbers
            memo[num] = minSteps(num // 2) if num % 2 == 0 else 1 + minSteps(num - 1)
            
            return memo[num]
        
        def countPowerOfTwo(num):
            if num < 2: 
                return 0
            cnt, cur = 1, 2
            while cur * 2 <= num:
                cnt += 1
                cur <<= 1
            
            return cnt
        
        memo = {}
        # count the power of two for once and only once
        # because it these number can be used by the \"multiply by 2\" operation to all elements
        res = countPowerOfTwo(max(nums))
        for num in nums:
            if num == 0:
                continue
            res += minSteps(num)
        
        return res

import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        p=[]
        ans=0
        for i in nums:
            r=0
            while(i>0):
                if (i%2==0):
                    r+=1
                    i/=2
                else:
                    ans+=1
                    i-=1;
            p.append(r);
        

        ans+=max(p)
        return ans
        
        
        
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        max_count = 0
        
        for num in nums:
            cnt = 0
            while num > 0:
                if num % 2 != 0:
                    num -= 1
                    ans += 1
                else:
                    num /= 2
                    cnt += 1
            max_count = max(max_count, cnt)
        
        return ans + max_count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        big = 0
        
        for i in range(len(nums)):
            k = nums[i]
            k = bin(k)
            ans += k.count('1')
           # print(k)
            big = max(big, 0, len(k)-3)
                        
      #  print(ans, big)
        ans += big
        
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeros, ops = 0, 0
        while zeros != len(nums):
            odds, evens, zeros = 0, 0, 0
            for i in range(0, len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    odds += 1
                
                if nums[i] == 0:
                    zeros += 1
                else:
                    evens += 1
                    nums[i] //= 2
            ops += odds
            ops += 1 if evens else 0
        return ops

class Solution:
    def minOperations_1(self, nums: List[int]) -> int:
        '''        
        Instead of trying to go from 0 array to nums,
        go from nums to 0 array, decrement index by 1
        divide all elements by 2 if divisible by 2
        
        Nevermind this isn't DP, do greedy, divide by
        2 as much as possible then decrement indexes by 1
        
        Repeat until everything is divisble by 2 again
        
        Runtime?
        
        O(3n) inner loop, 32 times outer loop because
        divison by 2 happens frequently which shifts
        '''
        ops = 0
        while not all(n == 0 for n in nums):
            for i, n in enumerate(nums):
                if n % 2 != 0:
                    nums[i] = n - 1
                    ops += 1
            
            if all(n == 0 for n in nums):
                break
            
            nums = [n // 2 for n in nums]
            ops += 1
        
        return ops
    
    def minOperations(self, nums: List[int]) -> int:
        '''
        More efficient way to do this:
        
        Loop through the numbers individually, count
        the number of times you have to subtract 1 and divide
        by 2. Add 1's to total but only take the maximum number
        of times to divide by 2 since division affects everything
        and so only the largest number of divisions gets taken
        into account
        
             24 2 5 
        
        ones  2 1 2
        
        twos  4 1 2
        
        5 + max(twos) = 9
        '''
        op_1 = 0
        op_2 = 0
        for n in nums:
            op_2_cur = 0
            while n > 0:
                if n % 2 != 0:
                    op_1 += 1
                    n -= 1
                else:
                    op_2_cur += 1
                    n = n // 2
            
            op_2 = max(op_2, op_2_cur)
        
        return op_1 + op_2
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def get_counts(x):
            if x == 0:
                return 0, 0
            elif x % 2 == 0:
                add_count, mul_count = get_counts(x // 2)
                return add_count, mul_count+1
            else:
                add_count, mul_count = get_counts(x - 1)
                return add_count + 1, mul_count
        add_count, mul_count = 0, 0
        for num in nums:
            ac, mc = get_counts(num)
            add_count += ac
            mul_count = max(mc, mul_count)
        return add_count + mul_count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op=0
        while True:
            doDivision=0
            NoZero=1
            for i in range(len(nums)):
                if nums[i]!=0:
                    NoZero=0
                if nums[i]%2==1:
                    nums[i]-=1
                    op+=1
                if nums[i]!=1 and nums[i]!=0:
                    doDivision=1  
                    nums[i]//=2
            if doDivision==1:
                op+=1
                
            if NoZero==1:
                return op


from typing import Tuple
class Solution:
    def ones_twos(self, n: int, ones: int, twos: int) -> Tuple[int,int]:
        if n==0:
            return ones, twos
        if n==1:
            return ones+1, twos
        if n%2==0:
            return self.ones_twos(n//2, ones, twos+1)
        else:
            return self.ones_twos(n-1, ones+1, twos)
        
        
    def minOperations(self, nums: List[int]) -> int:
        ones, twos = 0, 0
        for num in nums:
            o,t = self.ones_twos(num, 0, 0)
            ones += o
            twos = max(twos, t)
        return ones+twos
            
        


from collections import deque
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        step = 0
        while len(nums):
            for i, val in enumerate(nums):
                if val % 2:
                    nums[i] -= 1
                    step += 1
            nums = self.trim(nums)
            if len(nums):
                step += 1
                for i, val in enumerate(nums):
                    if val:
                        nums[i] /= 2
            nums = self.trim(nums)
        return step

    def trim(self, nums):
        return [e for e in nums if e]


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op=0
        while True:
            doDivision=0
            AllZero=1
            for i in range(len(nums)):
                if nums[i]!=0:
                    AllZero=0
                if nums[i]%2==1:
                    nums[i]-=1
                    op+=1
                if nums[i]!=1 and nums[i]!=0:
                    doDivision=1  
                    nums[i]//=2
            if doDivision==1:
                op+=1
                
            if AllZero==1:
                return op


class Solution1:
    def minOperations(self, nums: List[int]) -> int:
        twos = 0
        ones = 0
        for n in nums:
            mul = 0
            while n:
                if n%2: # odd number, just delete 1 so that it's now a multiple of 2
                    n -= 1
                    ones += 1
                else: # multiple of 2, so just divide by 2 
                    n //= 2
                    mul += 1
            twos = max(twos, mul)
        return ones + twos
    
class Solution:
    def minOperations(self, nums: List[int]) -> int:

        maxval = max(nums)
        idx = nums.index(maxval)
        ans = 0

        while nums[idx]!=0:
            for i,n in enumerate(nums):
                ans += n%2 # minus 1 to make all number even
                nums[i] = n-n%2
            if nums[idx]!=0: 
                for i, n in enumerate(nums): # devide all numbers by 2
                    nums[i]=nums[i]//2
                ans += 1
        
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        a = [x for x in nums if x]
        while a:
            # print(a, res)
            for i, x in enumerate(a):
                if x & 1:
                    a[i] -= 1
                    res += 1
            a = [x // 2 for x in a if x]
            if a: # if we halved any numbers
                res += 1
        return res


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum( bin(x).count('1') for x in nums ) + max(len(bin(x)) for x in nums ) - 3
            
                
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        lru_cache(maxsize=None)
        def check(n):
            if n == 0:
                return (0, 0)
            elif n == 1:
                return (1, 0)
            else:
                r1 = 0
                r2 = 0

                k, l = divmod(n, 2)
                r1, r2 = check(k)
                r1 += l
                r2 += 1
            return r1, r2
            
        #   倒着转换
        r1 = 0  #   op1 的次数，累加
        r2 = 0  #   op2 的次数，求最大
        for n in nums:
            c1, c2 = check(n)
            r1 += c1
            r2 = max(r2, c2)
        
        return r1 + r2

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeros = []
        operations = 0
        for item in nums:
            zeros.append(0)
        
        while nums != zeros:
            for index,item in enumerate(nums):
                if item%2==1:
                    nums[index]=item-1
                    operations +=1
                    
            if nums==zeros:
                break 
            for index, item in enumerate(nums):
                if item%2==0:
                    nums[index] = item/2
            operations +=1 
        
        return operations
            
            
                
                
            
            
            
            
        
                
                    
                    
                
                    
            
            
    
            
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans=0
        count = collections.Counter()
        for n in nums:
            if n != 0:
                count[n] += 1
        while len(count) > 0:
            newcount = collections.Counter()
            for k,v in count.items():
                if k%2 == 0:
                    newcount[k//2] += v
                elif k > 1:
                    newcount[(k-1)//2] += v
                    ans += v
                else:
                    ans += v
            ans += 1
                    
            count = newcount
        return ans-1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            for i in range(len(nums)):
                if nums[i]%2: 
                    count += 1
                    nums[i] -= 1
                nums[i] //= 2
            if not sum(nums): return count
            count += 1
        return count-1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def _op(arr):
            odds, zeros = 0, 0
            for i in range(len(arr)):
                if arr[i] == 0:
                    zeros += 1
                elif arr[i]%2 == 1:
                    arr[i] -= 1
                    odds += 1
            if zeros == len(arr):
                return 0
            if odds != 0:
                return odds
            for i in range(len(arr)):
                arr[i] //= 2
            return 1
        
        ans = 0
        ops = _op(nums)
        while ops != 0:
            ans += ops
            ops = _op(nums)
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        #print(nums)
        
        ops = 0
        
        if not any(n != 0 for n in nums):
            return 0
        
        while nums:
            if any((n % 2 != 0) for n in nums):
                #print(\"Not all even\")
                for idx,n in enumerate(nums):
                    #print(\"iterating on idx={} and n={}\".format(idx, n))
                    if nums[idx] % 2 != 0:
                        nums[idx] -= 1
                        ops += 1
                nums = [n for n in nums if n!=0]
                #print(nums)
            else:
                #print(\"All even\")
                ops += 1
                nums = [int(n / 2) for n in nums]
                #print(nums)
            
        return ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        steps = 0
        nums = sorted(nums)
        j = -1
        while(j < len(nums)-1): # not every elements are 0
            s = j+1 # calculate steps for next non_zero item
            while s < len(nums):
                if nums[s] == 0:
                    j+=1
                elif nums[s] == 1:
                    steps+=1
                    j+=1
                    nums[s] = 0
                elif nums[s]%2 == 1:
                    steps += 1
                    nums[s] -= 1
                    nums[s] //= 2
                else:
                    nums[s] //= 2
                s += 1
            steps += 1
                
  
            
        return steps - 1
        
        
        
    
    
    
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        N = len(nums)
        res = 0
        while True:
            for i in range(N):
                res += nums[i] % 2
                nums[i] = (nums[i] - nums[i] % 2) // 2
            if all(n == 0 for n in nums):
                return res
            res += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        def do(n):
            a, b = 0, 0
            while n != 0:
                if n % 2 == 1:
                    a += 1
                    n -= 1
                else:
                    b += 1
                    n //= 2
            return [a, b]
        
        aa, bb = 0, 0
        for n in nums:
            a, b = do(n)
            aa += a
            bb = max(b, bb)
        return aa + bb

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        d = max(nums)
        
        if d==0:
            return 0
        
        res = 0
        while d>=2:
            res += 1
            d >>= 1
            

        for num in nums:
            while num:
                res += 1
                num &= (num-1)
            
        return res


import math
class Solution:
    
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        power = [0]*n
        rem = [0]*n
        for i in range(n):
            j = nums[i]
            count1 = 0
            count2 = 0 
            while j > 0:
                if j%2 == 0:
                    count1+=1
                    j = j//2
                else:
                    count2+=1
                    j = j - 1
            power[i], rem[i] = count1, count2
        ans = max(power) + sum(rem)
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        arr = [0] * len(nums)
        if arr == nums:
            return 0
        ops = 0
        while arr != nums:
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ops += 1
            ops += 1
            nums = [x / 2 for x in nums]
        return ops - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def odd_2_even(nums):
            step = 0
            new_nums = []
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    step += 1
                    nums[i] -= 1
                    if nums[i] > 0:
                        new_nums.append(nums[i])
                elif nums[i] > 0:
                    new_nums.append(nums[i])
            return step,new_nums
        
        def even_2(nums):
            return [a//2 for a in nums]
        
        step = 0
        while len(nums) > 0:
            add,nums = odd_2_even(nums)
            if len(nums) > 0:
                nums = even_2(nums)
                step += 1
            step = step + add
        
        return step

class Solution:
  def minOperations(self, nums: List[int]) -> int:
    cost = 0
    d = 0
    for a in nums:
      division, increments = self.trick(a)
      d = max(division, d)
      cost += increments
    return d + cost
  
  def trick(self, mx):
    if mx in {0, 1}:
      return (0, 0) if mx == 0 else (0, 1)
    if mx % 2 == 0:
      d, i = self.trick(mx // 2)
      return (d + 1, i)
    else:
      d, i = self.trick(mx - 1)
      return (d, i + 1)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0
        
        result_num_div = 0
        for i in range(len(nums)):
            num_div = 0
            while nums[i] > 0:
                if nums[i] % 2 == 1:
                    result += 1
                    nums[i] -= 1
                if nums[i] > 1:
                    num_div += 1
                nums[i] /= 2
            result_num_div = max(result_num_div , num_div)
        return result + result_num_div

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        n = len(nums)
        while True:
            i = 0
            zc = 0
            while i < n:
                if (nums[i]&1) > 0:
                    break
                elif nums[i] == 0:
                    zc += 1
                i+=1
            if zc == n:
                return res
            if i == n:
                for j in range(n):
                    nums[j] = nums[j]//2
                res+=1
            for j in range(i,n):
                if nums[j]&1:
                    nums[j]-=1
                    res+=1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def count_ops(x: int) -> int:
            if x == 0: return (0, 0)
            elif x == 1: return (1, 0)
            elif x % 2 == 0:
                add, mul = count_ops(x // 2)
                return (add, mul+1)
            else:
                add, mul = count_ops(x-1)
                return (add+1, mul)
        
        count = maxmul = 0
        for i in nums:
            add, mul = count_ops(i)
            maxmul = max(maxmul, mul)
            count += add
        return count + maxmul

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans=0
        cnt=len(nums)
        for n in nums:
            if n==0:cnt-=1
        while cnt>0:
            for i,n in enumerate(nums):
                if n!=0 and n%2==1:
                    nums[i]-=1
                    ans+=1
                    if nums[i]==0:cnt-=1
            two=0
            for i,n in enumerate(nums):
                if n!=0 and n%2==0:
                    two=1
                    nums[i]//=2
            ans+=two
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        arr = [0]*len(nums)
        count=0
        while nums!=arr:
            check = True
            for x in nums:
                if x%2!=0:
                    check = False
            if check==True:
                count+=1
                for x in range(len(nums)):
                    nums[x]=nums[x]//2
            for x in range(len(nums)):
                if nums[x]%2!=0:
                    nums[x]=nums[x]-1
                    count+=1
        return count
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(num).count('1') for num in nums)+len(bin(max(nums)))-3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        out = 0 
        while sum(nums) != 0 :
            
            for i in range(len(nums)):
                if nums[i] %2 == 1:
                    nums[i] -= 1
                    out += 1
            
            if sum(nums) == 0 :
                break
            for i in range(len(nums)):
                nums[i] /= 2
            
            out += 1
        return out
    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while (sum(nums)):
            
            for i in range(len(nums)):
                if nums[i]%2 == 1:
                    nums[i] -= 1
                    count += 1
                nums[i] = nums[i]//2
            count += 1
            
        return count - 1
                    
            
                    
        


from copy import deepcopy

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def modify(arr, op, idx):
            if op == 0:
                arr[idx] = arr[idx] - 1
            elif op == 1:
                for i, num in enumerate(arr):
                    arr[i] = num // 2
                    
        zeros = [0] * len(nums)
        ans = 0
        while True:
            for i, num in enumerate(nums):
                if num % 2 == 1:
                    nums[i] = num - 1
                    ans += 1
                    
            if nums == zeros:
                return ans
            else:
                modify(nums, 1, 0)
                ans += 1
            
        return ans
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ops = 0
        N = len(nums)
        
        while True:
            n = 0
            alleven = True
            for i, num in enumerate(nums):
                if num == 0:
                    n += 1
                else:
                    if num % 2:
                        nums[i] -= 1
                        if num == 0: n += 1
                        alleven = False
                        ops += 1
                        
            if n == N:
                break 
            
            if alleven:
                for i in range(N):
                    if nums[i]:
                        nums[i] = nums[i] // 2
                ops += 1
        
        
        return ops


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0
        while True:
            to_continue = False
            ops = 0
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                elif nums[i] % 2 == 1:
                    nums[i] -= 1
                    ops += 1
                    to_continue = True
                else:
                    to_continue = True
            if ops > 0:
                result += ops
            elif to_continue:
                result += 1
                for i in range(len(nums)):
                    nums[i] //= 2
            else:
                break
        
        return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:   
        val=max(nums)

        double=0
        add=0
        value=0
        count=0
        value=val
        while value!=0:
            
            if value%2==0:
                value=value//2
                double+=1
            else:
                value-=1
                add+=1    
        count+=double
        print(add,double)
        for x in nums:
            value=x
            half=0
            add=0
            while value!=0:
                if value%2==0:
                    value=value//2
                    half+=1
                else:
                    value-=1
                    add+=1
               
            count+=add
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        count = 0
        nums = [num for num in nums if num]
        if not nums:
            return 0
        while nums:
            flag = False
            new_nums = []
            for num in nums:
                if num % 2:
                    flag = True
                    break
            if flag:
                for num in nums:
                    if num % 2:
                        num = num - 1
                        count += 1
                    if num:
                        new_nums.append(num)
            else:
                for num in nums:
                    new_nums.append(num / 2)
                count += 1
            nums = new_nums
        return count
        


class Solution:
    
    def minOperations(self, nums: List[int]) -> int:
        operations = 0
        while not all(n == 0 for n in nums):
            if all(n % 2 == 0 for n in nums):
                nums = [n / 2 for n in nums]
                operations += 1
            else:
                for i, num in enumerate(nums):
                    if num % 2 != 0:
                        nums[i] = num - 1
                        operations += 1
        return operations
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans_count = 0
        while True:
            zero_count = 0
            have_odd = False
            ## op1
            for idx in range(len(nums)):
                if nums[idx] % 2 != 0:
                    have_odd = True
                    ans_count += 1
                    nums[idx] -= 1
                if nums[idx] == 0:
                    zero_count += 1
            ## check if all zero(break)
            if zero_count == len(nums):
                break
            ## op2
            if not have_odd:
                ans_count += 1
                for idx in range(len(nums)):
                    nums[idx] //= 2
            #print(nums, ans_count, zero_count)

        return ans_count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            ans += sum(n % 2 for n in nums)
            if any(n > 1 for n in nums):
                ans += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # l = len(nums)
        sol = nums
        cost = 0 
        # print(len(sol))
        while sum(sol)>0:
            for i in range(len(sol)):
                # print(sol[i]&1)
                if sol[i]&1 != 0:
                    sol[i]-=1
                    cost+=1
            # print('sol after odd flip :',sol)
            if len(sol)>0:
                sol = [x//2 for x in sol if x>0]
                if len(sol)>0:
                    cost+=1
            # print('sol after /2 :',sol)
        return cost 

            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        delete_count = 0
        divide_count = 0
        for e in nums:
            divide = 0
            while e != 0:
                if e % 2:
                    e -= 1
                    delete_count += 1
                else:
                    e /= 2
                    divide += 1
            divide_count = max(divide_count, divide)
        return delete_count + divide_count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # do it the other way around
        n_op = 0
        l = len(nums)
        target = l*[0]
        while nums != target:
            if all(i%2 == 0 for i in nums):
                nums = [i/2 for i in nums]
                n_op+=1
            else:
                for i in range(l):
                    if nums[i]%2 == 1:
                        nums[i]-=1
                        n_op+=1
        return n_op

class Solution:
    
    def minOperations(self, nums: List[int]) -> int:
        ans=0
        ma=0
        for n in nums:
            k=0
            while(n!=0):
                if(n%2==0):
                    k+=1
                    n=n//2
                else:
                    n-=1
                    ans+=1
                ma=max(ma,k)
        return ans+ma
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        '''        
        Instead of trying to go from 0 array to nums,
        go from nums to 0 array, decrement index by 1
        divide all elements by 2 if divisible by 2
        
        Nevermind this isn't DP, do greedy, divide by
        2 as much as possible then decrement indexes by 1
        
        Repeat until everything is divisble by 2 again 
        
        4 2 5 
        
        4 2 4  + 1
        
        2 1 2  + 1
        
        2 0 2  + 1
        
        1 0 1  + 1
        
        0 0 0  + 2
        '''
        ops = 0
        while not all(n == 0 for n in nums):
            for i, n in enumerate(nums):
                if n % 2 != 0:
                    nums[i] = n - 1
                    ops += 1
            
            if all(n == 0 for n in nums):
                break
            
            nums = [n // 2 for n in nums]
            ops += 1
        
        return ops
    
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        divied2 = 0
        res = 0
        for i in nums:
            temp = 0
            while i>0:
                if i % 2 == 0:
                    i //= 2
                    temp += 1
                else:
                    i -= 1
                    res += 1
                divied2 = max(divied2, temp)
            #print(res)
        return res + divied2
                    
        # max_ = max(nums)
        # dp = [(float('inf'),float('inf'),float('inf'))]*(max_+1)
        # dp[0] = (0,0,0)
        # dp[1] = (1,1,0)
        # dp[2] = (2,1,1)
        # for i in range(3, len(dp)):
        #     if i % 2 == 0:
        #         if dp[i//2][0]+1 > dp[i-1][0]+1:
        #             dp[i] = (dp[i-1][0]+1, dp[i-1][1]+1, dp[i-1][2])
        #         else:
        #             dp[i] = (dp[i//2][0]+1, dp[i-1][1], dp[i-1][2]+1)
        #     else:
        #         dp[i] = (dp[i-1][0]+1, dp[i-1][1]+1, dp[i-1][2])
        # print(dp)
        # temp = 0
        # res = 0
        # for i in nums:
        #     temp = max(temp, dp[i][2])
        #     res += dp[i][1] 


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        double = 0
        
        for i in range(len(nums)):
            cd = 0
            while nums[i] > 0:
                if nums[i] % 2 == 1:
                    count += 1
                cd += 1
                nums[i] //= 2
            double = max(double,cd)
            
        return count + double - 1 

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        counter = 0
        while 1:
            temp_counter = 0
            bigger_than_zero = 0
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    temp_counter += 1
                    nums[i] -= 1
                if nums[i] > 0:
                    bigger_than_zero += 1
                    temp = bin(nums[i])
            counter += temp_counter
            if bigger_than_zero == 0 :
                return counter

            counter += 1
            for i in range(len(nums)):
                nums[i] //= 2
        return counter

class Solution:
    def minOperations(self, A: List[int]) -> int:
        return sum(bin(a).count('1') for a in A) + len(bin(max(A))) - 3        

masks = [0b01010101010101010101010101010101,
         0b00110011001100110011001100110011,
         0b00001111000011110000111100001111,
         0b00000000111111110000000011111111,
         0b00000000000000001111111111111111]

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        totOddRem = 0
        maxX = nums[0]
        for x in nums:
            if x == 1:
                totOddRem += 1
            else:                
                xCopy = x
                for p, m in enumerate(masks):
                    xCopy = (xCopy & m) + ((xCopy & ~m) >> (1 << p))
                totOddRem += xCopy
            if x > maxX:
                maxX = x
                
        leftMost = 0
        step = 16
        for m in reversed(masks):
            m = ~m
            if m & maxX != 0:
                leftMost += step
                maxX &= m
            step >>= 1       
                    
        return totOddRem + leftMost

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        onesCount = 0
        aboveOneIdxs = []
        for idx, n in enumerate(nums):
            if n == 1:
                onesCount += 1
            elif n > 1:
                aboveOneIdxs.append(idx)
                
        while onesCount + len(aboveOneIdxs) != 0:
            count += onesCount
            onesCount = 0
            newAboveOneIdxs = []
            for idx in aboveOneIdxs:
                if nums[idx] % 2 != 0:
                    nums[idx] -= 1
                    count += 1
                nums[idx] //= 2
                if nums[idx] == 1:
                    onesCount += 1
                else:
                    newAboveOneIdxs.append(idx)
            if len(aboveOneIdxs) > 0:
                count += 1 # multiplied by 2
            aboveOneIdxs = newAboveOneIdxs
                    
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n=len(nums)
        noz=0
        nosteps=0
        while(noz!=n):
            noz=0
            noe=0
            noo=0
            for i in range(len(nums)):
                if(nums[i] == 0):
                    noz+=1
                    noe+=1
                elif(nums[i]%2 == 0):
                    noe+=1
                    nums[i]=nums[i]//2
                else:
                    noo+=1
                    nums[i]-=1
                    nums[i]=nums[i]//2
            nosteps+=noo
            if(noz==n):
                break
            nosteps+=1
        return nosteps-1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # After having implemented minOperations_dumb_solution(), we realize that 
        # the number of op 1 we'll need to do is just the number of times we need
        # to divide the max even number we ever encounter to get it down to zero. 
        # Because, a division would reduce everyone by 2 and when the smaller even
        # numbers we see gets down to zero, it will no longer be affected. We only care
        # about dividing the biggest even number down to zero.
        cost = 0
        max_nb_op_1 = 0
        for i in range(len(nums)):
            nb_op_0 = nb_op_1 = 0
            x = nums[i]
            while x > 0:
                if x % 2 != 0:
                    nb_op_0 += x % 2
                    x -= x % 2
                if x > 0:
                    nb_op_1 += 1
                    x = x // 2
            cost += nb_op_0
            max_nb_op_1 = max(max_nb_op_1, nb_op_1)
        cost += max_nb_op_1
        return cost
    
    def minOperations_dumb_solution(self, nums: List[int]) -> int:
        # Key insight is if nums[i] is odd, there's no way we could have arrived at nums[i]
        # via op 1, i.e. by multiplying by 2 some previous value. So the only way we could
        # have gotten here is by using op 0, nums[i] % 2 times. That is we need to skim off
        # the remainder part that makes it non-even before we can consider using op 1.
        cost = 0
        while True:
            all_zeros = True
            all_evens = True
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                
                all_zeros = False
                if nums[i] % 2 != 0:
                    cost += nums[i] % 2
                    nums[i] = nums[i] - (nums[i] % 2)
                    all_evens = False
            
            if all_zeros:
                break
            while all_evens:
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                    if nums[i] % 2 != 0:
                        all_evens = False
                cost += 1
                
        return cost
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        num_operations = 0
        
        odd = True
        even = False
        
        while odd or even:
            if odd:
                for i in range(len(nums)):
                    if nums[i] != 0:
                        if nums[i] % 2:
                            nums[i] -= 1
                            num_operations += 1
                        if nums[i]:
                            even = True
                odd = False
                
            if even:
                num_operations += 1
                for i in range(len(nums)):
                    nums[i] /= 2
                    if nums[i] % 2:
                        even = False
                        odd = True
                        
        
        return num_operations

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        
        def modify(arr, op, ind):
            if op == 0:
                arr[ind] = arr[ind] + 1
            if op == 1:
                for i in range(len(arr)):
                    arr[i] = arr[i] * 2
            return arr
        
        arr = [0] * n
        # print(arr)
        # interesting how would you go about solving this?
        # is there a greedy solution
        # so for example every non 0 elt in the array
        # need a +1 operation to make it non zero
        # if a value is odd and not one we need a min of 
        # 3 operations to get to where it needs to be
        # 
        # can cache number of ops probably
        # print(nums)
        ops_needed = 0
        check_ind = 0
        nums.sort(key = lambda x: -x)
        while any(n!=0 for n in nums):
            for ind, numb in enumerate(nums):
                if numb >= 1 and numb % 2 == 1:
                    ops_needed += 1
                    # print(\"odd: \", nums, ops_needed)
                    nums[ind] = nums[ind] - 1
            
            for numb in nums:
                if numb >= 1 and numb % 2 == 0:
                    ops_needed += 1
                    # print(\"even: \", nums, ops_needed)
                    for ind, elt in enumerate(nums):
                        nums[ind] = nums[ind] / 2
                    break
                        
            check_ind += 1
            if check_ind > 100:
                break
            # nums.sort(key = lambda x: -x)
        return ops_needed

class Solution:
    def makeHalf(self, a):
        for i in range(len(a)):
            a[i] //= 2
            
    def makeEven(self, a):
        c = 0
        for i in range(len(a)):
            if a[i]%2 == 0:
                continue
            else:
                a[i] -= 1
                c+=1
        return c
    def minOperations(self, nums: List[int]) -> int:
        op = 0
        while sum(nums) != 0:
            op += self.makeEven(nums)
            if sum(nums) == 0:
                return op
            self.makeHalf(nums)
            op +=1
        return op


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        counter = 0
        while 1:
            temp_counter = 0
            bigger_than_zero = 0
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    temp_counter += 1
                    nums[i] -= 1
                if nums[i] > 0:
                    bigger_than_zero += 1
                    temp = bin(nums[i])
            counter += temp_counter
            if bigger_than_zero == 0 :
                return counter

            counter += 1
            
            for i in range(len(nums)):
                nums[i] //= 2
        return counter

import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
      res = 0
      while sum(nums) != 0:
        counts = sum([x % 2 == 0 for x in nums])
        if counts == len(nums):
          for i in range(len(nums)):
            nums[i] = nums[i]//2
          res += 1
        else:
          for i in range(len(nums)):
            if nums[i] % 2 != 0:
              nums[i] -= 1
              res += 1
      return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        print(0 % 2)
        step = 0
        while any(( n > 0 for n in nums)):
            # print('nums', nums)
            if all((n % 2 == 0 for n in nums)):
                nums = [n // 2 for n in nums]
                step += 1
            else:
                # find odd element
                remain_idx = []
                for i, v in enumerate(nums):
                    if v % 2 == 1:
                        nums[i] = nums[i] - 1
                        if nums[i] == 0:
                            # remain_idx.append(i)
                            del nums[i]
                        step += 1
                # nums = [ nums[ri] for ri in remain_idx]
        return step

masks = [0b01010101010101010101010101010101,
         0b00110011001100110011001100110011,
         0b00001111000011110000111100001111,
         0b00000000111111110000000011111111,
         0b00000000000000001111111111111111]

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        totOddRem = 0
        maxX = nums[0]
        for x in nums:
            if x == 1:
                totOddRem += 1
            else:                
                xCopy = x
                for p, m in enumerate(masks):
                    xCopy = (xCopy & m) + ((xCopy & ~m) >> (1 << p))
                totOddRem += xCopy
            if x > maxX:
                maxX = x
                
        leftMost = 0
        step = 16
        for m in reversed(masks):
            mr = ~m
            if mr & maxX != 0:
                leftMost += step
                maxX &= mr
            step >>= 1       
                    
        return totOddRem + leftMost

class Solution:
    def minOperations(self, A: List[int]) -> int:
        
        def even(A):
            for i in range(len(A)):
                A[i]//=2
            return A
        
        def odd(A):
            c=0
            z=0
            for i in range(len(A)):
                if A[i]%2==1:
                    A[i]-=1
                    c+=1
                    if A[i]==0:
                        z+=1
            return A,c,z
        
        res=0
        zero=0
        for i in A:
            if i==0:
                # res+=1
                zero+=1
        
        while(zero<len(A)):
            A,c,z=odd(A)
            zero+=z
            res+=c
            
            if zero<len(A):
                A=even(A)
                res+=1
        return res
        # A=[]
        # for i in range(1, 10001):
        #     A.append(i)
        # print(A)

        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        res={}
        for i in range(len(nums)):
            if nums[i]!=0:
                res[i]=nums[i]
        zeros=[]
        while res:
            zeros.clear()
            for key in res:
                if res[key]%2!=0:
                    res[key]-=1
                    count+=1
                    minus=True
                if res[key]==0:
                    zeros.append(key)
            for zero in zeros:
                res.pop(zero)
            if res:
                for key in res:
                    res[key]//=2
                count+=1
        return count
            
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            temp = [0] * len(nums)
            flag = False
            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    flag = True
                    ans += 1
                elif not flag and not nums[i] % 2:
                    temp[i] = nums[i] // 2
            if not flag:
                ans += 1
                nums = temp
            #print(nums)
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums.sort(reverse=True)
        s = sum(nums)
        res = 0
        while s:
            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    res += 1
            s = 0
            nums = list([x for x in nums if x>0])
            if not nums:
                break
            # mineve = min(nums)
            for i in range(len(nums)):
                nums[i] //= 2
                s += nums[i]
            res += 1
        return res
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # try to get to same distance from the 2's time
        nops = 0
        all_z = False
        while not all_z: 
            all_z = True
            op2_mark = False
            for idx, val in enumerate(nums): 
                if val != 0: 
                    all_z = False
                else: 
                    continue
                if val % 2 ==0: 
                    if not op2_mark: 
                        nops += 1
                        op2_mark = True
                    nums[idx] /= 2
                else: 
                    nops += 1
                    if (nums[idx] -1) > 0: 
                        if not op2_mark: 
                            nops += 1
                            op2_mark = True
                    nums[idx] = (nums[idx] -1 ) / 2
        return nops
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        seen_nonzero = True
        while True:
            all_zeros = True
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ans += 1
                if nums[i] > 0:
                    all_zeros = False
                    
            if all_zeros:
                break
                
            for i in range(len(nums)):
                nums[i] = nums[i] // 2
            ans += 1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0

        
        while True:
            for i, x in enumerate(nums):
                if x & 1:
                    result += 1
                    nums[i] -= 1
            if all(x == 0 for x in nums):
                return result
            
            for i, x in enumerate(nums):
                nums[i] //= 2
            result += 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans = 0
        
        while sum(nums) != 0:
            tmp = nums.copy()
            ones_tmp = nums.copy()
            cnt = 0
            ones_cnt = 0
            flag = False
            for i,a in enumerate(nums):
                if a == 1:
                    ones_cnt += 1
                    ones_tmp[i] = 0
                    flag = True
                
                tmp[i] = nums[i] // 2
                cnt += nums[i] % 2
            
            if flag:
                ans += ones_cnt
                nums = ones_tmp[:]
            else:
                ans += cnt + 1
                nums = tmp[:]
        
        return ans
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while nums != [0] * len(nums):
            for i in range(len(nums)):
                if nums[i] == 1:
                    nums[i] -= 1
                    res += 1
                elif nums[i] % 2 == 1:
                    nums[i] -= 1
                    res += 1
            if nums == [0] * len(nums):
                break
            for i in range(len(nums)):
                nums[i] //= 2
            res += 1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        #print(nums)

        
        ret = 0
        for i, x in enumerate(nums):
            if x % 2:
                ret += 1
                nums[i] -= 1
        
        if all(x == 0 for x in nums):
            return ret
        
        for i, x in enumerate(nums):
            nums[i] //= 2
        ret += 1
        #print(nums, ret)
        return ret + self.minOperations(nums)

class Solution:
    def minOperations(self, nums: List[int]) -> int:

        count = 0
    
        while 1:
            
            for i, vi in enumerate(nums):
                
                if vi&1:
                    count += 1
                    nums[i] = vi - 1
                        
            
            chk = True
            
            for i, vi in enumerate(nums):
                if vi > 0:
                    chk = False
                nums[i] = vi // 2
                
            if chk:
                break
                
            count += 1
            
                
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeros = sum([num==0 for num in nums])
        odds = set([i for i in range(len(nums)) if nums[i]%2])
        n = len(nums)
        count = 0
        while zeros < n:
            if odds:
                for oddidx in odds:
                    nums[oddidx] = nums[oddidx]-1
                    if nums[oddidx] == 0:
                        zeros += 1
                count += len(odds)
                odds = set()
            else:
                for i in range(n):
                    if nums[i] > 0:
                        nums[i] = nums[i]//2
                        if nums[i]%2:
                            odds.add(i)
                count += 1
        return count
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n , res = len(nums), 0
        mul = [0] * n
        for i in range(n):
            while nums[i]!= 0:
                if nums[i]%2:
                    res += 1
                    nums[i] -= 1
                else:
                    mul[i] += 1
                    nums[i] //= 2
            
        return res + max(mul)
                
           
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        s = sum(nums)
        while s!=0:
            nums_2 = [num%2 for num in nums]
            diff = sum(nums_2)
            if diff==0:
                nums = [num//2 for num in nums]
                ans += 1
                s //= 2
            else:
                ans += diff
                s -= diff
                nums = [nums[i]-nums_2[i] for i in range(n)]
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cost = 0
        while True:
            all_zeros = True
            all_evens = True
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                
                all_zeros = False
                if nums[i] % 2 != 0:
                    cost += nums[i] % 2
                    nums[i] = nums[i] - (nums[i] % 2)
                    all_evens = False
            
            if all_zeros:
                break
            if all_evens:
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                cost += 1
                
        return cost
                    


class Solution:
    def minOperations(self, nums):
        add_operations = {}
        result = 0
        max_m = 0
        
        
        for i in nums:
            current = i
            if current in add_operations:
                result += add_operations[current]
            else:
                add_amount = 0
                multiplying_amount = 0
                
                while current:
                    if current % 2:
                        add_amount += 1
                        current -= 1
                    else:
                        multiplying_amount += 1
                        current = current / 2
                max_m = max(max_m, multiplying_amount)
                result += add_amount
                add_operations[i] = add_amount
        return result + max_m
                        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        mmax = float('inf')
        while mmax > 0:
            mmax = 0
            for i in range(len(nums)):
                if nums[i]&1 == 1:
                    nums[i] -= 1
                    res += 1
                mmax = max(mmax, nums[i])
            if mmax > 0:
                nums = [x//2 for x in nums]
                res += 1
        return res
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        self.ans = 0
        self.nums = nums
        ## ALL numbers are even now
        def manipulate():
            for i in range(len(self.nums)):
                if self.nums[i] % 2 == 1:
                    self.ans += 1
                    self.nums[i] -= 1
            
            ### TRY maximum divide
            def allEven():
                for num in self.nums:
                    if num % 2 == 1:
                        return False
                return True
            if AllZero():
                return
            while allEven():
                self.nums = [num / 2 for num in self.nums]
                self.ans += 1
        
        
        def AllZero():
            for num in self.nums:
                if num != 0:
                    return False
            return True
        
        while not AllZero():
            manipulate()
        return int(self.ans)
        
        


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        m = max(nums)
        n = math.floor(math.log(m,2))
        res = 0
        while n >= 1:
            #print(nums)
            for i, num in enumerate(nums):
                if num >= 2**n:
                    if num%2 == 1:
                        res += 1
                        nums[i] = (nums[i]-1)/2
                    else:
                        nums[i] = nums[i]/2
            res += 1
            n = n-1
        for num in nums:
            if num == 1:
                res += 1
        return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        total = sum(nums)

        while total != 0:
            evens = 0
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    nums[i] -= 1
                    res += 1
                    total -= 1
                else:
                    evens += 1
            
            if evens == len(nums):
                for i in range(len(nums)):
                    nums[i] /= 2
                    total -= nums[i]
                res += 1
        
        return res

class Solution:
    def pow2(self, num):
        addition = 0
        mult = 0
        while num > 0:
            if num % 2 == 0:
                num = num // 2
                mult += 1
            else:
                num -= 1
                addition += 1
        return (mult, addition)
    
    def minOperations(self, nums: List[int]) -> int:
        result, _ = self.pow2(max(nums))
        for num in nums:
            if num > 0:
                result += self.pow2(num)[1]
        return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        lim = len(nums)
        
        test = [0]*lim
        
        t = 0
        
        while nums!=test:
            vals = []
            v = 0
            
            for i in range(0,lim):
                if nums[i]%2==0:
                    vals.append(nums[i]//2)
                else:
                    nums[i]-=1
                    v+=1
            if v==0:
                nums = vals
                t+=1
            else:
                t+=v
        return t
            
                    
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        big = 0
        ans = 0
        for i in range(len(nums)):
            twos = 0
            while nums[i] > 0:
                if nums[i] % 2 == 0:
                    twos += 1
                    nums[i] = nums[i] // 2
                else:
                    ans += 1
                    nums[i] -= 1
                
            if twos > big:
                big = twos
        return ans + big

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ones = 0
        twos = 0
        
        for n in nums:
            muls = 0
            while n > 0:
                if n % 2 != 0:
                    ones += 1
                    n -= 1
                else:
                    muls += 1
                    n /= 2
                    
            twos = max(muls, twos)
            
        return ones+twos

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if set(nums) == set([0]):
            return 0
        ops = 0
        while set(nums) != set([0]):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ops += 1
            if set(nums) != set([0]):
                nums = list([x // 2 for x in nums])
                ops += 1
        return ops                    


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # 单数肯定要单独加，偶数可以一起增长
        max_log = 0
        count_zero = 0
        steps = 0
        for num in nums:
            if num!= 0:
                log_num = 0
                while num>0:
                    if num%2==0: # 偶数
                        num /= 2
                        log_num += 1
                    else: # 奇数
                        steps += 1
                        num -= 1
                max_log = max(max_log, log_num)
        return steps + max_log

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans = 0 
        peak = 0 
        for n in nums :
            ans += bin(n)[2:].count('1')
            peak = max(peak,len(bin(n)[2:])-1)
        return ans + peak 
            


class Solution:
    def minOperations(self, target: List[int]) -> int:
        result = 0  
        while (True):    
            zero_count = 0
            i = 0
            n = len(target)
            while (i < n): 
                if ((target[i] & 1) > 0):  
                    break;  
                elif (target[i] == 0):  
                    zero_count += 1
                i += 1 
            if (zero_count == n):  
                return result
            if (i == n):  
                for j in range(n): 
                    target[j] = target[j] // 2 
                result += 1 
            for j in range(i, n):  
                if (target[j] & 1):  
                    target[j] -= 1 
                    result += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while nums != [0]*len(nums):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ans += 1
            if nums != [0]*len(nums):
                for i in range(len(nums)):
                    nums[i] //= 2
                ans += 1
        return ans

class Solution:
    def minOperations(self, A: List[int]) -> int:
        if all(v == 0 for v in A):
            return 0
        curr = 0
        A_next = A.copy()
        changed = False
        for i, v in enumerate(A):
            if v % 2 == 1:
                changed = True
                curr += 1
                A_next[i] = v-1
        if not changed:
            return 1 + self.minOperations([v//2 for v in A])
        else:
            return curr + self.minOperations(A_next)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        moves =0
        while True:
            zeros = 0
            for i in range(n):
                if nums[i] % 2:
                    nums[i] -= 1
                    moves += 1
                    
            for i in range(n):
                if nums[i] == 0: zeros += 1
            if zeros == n:
                return moves
            
            for j in range(n):
                nums[j] //= 2
            moves += 1
            
                
                    
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0 
        while any(nums):
            even = 0
            # if any odd -> deduct 1 from all 
            for k, v in enumerate(nums):
                if v % 2 == 1:
                    cnt += 1 
                    nums[k] -= 1  
                elif v > 0:
                    even += 1 
            if even > 0:
                nums = list([x//2 for x in nums])
                cnt +=1
            
        return cnt


class Solution:
    def minOperations(self, nums: List[int]) -> int:
     
        self.count = 0
        def sub(nums):
            for i in range(len(nums)):
                if nums[i]%2!=0:
                    nums[i]-=1
                    self.count+=1
            return nums
        
        def divide_all(nums):
            for k in range(len(nums)):
                if nums[k] == 0 or nums[k]%2==0:
                    nums[k]//=2
                else:
                    return []
            return nums
        
        def zeros(nums):
            c = 0
            for n in nums:
                if n==0:
                    c+=1
            return c
        
        sub(nums)
        while zeros(nums)<len(nums):
            divide_all(nums)
            self.count+=1
            sub(nums)

        return self.count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        while any(nums):
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    nums[i] -= 1
                    ops += 1
            if any(nums):
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                ops += 1
        return ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def check(nums):
            flag = False
            for n in nums:
                if n > 1:
                    flag = True
            return flag
        
        cnt = 0
        n = len(nums)
        flag = check(nums)
        while flag:
            # print(nums)
            cnt += 1
            for i in range(n):
                if nums[i] % 2:
                    nums[i] -= 1
                    nums[i] = nums[i] // 2
                    cnt += 1
                else:
                    nums[i] = nums[i] // 2
            # print(cnt)
            flag = check(nums)
        for n in nums:
            if n != 0:
                cnt += 1
        return cnt                

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        nums.sort()
        
        n = len(nums)
        
        q = collections.deque()
        q += [(0, nums)]
        tot = [0] * n
        while q:
            
            cnt, t = q.popleft()
            if t == tot:
                return cnt
            flag = False
            for i in range(n):
                if t[i] % 2:
                    cnt += 1
                    t[i] -= 1
                if t[i] != 0:
                    flag = True
                t[i] //= 2
                # print (t[i], cnt, flag)
            if flag:
                cnt += 1
            # print (cnt, t)
            q+=[(cnt, t)]
        
        return 0


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(x).count('1') for x in nums ) + len(bin(max(nums))) -3 

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        plus = 0
        double = 0
        for x in nums:
            if(x!=0):
                plus+=1
            counter =0
            while(x/2>=1):
                if(x%2!=0 and x!=1):
                    plus+=1
                    x-=1
                x/=2
                counter+=1
            double = max(double,counter)
        return plus+double

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        m = 0
        numb = len(nums)
        while True:
            zc = 0
            var = 0
            for i in range(numb):
                if nums[i]%2 != 0:
                    nums[i] = nums[i]-1
                    m+=1
                if nums[i] == 0:
                    zc +=1
            if zc == numb:
                break
            nums = list([i//2 for i in nums])
            m +=1
        return m


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        
        
        res=0
        while sum(nums) !=0:
            for i in range(len(nums)):
                if nums[i] %2 ==1:
                    res +=1
                    nums[i] -=1
            if sum(nums) !=0:
                res +=1
                for i in range(len(nums)):
                    nums[i] = nums[i]//2
        
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        counter = 0
        while 1:
            temp_counter = 0
            bigger_than_zero = 0
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    temp_counter += 1
                    nums[i] -= 1
                if nums[i] > 0:
                    bigger_than_zero += 1
                    temp = bin(nums[i])
            counter += temp_counter
            if bigger_than_zero == 0 :
                return counter

            run_again = True
            while run_again:
                counter += 1
                for i in range(len(nums)):
                    nums[i] //= 2
                    if nums[i] % 2 == 1:
                        run_again = False
        return counter

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        self.count = 0
        all_even = False
        def reduce():
            nonlocal all_even
            zero = 0
            if all_even:
                for i, num in enumerate(nums):
                    nums[i] >>= 1
                    if nums[i] & 1:
                        all_even = False
                    zero += num == 0
                self.count += 1
            else:
                for i, num in enumerate(nums):
                    if num & 1:
                        self.count += 1
                        nums[i] -= 1
                all_even = True
            return zero
        
        while True:
            n = reduce()
            if n == len(nums):
                break
        return self.count - 1
            
                    
            
                    
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        mul = [0 for i in range(len(nums))] #for each number of increment by 1 needed
        res = 0
        for i in range(len(nums)):
            while nums[i]!=0:
                if nums[i]%2 ==1:
                    res +=1
                    nums[i]-=1
                else:
                    mul[i]+=1
                    nums[i]//=2
            
        return res + max(mul)
                
           
            


from collections import deque
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        stack = deque([[nums, 0]])
        while stack:
            cur_nums, count = stack.popleft()
            if all([n == 0 or n == 1 for n in cur_nums]):
                return sum(cur_nums) + count
            
            if all([n % 2 == 0 for n in cur_nums]):
                stack.append([[n // 2 for n in cur_nums], count + 1])
                continue
            
            tmp = [] 
            for n in cur_nums:
                if n % 2 == 1:
                    count += 1
                    tmp.append(n - 1)
                else:
                    tmp.append(n)
            stack.append([tmp, count]) 

class Solution:
    def minOperations(self, nums, op = 0):
        isum = 0 
        e = 0
        for i in range(len(nums)):
            if nums[i] % 2 != 0:
                op = op + 1
                nums[i] = (nums[i] - 1)
                if nums[i] != 0:
                    e = 1 
                    nums[i] = nums[i]/2
            else:
                if nums[i] != 0:
                    e = 1 
                    nums[i] = nums[i]/2
            isum  = isum +nums[i]
        op = op + e
        if isum == 0:
            return op
        return  self.minOperations(nums,op)
                      


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while True:
            maxv = 0
            for k in range(len(nums)):
                if nums[k] % 2:
                    nums[k] -= 1
                    ans += 1
                maxv = max(maxv, nums[k])
            if maxv == 0:
                break
            if maxv > 0:
                for k in range(len(nums)):
                    nums[k] //= 2
                ans += 1
        return ans
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while any(nums):
            for i, n in enumerate(nums):
                if n & 1:
                    nums[i] -= 1
                    res += 1
                nums[i] >>= 1
            res += any(nums)
        return res
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res, n=0, len(nums)
        for i in range(32):
            zero, one=0, 0
            for j in range(n):
                if nums[j] & 1==1: one+=1                
                nums[j]>>=1
                if nums[j]==0: zero+=1
            res+=one
            if zero==n: break
            else: res+=1
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        res = 0
        max_zero = 0

        for i in range(len(nums)):
            zero, one = Solution.parse(nums[i])
            res += one
            max_zero = max(max_zero, zero)
        res += max_zero
        
        return res
        
    def parse(v):
        zero, one = 0, 0
        while v > 0:
            if v % 2 == 1:
                one += 1
                v -= 1
            else:
                zero += 1
                v /= 2
        return zero, one

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        count=0
        while sum(nums)!=0:
            for i in range(len(nums)):
                if nums[i]%2!=0:
                    nums[i]-=1
                    count+=1
                    
            for i in range(len(nums)):   
                nums[i]/=2
            if sum(nums)!=0:
                count+=1
            
        return count         

class Solution:
    def minOperations(self, nums: List[int]) -> int:

        res = 0
        while True:
            divide = False
            all_zero = True
            for i, n in enumerate(nums):
                if n == 0: continue
                all_zero = False
                if n > 1: divide = True
                res += n % 2
                nums[i] //= 2
            res += int(divide)
            if all_zero: break
        
        return res


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if not nums or sum(nums) == 0: return 0
        cnt = 0
        while sum(nums) != 0:
            if all(num % 2 == 0 for num in nums):
                cnt += 1
                for i in range(len(nums)):
                    nums[i] //= 2
            else:
                for i in range(len(nums)):
                    if nums[i] % 2:
                        cnt += 1
                        nums[i] -= 1
        return cnt

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        steps = 0
        nums = sorted(nums)
        j = -1
        while(j < len(nums) - 1): # not every elements are 0
            s = j+1 # calculate steps for next non_zero item
            while s < len(nums):
                if nums[s] == 0:
                    j+=1
                elif nums[s] == 1:
                    steps+=1
                    j+=1
                    nums[s] = 0
                elif nums[s]%2 == 1:
                    steps += 1
                    nums[s] -= 1
                    nums[s] //= 2
                else:
                    nums[s] //= 2
                s += 1
            if j != len(nums) - 1:
                steps += 1
      
                
  
            
        return steps 
        
        
        
    
    
    
            
        


from math import log
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        max2=0
        count=0
        
        for n in nums:
            
            n_mult2=0
            
            while n!=0:
                
                if n%2==0:
                    
                    n=n/2
                    n_mult2+=1
                    
                else:
                    
                    n=n-1
                    count+=1
                    
            max2=max(max2,n_mult2)
            
        return count+max2
        
        
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            s = 0
            for i in range(len(nums)):
                num = nums[i]
                if num & 1:
                    count += 1
                    nums[i] = num-1
                    s += (num-1)
                else:
                    s += num
                    
            if s == 0:
                return count
            
            nums = [num//2 for num in nums]
            count += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        num_zero = sum(n == 0 for n in nums)
        while num_zero != len(nums):
            for i, n in enumerate(nums):
                if n%2 == 1:
                    ans += 1
                    nums[i] -= 1
                    if nums[i] == 0:
                        num_zero += 1
                nums[i] >>= 1    
            ans += 1    
        return ans - 1
    
        #m = m_steps = 0
        #for n in nums:
        #    steps = self.num_steps(n)
        #    if steps > m_steps or (steps == m_steps and n > m):
        #        m, m_steps = n, steps
        #bonus = 0
        #for n in nums:
        #    if n:
        #        bonus += 1
        #        if n != 1 and n != m and n%2 == 1:
        #            bonus += 1
        #if bonus == 0:            
        #    bonus = 1
        #return m_steps + bonus - 1
         
    def num_steps(self, n):        
        #steps = 0
        #tmp = n
        #while n:
        #    if n&1:
        #        n ^= 1
        #    else:    
        #        n >>= 1
        #    steps += 1    
        #return steps    
        #        
        if n == 0:
            return 0
        steps, mask = 0, 1
        while mask <= n:
            if n & mask:
                steps += 2
            else:
                steps += 1    
            mask <<= 1    
        return steps-1    

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        numreps = []
        
        for num in nums:
            numreps.append(self.numToOps(num))
        
        numops = 0
        max2s = 0
        for rep in numreps:
            numops += rep[1]
            
            if rep[2] > max2s:
                max2s = rep[2]
                
        return numops + max2s
        
    def numToOps(self,val):
        rep = {1:0,2:0}

        while(val):
            if val%2:
                rep[1] += 1
                val = val-1
            else:
                rep[2] += 1
                val = int(val/2)
        return rep

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0        
        while sum(nums) != 0:
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    nums[i] = nums[i] - 1
                    res += 1
            # print([x % 2 for x in nums])
            if sum([x % 2 for x in nums]) == 0:
                for i in range(len(nums)):
                    nums[i] = nums[i] / 2
                res += 1
        return res - 1
        
                



class Solution:
    def minOperations(self, nums: List[int]) -> int:
        adds = []
        muls = []
        
        for idx, num in enumerate(nums):
            adds.append(0)
            muls.append(0)
            while num > 0:
                if num % 2 == 1:
                    adds[idx] += 1
                    num -= 1
                else:
                    muls[idx] += 1
                    num /= 2
        
        return sum(adds) + max(muls)

class Solution:
    def minOperations(self, nums: List[int]) -> int:

        maxval = max(nums)
        idx = nums.index(maxval)
        ans = 0

        while nums[idx]!=0:
            for i,n in enumerate(nums):
                ans += n%2 # minus 1 to make all number even
                nums[i] = n-n%2
            if nums[idx]!=0: 
                for i, n in enumerate(nums): # devide all numbers by 2
                    nums[i]=nums[i]//2
                ans += 1
        
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if not nums: return 0
        n = len(nums)
        ans = 0
        while (True):  
            zero_count = 0
            i = 0
            # for i in range(n):
            while i<n:
                if nums[i] % 2 ==1:  # first odd num
                    break
                elif nums[i] == 0:  
                    zero_count += 1
                i+=1
                
            if zero_count == n: return ans
            
            if i == n:
                for j in range(n): 
                    nums[j]//=2  
                ans += 1  
                
            for j in range(i, n):  
                if nums[j]%2==1:  
                    nums[j]-= 1 
                    ans += 1
                    
        return ans
#         ans = 0
#         n = len(nums)
#         zeros = len([i==0 for i in nums])
#         if n==zeros: return ans
#         for i in range(n):
#             if nums[i]%2==1: # convert odd to even num
#                 ans+=1
#                 nums[i]-=1
#                 if nums[i]==0:
#                     zeros+=1
#         if n==zeros: return ans
        
#         while zeros<n:
#             for i in range(n):
#                 nums[i]//=2
#             ans+=1
#         return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        N = len(nums)
        ref = [0] * N
        res = 0
        while nums != ref:
            isAllEven = 1
            for i in range(N):
                if nums[i]%2:
                    nums[i] -= 1
                    res += 1
                    isAllEven = 0
            if isAllEven:
                for i in range(N):
                    nums[i] //= 2
                res += 1
            # print(nums, res)
        return res
                    
                
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ## brute-force: simulation
        res = 0
        odd = 0
        flag = True
        while len(nums)>0:
            # print(nums)
            temp = []
            if flag:
                for x in nums:
                    if x&1 == 1:
                        res += 1
                        if x-1!=0:
                            temp.append(x-1)
                    elif x!=0:
                        temp.append(x)
                flag = False
            else:
                for x in nums:
                    temp.append(x//2)
                res += 1
                flag = True
            nums = temp
        return res
            
# [1,5]
# [2,2]
# [4,2,5]
# [3,2,2,4]
# [2,4,8,16]


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        ans = 0
        while True:
            # check if there is odd number
            for i in range(n):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    ans += 1
                
            # all even numbers, divide all by 2
            all_zeros = True
            for i in range(n):
                if nums[i] != 0:
                    all_zeros = False
                nums[i] = nums[i] // 2
            
            if all_zeros:
                break
            else:
                ans += 1
                
        return ans
            
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        calls = 0
        while True:
            num_zeros = 0
            odd_index = 0
            for i in range(n):
                if nums[i] % 2 != 0:
                    break
                elif nums[i] == 0:
                    num_zeros += 1
                odd_index += 1
            if num_zeros == n:
                return calls

            if odd_index == n:
                for j in range(n):
                    nums[j] /= 2
                calls += 1

            for j in range(i, n):
                if nums[j] % 2 != 0:
                    nums[j] -= 1
                    calls += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans=0
        s2=[]
        for i in nums:
            n1=0
            m=0
            for j in range(32):
                if i&(2**j)!=0:
                    m=j
                    n1+=1
            ans+=n1
            s2.append(m)
        s2.sort()
       
        ans+=s2[0]
        
        for i in range(1,len(s2)):
            ans+=s2[i]-s2[i-1]
        return ans
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        total = 0
        max_divide = 0
        
        for i, x in enumerate(nums):
            divide = 0
            while x > 0:
                if x % 2 == 1:
                    x -= 1
                    total += 1
                else:
                    x /= 2
                    divide += 1
            
            if divide > max_divide:
                max_divide = divide
        
        
        
        return total + max_divide

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while sum(nums) > 0:
            can_divide = False
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    ans += 1
                    nums[i] -= 1
                if nums[i] > 0:
                    can_divide = True
                    
            if can_divide:
                ans += 1
                for i in range(len(nums)):
                    nums[i] //= 2
                
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = {}
        
        def iseven(n):
            return n%2==0
        
        ans = 0
        
        for n in nums:
            count[n] = count.get(n, 0) + 1
            
        keys = list(count.keys())
        for n in keys:
            if n == 0:
                count.pop(n)
            if not iseven(n):
                ans += count[n]
                n -= 1                
                if n != 0:
                    count[n] = count.get(n,0) + count[n+1]
                count.pop(n+1)
            
        while len(count) > 0:
            # print(ans)
            # print(count)
            keys = list(count.keys())
            ans += 1
            new_count = {}
            for n in keys:
                if not iseven(int(n/2)):
                    if int(n/2) != 1:
                        new_count[int(n/2)-1] = new_count.get(int(n/2)-1, 0) + count[n]
                    ans += count[n]
                else:
                    new_count[int(n/2)] = new_count.get(int(n/2), 0) + count[n]
                    
            count = new_count
            
        return ans
                
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # Key insight is if nums[i] is odd, there's no way we could have arrived at nums[i]
        # via op 1, i.e. by multiplying by 2 some previous value. So the only way we could
        # have gotten here is by using op 0, nums[i] % 2 times. That is we need to skim off
        # the remainder part that makes it non-even before we can consider using op 1.
        cost = 0
        while True:
            all_zeros = True
            all_evens = True
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                
                all_zeros = False
                if nums[i] % 2 != 0:
                    cost += nums[i] % 2
                    nums[i] = nums[i] - (nums[i] % 2)
                    all_evens = False
            
            if all_zeros:
                break
            while all_evens:
                for i in range(len(nums)):
                    nums[i] = nums[i] // 2
                    if nums[i] % 2 != 0:
                        all_evens = False
                cost += 1
                
        return cost
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0

        def op0() -> int:
            nonlocal nums
            ops = sum([n % 2 for n in nums])
            nums = [((n >> 1) << 1) for n in nums]
            return ops

        def op1() -> int:
            nonlocal nums
            ops = 0
            while sum([n % 2 for n in nums]) == 0:
                ops += 1
                nums = [n // 2 for n in nums]
            return ops

        # print(nums)
        while sum(nums):
            ops += op0()
            # print(f\"op0: {nums}, ops={ops}\")
            if sum(nums):
                ops += op1()
                # print(f\"op1: {nums}, ops={ops}\")

        return ops

def adjust2power(n):
    if n==0:
        return 0
    for i in range(1,n+1):
        if 1<<i >= n:
            if n%(1<<i)!=0:
                i-=1
            break
    return 1<<i

def howManyPower(n):
    for i in range(1,n+1):
        if 1<<i == n:
            return i

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums2p = [] #nums of 2 powers
        ans=0
        while max(nums)>1:
            ans+=1
            for i in range(len(nums)):
                if nums[i]==0:
                    continue
                if nums[i] > 1:
                    ans += nums[i]%2
                nums[i] = max(nums[i]//2, 1)
 #           print(nums)
        return ans+len(nums)-nums.count(0)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        while True:
            ok = False
            flag = True
            for i in range(n):
                if nums[i] & 1:
                    ans += 1
                    nums[i] -= 1
                if nums[i] != 0 and not (nums[i] & 1):
                    nums[i] //= 2
                    if flag:
                        ans += 1
                        flag = False
                if nums[i] != 0:
                    ok = True
            if not ok:
                break
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ret = 0
        change = 0
        
        while sum(nums):
            change = 0
            for i in range(len(nums)):
                if nums[i]%2:
                    ret +=1

                    nums[i] -=1
                    change = 1

            if change==0:
                ret+=1
                for i in range( len(nums)):
                    nums[i] = nums[i]//2
                
        return ret


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        f = {}
        def calc(x):
            if x == 0:
                return 0, 0
            if x not in f:
                if x % 2 == 1:
                    a, b = calc(x - 1)
                    f[x] = (a + 1, b)
                else:
                    a, b = calc(x // 2)
                    f[x] = (a, b + 1)
            return f[x]
        
        x = []
        y = []
        for e in nums:
            a, b = calc(e)
            x.append(a)
            y.append(b)
        return sum(x) + max(y)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        done = [0]*n
        ans = 0
        while nums != done:
            for i, x in enumerate(nums):
                if x%2:
                    nums[i] -= 1
                    ans += 1
            if nums != done:
                for i, x in enumerate(nums):
                    nums[i] /= 2
                ans += 1
        return ans

class Solution:
    def minOperations(self, a: List[int]) -> int:
        res = [0]
        while True:
            self.checkOdd(a, res)
            end = self.checkDivide(a)
            if end:
                break
            else:
                res[0] += 1
        return res[0]
        
    def checkOdd(self, a, res):
        for i in range(len(a)):
            if a[i] % 2 != 0:
                a[i] -= 1
                res[0] += 1

    def checkDivide(self, a):
        flg = True
        for i in range(len(a)):
            if a[i] > 0:
                a[i] /= 2
                flg = False
        return flg

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(nums):
            for i,v in enumerate(nums):
                if v % 2 == 1:
                    nums[i] -= 1
                    ans += 1
            if any(nums):
                ans += 1
                nums = [i/2 for i in nums]
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count  = 0

        while True:
            op =False
            zeroes = 0
            for i in range(len(nums)):
                if nums[i]%2 != 0:
                    count +=1
                    nums[i]-=1
            for i in range(len(nums)):
                if nums[i] == 0:
                    zeroes+=1
                else:
                    nums[i]=nums[i]//2
                    op = True
            if op:
                count +=1
            if zeroes == len(nums):
                return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        n = len(nums)
        while True:
            zero_c = 0
            i = 0
            while i < n:
                if nums[i] % 2 == 1:
                    break
                elif nums[i] == 0:
                    zero_c += 1
                i += 1
                    
            if zero_c == n:
                return res
            
            if i == n:
                for j in range(n):
                    nums[j] = nums[j]//2
                res += 1
            
            for j in range(i, n):
                if nums[j] % 2 == 1:
                    nums[j] -= 1
                    res += 1
            
        return res
            




class Solution:
  def minOperations(self, nums: List[int]) -> int:
    result = 0
    while True:
      allzero = True
      for index, num in enumerate(nums):
        if num != 0:
          allzero = False

        if num % 2 == 1:
          nums[index] = num - 1
          result += 1

      if allzero:
        break

      allzero = True
      for index, num in enumerate(nums):
        if num != 0:
          allzero = False
        nums[index] = num // 2

      if allzero:
        break
      else:
        result += 1

    return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        num_operations = 0
        
        stacks = [[],[]]
        
        cur_idx = 0
        nxt_idx = 1
        
        odd = False
        
        for num in nums:
            if num % 2:
                odd = True
            if num:
                stacks[0].append(num)
                
        
        num_operations = 0
        
        while stacks[0] or stacks[1]:
            if odd:
                while stacks[cur_idx]:
                    nxt = stacks[cur_idx].pop()
                    if nxt % 2:
                        nxt -= 1
                        num_operations += 1
                    if nxt:
                        stacks[nxt_idx].append(nxt)
                odd = False
            else:
                num_operations += 1
                while stacks[cur_idx]:
                    nxt = stacks[cur_idx].pop()
                    nxt /= 2
                    if nxt % 2:
                        odd = True
                    if nxt:
                        stacks[nxt_idx].append(nxt)
            
            cur_idx, nxt_idx = nxt_idx, cur_idx
            
        return num_operations
                        
                        
                        
                        
                        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def proc(nums):
            cnt = 0
            for i in range(len(nums)):
                if nums[i] % 2 > 0:
                    nums[i] -= 1
                    cnt += 1
            if cnt == 0:
                for i in range(len(nums)):
                    nums[i] //= 2
            return max(cnt, 1)
                    
            
        
        ops = 0
        while sum(nums) > 0:
            ops += proc(nums)
        return ops
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        m = max(nums)
        n = nums.count(m)
        # as 'bin(len(5)) == 5'
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3
    
    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        zeros = [0 for el in nums]
        res = 0
        while nums != zeros:
            for i in range(len(nums)):
                if nums[i] % 2 != 0:
                    nums[i] -= 1
                    res += 1
            if nums == zeros: break
            nums = [el / 2 for el in nums]
            res += 1
        return res
                
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
#         double_arr = [math.floor(math.log(num, 2)) for num in nums]
#         calc = [0 for el in nums]
#         zeros_arr = [0 for el in nums]
#         # iters = 0
#         res = 0
#         while True:
#             # Add 1s
#             print(\"~~~~~~~~~calc\", calc)
#             print(\"double arr\", double_arr)
#             max_idxs = []
#             max_val = 0
#             for idx, val in enumerate(double_arr):
#                 if val > max_val:
#                     max_val = val
#                     max_idxs = [idx]
#                 elif val == max_val:
#                     max_idxs.append(idx)
#             if max_val == 0: break
#             # print(\"max idxs\", max_idxs)
#             for idx in max_idxs:
#                 if calc[idx] == 0:
#                     calc[idx] += 1
#                     res += 1
#                 double_arr[idx] -= 1
#             # print(\"inter calc\", calc)
#             calc = [el*2 for el in calc]
#             # print(\"end calc\", calc)
#             res += 1
#             print(\"res\", res)
#             # if iters>50: break
#             # iters += 1
        
#         diff_remain = sum(nums) - sum(calc)
#         res += diff_remain
#         return res
        
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while sum(nums) > 0:
            for i in range(len(nums)):
                if nums[i]%2==1:
                    ans += 1
                    nums[i] -= 1
            if sum(nums)!=0:
                ans += 1
                for i in range(len(nums)):
                    nums[i] = nums[i]//2
                
        return ans

class Solution:
  def minOperations(self, nums) -> int:
    steps = 0

    while True:
      # make even
      for i in range(len(nums)):
        if nums[i] % 2 == 1:
          nums[i] -= 1
          steps += 1

      # check if done
      remaining = 0
      for i in range(len(nums)):
        if nums[i] > 0:
          remaining += 1
      if remaining == 0:
        return steps

      # divide
      for i in range(len(nums)):
        nums[i] /= 2
      steps += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        count = 0
        l = len(nums)
        while True:
        
            allZeros = True
            
            for i in range(l):
                
                if nums[i]!=0:
                    allZeros = False
                if nums[i]%2:
                    count+=1
                    nums[i]-=1
                    
           
            if allZeros:
                return count
            flag = False
            for i in range(l):
                if nums[i]!=0:  
                    flag = True
                    nums[i] = nums[i]//2
            if flag:
                count+=1
            
            
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0

        while nums:
            new = []
            for x in nums:
                if x > 0:
                    if x != 1:
                        new.append(x - (x&1))
                    result += x&1
            nums = new
            
            if not nums:
                break
            
            for i in range(len(nums)):
                nums[i] //= 2
            result += 1
            
        return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ret = 0
        def check(nums):
            isAllZero = 1
            multiplied = 0
            res = 0
            for i in range(len(nums)):
                if nums[i] != 0:
                    isAllZero = 0
                if nums[i] & 1:
                    res += 1
                    nums[i] -= 1
                if nums[i] != 0:
                    nums[i] = nums[i] // 2
                    multiplied = 1
            if multiplied == 1:
                res += 1
            return (isAllZero, res)
        
        while True:
            done, cnt = check(nums)
            ret += cnt
            if done == 1:
                break
        return ret
        
        

                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        s = set(nums)
        if len(s)==1 and 0 in s:
            return 0
        else:
            l = nums
            cnt = 0
            for i in range(len(l)):
                if l[i]%2==1:
                    cnt += 1
                    l[i] -= 1
            if cnt == 0:
                return 1+self.minOperations([a//2 for a in l])
            else:
                return cnt+self.minOperations(l)

import math
class Solution:
    def minOperations(self, n: List[int]) -> int:
        nums = []
        for i in range(len(n)):
            if n[i]==0:
                continue
            nums.append(n[i])
        def countOdd(nums):
            c = 0
            for i in range(len(nums)):
                if nums[i]!=1 and nums[i]%2==1:
                    nums[i]-=1
                    c+=1
            return c
        count = 0
        while set(nums)!={1}:
            count+=countOdd(nums)
            for i in range(len(nums)):
                if nums[i]==1:
                    continue
                nums[i] = nums[i]//2
                    
            count+=1
        count+=len(nums)
        return count
                
                


class Solution:
    def is_divisible(self,nums):
        res = []
        for ix in range(len(nums)):
            if nums[ix] % 2 != 0:
                res.append(ix)
        return res
    
    
    def divide_by_2(self,nums):
        for ix in range(len(nums)):
            nums[ix] = nums[ix] / 2
        
    
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        while nums != [0] * len(nums):
            minus_ix = self.is_divisible(nums)
            for ix in minus_ix:
                nums[ix] -= 1
                ops += 1
            
            if nums == [0]* len(nums):
                return ops
            
            # divide all by 2
            self.divide_by_2(nums)
            ops += 1
        return ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        high=len(bin(max(nums)))-3
        one=sum([bin(n).count('1') for n in nums])
        return high+one
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n=len(nums)
        temp=c=0
        while True:
            for i in range(n):
                if nums[i]==1:
                    c+=1
                    nums[i]=0
                elif nums[i]%2==1:
                    nums[i]-=1
                    c+=1   
                if nums[i]==0:
                    temp+=1
            if temp==n:
                return c
            temp=0
            for i in range(n):
                nums[i]=int(nums[i]/2)
            c+=1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def nrOfOpsToZero(n):
            if n == 0:
                return (0, 0)
            if n % 2 == 1:
                recDups, recIncs = nrOfOpsToZero(n - 1)
                return (recDups, recIncs + 1)
            recDups, recIncs = nrOfOpsToZero(n // 2)
            return (recDups + 1, recIncs)
        maxDups = 0
        totalIncs = 0
        for i in range(0, len(nums)):
            dups, incs = nrOfOpsToZero(nums[i])
            totalIncs += incs
            maxDups = max(maxDups, dups)
        return int(maxDups + totalIncs)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # iseven = False
        def makeeven():
            did = 0
            for i in range(len(nums)):
                if nums[i]&1:
                    nums[i] -= 1
                    did += 1
            # iseven = True
            return did
        def halv():
            did = False
            for i in range(len(nums)):
                if nums[i]:
                    nums[i] >>= 1
                    did = True
            return did
        count = 0
        while any(nums):
            count += (makeeven())
            count += int(halv())
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        odd = 0
        flag = True
        while len(nums)>0:
            # print(nums)
            temp = []
            if flag:
                for x in nums:
                    if x&1 == 1:
                        res += 1
                        if x-1!=0:
                            temp.append(x-1)
                    elif x!=0:
                        temp.append(x)
                flag = False
            else:
                for x in nums:
                    temp.append(x//2)
                res += 1
                flag = True
            nums = temp
        return res
            
# [1,5]
# [2,2]
# [4,2,5]
# [3,2,2,4]
# [2,4,8,16]


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        odds, even = [], []
        for i in nums:
            if i & 1:
                odds.append(i)
            elif i != 0:
                even.append(i)
        
        count = 0
        while odds or even:
            if odds:
                i = odds.pop()
                if i - 1 != 0:
                    even.append(i-1)
            else:
                new_even = []
                for i in even:
                    i //= 2
                    if i & 1:
                        odds.append(i)
                    else:
                        new_even.append(i)
                even = new_even
            count += 1
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        @lru_cache(None)
        def steps(n):
            if n == 0: return 0,0,0
            if n == 1: return 1,1,0
            if n&1: 
                a,b,c = steps(n-1)
                return a+1,b+1,c
            
            a,b,c = steps(n//2)
            return a+1,b,c+1
        
        # print(steps(5))
        evens = 0
        odds = 0
        for num in nums:
            a,b,c = steps(num)
            odds += b
            # print(num, a,b,c)
            evens = max(evens, c)
        
        return odds + evens
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        length = len(nums)
        
        def check_all_zeros(arr):
            for ele in arr:
                if ele != 0:
                    return False
            return True 
        
        def divide_by_2(arr):
            return list([x/2 for x in arr])
        
        ops = 0
        
        while True:
            
            if check_all_zeros(nums):
                return ops
        
            all_even = True
            for i in range(length):
                num = nums[i]
                if num % 2 == 0:
                    if i == length - 1 and all_even:
                        nums = divide_by_2(nums)
                        ops += 1

                else:
                    all_even = False
                    nums[i] -= 1
                    ops += 1     
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def minSteps(num):
            if num == 0:
                return 0
            if num == 1:
                return 1
            
            if num in memo:
                return memo[num]
            
            if num & 1: # odd
                num_ways = 1 + minSteps(num - 1)
            else: # even
                num_ways = minSteps(num // 2)
            
            memo[num] = num_ways
            
            return memo[num]
        
        def countPowerOfTwo(num):
            if num < 2: return 0
            cnt = 1
            cur = 2
            while cur * 2 <= num:
                cnt += 1
                cur <<= 1
            
            return cnt
        
        memo = {}
        res = countPowerOfTwo(max(nums))
        for num in nums:
            res += minSteps(num)
        
        return res
            
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        res = 0
        n = len(nums)
        
        while True:
            
            p = 0
            for i in range(n):
                if nums[i]%2:
                    nums[i]-=1
                    res += 1
                p+=nums[i]    
            
            if p==0:
                return res
            
            for i in range(n):
                nums[i]//=2
            
            res += 1

    

            
       
                
        
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        result = 0
        n = len(nums)
        
        while True:
            
            zcount = 0
            
            i = 0
            while i < n:
                if nums[i] % 2 == 1:
                    break
                elif nums[i] == 0:
                    zcount = zcount + 1
                i = i + 1
            
            if zcount == n:
                return result
            
            if i == n:
                for j in range (0, n):
                    nums[j] = nums[j] // 2
                result = result + 1
            
            for j in range (i, n):
                if nums[j] % 2 == 1:
                    nums[j] = nums[j] - 1
                    result = result + 1
            
        return result

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        co = 0
        while True:
            co = 0
            for i in range(n):
                if nums[i] % 2 == 1:
                    nums[i]-=1
                    ans+=1
            for i in range(n):
                if nums[i] == 0:
                    co+=1
            if co==n:
                return ans
            for i in range(n):
                nums[i] = (nums[i] // 2)
            ans+=1
            # print(nums, ans, co)
            
        return ans

class Solution:
    def minOperations(self, A: List[int]) -> int:
        if all(v == 0 for v in A):
            return 0
        odds = 0
        A_next = A.copy()
        for i, v in enumerate(A):
            if v % 2 == 1:
                odds += 1
                A_next[i] = v-1
        if odds > 0:
            return odds + self.minOperations(A_next)
        return 1 + self.minOperations([v//2 for v in A])
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op = 0
        while max(nums) != 0:
            allEven = True
            for i,n in enumerate(nums):
                if n % 2 == 1:
                    nums[i] -= 1
                    op += 1
                    allEven = False
            if allEven:
                nums = [n//2 for n in nums]
                op += 1
        return op
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        c=0
        
        while len(nums)!=0:
            L=[]
            for i in range(len(nums)):
                if nums[i]==1:
                    c+=1
                elif nums[i]%2==1:
                    L.append(nums[i]//2)
                    c+=1
                elif nums[i]!=0 and nums[i]%2==0:
                    L.append(nums[i]//2)
            if len(L)!=0:
                c+=1
            nums=L
                        

                    
        return c                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while set(nums) != {0}:
            even = True
            for i in range(len(nums)):
                if nums[i]&1:
                    ans += 1
                    even = False
                    nums[i] -= 1
            if even:
                nums = [i//2 for i in nums]
                ans += 1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while sum(nums) != 0:

            for i in range(len(nums)):
                if nums[i] % 2:
                    nums[i] -= 1
                    count += 1
            
            if sum(nums) == 0:
                return count
            
            flag = False
            for i in range(len(nums)):
                if nums[i] % 2 == 0:
                    nums[i] //= 2
                    flag = True
            if flag:
                count += 1
            
        return count
                
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        c=0
        n=len(nums)
        while True:
            if len(set(nums))==1 and nums[0]==0:
                break
            for i in range(n):
                if nums[i]%2!=0 and nums[i]>0 and nums[i]!=0:
                    nums[i]=nums[i]-1
                    c+=1
            f=0
            for i in range(n):
                if nums[i]%2==0:
                    f+=1
            if len(set(nums))==1 and nums[0]==0:
                break
            if f==len(nums):
                for i in range(n):
                    if nums[i]%2==0 and nums[i]!=0:
                        nums[i]=nums[i]//2
                c+=1
        return c

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op = 0
        while sum(nums) != 0:
            odds = 0
            for i in range(len(nums)):
                if nums[i] & 1 != 0:
                    odds += 1
                    nums[i] -= 1
            if odds == 0:
                nums = list(map(lambda x: x // 2, nums))
                op += 1
            else:
                op += odds
                
        return op

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if sum(nums) == 0:
            return 0
        total = 0
        zeros = False
        while sum(nums) > 0:
            for i, num in enumerate(nums):
                if num < 1:
                    continue
                zeros = False
                total += num % 2
                nums[i] -= num % 2
            if sum(nums) > 0:
                total += 1
                for i, num in enumerate(nums):
                    nums[i] >>= 1
        return total

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        if sum(nums) == 0:
            return 0
        # print(nums)
        s = 0
        for i in range(len(nums)):
            if nums[i] % 2 == 1:
                nums[i] -= 1
                s += 1
        if s == 0:
            for i in range(len(nums)):
                nums[i] //= 2
            s += 1
        return self.minOperations(nums) + s

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def deductOdd(nums):
            n = len(nums)
            cnt = 0
            for i in range(n):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    cnt += 1        
            return cnt
        
        def halfEven(nums):
            n = len(nums)
            allZero = True
            for i in range(n):
                if nums[i] > 0:
                    nums[i] //= 2
                    allZero = False
            return allZero
              
        result = deductOdd(nums)
        while not halfEven(nums):
            result += 1
            result += deductOdd(nums)
            
        return result
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        numzeros=0
        n=len(nums)
        for i in range(n):
            if(nums[i]==0):
                numzeros+=1
        while(numzeros<n):
            k=0
            for i in range(n):
                if(nums[i] % 2):
                    nums[i]-=1
                    count+=1
                    if(nums[i]==0):
                        numzeros+=1
                    else:
                        k=1
                        nums[i]=nums[i]/2
                else:   
                    if(nums[i]==0):
                        continue
                    else:
                         k=1
                         nums[i]=nums[i]/2
            if(k==1):
                count+=1
        return count
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        c=1
        count=0
        maxn=max(nums)
        while c*2<=maxn:
            c=c*2
            count+=1
        @lru_cache
        def dfs(n):
            if n<=1:
                return n
            else:
                if n%2==0:
                    return dfs(n//2)
                else:
                    return 1+dfs(n//2)
        for i in nums:
            count+=dfs(i)
        return count

class Solution:
    def minOperations(self, target):
        n = len(target)
        result = 0
        while True:
            zero_count = 0
            i = 0
            while (i < n):
                if ((target[i] & 1) > 0):
                    break
                elif (target[i] == 0):
                    zero_count += 1
                i += 1
            if (zero_count == n):
                return result
            if (i == n):
                for j in range(n):
                    target[j] = target[j]//2
                result += 1
            for j in range(i, n):
                if (target[j] & 1):
                    target[j] -= 1
                    result += 1


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        while True:
            for i in range(len(nums)):
                if nums[i] == 1:
                    nums[i] = 0
                    count += 1
            if max(nums) < 1:
                break
            for i in range(len(nums)):
                if nums[i] < 2:
                    continue
                if nums[i] % 2 != 0:
                    count += 1
                nums[i] //= 2
            count += 1
        return count

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def cod(k,i):
            if k==0: 
                self.memo[k]=[self.g[i],self.h[i]]
                return 0
            if k not in self.memo:
                if k%2==0:
                    self.g[i] += 1
                    cod(int(k/2),i)
                else:
                    self.h[i] += 1
                    cod(k-1,i)
        
        self.memo = {}
        l = len(nums)
        f = [0]*l
        self.g = [0]*l
        self.h = [0]*l
        for i in range(l):
            f[i] = cod(nums[i],i)
        return sum(self.h)+max(self.g)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        flag = True
        count = 0
        while flag:
            flag = False
            for i in range(len(nums)):
                if nums[i]&1:
                    nums[i] -= nums[i]&1
                    count += 1
                if nums[i] > 0:
                    nums[i] >>= 1
                    flag = True
            
            if flag:
                count += 1
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n=len(nums)
        ss = sum(nums)
        ans=0
        while(ss>0):
            for i in range(n):
                if nums[i]%2!=0:
                    ans+=1
                    nums[i]-=1
                    ss-=1
            if ss>0:
                for i in range(n):
                    nums[i]//=2
                    ss-=nums[i]
                ans+=1
            
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        result = 0
        new_nums = sorted(nums, reverse=True)
        while len(new_nums) > 0:
            if new_nums[-1] == 0:
                new_nums.pop(len(new_nums) - 1)
            elif new_nums[-1] == 1:
                new_nums.pop(len(new_nums) - 1)
                result += 1
            else:
                flag = True
                for i in range(len(new_nums)):
                    if new_nums[i] & 0x1 == 1:
                        new_nums[i] -= 1
                        result += 1
                        flag = False
                if flag:
                    for i in range(len(new_nums)):
                        new_nums[i] >>= 1
                    result += 1
        return result


def ops(x):
    if x == 1:
        return (0, 1)
    if x % 2 == 0:
        d, i = ops(x // 2)
        return (d + 1, i)
    else:
        d, i = ops(x - 1)
        return (d, i + 1)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        increments = 0
        max_doubles = 0

        for x in nums:
            if x == 0:
                continue
            doubs, incrs = ops(x)
            increments += incrs
            if doubs > max_doubles:
                max_doubles = doubs

        return increments + max_doubles



class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        
        def modify(arr, op, ind):
            if op == 0:
                arr[ind] = arr[ind] + 1
            if op == 1:
                for i in range(len(arr)):
                    arr[i] = arr[i] * 2
            return arr
        
        arr = [0] * n
        # print(arr)
        # interesting how would you go about solving this?
        # is there a greedy solution
        # so for example every non 0 elt in the array
        # need a +1 operation to make it non zero
        # if a value is odd and not one we need a min of 
        # 3 operations to get to where it needs to be
        # 
        # can cache number of ops probably
        # print(nums)
        ops_needed = 0
        check_ind = 0
        nums.sort(key = lambda x: -x)
        while any(n!=0 for n in nums):
            for ind, numb in enumerate(nums):
                if numb >= 1 and numb % 2 == 1:
                    ops_needed += 1
                    # print(\"odd: \", nums, ops_needed)
                    nums[ind] = nums[ind] - 1
            
            for numb in nums:
                if numb >= 1 and numb % 2 == 0:
                    ops_needed += 1
                    # print(\"even: \", nums, ops_needed)
                    for ind, elt in enumerate(nums):
                        nums[ind] = nums[ind] / 2
                    break
                        
            check_ind += 1
            if check_ind > 100:
                break
            # nums.sort(key = lambda x: -x)
        return ops_needed
    
[3,3]
[1,5]
[2,2]

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans=-1
        l=nums
        while 1:
            tf=0
            for i in range(len(nums)):
                if l[i]>0:
                    tf=1
                    if l[i]%2:
                        l[i]-=1
                        ans+=1
                    if l[i]:
                        l[i]//=2
            if not tf:
                break
            ans+=1
        return ans

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        total = 0
        zeros = 0
        for i in nums:
            if i == 0:
                zeros += 1
        while zeros < len(nums):
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    nums[i] -= 1
                    if nums[i] == 0:
                        zeros += 1
                    total += 1
            allEven = True
            while allEven and zeros < len(nums):
                for i in range(len(nums)):
                    nums[i] = nums[i] >> 1
                    if nums[i] % 2 == 1:
                        allEven = False
                total += 1
        return total
            

        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = sum(num > 0 for num in nums)
        max_time = 0
        for num in nums:
            add_op = 0
            time_op = 0
            Y = num
            X = 1
            while Y > X:
                # step += 1
                if Y % 2 == 1: 
                    Y -= 1
                    add_op += 1
                else: 
                    Y /= 2
                    time_op += 1
            max_time = max(max_time, time_op)
            if num > 1:
                res += (add_op)
        res += max_time
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        even_num = []
        odd_num = []
        zero_num = []
        
        def category(n, zero_num, even_num, odd_num):
            if n == 0:
                zero_num.append(n)
            elif n % 2 == 0:
                even_num.append(n)
            else:
                odd_num.append(n)
            
        for n in nums:
            category(n, zero_num, even_num, odd_num)
        # print(zero_num, even_num, odd_num)
        ans = 0
        while len(even_num) or len(odd_num):
            new_odd_num = []
            if len(odd_num): ans += len(odd_num)
            for n in odd_num:
                n = n - 1
                category(n, zero_num, even_num, new_odd_num)
            odd_num = new_odd_num    

            new_even_num = []
            if len(even_num): ans += 1
            for n in even_num:
                n = n // 2
                category(n, zero_num, new_even_num, odd_num)
            even_num = new_even_num

            # print(zero_num, even_num, odd_num)

            
        return ans


class Solution:
    def minOperations(self, t: List[int]) -> int:
        n=len(t)
        ans = 0  
        while (1):  
            z = 0   
            i = 0 
            while (i < n): 
                if ((t[i] %2)):  
                    break 
  
                elif (t[i] == 0):  
                    z += 1
                i += 1
            if (z == n):  
                return ans 
            if (i == n):    
                for j in range(n): 
                    t[j] = t[j] // 2
                ans += 1  
            for j in range(i, n):  
                if (t[j] & 1):  
                    t[j] -= 1  
                    ans += 1
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while any(num != 0 for num in nums):
            odd = 0
            for idx, num in enumerate(nums):
                if num & 1:
                    nums[idx] -= 1
                    odd += 1
                    ans += 1
            if not odd:
                for idx, num in enumerate(nums):
                    nums[idx] = num // 2
                ans += 1
            
        return ans
                    
                


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        valid = {0: 0}
        for i in range(31):
            valid[2 ** i] = i
        
        ans = 0
        max_multi_step = float('-inf')
        for i in range(len(nums)):
            if nums[i] > 0:
                ans += 1
            else:
                continue
            one_step, multi_step = 0, 0
            
            while nums[i] not in valid:
                if nums[i] & 1:
                    one_step += 1
                    nums[i] -= 1
                else:
                    multi_step += 1
                    nums[i] //= 2
            
            ans += one_step
            max_multi_step = max(max_multi_step, multi_step + valid[nums[i]])
            
        ans += max_multi_step
        return ans


from math import floor, log
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        for x in nums:
            for i in bin(x)[2:]:
                if i != '0':
                    ans += 1
            # if floor(log(i, 2)) != log(i,2):
            #     # print(2**(floor(log(i, 2))), floor(log(i, 2)),i**(1/2), i)
            #     ans += i - (2**(floor(log(i, 2))))
        
        m = max(nums)
        ans += floor(log(m, 2))
        # print(floor(m**(1/2)))
        return ans 


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        
        def it():
            nonlocal ops
            postAllZero = True
            for i in range(len(nums)):
                n = nums[i]
                if n % 2 == 1:
                    nums[i] -= 1
                    ops += 1
                if nums[i] > 0:
                    postAllZero = False
            if postAllZero:
                return                    
            for i in range(len(nums)):
                nums[i] /= 2
            ops += 1
            it()
                    
        it()
        return ops
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        nums.sort()
        result = 0
        multiple = 0
        last = 0
        
        #@lru_cache(None)
        def find(mx):
            nonlocal last
            if mx <= 1:
                return mx
            if mx % 2 == 1:
                return find(mx-1)+1
            last += 1
            return find(mx//2)+1
        
        result = 0
        for i, n in enumerate(nums):
            result += find(n)-last
            multiple = max(multiple, last)
            last = 0
            
        return result + multiple


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_mul = 0
        total_add = 0
        ope_dict = {0: (0, 0)}
        def func(num: int):
            if num in ope_dict:
                return ope_dict[num]
            elif num % 2:
                r = func(num - 1)
                ope_dict[num] = (r[0] + 1, r[1])
            else:
                r = func(num // 2)
                ope_dict[num] = (r[0], r[1] + 1)
            return ope_dict[num]
        for n in nums:
            add, mul = func(n)
            total_add += add
            max_mul = max(max_mul, mul)
        return total_add + max_mul
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        numOperations = 0
        compare = [0]*len(nums)
        while nums != compare:
            # divByTwo = True
            for i in range(len(nums)):
                if nums[i]%2 != 0:
                    nums[i]-=1
                    numOperations+=1
                    # divByTwo == False
            # if divByTwo:
            if nums == compare:
                return numOperations
            for i in range(len(nums)):
                nums[i]/=2
            numOperations+=1
            # print(nums)
        return numOperations        


class Solution:
    def minOperations(self, A: List[int]) -> int:
        r = 0

        while A != [0 for i in A]:
            odd = 0
            for i in range(len(A)):
                if A[i]%2 == 1:
                    A[i] = A[i]-1
                    odd += 1
            if odd == 0:
                A = [x//2 for x in A]
                r += 1
            else:
                r += odd
        return r


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        
        result = 0
        while (True):        
            zero_count = 0
      
            i = 0
            while (i < n):
                
                if ((nums[i] & 1) > 0): 
                    break  
                elif (nums[i] == 0):  
                    zero_count += 1 
                i += 1

            if (zero_count == n):  
                return result
    
            if (i == n):  
                for j in range(n): 
                    nums[j] = nums[j] // 2
                result += 1
  
            for j in range(i, n):  
                if (nums[j] & 1):  
                    nums[j] -= 1
                    result += 1  
        
        return result


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count=0
        numzeros=0
        n=len(nums)
        for i in range(n):
            if(nums[i]==0):
                numzeros+=1
        while(numzeros<n):
            k=0
            for i in range(n):
                if(nums[i] % 2):
                    nums[i]-=1
                    count+=1
                    if(nums[i]==0):
                        numzeros+=1
                    else:
                        k=1
                        nums[i]=nums[i]/2
                else:   
                    if(nums[i]==0):
                        continue
                    else:
                         k=1
                         nums[i]=nums[i]/2
            if(k==1):
                count+=1
            print((count,numzeros))
        return count
            


class Solution:
    def minOperations(self, A: List[int]) -> int:
        return sum(bin(a).count('1') for a in A) + len(bin(max(A))) - 3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        import sys 
        import math
        def h2(n): 
            ans1=0
            ans2=0
            while(n!=1):
                if(n%2==0):
                    ans1+=1
                    n/=2
                else:
                    n-=1
                    ans2+=1
            return ans1,ans2
        
        ans=0
        mixx=-1
        for i in nums:
            if(i!=0):
                ans+=1
                ans1,ans2 = h2(i)
                ans+=ans2
                mixx = max(ans1,mixx)
        ans+=mixx
        return int(ans)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        count = 0
        
        while any(num != 0 for num in nums):
            for pos in range(len(nums)):
                if nums[pos] % 2 != 0:
                    nums[pos] -= 1
                    count += 1
            
            if all(num == 0 for num in nums):
                return count
            
            else:
                nums = [num / 2 for num in nums]
                count += 1
            
        return count


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cou=[0]*len(nums)
        count=0
        for i in range(len(nums)):
            while(nums[i]>0):
                if nums[i]%2!=0:
                    nums[i]-=1
                    count+=1
                else:
                    nums[i]=nums[i]//2
                    cou[i]+=1
        res=max(cou)+count

        return res


class Solution:
    def minOperations(self, target: List[int]) -> int:
        # Initialize result (Count of minimum moves)  
        result = 0;  
        n = len(target)

        # Keep looping while all elements of  
        # target don't become 0.  
        while (True):  

            # To store count of zeroes in  
            # current target array  
            zero_count = 0;  

            # To find first odd element  
            i = 0;  
            while (i < n): 

                # If odd number found  
                if ((target[i] & 1) > 0):  
                    break;  

                # If 0, then increment  
                # zero_count  
                elif (target[i] == 0):  
                    zero_count += 1; 
                i += 1; 

            # All numbers are 0  
            if (zero_count == n):  
                return result;  

            # All numbers are even  
            if (i == n):  

                # Divide the whole array by 2  
                # and increment result  
                for j in range(n): 
                    target[j] = target[j] // 2;  
                result += 1;  

            # Make all odd numbers even by  
            # subtracting one and increment result.  
            for j in range(i, n):  
                if (target[j] & 1):  
                    target[j] -= 1;  
                    result += 1;  
    
                    
                    
        
            
            
            
    


import math
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        while any(nums):
            if any( x%2 for x in nums ):
                for i in range(len(nums)):
                    if nums[i] != 0 and nums[i]%2:
                        nums[i] -= 1
                        res += 1
            else:
                nums = [ x/2 for x in nums ]
                res += 1
        return res
            
                
        
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # [4, 2, 13]
        # 4 = 2^2
        # 2 = 2^1
        # 13 = 2^3 + 2^2 + 1 = 2^2(2 + 1) + 1
        # increment nums[2]
        # multiply by 2
        # increment nums[2] and nums[1]
        # multiply by 2
        # increment nums[1]
        # multiply by 2
        # total: 1 increment for each power of 2 in an element
        
        count = 0
        max_max_power = 0
        for n in nums:
            if n == 0:
                continue
            
            # get max power
            max_power = 0
            temp = n
            while temp > 1:
                max_power += 1
                temp >>= 1
                        
            # record max max power
            max_max_power = max(max_max_power, max_power)
            
            # record digits of binary
            while max_power >= 0:
                if 2**max_power <= n:
                    n -= 2**max_power
                    count += 1
                max_power -= 1
            
        return count + max_max_power
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        i = 0
        k = 0
        for x in range(10**9):
            if nums == [0.0] * len(nums):
                break
            if i >= 1:
                k+=1
                i = 0
            for y in range(len(nums)):
                if nums[y] % 2 != 0:
                    nums[y] -= 1
                    k+=1
                if nums[y] % 2 == 0:
                    nums[y] = nums[y] / 2
                    i+=1
        return k

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        
        arr = [0]*(len(nums))
        count=0
        while nums!=arr:
            f = 0
            for i in range(len(nums)):
                if nums[i]%2==1:
                    nums[i]-=1
                    count+=1
                    f=1
            if f==0:
                for i in range(len(nums)):
                    nums[i] = nums[i]//2
                count+=1
        return (count)


class Solution:
    def minOperations(self, A) -> int:
        return sum(bin(a).count('1') for a in A) + len(bin(max(A))) - 3

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n, res = len(nums), 0
        while True:  
            count, i = 0, 0
            while i < n: 
                if nums[i] % 2: break
                if nums[i] == 0: count += 1
                i += 1
            if count == n: return res  
            if i == n:
                for j in range(n): nums[j] = nums[j] // 2 
                res += 1
            for j in range(i, n):  
                if nums[j] % 2:  
                    nums[j] -= 1 
                    res += 1 
        return res

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        ans = 0
        
        def cal1(arr):
            z = 0
            op = 0
            for i in range(len(arr)):
                if arr[i]%2 == 1:
                    arr[i] -= 1
                    op += 1
                    if arr[i]==0:
                        z += 1
            return op, z
        
        def cal2(arr):
            flg = 0
            for i in range(len(arr)):
                if arr[i]%2==0 and arr[i]>0:
                    arr[i]//=2
                    flg = 1
            return flg
                    
        nz = sum([1 for i in nums if i != 0])
        while nz > 0:
            op, z = cal1(nums)
            ans += op
            nz -= z
            ans += cal2(nums)
            
        return ans

class Solution:
    import math
    def minOperations(self, nums: List[int]) -> int:
        def f(s):
            n=0
            p=0
            while s:
                if s%2==0:
                    s=s//2
                    p+=1
                else:
                    s-=1
                n+=1
            return (n,p)
        nums.sort(key=lambda x: f(x)[1])
        res=0
        inc=0
        for i in range(len(nums)):
            if nums[i]!=0:
                n,p=f(nums[i])
                res+=(n-p)
                res+=(p-inc)
                inc=p
                
        return res
                
                
                
            
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        add = 0
        mul = 0
        for n in nums:
            m = 0
            while n > 0:                
                if (n & 1) == 1:
                    add += 1
                    n -= 1
                else:
                    m += 1
                    mul = max(m, mul)
                    n //= 2
        return add + mul
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        max_div = [0]
        res = 0
        for i in range(n):
            count = 0
            while nums[i] > 0:
                if nums[i] % 2:
                    nums[i] -= 1
                    res += 1
                else:
                    nums[i] /= 2
                    count += 1
                max_div.append(count)
        return res + max(max_div)
            
                    
                
           
            


class Solution:
    def odds(self, nums):
        ops=0
        for i in range(len(nums)):
            if nums[i]%2==1:
                nums[i]-=1
                ops+=1
        return nums,ops
    def opsc(self, nums, final):
        if nums==final:
            return 0
        nums, ops = self.odds(nums)
        if nums==final:
            return ops
        for i in range(len(nums)):
            nums[i]/=2
        ops+=1
        ops += self.opsc(nums,final)
        return ops
    def minOperations(self, nums: List[int]) -> int:
        final=[]
        for i in range(len(nums)):
            final.append(0)
        return self.opsc(nums,final)
        
                
        


class Solution:  
    def soln(self,nums,ans,e,o):
        if len(nums)==0:
            return ans
        for i in nums:
            if i%2==0 and i!=0:
                e.append(i)
            elif i!=0:
                o.append(i)
        # print(\"init\",o,e,ans)
        ans+=len(o)
        for i in range(len(o)):
            o[i]-=1
        oo=[]
        for i in range(len(o)):
            if o[i]!=0:
                oo.append(o[i])
        # print(\"CH\",o,oo)
        o=oo.copy()
        # print(\"thsi\",o,e,ans)
        for i in range(len(o)):
            o[i]=int(o[i]/2)
        # print(\"ISSUE HERE\",e,len(e))
        if len(e)!=0 or len(o)!=0:
            ans+=1
        for i in range(len(e)):
            e[i]=int(e[i]/2)
        nnu=[]
        for i in e:
            if i!=0:
                nnu.append(i)
        for i in o:
            if i!=0:
                nnu.append(i)
        # print(e,o,nnu,ans,nums)
        return self.soln(nnu,ans,[],[])
            
        
    def minOperations(self, nums: List[int]) -> int:
        e=[]
        o=[]
        ans=0
        return self.soln(nums,ans,e,o)
        # return ans
        #   ()
        # for i in range(len(nums)):
        


from functools import lru_cache
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        res = 0
        
        @lru_cache(None)
        def dp(n):
            if n == 0:
                return (0,0)
            else:
                add,mul = 0,0
                if n & 1 == 1:
                    a,b = dp(n-1)
                    return (a+1,b)
                else:
                    a,b = dp(n//2)
                    return (a,b+1)
        res = 0
        m = 0
        for i in nums:
            a,b = dp(i)
            res += a
            m = max(m,b)
        return res + m
            
        


class Solution:
    def minOperations(self, A):
        return sum(bin(a).count('1') for a in A) + len(bin(max(A))) - 3

class Solution:
    def modify(self, arr, op, idx):
        if op == 0:
            arr[idx] = arr[idx] - 1
        
        if op == 1:
            for i in range(len(arr)):
                arr[i] = arr[i] / 2
                
                
    def minOperations(self, nums: List[int]) -> int:
        result = [0 for _ in range(len(nums))]
        operations = 0
        while nums != result:
            for i in range(len(nums)):
                if nums[i] % 2 == 1:
                    self.modify(nums, 0, i)
                    operations+=1
            
            if nums == result:
                return operations
            
            self.modify(nums,1,i)
            operations+=1
        return operations


import functools
import sys
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        sys.setrecursionlimit(10**6)
        @functools.lru_cache(None)
        def cal(n):
            if n == 0:
                return 0,0
            if n%2 == 0:
                a, b = cal(n//2)
                return a, b+1
            else:
                a,b = cal(n-1)
                return a+1, b
            return a, b
        ans = 0
        mul = 0
        for e in nums:
            a,b = cal(e)
            ans += a
            mul = max(mul,b)
        #print(ans, mul)
        return ans + mul

from typing import List

class Counter:
    def __init__(self):
        self.c = 0

class Solution:

    def minOperations(self, nums: List[int]) -> int:

        def makeAllEven(nums, counter):
            def decrease(num, counter):
                if num % 2 != 0:
                    num -= 1

                    counter.c += 1
                return num

            ret = list(map(lambda n: decrease(n, counter), nums))

            return ret

        def allZero(nums):
            return sum(nums) == 0

        def makeAllHalf(nums, counter):

            ret = list(map(lambda x: x // 2, nums))

            counter.c += 1

            return ret

        counter = Counter()
        while not allZero(nums):
            nums = makeAllEven(nums, counter)

            if not allZero(nums):
                nums = makeAllHalf(nums, counter)

        return counter.c

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        mem = {}
        
        ans = [[0 for i in range(len(nums))] for j in range(2)]
        for i, num in enumerate(nums):
            times = [0, 0]
            _num = num
            while _num != 0:
                if _num in mem:
                    times[0] += mem[_num][0]
                    times[1] += mem[_num][1]
                    break
                if _num % 2 == 1:
                    _num -= 1
                    times[0] += 1
                else:
                    _num /= 2
                    times[1] += 1
            mem[num] = times
            ans[0][i] = times[0]
            ans[1][i] = times[1]
            
        print(ans)
            
        return sum(ans[0]) + max(ans[1])
                


from math import log2, log
from typing import List


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0

        def op0() -> int:
            nonlocal nums
            ops = sum([n % 2 for n in nums])
            nums = [((n >> 1) << 1) for n in nums]
            return ops

        def op1() -> int:
            nonlocal nums
            ops = 0
            while sum([n % 2 for n in nums]) == 0:
                ops += 1
                nums = [n // 2 for n in nums]
            return ops

        # print(nums)
        while sum(nums):
            ops += op0()
            # print(f\"op0: {nums}, ops={ops}\")
            if sum(nums):
                ops += op1()
                # print(f\"op1: {nums}, ops={ops}\")

        return ops

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        result = 0;  
        n = len(nums)
        while True : 
            zeros = 0   
            i = 0 
            while (i < n) :   
                if nums[i] % 2 :  
                    break   
                    
                elif nums[i] == 0 :  
                    zeros += 1 
                i += 1 
                
            if (zeros == n):  
                return result   
  
            if (i == n):  
 
                for j in range(n): 
                    nums[j] = nums[j] // 2;  
                result += 1 
  
            for j in range(i, n):  
                if nums[j] % 2 :  
                    nums[j] -= 1  
                    result += 1  


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        changed = True
        while changed:
            
            changed = False
            for i, x in enumerate(nums):
                if not x % 2 == 0:
                    nums[i] -= 1
                    ops += 1
                    changed = True
            divided = False
           
            for i, x in enumerate(nums):
                if x > 0:
                    nums[i] = nums[i] // 2
                    divided = True
                    
            if divided:
                changed = True
                ops += 1
        return ops


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        memo = {0:(0,0)} # (+1,*2)
        
        def helper(num):
            if num not in memo:
                if num % 2 == 1:
                    a,b = helper(num-1)
                    memo[num] = (a+1,b)
                else:
                    a,b = helper(num//2)
                    memo[num] = (a,b+1)
            return memo[num]
        a = b = 0
        for num in nums:
            tmpa,tmpb = helper(num)
            a += tmpa
            b = max(b,tmpb)
        return a + b

        


# 尝试策略: 将数组内所有数字变成偶数然后处理/2，重复此过程直到有结果
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        tot_step = 0
        while True:
            not_zero = False    
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                not_zero = True
                if nums[i] % 2 != 0:
                    nums[i] -= 1
                    tot_step += 1
            # Already reach the result, stop now.
            not_zero = False    
            for i in range(len(nums)):
                if nums[i] == 0:
                    continue
                not_zero = True    
                nums[i] = nums[i] / 2    
            if not_zero == False:
                break
            tot_step += 1    
        return tot_step           
                            
                        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        max_div = 0
        max_sub = 0
        for num in nums:
            div_times, sub_times = self.calc_steps(num)
            max_div = max(max_div, div_times)
            max_sub +=  sub_times
        return max_div + max_sub
        
    #返回除2的次数和减1的次数
    @lru_cache
    def calc_steps(self, num):
        if num == 0:
            return 0,0
        if num == 1:
            return 0,1
        if num == 2:
            return 1,1
        if num == 3:
            return 1,2
        
        div_times, sub_times = self.calc_steps(num//2)
        
        return div_times+1, num % 2 + sub_times

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        _max = -1
        ans = 0
        for x in nums:
            ans += bin(x).count('1')
            _max = max(_max, x)
        
        ans += len(bin(_max)) - 3
        
        return ans


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(num).count('1') for num in nums) + len(bin(max(nums))) - 3


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        for x in nums:
            ans += bin(x).count('1')
        width = len(bin(max(nums)))-2
        
        return ans+width-1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = max_op = 0
        for b in map(bin, nums):
            ans += b.count('1')
            max_op = max(max_op, len(b) - 3)
        return ans + max_op

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        op0 = sum(bin(num).count('1') for num in nums)
        op1 = len(bin(max(nums))) - 3
        return op0 + op1
            
                    
            


class Solution:
  def minOperations(self, nums: List[int]) -> int:
    # maxDivideCount = 0
    # minusCount = 0
    # for num in nums:
    #   divideCount = 0
    #   while num != 0:
    #     if num % 2 == 0:
    #       num //= 2
    #       divideCount += 1
    #     else:
    #       num -= 1
    #       minusCount += 1
    #   maxDivideCount = max(divideCount, maxDivideCount)
    # return maxDivideCount + minusCount
    return sum(bin(a).count('1') for a in nums) + len(bin(max(nums))) - 3
    
#     while self.isAllZero(nums) is False:
#       if self.isAllEven(nums):
#         nums = [a // 2 for a in nums]
#         count += 1
#         continue
#       for i in range(len(nums) - 1):
#         if nums[i] != 0 and nums[i] % 2 == 1:
#           nums[i] -= 1
#           count += 1
        
#     return count
      
#   def isAllZero(self, nums: List[int]) -> bool:
#     for n in nums:
#       if n != 0:
#         return False
#     return True
  
#   def isAllEven(self, nums: List[int]) -> bool:
#     for n in nums:
#       if n % 2 != 0:
#         return False
#     return True
    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        sumOp0,maxOp1=0,0
        for num in nums:
            op0,op1=list(bin(num)).count('1'),len(bin(num)[2:])-1
            sumOp0+=op0
            maxOp1=max(maxOp1,op1)
        return sumOp0+maxOp1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        mx = 0
        for n in nums:
            b = bin(n)
            ans += b.count('1')
            mx = max(mx, len(b)-3)
            
        return ans + mx


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # count = 0
        # l =[0]*len(nums)
        # while nums != l:
        #     flag = 0
        #     for i in range(len(nums)):
        #         if nums[i]%2 != 0:
        #             flag = 1
        #             nums[i] = nums[i]-1
        #             count+=1
        #             break
        #     if flag == 0:
        #         nums = [int(e/2) for e in nums]
        #         count+=1
        # return count
        ans = 0
        bns = 0
        for x in nums:
            b = bin(x)
            ans += b.count('1')
            if x:
                bns = max(bns, len(b) - 2)
        return ans + max(bns-1,0)


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = length = 0
        for num in nums:
            bits = bin(num)
            res += bits.count('1')
            length = max(length, len(bits)-2)
        return res + length -1

class Solution:
    def minOperations(self, arr: List[int]) -> int:
        ret, maxx = 0, 0
        import math
        for i in arr:
            maxx = max(maxx, len(bin(i))-3)
            ret += bin(i).count('1')
        return ret + maxx

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        return sum(bin(num).count('1') for num in nums) + len(bin(max(nums)))-3


masks = [0b01010101010101010101010101010101,
         0b00110011001100110011001100110011,
         0b00001111000011110000111100001111,
         0b00000000111111110000000011111111,
         0b00000000000000001111111111111111]

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        totOddRem = 0
        max2Power = 0
        for x in nums:
            if x == 1:
                totOddRem += 1
            else:
                leftMost = 0
                step = 16
                xCopy = x
                for m in reversed(masks):
                    mr = ~m
                    if mr & xCopy != 0:
                        leftMost += step
                        xCopy &= mr
                    step >>= 1
                if leftMost > max2Power:
                    max2Power = leftMost
                
                xCopy = x
                for p, m in enumerate(masks):
                    xCopy = (xCopy & m) + ((xCopy & ~m) >> (1 << p))
                totOddRem += xCopy
                    
        return totOddRem + max2Power

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        n = len(nums)
        result = 0
        m = 0
        def bitcount(a):
            cnt = 0
            while a:
                cnt += 1
                a &= a - 1
            return cnt
        
        for num in nums:
            result += bitcount(num)
            m = max(m, num)
        for i in range(32):
            if m > 1:
                result += 1
            else:
                break
            m >>= 1
        return result
        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        shifts = 0
        adds = 0
        for n in nums:
            if n == 0:
                continue
            b = bin(n)[2:]
            shifts = max(shifts, len(b) - 1)
            adds += sum(c == '1' for c in b)
        return shifts + adds


import numpy as np
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # likely easiest to go backwards
        # subtract one from all odd numbers. divide by two, repeat until 0
        ops = 0
        arr = np.array(nums)
        while np.sum(arr) != 0:
            inds = np.where(arr % 2 == 1)[0]
            ops += len(inds)
            arr[inds] -= 1
            # must be even at this point
            if np.sum(arr) != 0:
                arr = arr / 2
                ops += 1
        return ops
                
        


class Solution:
    '''
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        while True:
            maxv = 0
            for k in range(len(nums)):
                if nums[k] % 2:
                    nums[k] -= 1
                    ans += 1
                maxv = max(maxv, nums[k])
            if maxv == 0:
                break
            if maxv > 0:
                for k in range(len(nums)):
                    nums[k] //= 2
                ans += 1
        return ans
    '''
    
    def minOperations(self, nums: List[int]) -> int:
        ans = 0
        shift = 0
        for k in nums:
            strk = bin(k)[2:]
            ans += strk.count('1')
            shift = max(shift, len(strk)-1)
        return ans + shift

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        res = 0
        mul_max = 0
        for x in nums:
            if x == 0:
                continue
            x_bin = bin(x)
            mul = -1
            for i in x_bin[2:]:
                if i == '1':
                    res += 1
                mul += 1
            if mul > mul_max:
                mul_max = mul
        return res + mul_max
                    


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        num_set_bits = 0
        max_bit_len = 0
        for n in nums:
            num_set_bits += bin(n).count('1')
            max_bit_len = max(max_bit_len, len(bin(n)) - 2) # -2 since bin adds 0b for binary
        
        return num_set_bits + max_bit_len - 1


from math import log2 as l
class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        cnt=0
        mx=max(nums)
        if mx&1 and mx!=1:
            mx-=1
        for x in nums:
            while(x):
                if x&1:
                    cnt+=1
                x//=2
                
        
        return(int(l(mx))+cnt)

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        s = 0
        b = 0
        for n in nums:
            b += (f := f'{n:b}').count('1')
            s = max(s, len(f))
        return s - 1 + b


class Solution:
    def minOperations(self, nums):
        result = 0
        max_value = 0
        
        for n in nums:
            max_value = max(max_value, n)
            
            while n:
                if n & 1:
                    result += 1
                n = n >> 1
        if not max_value:
            return 0
        
        while max_value:
            result += 1
            max_value = max_value >> 1
        return result - 1
                        


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        # count all ones in binary representation
        # count length of max number (number of double operation)
        ones=0
        maxLength=0
        for x in nums:
            x=bin(x)[2:]
            maxLength=max(maxLength,len(x))
            ones+=x.count('1')
        
        print((ones,maxLength-1))
        
        return ones+maxLength-1
            
            


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        ops = 0
        max_num = 0
        
        for n in nums:
            max_num = max(max_num, n)
            while n > 0:
                # drop lowest bit
                n = n & (n - 1)
                ops += 1
        
        if max_num:
            ops -= 1
        
        while max_num > 0:
            max_num >>= 1
            ops += 1
        
        return ops


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        highest_bit = one_bit = 0
        for i in range(32):
            for num in nums:
                if num & (1 << i):
                    highest_bit = i
                    one_bit += 1
        
        return highest_bit + one_bit


class Solution:
    def minOperations(self, nums: List[int]) -> int:
        cnt = 0   # minus 1
        maxLen = 0   # divided by 2
        for num in nums:
            num_bin = bin(num)[2:]
            cnt += sum(map(int, num_bin))
            maxLen = max(maxLen, len(num_bin))
        return cnt + maxLen - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        to_ret = 0
        max_len = 0
        for t in nums :
            st = bin(t)[2:]
            max_len = max(max_len, len(st))
            to_ret += sum(map(int, st))
        return to_ret + max_len - 1

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        
        twos = len(bin(max(nums))[2:])-1
        ones = collections.Counter(''.join(bin(i)[2:] for i in nums))['1']
        
        
        return ones+twos

class Solution:
    def minOperations(self, nums: List[int]) -> int:
        def check(num):
            divisions = inc = 0
            while num:
                if num % 2:
                    inc += 1
                divisions += 1
                num //= 2
            return divisions, inc

        res = 0
        m = 1
        for n in nums:
            d, r = check(n)
            m = max(m, d)
            res += r

        return res + m - 1