Minimum Time to Revert Word to Initial State I

Minimum Time to Revert Word to Initial State I - Problem

You are given a 0-indexed string word and an integer k.

At every second, you must perform the following operations:

Remove the first k characters of word.
Add any k characters to the end of word.

Note that you do not necessarily need to add the same characters that you removed. However, you must perform both operations at every second.

Return the minimum time greater than zero required for word to revert to its initial state.

Input & Output

Example 1 — Basic Case

$ Input: word = "abacaba", k = 3

› Output: 2

💡 Note: At t=1: remove "aba", remaining = "caba". "caba" is not a prefix of "abacaba". At t=2: remove "abacab", remaining = "a". "a" is a prefix of "abacaba". Return 2.

Example 2 — Immediate Match

$ Input: word = "abcabc", k = 2

› Output: 3

💡 Note: At t=1: remove "ab", remaining = "cabc". "cabc" is not a prefix of "abcabc". At t=2: remove "abca", remaining = "bc". "bc" is not a prefix of "abcabc". At t=3: remove "abcabc", remaining = "". Empty string can always be reconstructed to original. Return 3.

Example 3 — Complete Removal

$ Input: word = "abc", k = 1

› Output: 3

💡 Note: At t=1: remove "a", remaining = "bc". At t=2: remove "ab", remaining = "c". At t=3: remove "abc", remaining = "". Empty string can always be reconstructed to original.

Constraints

1 ≤ word.length ≤ 50
1 ≤ k ≤ word.length
word consists only of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that the word can revert to its initial state when the remaining suffix after removing characters forms a valid prefix of the original word. The optimal approach checks each possible time step and verifies if the suffix matches the original prefix. Time: O(n²), Space: O(1)

Common Approaches

✓ Simulation Approach

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

For each time t, check if removing the first t*k characters leaves a suffix that can form the original word. We iterate through possible time values and verify if the remaining suffix can be extended to match the original word.

String Matching Optimization

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

Instead of simulating each step, we directly check if removing t*k characters results in a suffix that matches the original word's prefix. This approach uses the key insight that the word can revert when the remaining suffix forms a valid prefix of the original word.

Simulation Approach — Algorithm Steps

Try each time t from 1 to n/k
For each t, check if word[t*k:] is a prefix of the original word
Return the first valid time found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original word

Remove k chars

Check if remaining suffix matches original prefix

Find Match

Return first time when match is found

Code -

solution.c — C

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

int solution(char* word, int k) {
    int n = strlen(word);
    char* original = word;
    
    // Try each possible time from 1 to ceil(n/k)
    for (int t = 1; t <= (n + k - 1) / k; t++) {
        int charsRemoved = t * k;
        if (charsRemoved >= n) {
            // All characters removed, can always reconstruct
            return t;
        }
        
        // Check if remaining suffix can form the original word
        char* suffix = word + charsRemoved;
        if (strncmp(original, suffix, strlen(suffix)) == 0) {
            return t;
        }
    }
    
    return (n + k - 1) / k;
}

int main() {
    char word[1001];
    int k;
    
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(word, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of O(n/k) time steps, we perform O(n) string comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for iteration

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

245 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler