Build an Array With Stack Operations - Practice Coding Problems

Build an Array With Stack Operations - Problem

Stack Construction Challenge

Imagine you have a stream of consecutive integers from 1 to n flowing towards you, and you need to use a stack to build a specific target array. You can only perform two operations:

🔄 "Push": Take the next number from the stream and push it onto the stack
🗑️ "Pop": Remove the top element from the stack

Your goal is to determine the sequence of operations needed so that the stack (from bottom to top) matches the target array exactly. The challenge is that you must process the stream in order (1, 2, 3, ..., n) and decide whether to keep each number or discard it.

Example: If target = [1,3] and n = 3, the stream gives you 1,2,3. You'd push 1 (keep), push 2 then pop it (discard), then push 3 (keep).

Return the list of operations: ["Push", "Push", "Pop", "Push"]

Input & Output

example_1.py — Simple Skip Pattern

$ Input: target = [1,3], n = 3

› Output: ["Push","Push","Pop","Push"]

💡 Note: Stream gives us 1,2,3. We want 1 (push and keep), don't want 2 (push then pop to skip), want 3 (push and keep). Final stack: [1,3] from bottom to top.

example_2.py — Consecutive Numbers

$ Input: target = [1,2,3], n = 3

› Output: ["Push","Push","Push"]

💡 Note: Stream gives us 1,2,3 and we want all of them in order. Just push each number as it comes. No pops needed since we want every number.

example_3.py — Early Termination

$ Input: target = [1,2], n = 4

› Output: ["Push","Push"]

💡 Note: We only need 1,2 from the stream. After getting both numbers, we stop processing even though n=4 allows us to see numbers 3,4. Early termination optimization.

Visualization

Tap to expand

Understanding the Visualization

Belt Starts Moving

Products 1,2,3... come down the conveyor belt in order

Decision Point

For each product: Is this one I need for my collection?

Keep or Skip

If needed: place in collection bin. If not needed: take it and immediately discard

Perfect Collection

End with exactly the products you wanted, in the right order

Key Takeaway

🎯 Key Insight: Since both the stream (1,2,3...) and target are in ascending order, we can make greedy decisions without backtracking. Each stream number either belongs in our final result (push and keep) or doesn't (push then immediately pop to skip).

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We process at most n numbers from stream, and m is target length for set operations

✓ Linear Growth

Space Complexity

O(m)

Space for the target set and result operations list

✓ Linear Space

Constraints

1 ≤ target.length ≤ 100
1 ≤ target[i] ≤ n ≤ 100
target is strictly increasing (no duplicates, sorted order)
All elements in target are distinct and within range [1, n]

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses a greedy simulation strategy. Since the stream provides numbers in sequential order (1,2,3,...,n) and our target array is sorted, we can make a simple decision for each stream number: if it matches the next number we need in our target, we push and keep it; otherwise, we push it and immediately pop it to 'skip' it. This O(n) time complexity solution processes each stream number exactly once and uses O(m) space where m is the target array length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(2n))	O(2n)	Try every possible sequence of push/pop operations until we find one that works
Greedy Simulation (Optimal)	O(n + m)	O(m)	Process the stream sequentially, using a set to quickly check if current number is needed

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible sequences of 'Push' and 'Pop' operations
For each sequence, simulate the stack operations with the stream 1,2,...,n
Check if the final stack matches the target array
Return the first sequence that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Sequences

Create all possible combinations of Push/Pop operations

Test Each Sequence

Simulate each sequence with the number stream

Check Result

Compare final stack with target array

Return First Match

Stop when we find a working sequence

Code -

solution.c — C

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

char** buildArray(int* target, int targetSize, int n, int* returnSize) {
    // This is a simplified brute force approach
    // Full implementation would be quite complex in C
    char** result = (char**)malloc(2000 * sizeof(char*));
    int idx = 0;
    int streamIdx = 1;
    int targetIdx = 0;
    
    while (targetIdx < targetSize && streamIdx <= n) {
        result[idx] = (char*)malloc(10 * sizeof(char));
        strcpy(result[idx], "Push");
        idx++;
        
        if (streamIdx == target[targetIdx]) {
            targetIdx++;
        } else {
            result[idx] = (char*)malloc(10 * sizeof(char));
            strcpy(result[idx], "Pop");
            idx++;
        }
        streamIdx++;
    }
    
    *returnSize = idx;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(2n))

We potentially try all combinations of push/pop operations, which can be up to 2^(2n) possibilities

✓ Linear Growth

Space Complexity

O(2n)

Stack space for simulation and storing the operation sequence

⚡ Linearithmic Space

Constraints

1 ≤ target.length ≤ 100
1 ≤ target[i] ≤ n ≤ 100
target is strictly increasing (no duplicates, sorted order)
All elements in target are distinct and within range [1, n]

45.0K Views

Medium Frequency

~8 min Avg. Time

2.1K 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler