Codestin Search App

Swap For Longest Repeated Character Substring - Problem

Given a string text, you can perform at most one swap of any two characters in the string. Your goal is to maximize the length of the longest substring containing repeated characters.

A substring is a contiguous sequence of characters within the string. After the optional swap, you want to find the longest possible substring where all characters are identical.

Example: In string "ababa", swapping positions 1 and 2 gives "aabba", creating a substring "aa" of length 2.

Note: You don't have to perform a swap if the original string already contains the optimal solution.

Input & Output

example_1.py — Basic case

$ Input: "ababa"

› Output: 3

💡 Note: We can swap positions 0 and 2 to get "abaab", then positions 2 and 4 to get "aabab". But optimally, swap positions 1 and 3 to get "aabaa", giving us a substring "aaa" of length 3.

example_2.py — All same characters

$ Input: "aaaa"

› Output: 4

💡 Note: The string already consists of repeated characters, so no swap is needed. The entire string has length 4.

example_3.py — Two character types

$ Input: "aaabbaaa"

› Output: 6

💡 Note: We can swap one 'b' with an 'a' to create a longer sequence of 'a's. For example, swap position 3 (first 'b') with position 4 (second 'b') doesn't help, but we can rearrange to get "aaaabaaa" giving us 4 consecutive 'a's, or "aaaaaaabb" giving us 6 consecutive 'a's by moving characters optimally.

Visualization

Tap to expand

Understanding the Visualization

Analyze Original

Count each character type and find current longest repeated substring

For Each Character

Use sliding window to find longest achievable sequence for each character type

Simulate Swap

Allow at most one 'wrong' character in window that could be swapped out

Find Maximum

Return the maximum achievable length across all character types

Key Takeaway

🎯 Key Insight: Rather than actually performing swaps, we can simulate their effect using a sliding window that allows at most one character that could be 'swapped out' to achieve our target character sequence.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(26 * n) in worst case, where 26 is number of possible characters, but effectively O(n) since we process each position constant times

✓ Linear Growth

Space Complexity

O(1)

Only storing character frequencies (at most 26 characters) and a few variables

✓ Linear Space

Constraints

1 ≤ text.length ≤ 10⁵
text consists of lowercase English letters only
You can perform at most one swap operation

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal solution uses a sliding window approach with character frequency counting. For each unique character, we maintain a window containing at most 2 different character types, where one must be our target character. The key insight is that we can simulate the effect of one swap by allowing one non-target character in our window, which could potentially be swapped with a target character from outside the window.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n³)	O(1)	Try every possible swap and find the longest repeated substring in each case
Sliding Window with Character Counting	O(n)	O(1)	For each character, find the longest window allowing at most one swap

Brute Force (Try All Swaps) — Algorithm Steps

Generate all possible strings by swapping each pair of positions
Include the original string (no swap case)
For each string, find the longest substring with repeated characters
Return the maximum length found across all cases

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with the original string and find longest repeated substring

Try All Swaps

Systematically try swapping every pair of positions

Check Each Result

For each swap, find the longest repeated substring

Track Maximum

Keep track of the maximum length found so far

Code -

solution.c — C

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

int longestRepeatedSubstring(const char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    int maxLen = 1;
    int currentLen = 1;
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i-1]) {
            currentLen++;
            if (currentLen > maxLen) {
                maxLen = currentLen;
            }
        } else {
            currentLen = 1;
        }
    }
    return maxLen;
}

int maxRepOpt1(char* text) {
    int n = strlen(text);
    int maxLength = longestRepeatedSubstring(text); // No swap case
    
    // Try all possible swaps
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Perform swap
            char temp = text[i];
            text[i] = text[j];
            text[j] = temp;
            
            // Find longest repeated substring
            int length = longestRepeatedSubstring(text);
            if (length > maxLength) {
                maxLength = length;
            }
            
            // Swap back
            temp = text[i];
            text[i] = text[j];
            text[j] = temp;
        }
    }
    
    return maxLength;
}

int main() {
    char text[1001];
    fgets(text, sizeof(text), stdin);
    // Remove newline and quotes
    text[strcspn(text, "\n")] = 0;
    if (text[0] == '"' && text[strlen(text)-1] == '"') {
        memmove(text, text+1, strlen(text)-1);
        text[strlen(text)-1] = '\0';
    }
    printf("%d\n", maxRepOpt1(text));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to swap × O(n) to find longest substring in each case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables and string creation

✓ Linear Space

Constraints

1 ≤ text.length ≤ 10⁵
text consists of lowercase English letters only
You can perform at most one swap operation

52.4K Views

High Frequency

~18 min Avg. Time

1.8K 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

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler