Find the Number of Copy Arrays - Practice Coding Problems

Find the Number of Copy Arrays - Problem

Array Math Medium

Array Transformation with Constraints

You're given an original array of length n and a 2D array bounds where each bounds[i] = [ui, vi] defines the valid range for position i.

Your task is to find how many different copy arrays can be created such that:

📏 Preserve Differences: The difference between consecutive elements in copy must match the differences in original: (copy[i] - copy[i-1]) == (original[i] - original[i-1]) for all valid i

🎯 Stay Within Bounds: Each copy[i] must satisfy ui ≤ copy[i] ≤ vi

Example: If original = [1, 3, 2] and we start copy[0] = 5, then copy[1] = 7 and copy[2] = 6 to preserve the differences +2 and -1.

Input & Output

example_1.py — Basic Case

$ Input: original = [1, 3, 2], bounds = [[1,5], [2,4], [1,3]]

› Output: 2

💡 Note: Two valid copy arrays exist: [1,3,2] and [2,4,3]. Both preserve the differences +2,-1 and stay within bounds.

example_2.py — No Valid Arrays

$ Input: original = [1, 5], bounds = [[1,2], [1,3]]

› Output: 0

💡 Note: The difference +4 is required, but starting from bounds [1,2] would need copy[1] to be 5-7, exceeding bound [1,3].

example_3.py — Single Element

$ Input: original = [5], bounds = [[2,8]]

› Output: 7

💡 Note: With only one element, any value in bounds [2,8] works: 2,3,4,5,6,7,8 = 7 possibilities.

Visualization

Tap to expand

Understanding the Visualization

Identify Differences

Calculate differences between consecutive elements in original array

Apply Constraints

For each position, determine what values are valid given the bounds

Propagate Backwards

Work backwards to find valid starting positions

Count Solutions

Count how many starting positions lead to valid arrays

Key Takeaway

🎯 Key Insight: Once we choose the first element, the entire array is determined by the difference pattern. We only need to find which starting values keep all elements within bounds.

Time & Space Complexity

Time Complexity

⏱️

O(R × n)

R is the range of the first bound (vi - ui), n is array length

✓ Linear Growth

Space Complexity

O(n)

Space to store the copy array being constructed

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
bounds.length == n
bounds[i].length == 2
-10⁴ ≤ original[i] ≤ 10⁴
-10⁴ ≤ bounds[i][0] ≤ bounds[i][1] ≤ 10⁴
The bounds are inclusive ranges

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires finding valid starting positions for the first element, as the rest of the array is determined by the difference constraints. The key insight is that we can work backwards from all bounds to determine the valid range for the first element, making this an O(n) problem rather than trying all possible starting values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Starting Values)	O(R × n)	O(n)	Try every possible value for the first element within its bounds

Brute Force (Try All Starting Values) — Algorithm Steps

Iterate through all possible values for copy[0] from bounds[0][0] to bounds[0][1]
For each starting value, build the complete copy array using original's differences
Check if all elements in the constructed array satisfy their bounds
Count valid arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Starting Value

Pick a value from the first bound range

Apply Differences

Use original array differences to build copy array

Check Bounds

Verify each element stays within its bounds

Count Valid Arrays

Increment counter if all bounds are satisfied

Code -

solution.c — C

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

int numOfArrays(int* original, int originalSize, int** bounds, int boundsSize) {
    int count = 0;
    
    // Try each possible starting value
    for (int start = bounds[0][0]; start <= bounds[0][1]; start++) {
        bool valid = true;
        int* copy = malloc(originalSize * sizeof(int));
        copy[0] = start;
        
        // Build the copy array using original's differences
        for (int i = 1; i < originalSize; i++) {
            int diff = original[i] - original[i-1];
            copy[i] = copy[i-1] + diff;
            
            // Check if within bounds
            if (copy[i] < bounds[i][0] || copy[i] > bounds[i][1]) {
                valid = false;
                break;
            }
        }
        
        if (valid) count++;
        free(copy);
    }
    
    return count;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R × n)

R is the range of the first bound (vi - ui), n is array length

✓ Linear Growth

Space Complexity

O(n)

Space to store the copy array being constructed

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
bounds.length == n
bounds[i].length == 2
-10⁴ ≤ original[i] ≤ 10⁴
-10⁴ ≤ bounds[i][0] ≤ bounds[i][1] ≤ 10⁴
The bounds are inclusive ranges

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Brute Force (Try All Starting Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler