Minimum Numbers of Function Calls to Make Target Array

Minimum Numbers of Function Calls to Make Target Array - Problem

Transform Array with Minimum Operations

You're given an integer array nums and need to transform an array of zeros into this target array using the minimum number of operations.

Starting with an array arr of the same length filled with zeros, you can perform two types of operations:

Operation 1: Increment any single element by 1
Operation 2: Double all elements in the array

Your goal is to find the minimum total number of operations needed to transform the zero array into the target array nums.

Example:
Target: [1, 5]
• Start: [0, 0]
• Increment index 0: [1, 0] (1 operation)
• Increment index 1: [1, 1] (1 operation)
• Double all: [2, 2] (1 operation)
• Double all: [4, 4] (1 operation)
• Increment index 1: [4, 5] (1 operation)
• Increment index 0 three times: [1, 5] (3 operations)
Wait, that's not optimal! There's a clever greedy approach using bit manipulation.

Input & Output

example_1.py — Basic case

$ Input: [1, 5]

› Output: 5

💡 Note: For target [1,5]: Number 1 has binary 001 (1 bit set), number 5 has binary 101 (2 bits set). Total 1-bits = 3 increment operations. Highest bit position is 2, so we need 2 double operations. Total: 3 + 2 = 5 operations.

example_2.py — All zeros

$ Input: [0, 0, 0]

› Output: 0

💡 Note: Target array is already all zeros, so no operations needed.

example_3.py — Powers of 2

$ Input: [1, 2, 4]

› Output: 5

💡 Note: 1=001₂ (1 bit), 2=010₂ (1 bit), 4=100₂ (1 bit). Total 1-bits = 3. Max bit position = 2 (from 100₂). Total: 3 + 2 = 5 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
The answer is guaranteed to fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Convert to Binary

Each target number reveals its construction pattern in binary

Count Set Bits

Every '1' bit represents a required increment operation

Find Maximum Height

Highest bit position determines how many global doubling operations we need

Calculate Total

Sum of all increment operations plus maximum doubling operations

Key Takeaway

🎯 Key Insight: Binary representation reveals the optimal construction strategy - count all 1-bits for increments, find highest bit position for doublings!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses bit manipulation and a greedy approach. Key insight: each number's binary representation reveals its construction path. Count all 1-bits (increment operations) across all numbers, plus the highest bit position (double operations needed). Time: O(n log m), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Bit Manipulation (Optimal)	O(n * log(max_val))	O(1)	Use binary representation to count increment operations and maximum doublings needed
Brute Force (Simulation)	O(2^(sum of all elements))	O(2^(sum of all elements))	Try all possible sequences of operations using recursive exploration

Greedy Bit Manipulation (Optimal) — Algorithm Steps

For each number, count the number of 1-bits (increment operations needed)
Find the position of the highest bit across all numbers
Sum all increment operations (total 1-bits across all numbers)
Add the maximum number of doublings needed (highest bit position)
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Binary

Represent each target number in binary: 1→001, 5→101

Count 1-bits

Each '1' bit represents an increment operation needed

Find Max Bit Position

Highest bit position tells us maximum doublings needed

Sum Operations

Total = sum of all 1-bits + max bit position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int countBits(int n) {
    int count = 0;
    while (n) {
        count++;
        n &= (n - 1); // Remove the rightmost set bit
    }
    return count;
}

int findHighestBit(int n) {
    if (n == 0) return 0;
    return (int)log2(n);
}

int minOperations(int* target, int targetSize) {
    int incrementOps = 0;
    int maxBits = 0;
    
    for (int i = 0; i < targetSize; i++) {
        if (target[i] == 0) continue;
        
        // Count 1-bits
        incrementOps += countBits(target[i]);
        
        // Find highest bit position
        int bitPos = findHighestBit(target[i]);
        if (bitPos > maxBits) {
            maxBits = bitPos;
        }
    }
    
    return incrementOps + maxBits;
}

int main() {
    int target[] = {1, 5};
    int targetSize = 2;
    printf("%d\n", minOperations(target, targetSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(max_val))

For each number, we count bits which takes O(log(max_val)) time

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

18.4K Views

Medium Frequency

~15 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler