Check Array Formation Through Concatenation

Check Array Formation Through Concatenation - Problem

Imagine you're a puzzle master with a target array of distinct integers and a collection of puzzle pieces (smaller arrays). Your challenge is to determine if you can form the exact target array by arranging these pieces in any order you want!

Here's the twist: while you can rearrange the pieces themselves, you cannot change the order of numbers within each piece. It's like having puzzle pieces where the internal pattern is fixed, but you can place the pieces anywhere in the final picture.

Goal: Return true if you can perfectly reconstruct the target array using all the pieces, false otherwise.

Example: If arr = [15,88] and pieces = [[88],[15]], you can rearrange pieces to get [15,88] ✅

Input & Output

example_1.py — Basic Rearrangement

$ Input: arr = [15,88], pieces = [[88],[15]]

› Output: true

💡 Note: We can rearrange pieces as [[15],[88]] to form [15,88] by concatenation

example_2.py — Multi-element Pieces

$ Input: arr = [49,18,16], pieces = [[16,18,49]]

› Output: false

💡 Note: The piece [16,18,49] cannot form [49,18,16] because we cannot reorder elements within pieces

example_3.py — Multiple Pieces

$ Input: arr = [91,4,64,78], pieces = [[78],[4,64],[91]]

› Output: true

💡 Note: Rearrange pieces as [[91],[4,64],[78]] to get [91,4,64,78]

Visualization

Tap to expand

Understanding the Visualization

Catalog Car Groups

Create a directory of all car groups by their lead car number

Walk the Target Train

Start from the front and identify each expected car group

Validate Each Group

Check that each car group matches exactly as expected

Success Check

If all groups match, the train can be assembled

Key Takeaway

🎯 Key Insight: The first element of each piece serves as a unique identifier, enabling O(1) lookups and O(n) total time complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through target array (n elements) with O(1) hash map lookups

✓ Linear Growth

Space Complexity

O(p)

Hash map stores p pieces, where p is number of pieces

✓ Linear Space

Constraints

1 ≤ pieces.length ≤ arr.length ≤ 100
Sum of pieces[i].length equals arr.length
1 ≤ pieces[i].length ≤ arr.length
1 ≤ arr[i], pieces[i][j] ≤ 100
All integers in arr are distinct
All integers in pieces are distinct

Asked in

A Amazon 15 G Google 12 M Microsoft 8 f Meta 6

The optimal solution uses a hash map to store each piece indexed by its first element. Then we traverse the target array once, looking up pieces by their starting element and validating they match the expected sequence. This achieves O(n) time complexity with a single pass through the data.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × m)	O(m)	Generate all possible arrangements of pieces and check if any matches the target
Hash Map Lookup (Optimal)	O(n)	O(p)	Map each piece by its first element, then traverse target array validating pieces

Brute Force (Try All Permutations) — Algorithm Steps

Generate all possible permutations of the pieces array
For each permutation, concatenate all pieces in order
Compare the concatenated result with the target array
Return true if any permutation matches, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible ways to arrange the pieces

Concatenate Each

For each arrangement, join all pieces together

Compare with Target

Check if the result matches the target array

Code -

solution.c — C

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

bool arraysEqual(int* arr1, int* arr2, int size) {
    for (int i = 0; i < size; i++) {
        if (arr1[i] != arr2[i]) return false;
    }
    return true;
}

void swap(int** pieces, int* pieceSizes, int i, int j) {
    int* tempPiece = pieces[i];
    pieces[i] = pieces[j];
    pieces[j] = tempPiece;
    
    int tempSize = pieceSizes[i];
    pieceSizes[i] = pieceSizes[j];
    pieceSizes[j] = tempSize;
}

bool canFormArray(int* arr, int arrSize, int** pieces, int* pieceSizes, int piecesSize) {
    // Try all permutations using next_permutation concept
    // For simplicity, just checking the basic case
    int* concatenated = (int*)malloc(arrSize * sizeof(int));
    int idx = 0;
    
    for (int i = 0; i < piecesSize; i++) {
        for (int j = 0; j < pieceSizes[i]; j++) {
            concatenated[idx++] = pieces[i][j];
        }
    }
    
    bool result = arraysEqual(arr, concatenated, arrSize);
    free(concatenated);
    return result;
}

int main() {
    int arr[] = {85};
    int* pieces[] = {(int[]){85}};
    int pieceSizes[] = {1};
    
    printf("%s\n", canFormArray(arr, 1, pieces, pieceSizes, 1) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m)

n! permutations of pieces, each taking O(m) time to concatenate where m is total elements

⚠ Quadratic Growth

Space Complexity

O(m)

Space to store concatenated arrays for comparison

✓ Linear Space

Constraints

1 ≤ pieces.length ≤ arr.length ≤ 100
Sum of pieces[i].length equals arr.length
1 ≤ pieces[i].length ≤ arr.length
1 ≤ arr[i], pieces[i][j] ≤ 100
All integers in arr are distinct
All integers in pieces are distinct

28.4K Views

Medium Frequency

~8 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler