Patching Array - Practice Coding Problems

Patching Array - Problem

Array Greedy Hard

You're given a sorted integer array nums and an integer n. Your mission is to strategically patch (add) the minimum number of elements to the array so that any number from 1 to n can be formed by summing some elements in the array.

Think of it as filling gaps in your ability to represent numbers. If you can represent all numbers from 1 to miss-1, but can't represent miss, you need to add miss to your array to extend your range.

Goal: Return the minimum number of patches required to make all numbers in range [1, n] representable.

Example: For nums = [1, 3] and n = 6, you can represent 1, 3, 4 but missing 2, 5, 6. Adding just 2 allows you to represent all numbers 1-6!

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 3], n = 6

› Output: 1

💡 Note: Initially we can form {1, 3, 4}. We're missing 2, 5, 6. By adding 2, we can now form {1, 2, 3, 4, 5, 6} since 5 = 2+3 and 6 = 1+2+3. Only 1 patch needed!

example_2.py — Empty Array

$ Input: nums = [1, 5, 10], n = 20

› Output: 2

💡 Note: We can form {1, 5, 6, 10, 11, 15, 16}. Missing many numbers. We need to add 2 (extends to cover 1-2), then 4 (extends to cover 1-8), then we can use existing numbers to reach 20.

example_3.py — Already Complete

$ Input: nums = [1, 2, 2], n = 5

› Output: 0

💡 Note: We can already form all numbers 1-5: {1, 2, 3=1+2, 4=2+2, 5=1+2+2}. No patches needed!

Constraints

1 ≤ n ≤ 2³¹ - 1
0 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ n
nums is sorted in ascending order

Visualization

Tap to expand

Understanding the Visualization

Start at position 1

We need to cover from 1 to n

Use existing segments

If we have a segment that starts at or before our current position, use it

Add missing segments

If there's a gap, add the optimal segment that doubles our reach

Extend coverage

Each addition strategically extends our coverage range

Key Takeaway

🎯 Key Insight: If you can represent [1, miss-1], adding 'miss' optimally extends your range to [1, 2×miss-1]. This greedy choice minimizes patches needed!

Asked in

G Google 45 a Amazon 38 f Facebook 28 ⊞ Microsoft 22

The optimal solution uses a greedy approach with the key insight that if we can represent all numbers [1, miss-1], adding 'miss' extends our range to [1, 2×miss-1]. We track the smallest missing number and either use existing array elements or add patches strategically. Time: O(m), Space: O(1) where m is array length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subsets)	O(2^m * n)	O(2^m)	Generate all possible subset sums and check coverage
Greedy Approach (Optimal)	O(m)	O(1)	Track the smallest missing number and extend coverage greedily

Brute Force (Check All Subsets) — Algorithm Steps

Generate all possible subset sums from current array
Check which numbers from 1 to n are missing
Add the smallest missing number to the array
Repeat until all numbers 1 to n are covered
Count how many numbers we added

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Create all possible combinations of array elements

Calculate Sums

Compute sum for each subset

Check Coverage

See which numbers 1 to n are missing

Add Missing

Add smallest missing number and repeat

Code -

solution.c — C

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

int minPatches(int* nums, int numsSize, int n) {
    // Simplified brute force approach
    bool* canForm = (bool*)calloc(n + 1, sizeof(bool));
    canForm[0] = true;
    
    int patches = 0;
    int* currentNums = (int*)malloc(1000 * sizeof(int));
    int currentSize = 0;
    
    // Copy original array
    for (int i = 0; i < numsSize; i++) {
        currentNums[currentSize++] = nums[i];
    }
    
    while (true) {
        // Reset canForm array
        for (int i = 0; i <= n; i++) canForm[i] = false;
        canForm[0] = true;
        
        // Calculate what we can form
        for (int i = 0; i < currentSize; i++) {
            for (int j = n; j >= currentNums[i]; j--) {
                if (canForm[j - currentNums[i]]) {
                    canForm[j] = true;
                }
            }
        }
        
        // Find first missing number
        int missing = -1;
        for (int i = 1; i <= n; i++) {
            if (!canForm[i]) {
                missing = i;
                break;
            }
        }
        
        if (missing == -1) break;
        
        currentNums[currentSize++] = missing;
        patches++;
        
        if (patches > 32) break;
    }
    
    free(canForm);
    free(currentNums);
    return patches;
}

int main() {
    int nums[] = {1, 3};
    int result = minPatches(nums, 2, 6);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m * n)

For each of m elements (original + patches), we generate 2^m subsets, and check coverage of n numbers

✓ Linear Growth

Space Complexity

O(2^m)

Need to store all possible subset sums

✓ Linear Space

42.0K Views

Medium 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 (Check All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler