Codestin Search App

Minimum Operations to Form Subsequence With Target Sum - Problem

Minimum Operations to Form Subsequence With Target Sum

You're given an array nums containing only powers of 2 (like 1, 2, 4, 8, 16...) and need to find the minimum number of operations to create a subsequence that sums to a target value.

The Operation: You can split any element nums[i] (where nums[i] > 1) into two smaller pieces of nums[i] / 2 each. For example, splitting 8 gives you two 4's.

Goal: Return the minimum operations needed so that you can select some elements from the array (a subsequence) that sum exactly to target. If impossible, return -1.

Example: If nums = [1, 2, 8] and target = 7, you could split 8 into two 4's, then split one 4 into two 2's, giving you [1, 2, 4, 2, 2]. Now you can pick [1, 2, 4] to sum to 7.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 8], target = 7

› Output: 1

💡 Note: We need to make 7. We have 1+2=3, but need 4 more. We can split 8 into two 4s (1 operation), then use 1+2+4=7.

example_2.py — Multiple Operations

$ Input: nums = [1, 32], target = 12

› Output: 2

💡 Note: Target 12 = 8+4. Split 32→16,16 (1 op), then split 16→8,8 (2 ops total). Now we have [1,8,8,16] and can use 8+4=12, but we need 4, so split another 8→4,4 (3 ops total). Actually optimal is 2: split 32→16,16, then 16→8,8, use 8+4 where 4 comes from splitting 8→4,4.

example_3.py — Impossible Case

$ Input: nums = [1, 4], target = 6

› Output: -1

💡 Note: Sum of nums is 5, which is less than target 6. No amount of splitting can increase the total sum, so it's impossible.

Visualization

Tap to expand

Understanding the Visualization

Count Your Bills

First, count how many bills of each denomination you have

Process Target Bits

Look at each bit of the target amount from right to left

Make Change Greedily

For each bit, either use available bills or break larger ones

Count Operations

Each bill break costs one operation

Key Takeaway

🎯 Key Insight: Greedy works for powers of 2 because any larger denomination can always be broken into exactly what we need for smaller bits, without affecting the optimality of future decisions.

Time & Space Complexity

Time Complexity

⏱️

O(n + log target)

O(n) to count frequencies, O(log target) to process each bit of target

⚡ Linearithmic

Space Complexity

O(log target)

Array to store count of each power of 2 up to maximum value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2³⁰
nums[i] is a power of 2
1 ≤ target ≤ 2³¹ - 1

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses a greedy approach with bit manipulation. Since all numbers are powers of 2, we can count available denominations and process the target's binary representation bit by bit. For each required bit, we either use available numbers of that denomination or split larger ones. Time complexity: O(n + log target), making it highly efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Bit Counting (Optimal)	O(n + log target)	O(log target)	Count available powers of 2 and greedily use largest denominations first
Brute Force (Try All Combinations)	O(2^n * 2^sum)	O(2^n)	Generate all possible arrays after operations and check if target is achievable

Greedy with Bit Counting (Optimal) — Algorithm Steps

Count frequency of each power of 2 in the input array
Iterate through target's binary representation from least significant bit
For each required bit, try to use available numbers of that denomination
If not enough, split larger denominations and count operations
If we can't fulfill any bit requirement, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Powers

Count available: {1:1, 2:1, 8:1}, target=7 (111₂)

Process Bit 1

Need 1×1: have 1×1, use it

Process Bit 2

Need 1×2: have 1×2, use it

Process Bit 4

Need 1×4: don't have 4, split 8→4,4 (1 op)

Code -

solution.c — C

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

#define MAX_VAL 100000

int minOperations(int* nums, int numsSize, int target) {
    long long sum = 0;
    for (int i = 0; i < numsSize; i++) {
        sum += nums[i];
    }
    if (sum < target) {
        return -1;
    }
    
    int count[MAX_VAL] = {0};
    int maxNum = 0;
    for (int i = 0; i < numsSize; i++) {
        count[nums[i]]++;
        if (nums[i] > maxNum) {
            maxNum = nums[i];
        }
    }
    
    int operations = 0;
    int power = 1;
    
    while (power <= target) {
        if (target & power) {
            if (count[power] > 0) {
                count[power]--;
            } else {
                int largerPower = power * 2;
                int found = 0;
                while (largerPower <= maxNum * 2 && largerPower < MAX_VAL) {
                    if (count[largerPower] > 0) {
                        count[largerPower]--;
                        int splitPower = largerPower;
                        
                        while (splitPower > power) {
                            splitPower /= 2;
                            count[splitPower] += 2;
                            operations++;
                        }
                        
                        count[power]--;
                        found = 1;
                        break;
                    }
                    largerPower *= 2;
                }
                if (!found) return -1;
            }
        }
        
        if (power * 2 < MAX_VAL) {
            count[power * 2] += count[power] / 2;
        }
        power *= 2;
    }
    
    return operations;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + log target)

O(n) to count frequencies, O(log target) to process each bit of target

⚡ Linearithmic

Space Complexity

O(log target)

Array to store count of each power of 2 up to maximum value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2³⁰
nums[i] is a power of 2
1 ≤ target ≤ 2³¹ - 1

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Bit Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler