Minimum Number of Operations to Make Word K-Periodic

Minimum Number of Operations to Make Word K-Periodic - Problem

You're given a string word of length n and an integer k where k divides n evenly. Your goal is to transform the string into a k-periodic string using the minimum number of operations.

What is a k-periodic string? A string is k-periodic if it can be formed by repeating the same substring of length k multiple times. For example, "ababab" is 2-periodic because it repeats "ab" three times.

Operation allowed: You can pick any two indices i and j that are both divisible by k, then replace the substring word[i..i+k-1] with the substring word[j..j+k-1].

Example: If word = "abcdef" and k = 2, you can replace "ab" (at index 0) with "ef" (at index 4) to get "efcdef".

Return the minimum number of operations needed to make the string k-periodic.

Input & Output

example_1.py — Basic case

$ Input: word = "leetcodeleet", k = 4

› Output: 1

💡 Note: We can divide the string into 3 segments: ["leet", "code", "leet"]. The pattern "leet" appears twice, so we need 1 operation to change "code" to "leet".

example_2.py — Already periodic

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

› Output: 0

💡 Note: The string is already 2-periodic with pattern "ab" repeated 3 times. No operations needed.

example_3.py — All different segments

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

› Output: 2

💡 Note: We have segments ["ab", "cd", "ef"]. All are different, so we need 2 operations to make them all the same (keep one, change the other two).

Visualization

Tap to expand

Understanding the Visualization

Divide into Segments

Split the string into equal segments of length k

Count Frequencies

Count how many times each unique segment appears

Find Optimal Pattern

The most frequent segment should be our target pattern

Calculate Operations

Operations needed = Total segments - Max frequency

Key Takeaway

🎯 Key Insight: The optimal target pattern is always the most frequently occurring k-length substring - this minimizes the number of changes needed!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each substring operation takes O(k) time

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n/k unique substrings, each of length k

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a hash table to count the frequency of each k-length substring in a single pass. The key insight is that we should make all segments match the most frequent existing pattern to minimize operations. The answer is simply (total segments - maximum frequency), giving us O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Count frequency of each k-length substring and find the most frequent one
Brute Force (Try Each Pattern)	O(n²/k)	O(k)	Try each existing k-length substring as the target pattern

One-Pass Hash Table (Optimal) — Algorithm Steps

Iterate through the string in steps of k
For each k-length substring, increment its count in a hash map
Track the maximum frequency seen so far
Return (total segments - max frequency) as the answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Segments

Split 'ababab' into segments: ['ab', 'ab', 'ab']

Count Frequencies

Count: 'ab' appears 3 times

Find Maximum

Most frequent pattern is 'ab' with count 3

Calculate Result

Operations = 3 total - 3 max_freq = 0

Code -

solution.c — C

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

struct Node {
    char* key;
    int count;
    struct Node* next;
};

int hash(char* str, int size) {
    int hash = 0;
    for (int i = 0; str[i]; i++) {
        hash = (hash * 31 + str[i]) % size;
    }
    return hash;
}

int minimumOperationsToMakeKPeriodic(char* word, int k) {
    int n = strlen(word);
    int totalSegments = n / k;
    struct Node* hashTable[1000] = {NULL};
    int maxFreq = 0;
    
    // Count frequency of each k-length substring
    for (int i = 0; i < n; i += k) {
        char* substring = (char*)malloc((k + 1) * sizeof(char));
        strncpy(substring, word + i, k);
        substring[k] = '\0';
        
        int index = hash(substring, 1000);
        struct Node* current = hashTable[index];
        
        // Search for existing entry
        while (current && strcmp(current->key, substring) != 0) {
            current = current->next;
        }
        
        if (current) {
            current->count++;
            free(substring);
        } else {
            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
            newNode->key = substring;
            newNode->count = 1;
            newNode->next = hashTable[index];
            hashTable[index] = newNode;
            current = newNode;
        }
        
        if (current->count > maxFreq) {
            maxFreq = current->count;
        }
    }
    
    return totalSegments - maxFreq;
}

int main() {
    char word[] = "ababab";
    int k = 2;
    printf("%d\n", minimumOperationsToMakeKPeriodic(word, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each substring operation takes O(k) time

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n/k unique substrings, each of length k

⚡ Linearithmic Space

Constraints

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

24.7K Views

Medium Frequency

~15 min Avg. Time

856 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler