Stamping The Sequence

Stamping The Sequence - Problem

You are given two strings stamp and target. Initially, there is a string s of length target.length with all s[i] == '?'.

In one turn, you can place stamp over s and replace every letter in the s with the corresponding letter from stamp. For example, if stamp = "abc" and target = "abcba", then s is "?????" initially. In one turn you can:

place stamp at index 0 of s to obtain "abc??"
place stamp at index 1 of s to obtain "?abc?"
place stamp at index 2 of s to obtain "??abc"

Note that stamp must be fully contained in the boundaries of s in order to stamp (i.e., you cannot place stamp at index 3 of s).

We want to convert s to target using at most 10 * target.length turns. Return an array of the index of the left-most letter being stamped at each turn. If we cannot obtain target from s within 10 * target.length turns, return an empty array.

Input & Output

Example 1 — Basic Case

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

› Output: [0,2]

💡 Note: Start with "?????". Stamp at position 0: "abc??". Stamp at position 2: "ababc" matches target.

Example 2 — Single Stamp

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

› Output: [0]

💡 Note: Target matches stamp exactly, so one stamp at position 0 creates the target.

Example 3 — Impossible Case

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

› Output: []

💡 Note: Cannot create target with given stamp - the 'aa' at start cannot be formed by 'abc'

Constraints

1 ≤ stamp.length ≤ target.length ≤ 1000
stamp and target consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to work backwards from the target string by removing stamp effects. The greedy reverse approach starts with the target and greedily removes stamps that could have contributed to the current state. Best approach is greedy reverse stamping. Time: O(n²), Space: O(n)

Common Approaches

✓ Brute Force Forward Simulation

⏱️ Time: O(m^k) Space: O(k)

Generate all possible sequences of stamp positions and simulate each one to see if it produces the target string within the move limit.

Greedy Reverse Stamping

⏱️ Time: O(n²) Space: O(n)

Start with the target and work backwards to the initial '?' state by identifying and removing stamp patterns. This avoids the exponential search space of forward simulation.

Brute Force Forward Simulation — Algorithm Steps

Step 1: Generate all possible stamping sequences up to 10*n length
Step 2: For each sequence, simulate stamping from '?' string
Step 3: Check if result matches target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with '?????' string

Try Positions

Test stamping at each valid position

Backtrack

If path fails, try different sequence

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_MOVES 10000

int canRemoveStamp(char* s, int pos, char* stamp, int sLen, int stampLen) {
    if (pos + stampLen > sLen) return 0;
    
    int hasMatch = 0;
    for (int i = 0; i < stampLen; i++) {
        if (s[pos + i] == '?') {
            continue;
        } else if (s[pos + i] == stamp[i]) {
            hasMatch = 1;
        } else {
            return 0;
        }
    }
    return hasMatch;
}

void removeStamp(char* s, int pos, int stampLen) {
    for (int i = 0; i < stampLen; i++) {
        s[pos + i] = '?';
    }
}

int isAllQuestions(char* s, int len) {
    for (int i = 0; i < len; i++) {
        if (s[i] != '?') return 0;
    }
    return 1;
}

int* solution(char* stamp, char* target, int* returnSize) {
    int targetLen = strlen(target);
    int stampLen = strlen(stamp);
    
    char current[MAX_LEN];
    strcpy(current, target);
    
    int* moves = (int*)malloc(MAX_MOVES * sizeof(int));
    int moveCount = 0;
    
    while (!isAllQuestions(current, targetLen) && moveCount < 10 * targetLen) {
        int found = 0;
        
        for (int pos = 0; pos <= targetLen - stampLen; pos++) {
            if (canRemoveStamp(current, pos, stamp, targetLen, stampLen)) {
                removeStamp(current, pos, stampLen);
                moves[moveCount++] = pos;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            *returnSize = 0;
            free(moves);
            return NULL;
        }
    }
    
    if (!isAllQuestions(current, targetLen)) {
        *returnSize = 0;
        free(moves);
        return NULL;
    }
    
    // Reverse the moves 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;
}

int main() {
    char stamp[MAX_LEN], target[MAX_LEN];
    fgets(stamp, sizeof(stamp), stdin);
    stamp[strcspn(stamp, "\n")] = 0;
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    int returnSize;
    int* result = solution(stamp, target, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m^k)

Where m is possible positions and k is max moves, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(k)

Store current stamping sequence and simulation state

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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 Forward Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler