Form Array by Concatenating Subarrays of Another Array

Form Array by Concatenating Subarrays of Another Array - Problem

Imagine you have a blueprint of several ordered building blocks (the groups array) and a long strip of numbered tiles (the nums array). Your task is to find if you can select non-overlapping consecutive segments from the strip that perfectly match each building block in the exact same order.

The Challenge: Given a 2D array groups containing n target sequences and an array nums, determine if you can find n disjoint subarrays in nums such that:

The i-th subarray exactly matches groups[i]
The subarrays appear in the same order as the groups (no backtracking)
No element from nums is used more than once

Example: If groups = [[1,2,3],[3,4]] and nums = [7,7,1,2,3,4,7,7], you can find [1,2,3] starting at index 2 and [3,4] starting at index 5, so return true.

Input & Output

example_1.py — Basic Match

$ Input: groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]

› Output: true

💡 Note: We can find [1,2,3] starting at index 2 and [3,4] starting at index 5. Both subarrays are disjoint and in correct order.

example_2.py — No Valid Arrangement

$ Input: groups = [[10,2],[1,2,3],[2,4]], nums = [1,2,3,4,10,2]

› Output: false

💡 Note: We can find [1,2,3] at index 0, but then [10,2] appears at index 4, which violates the order requirement.

example_3.py — Edge Case Single Elements

$ Input: groups = [[1],[2],[3]], nums = [1,2,3]

› Output: true

💡 Note: Each group is a single element and they appear consecutively in order in nums.

Visualization

Tap to expand

Understanding the Visualization

Setup

We have a blueprint of required carriage sequences and a railway yard

Scan

Walk through the yard looking for the first required sequence

Match

When found, mark those carriages as used and look for the next sequence

Result

Success if all sequences found in order, failure otherwise

Key Takeaway

🎯 Key Insight: Since groups must appear in order, we can use a greedy approach - always take the first valid match we find, as it never prevents finding a solution if one exists.

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

Where n is length of nums and k is average group length. We scan nums once and do substring matching.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

Constraints

1 ≤ groups.length ≤ 10³
1 ≤ groups[i].length ≤ 10⁶
1 ≤ nums.length ≤ 10⁶
1 ≤ groups[i][j], nums[k] ≤ 10⁷
Sum of all groups[i].length ≤ 10⁶

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 21

The optimal solution uses a greedy two-pointers approach in O(n*k) time. Since groups must appear in order, we can scan nums once and greedily match the first occurrence of each group. This works because taking the first valid match never prevents us from finding a solution that exists.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Two Pointers (Optimal)	O(n * k)	O(1)	Use one pointer for groups and one for nums, greedily matching first occurrence
Brute Force (Try All Positions)	O(n * m * k)	O(m)	Try every possible starting position for each group using nested loops

Greedy Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: groupIdx = 0, numsIdx = 0
For each position in nums, check if current group matches starting at this position
If match found, move groupIdx to next group and numsIdx past the matched segment
If all groups are matched, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

groupIdx = 0, numsIdx = 0

Scan and Match

Check if current group matches at current nums position

Move Pointers

On match: advance both pointers. No match: advance nums pointer only

Code -

solution.c — C

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

bool matchesAt(int* group, int groupSize, int* nums, int numsSize, int start) {
    if (start + groupSize > numsSize) return false;
    
    for (int i = 0; i < groupSize; i++) {
        if (nums[start + i] != group[i]) return false;
    }
    return true;
}

bool canChoose(int** groups, int* groupSizes, int groupsSize, int* nums, int numsSize) {
    int groupIdx = 0;
    int numsIdx = 0;
    
    while (groupIdx < groupsSize && numsIdx < numsSize) {
        int* group = groups[groupIdx];
        int groupSize = groupSizes[groupIdx];
        
        if (matchesAt(group, groupSize, nums, numsSize, numsIdx)) {
            groupIdx++;
            numsIdx += groupSize;
        } else {
            numsIdx++;
        }
    }
    
    return groupIdx == groupsSize;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

Where n is length of nums and k is average group length. We scan nums once and do substring matching.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and variables

✓ Linear Space

Constraints

1 ≤ groups.length ≤ 10³
1 ≤ groups[i].length ≤ 10⁶
1 ≤ nums.length ≤ 10⁶
1 ≤ groups[i][j], nums[k] ≤ 10⁷
Sum of all groups[i].length ≤ 10⁶

38.9K Views

Medium Frequency

~25 min Avg. Time

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

Greedy Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler