Stamping The Sequence - Practice Coding Problems

Stamping The Sequence - Problem

Imagine you have a rubber stamp and want to create a specific word by stamping it on a blank canvas. You're given two strings:

stamp - your rubber stamp pattern
target - the final sequence you want to create

Initially, you have a string s of length target.length filled with question marks ('?'). In each turn, you can place your stamp anywhere on s and replace the characters with your stamp pattern.

Example: If stamp = "abc" and target = "abcba", you start with s = "?????". You can:

Place stamp at index 0: "abc??"
Place stamp at index 1: "?abc?"
Place stamp at index 2: "??abc"

Goal: Transform s into target using at most 10 * target.length turns. Return the sequence of starting positions where you placed the stamp. If impossible, return an empty array.

Key constraint: The stamp must fit completely within the string boundaries!

Input & Output

example_1.py — Basic Stamping

$ Input: stamp = "abc", target = "ababc"

› Output: [0, 2]

💡 Note: Start with "?????" → stamp at 0: "abc??" → stamp at 2: "ababc". The sequence [0, 2] creates the target.

example_2.py — Overlapping Stamps

$ Input: stamp = "abca", target = "aabcaca"

› Output: [3, 0, 1]

💡 Note: Working backwards: "aabcaca" → remove at 3: "aab????" → remove at 0: "????aca" → remove at 1: "???????" then reverse to get [1, 0, 3].

example_3.py — Impossible Case

$ Input: stamp = "abc", target = "abcdef"

› Output: []

💡 Note: Cannot create "abcdef" using only stamp "abc" since 'def' characters don't exist in the stamp.

Constraints

1 ≤ stamp.length ≤ target.length ≤ 1000
stamp and target consist of lowercase English letters only
Key constraint: Must solve within 10 × target.length turns

Visualization

Tap to expand

Understanding the Visualization

Start with Final Design

Begin with your target string - this is your completed artwork

Find Removable Stamps

Look for positions where you can 'remove' a stamp (convert matching characters to '?')

Greedy Removal

Always pick the first valid position to remove - greediness works here!

Track the Process

Record each removal position as you work backwards to a blank canvas

Reverse for Answer

Flip your removal sequence to get the forward stamping order

Key Takeaway

🎯 Key Insight: The magic happens when we reverse our thinking - instead of building up the target, we tear it down greedily, which guarantees an optimal solution!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a reverse greedy approach. Instead of building the target from question marks, we start with the target and work backwards, greedily removing stamps until we reach all question marks. The key insight is that this reverse process is much more efficient and guarantees finding a solution if one exists. Time complexity: O(n × m × (n + m)) where n is target length and m is stamp length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Sequences)	O(k^n)	O(n)	Try all possible stamping sequences using backtracking
Reverse Greedy (Optimal)	O(n * m * (n + m))	O(n + m)	Work backwards from target, greedily removing stamps until reaching all '?'

Brute Force (Try All Sequences) — Algorithm Steps

Start with a string of all question marks
Try placing stamp at every valid position
For each placement, recursively try to reach target
Backtrack if current path doesn't lead to solution
Return first valid sequence found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with target string, try first position

Try Stamp

Check if stamp can be placed at current position

Recursive Call

If valid, mark as '?' and recurse

Backtrack

If path fails, undo and try next position

Code -

solution.c — C

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

bool canStamp(int pos, char* state, char* stamp, char* newState) {
    bool changed = false;
    int stampLen = strlen(stamp);
    strcpy(newState, state);
    
    for (int i = 0; i < stampLen; i++) {
        if (state[pos + i] == '?') {
            continue;
        } else if (state[pos + i] == stamp[i]) {
            changed = true;
        } else {
            return false;
        }
    }
    
    if (!changed) return false;
    
    for (int i = 0; i < stampLen; i++) {
        newState[pos + i] = '?';
    }
    return true;
}

bool backtrack(char* state, char* stamp, int* moves, int* moveCount, int maxMoves) {
    if (*moveCount > maxMoves) return false;
    
    bool allQuestions = true;
    int len = strlen(state);
    for (int i = 0; i < len; i++) {
        if (state[i] != '?') {
            allQuestions = false;
            break;
        }
    }
    if (allQuestions) return true;
    
    int stampLen = strlen(stamp);
    char* newState = malloc(len + 1);
    
    for (int pos = 0; pos <= len - stampLen; pos++) {
        if (canStamp(pos, state, stamp, newState)) {
            moves[(*moveCount)++] = pos;
            if (backtrack(newState, stamp, moves, moveCount, maxMoves)) {
                free(newState);
                return true;
            }
            (*moveCount)--;
        }
    }
    
    free(newState);
    return false;
}

int* movesToStamp(char* stamp, char* target, int* returnSize) {
    int maxMoves = 10 * strlen(target);
    int* moves = malloc(maxMoves * sizeof(int));
    int moveCount = 0;
    
    if (backtrack(target, stamp, moves, &moveCount, maxMoves)) {
        // Reverse the array
        for (int i = 0; i < moveCount / 2; i++) {
            int temp = moves[i];
            moves[i] = moves[moveCount - 1 - i];
            moves[moveCount - 1 - i] = temp;
        }
        *returnSize = moveCount;
        return moves;
    }
    
    free(moves);
    *returnSize = 0;
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is number of valid positions and n is the number of turns needed

✓ Linear Growth

Space Complexity

O(n)

For recursion stack and storing the current sequence

⚡ Linearithmic Space

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

Brute Force (Try All Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler