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.

Example: If word = "abacaba" and k = 3, after one operation we have "acaba" + "abc" = "acabaabc". We need to find the minimum operations to get back to "abacaba".

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: At t=1: Remove "aba" → "caba", need to add "aba" to get "cabaaba" ≠ "abacaba". At t=2: Remove "abacab" → "a", can add "bacaba" to get "abacaba" ✓

example_2.py — Single Character

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

› Output: 2

💡 Note: At t=1: Remove "a" → "a", need "a" == "a" but we need full word. At t=2: Remove "aa" → "", can build "aa" from scratch.

example_3.py — Immediate Match

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

› Output: 1

💡 Note: At t=1: Remove "ab" → "ab", and "ab" matches prefix "ab" of original word, so we can add "ab" to get "abab".

Visualization

Tap to expand

Understanding the Visualization

Original Film Strip

We start with the complete sequence 'abacaba'

Cut First k Frames

Remove first 3 characters: 'aba|caba' → 'caba'

Check Reconstruction

Can 'caba' + 3 new frames = 'abacaba'? Need 'caba' to match some prefix

Find Match

At step 2, 'a' matches prefix 'a', so we can reconstruct!

Key Takeaway

🎯 Key Insight: Instead of trying all possible character additions, we just check if the remaining suffix can naturally extend to form the original word by matching its prefix pattern.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check at most n/k positions, each requiring O(n) string comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

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

Asked in

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

The optimal approach uses string prefix matching instead of simulation. For each time step t, we check if the remaining suffix word[t*k:] matches the corresponding prefix of the original word. This gives us O(n²) time complexity and O(1) space, much better than brute force simulation.

Common Approaches

Approach	Time	Space	Notes
✓ Simulate All Operations	O(26^k * n)	O(n)	Simulate each time step by removing k characters and trying all possible additions
String Matching with Prefix Check (Optimal)	O(n²)	O(1)	Check if remaining suffix can form original word by matching prefixes

Simulate All Operations — Algorithm Steps

Start with the original word
For each time step, remove first k characters
Try to add k characters that could lead to the original word
Check if we've reached the original state
Continue until we find a solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original word

Remove k chars

Remove first k characters from current word

Check possibilities

See if we can add k characters to match original

Repeat

Continue until we find a valid solution

Code -

solution.c — C

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

int minimumTimeToInitialState(char* word, int k) {
    int n = strlen(word);
    char* original = malloc((n + 1) * sizeof(char));
    strcpy(original, word);
    
    char* current = malloc((n + 1) * sizeof(char));
    strcpy(current, word);
    
    int time = 0;
    
    while (1) {
        time++;
        int currentLen = strlen(current);
        
        // Remove first k characters
        if (k >= currentLen) {
            current[0] = '\0';
        } else {
            memmove(current, current + k, currentLen - k + 1);
        }
        
        int remainingLen = strlen(current);
        int neededLen = n - remainingLen;
        
        if (neededLen <= 0) {
            if (strcmp(current, original) == 0) {
                free(original);
                free(current);
                return time;
            }
        } else {
            if (remainingLen == 0) {
                free(original);
                free(current);
                return time;
            } else {
                char temp[n + 1];
                strncpy(temp, original, remainingLen);
                temp[remainingLen] = '\0';
                if (strcmp(current, temp) == 0) {
                    free(original);
                    free(current);
                    return time;
                }
            }
        }
        
        if (time * k >= n) {
            free(original);
            free(current);
            return time;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(26^k * n)

For each of the n/k possible time steps, we might need to try all 26^k possible character combinations

✓ Linear Growth

Space Complexity

O(n)

Space to store the current word state

⚡ Linearithmic Space

Constraints

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

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Simulate All Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler