Minimum Array Sum - Practice Coding Problems

Minimum Array Sum - Problem

You're tasked with minimizing the sum of an array using two powerful operations with limited uses. Given an integer array nums and three integers k, op1, and op2, you can strategically apply:

Operation 1: Divide any element by 2 (rounded up) - usable at most op1 times, once per index
Operation 2: Subtract k from any element ≥ k - usable at most op2 times, once per index

Both operations can be applied to the same index, but each operation at most once per position. Your goal is to find the minimum possible sum after optimally applying these operations.

Example: With nums = [2,8,3,19,3], k = 3, op1 = 2, op2 = 2, you could divide 8→4 and 19→10, then subtract 3 from both, resulting in [2,1,3,7,3] with sum 16.

Input & Output

example_1.py — Basic case

$ Input: nums = [2,8,3,19,3], k = 3, op1 = 2, op2 = 2

› Output: 16

💡 Note: Apply op1 to 8→4 and 19→10, then apply op2 to both (4→1, 10→7). Final array: [2,1,3,7,3] with sum 16.

example_2.py — Limited operations

$ Input: nums = [2,4,3], k = 3, op1 = 1, op2 = 1

› Output: 4

💡 Note: Apply op1 to 4→2, then apply op2 to one element ≥3. Apply op2 to 3→0. Final array: [2,2,0] with sum 4.

example_3.py — No valid op2

$ Input: nums = [1,2,1], k = 5, op1 = 2, op2 = 1

› Output: 2

💡 Note: No element ≥ k=5, so op2 cannot be used. Apply op1 to 2→1 and another 1→1. Final array: [1,1,1] with sum 2 (but we started with sum 4, so apply op1 to both 2→1). Actually: [1,1,1] sum=3, but we can only reduce the 2, so [1,1,1] giving sum 3. Wait - let me recalculate: apply op1 to the 2→1, giving [1,1,1] with sum 3. We still have 1 op1 left but using it on any 1 gives 1. So minimum sum is 3.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁵
0 ≤ op1, op2 ≤ nums.length
Each operation can be applied at most once per index

Visualization

Tap to expand

Understanding the Visualization

Analyze each item

For each item, consider: no discount, half-price coupon, fixed discount, or both coupons

Track coupon usage

Keep count of remaining coupons of each type as you decide

Consider operation order

When using both coupons, try both orders (half-price then fixed, or fixed then half-price)

Use memoization

Cache results for each state (position, coupons_remaining) to avoid recalculation

Key Takeaway

🎯 Key Insight: Use dynamic programming with memoization to efficiently explore all operation combinations, considering that each element has exactly 4 possible outcomes and caching results based on remaining operation counts.

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28 Apple 22

The optimal approach uses dynamic programming with memoization to explore all possible operation combinations while avoiding redundant calculations. The key insight is that each element has exactly 4 possible outcomes, and we can cache results based on (current_index, operations1_remaining, operations2_remaining) to achieve O(n × op1 × op2) time complexity instead of the naive O(4^n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(4^n)	O(n)	Recursively try all possible combinations of operations on each element
Dynamic Programming with Memoization (Optimal)	O(n × op1 × op2)	O(n × op1 × op2)	Use memoization to cache results and avoid recomputing the same subproblems

Brute Force (Try All Combinations) — Algorithm Steps

For each element, calculate 4 possible outcomes: no ops, op1 only, op2 only, both ops
Recursively try each valid combination based on remaining operation counts
Track the minimum sum across all valid combinations
Return the minimum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Consider 4 possible operations for nums[0]

Branch for each choice

Recursively solve for remaining elements

Track minimum

Keep track of minimum sum across all paths

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solve(int* nums, int size, int i, int k, int ops1Left, int ops2Left) {
    if (i == size) {
        return 0;
    }
    
    // Option 1: No operations
    int result = nums[i] + solve(nums, size, i + 1, k, ops1Left, ops2Left);
    
    // Option 2: Apply op1 only
    if (ops1Left > 0) {
        int newVal = (nums[i] + 1) / 2;
        result = min(result, newVal + solve(nums, size, i + 1, k, ops1Left - 1, ops2Left));
    }
    
    // Option 3: Apply op2 only
    if (ops2Left > 0 && nums[i] >= k) {
        int newVal = nums[i] - k;
        result = min(result, newVal + solve(nums, size, i + 1, k, ops1Left, ops2Left - 1));
    }
    
    // Option 4: Apply both operations
    if (ops1Left > 0 && ops2Left > 0) {
        // Try op1 then op2
        int temp1 = (nums[i] + 1) / 2;
        if (temp1 >= k) {
            int final1 = temp1 - k;
            result = min(result, final1 + solve(nums, size, i + 1, k, ops1Left - 1, ops2Left - 1));
        }
        
        // Try op2 then op1
        if (nums[i] >= k) {
            int temp2 = nums[i] - k;
            int final2 = (temp2 + 1) / 2;
            result = min(result, final2 + solve(nums, size, i + 1, k, ops1Left - 1, ops2Left - 1));
        }
    }
    
    return result;
}

int minArraySum(int* nums, int numsSize, int k, int op1, int op2) {
    return solve(nums, numsSize, 0, k, op1, op2);
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

Each element has 4 choices, leading to 4^n total combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to array size

⚡ Linearithmic Space

38.5K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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