Minimum Elements to Add to Form a Given Sum

Minimum Elements to Add to Form a Given Sum - Problem

Array Greedy Medium

You have an array of integers nums and need to reach a specific goal sum. However, there's a constraint: all elements in the array (existing and new) must have absolute values ≤ limit.

Your task is to find the minimum number of elements you need to add to the array to make its sum equal to the goal. You can add any integers as long as their absolute value doesn't exceed the limit.

Example: If nums = [1, -1, 1], limit = 3, and goal = -4, the current sum is 1. To reach -4, we need to decrease by 5. We can add two elements: [-3, -2] (both within limit), so the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,-1,1], limit = 3, goal = -4

› Output: 2

💡 Note: Current sum is 1. To reach -4, we need to decrease by 5. We can add [-3, -2] (both within limit 3), so minimum elements needed is 2.

example_2.py — Already at Goal

$ Input: nums = [1,-10,9,1], limit = 100, goal = 1

› Output: 0

💡 Note: Current sum is already 1, which equals our goal. No additional elements needed.

example_3.py — Large Gap

$ Input: nums = [1,2,3], limit = 2, goal = 20

› Output: 7

💡 Note: Current sum is 6. To reach 20, we need to increase by 14. Using limit=2, we need ⌈14/2⌉ = 7 elements of value +2 each.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ limit ≤ 10⁶
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ goal ≤ 10⁹
abs(nums[i]) ≤ limit for all existing elements

Visualization

Tap to expand

Understanding the Visualization

Measure Current Position

Sum up all existing bridge segments to find current position

Calculate Gap

Find the distance between current position and target goal

Use Largest Segments

Always use maximum-sized segments (±limit) to minimize total count

Apply Ceiling Division

Round up to get minimum whole segments needed

Key Takeaway

🎯 Key Insight: Since we want to minimize additions, always use the maximum allowed value (±limit) to cover the gap most efficiently!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal greedy solution calculates the gap between current sum and goal, then uses ceiling division to find minimum elements needed. Since we can add ±limit values, we always use maximum possible values to minimize additions: ⌈|goal - currentSum| / limit⌉

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^k)	O(2^k)	Try adding all possible combinations of elements within limit until we reach the goal
Greedy Approach (Optimal)	O(n)	O(1)	Calculate the gap and greedily use maximum possible values to minimize additions

Brute Force (Try All Combinations) — Algorithm Steps

Calculate current sum of the array
Use BFS/DFS to explore all possible additions
For each state, try adding values from -limit to +limit
Track minimum steps needed to reach goal
Return the minimum number of additions found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with current sum of the array

Explore Additions

Try adding each value from -limit to +limit

Track States

Keep track of visited sums to avoid cycles

Find Goal

Return when we reach the target sum

Code -

solution.c — C

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

typedef struct {
    long long sum;
    int steps;
} State;

int minimumElements(int* nums, int numsSize, int limit, int goal) {
    long long currentSum = 0;
    for (int i = 0; i < numsSize; i++) {
        currentSum += nums[i];
    }
    
    if (currentSum == goal) return 0;
    
    // Simple BFS implementation
    State* queue = (State*)malloc(1000000 * sizeof(State));
    int front = 0, rear = 0;
    
    queue[rear++] = (State){currentSum, 0};
    
    while (front < rear) {
        State curr = queue[front++];
        
        for (int addVal = -limit; addVal <= limit; addVal++) {
            if (addVal == 0) continue;
            long long newSum = curr.sum + addVal;
            
            if (newSum == goal) {
                free(queue);
                return curr.steps + 1;
            }
            
            if (rear < 1000000) {
                queue[rear++] = (State){newSum, curr.steps + 1};
            }
        }
    }
    
    free(queue);
    return -1;
}

int main() {
    printf("Brute force approach implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k)

Where k is the minimum number of elements needed. We explore exponentially many combinations.

✓ Linear Growth

Space Complexity

O(2^k)

Need to store all possible states in our search, which grows exponentially.

✓ Linear Space

23.4K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler