Longest Substring of One Repeating Character

Longest Substring of One Repeating Character - Problem

You are given a 0-indexed string s. You are also given a 0-indexed string queryCharacters of length k and a 0-indexed array of integer indices queryIndices of length k, both of which are used to describe k queries.

The i^th query updates the character in s at index queryIndices[i] to the character queryCharacters[i].

Return an array lengths of length k where lengths[i] is the length of the longest substring of s consisting of only one repeating character after the i^th query is performed.

Input & Output

Example 1 — Basic Updates

$ Input: s = "babacc", queryCharacters = "bcb", queryIndices = [1,3,3]

› Output: [3,3,4]

💡 Note: Query 1: s="baaacc" → longest "aaa" = 3. Query 2: s="babcc" → longest "cc" or "bb" = 3. Query 3: s="babbc" → longest "bbb" = 4.

Example 2 — Single Character

$ Input: s = "abcd", queryCharacters = "aa", queryIndices = [0,1]

› Output: [1,2]

💡 Note: Query 1: s="aacd" → longest single chars = 1. Query 2: s="aacd" → longest "aa" = 2.

Example 3 — All Same

$ Input: s = "aa", queryCharacters = "a", queryIndices = [0]

› Output: [2]

💡 Note: Query 1: s="aa" → longest "aa" = 2 (no change in this case).

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters
1 ≤ k ≤ 10⁵
0 ≤ queryIndices[i] < s.length
queryCharacters[i] is a lowercase English letter

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to efficiently track the longest repeating substring after each character update. The brute force approach scans the entire string after each query in O(k×n) time. The optimized approach uses segment tracking to minimize recalculations. Best approach depends on query patterns: O(k×n) time, O(n) space for segment tracking.

Common Approaches

✓ Brute Force

⏱️ Time: O(k × n) Space: O(1)

For each query, update the character at the specified index, then iterate through the entire string to find the longest contiguous sequence of identical characters.

Segment Tracking

⏱️ Time: O(n + k × n) Space: O(n)

Maintain segments of identical characters and only recalculate affected segments when a character changes, avoiding full string scans.

Brute Force — Algorithm Steps

Update character at query index
Scan entire string from left to right
Track current run length and maximum run length
Return maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Update

Change character at query position

Scan

Check all substrings for longest repeating

Result

Return maximum length found

Code -

solution.c — C

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

void solution(char* s, char* queryCharacters, int* queryIndices, int k, int* result) {
    int n = strlen(s);
    
    for (int i = 0; i < k; i++) {
        // Update character
        s[queryIndices[i]] = queryCharacters[i];
        
        // Find longest repeating substring
        int maxLen = 1;
        int currentLen = 1;
        
        for (int j = 1; j < n; j++) {
            if (s[j] == s[j-1]) {
                currentLen++;
                if (currentLen > maxLen) {
                    maxLen = currentLen;
                }
            } else {
                currentLen = 1;
            }
        }
        
        result[i] = maxLen;
    }
}

int main() {
    char s[100001];
    char queryCharacters[100001];
    char indicesLine[500000];
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(queryCharacters, sizeof(queryCharacters), stdin);
    queryCharacters[strcspn(queryCharacters, "\n")] = 0;
    
    fgets(indicesLine, sizeof(indicesLine), stdin);
    indicesLine[strcspn(indicesLine, "\n")] = 0;
    
    // Parse array manually
    int queryIndices[100000];
    int k = 0;
    char* token = strtok(indicesLine + 1, ",]");
    while (token != NULL) {
        queryIndices[k++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int* result = (int*)malloc(k * sizeof(int));
    solution(s, queryCharacters, queryIndices, k, result);
    
    printf("[");
    for (int i = 0; i < k; i++) {
        printf("%d", result[i]);
        if (i < k - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

k queries, each requiring O(n) scan of entire string

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking, no extra data structures

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~35 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler