Patching Array - Practice Coding Problems

Patching Array - Problem

Array Greedy Hard

Given a sorted integer array nums and an integer n, you need to add/patch elements to the array such that any number in the range [1, n] inclusive can be formed by the sum of some elements in the array.

Return the minimum number of patches required.

The patching strategy should ensure that we can represent all integers from 1 to n using subsets of the modified array.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can make [1,3,4] with the array. Missing 2,5,6. By patching 2, we can make [1,2,3,4,5,6]. Only 1 patch needed.

Example 2 — Empty Array

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

› Output: 2

💡 Note: With [1,5,10], we can make some sums but need patches. We need to patch 2 and 4 to cover [1,20].

Example 3 — No Patches Needed

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

› Output: 0

💡 Note: We can make [1,2,3,4,5] using subsets: 1→[1], 2→[2], 1+2→[3], 2+2→[4], 1+2+2→[5]. No patches needed.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Sorted array nums and target range [1, n]

Process

Find minimum patches to cover all numbers

Output

Number of patches required

Key Takeaway

🎯 Key Insight: If we can make sums [1, x], adding y extends to [1, x+y]. Greedily patch gaps!

Asked in

G Google 15 a Amazon 8 f Facebook 6

The key insight is that if we can make all sums [1, x], adding value y lets us make [1, x+y]. The greedy approach tracks the maximum achievable sum and patches optimally. Time: O(m + log n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Greedy - Track Maximum Achievable Sum	O(m + log n)	O(1)	Greedily track the maximum sum we can achieve and add minimal patches when gaps are found
Brute Force - Generate All Subset Sums	O(2^m × n)	O(2^m)	Generate all possible subset sums and check which numbers from 1 to n are missing

Greedy - Track Maximum Achievable Sum — Algorithm Steps

Step 1: Initialize maxReach = 0 (we can make sums [1, 0] = empty set)
Step 2: For each number in array, if it's ≤ maxReach + 1, extend our range
Step 3: If current number > maxReach + 1, patch with (maxReach + 1)
Step 4: Continue until maxReach ≥ n

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Range

Keep track of maximum sum we can achieve: [1, maxReach]

Extend or Patch

Use array elements to extend range, or patch when gap found

Count Patches

Minimum patches needed to cover [1, n]

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int n) {
    int patches = 0;
    long long maxReach = 0; // We can make all sums in [1, maxReach]
    int i = 0;
    
    while (maxReach < n) {
        // If current number can extend our range
        if (i < numsSize && nums[i] <= maxReach + 1) {
            maxReach += nums[i];
            i++;
        } else {
            // Need to patch with (maxReach + 1)
            patches++;
            maxReach += maxReach + 1;
        }
    }
    
    return patches;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    if (strlen(line) > 3) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int n;
    scanf("%d", &n);
    
    printf("%d\n", solution(nums, numsSize, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + log n)

Single pass through array of length m, plus at most log n patches

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Greedy - Track Maximum Achievable Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler