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

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

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

_target = None
_fn_name = 'minOperations'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 5364