Apply Operations to Make Sum of Array Greater Than or Equal to k

Apply Operations to Make Sum of Array Greater Than or Equal to k - Problem

Apply Operations to Make Sum of Array Greater Than or Equal to k

You're given a positive integer k and start with an array containing just [1]. Your goal is to make the sum of all elements in the array reach at least k using the minimum number of operations.

You can perform two types of operations any number of times:
1. Increment: Choose any element in the array and increase its value by 1
2. Duplicate: Copy any element and add it to the end of the array

For example, if k = 11:
• Start: [1] (sum = 1)
• Duplicate: [1, 1] (sum = 2)
• Increment first element: [2, 1] (sum = 3)
• Duplicate first element: [2, 1, 2] (sum = 5)
• Continue until sum ≥ 11

Return the minimum number of operations needed to achieve this goal.

Input & Output

example_1.py — Basic Case

$ Input: k = 11

› Output: 5

💡 Note: Start with [1]. Duplicate to get [1,1] (1 op). Increment both to get [2,2] (2 ops). Duplicate first to get [2,2,2] (1 op). Increment first to get [3,2,2] (1 op). Total: 5 operations, sum = 7. Continue optimally to reach sum ≥ 11.

example_2.py — Small Case

$ Input: k = 1

› Output: 0

💡 Note: We start with [1] and the sum is already 1, which equals k=1. No operations needed.

example_3.py — Edge Case

$ Input: k = 4

› Output: 2

💡 Note: Start with [1]. Duplicate to get [1,1] (1 op). Increment both to get [2,2] (2 ops total). Sum = 4 ≥ k. Minimum is 2 operations.

Visualization

Tap to expand

Understanding the Visualization

Start Small

Begin with one plant worth 1 harvest unit

Clone vs Grow

Decide whether to clone (duplicate) or grow (increment) existing plants

Find Balance

Mathematical analysis shows optimal balance between quantity and quality

Reach Target

Continue until total harvest reaches target k

Key Takeaway

🎯 Key Insight: The problem reduces to finding the optimal number of duplicate operations that minimizes the total cost. Mathematical enumeration gives us an efficient O(k) solution.

Time & Space Complexity

Time Complexity

⏱️

O(k)

We try at most k different values for number of duplicates

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables for calculation

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
k is a positive integer
You start with exactly one element with value 1

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses mathematical enumeration to try different numbers of duplicate operations and calculate the minimum increments needed. The key insight is that we want to balance the cost of creating copies versus incrementing existing elements. For each possible number of duplicates d, we calculate total operations as d + max(0, k - (d + 1)) and find the minimum.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Enumeration (Optimized)	O(k)	O(1)	Try different numbers of duplicates and calculate required increments
Brute Force (Try All Combinations)	O(2^k)	O(k)	Try all possible sequences of increment and duplicate operations

Mathematical Enumeration (Optimized) — Algorithm Steps

Try different numbers of duplicate operations (d = 0, 1, 2, ...)
For d duplicates, we have d+1 elements in the array
Calculate minimum increments needed to reach sum k
Use greedy approach: distribute increments as evenly as possible
Return minimum across all valid d values

Visualization

Tap to expand

Step-by-Step Walkthrough

Try d=0

No duplicates: [1], need k-1 increments

Try d=1

1 duplicate: [1,1], need k-2 increments

Try d=2

2 duplicates: [1,1,1], need k-3 increments

Find Minimum

Choose d that minimizes d + max(0, k-(d+1))

Code -

solution.c — C

#include <stdio.h>

int minOperations(int k) {
    if (k == 1) return 0;
    
    int minOps = k; // worst case
    
    // Try different numbers of duplicate operations
    for (int duplicates = 0; duplicates < k; duplicates++) {
        int arraySize = duplicates + 1;
        
        if (k <= arraySize) {
            if (duplicates < minOps) {
                minOps = duplicates;
            }
        } else {
            int incrementsNeeded = k - arraySize;
            int totalOps = duplicates + incrementsNeeded;
            if (totalOps < minOps) {
                minOps = totalOps;
            }
        }
    }
    
    return minOps;
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%d\n", minOperations(k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

We try at most k different values for number of duplicates

✓ Linear Growth

Space Complexity

O(1)

Only storing a few variables for calculation

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
k is a positive integer
You start with exactly one element with value 1

12.5K Views

Medium Frequency

~15 min Avg. Time

342 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

Mathematical Enumeration (Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler