Codestin Search App

Construct String With Repeat Limit - Problem

You're tasked with creating the lexicographically largest string possible from given characters, but with a twist: no character can appear more than repeatLimit times consecutively.

Given a string s and an integer repeatLimit, construct a new string using the characters from s such that:

No letter appears more than repeatLimit times in a row
The result is the lexicographically largest possible string
You don't need to use all characters from s

What does lexicographically larger mean? String a is lexicographically larger than string b if at the first differing position, a has a character that comes later in the alphabet than the corresponding character in b.

Example: For s = "cczazcc" and repeatLimit = 3, we want to maximize our string by using characters in descending order: 'z', 'c', 'c', 'c', 'a', 'c', 'c' → "zccaccc"

Input & Output

example_1.py — Basic Case

$ Input: s = "cczazcc", repeatLimit = 3

› Output: "zcccaca"

💡 Note: We want the lexicographically largest string. Start with 'z' (largest), then add 'c' up to limit (3), then need separator 'a', then remaining 'c', then remaining 'a'.

example_2.py — Single Character Type

$ Input: s = "aababab", repeatLimit = 2

› Output: "bbabaa"

💡 Note: We have 'b':3 and 'a':4. Start with 'b', add 2 (limit), then 'a' as separator, then 'b', then remaining 'a's with separator pattern.

example_3.py — No Repeat Limit Hit

$ Input: s = "aab", repeatLimit = 5

› Output: "baa"

💡 Note: Since repeatLimit is 5 and we have at most 2 of any character, we can simply arrange in descending order: 'b' then 'a','a'.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters
1 ≤ repeatLimit ≤ 10⁵
The result should be lexicographically largest possible

Visualization

Tap to expand

Understanding the Visualization

Count VIP Types

Count how many guests of each VIP level we have

Priority Queue

Use a priority system to always serve the highest VIP level available

Seat with Limits

Seat up to 'repeatLimit' guests of the highest level

Strategic Separation

When hitting the limit, seat one guest of the next highest level as a separator

Repeat Process

Continue until all guests are seated or no valid arrangement exists

Key Takeaway

🎯 Key Insight: Use a max heap to always prioritize the largest available character, and strategically use smaller characters as separators when hitting the repeat limit. This greedy approach guarantees the lexicographically largest result.

Asked in

G Google 23 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a max heap (priority queue) with a greedy strategy. We always try to use the largest available character up to the repeat limit, and when we hit the limit, we strategically place one instance of the next largest character as a separator. This ensures we build the lexicographically largest possible string while satisfying the repeat constraint. Time complexity is O(n + k log k) where k is the alphabet size (≤ 26).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Max Heap + Greedy (One Pass)	O(n + k log k)	O(k)	Use a max heap to always get the largest available character while building the result
Two-Pass: Count + Greedy Construction	O(n + k log k)	O(k)	Count character frequencies first, then greedily build the result string
Brute Force (Generate All Permutations)	O(n! × n)	O(n × n!)	Generate all possible valid strings and return the lexicographically largest one

Optimal: Max Heap + Greedy (One Pass) — Algorithm Steps

Count character frequencies and push all characters into a max heap
While heap is not empty, pop the largest character
Add up to repeatLimit instances of this character to result
If we still have instances of this character and heap has more characters:
Pop the next largest character, add one instance as separator
Push both characters back to heap if they still have remaining count
Continue until heap is empty or no valid moves remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Max Heap

Create heap with character frequencies, largest char at top

Pop Largest

Always get the lexicographically largest available character

Add Characters

Add up to repeatLimit instances of the largest character

Handle Separator

If more instances remain, use next largest as separator

Code -

solution.c — C

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

typedef struct {
    char ch;
    int count;
} CharCount;

int compare(const void *a, const void *b) {
    CharCount *ca = (CharCount*)a;
    CharCount *cb = (CharCount*)b;
    return cb->ch - ca->ch;  // For max heap behavior
}

char* repeatLimitedString(char* s, int repeatLimit) {
    int freq[26] = {0};
    int len = strlen(s);
    
    // Count frequencies
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Create array of characters with their counts
    CharCount chars[26];
    int charCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            chars[charCount].ch = 'a' + i;
            chars[charCount].count = freq[i];
            charCount++;
        }
    }
    
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultLen = 0;
    
    while (charCount > 0) {
        // Sort to simulate max heap
        qsort(chars, charCount, sizeof(CharCount), compare);
        
        // Get the largest character
        char char1 = chars[0].ch;
        int count1 = chars[0].count;
        
        // Determine how many of char1 to use
        int use = (count1 < repeatLimit) ? count1 : repeatLimit;
        for (int i = 0; i < use; i++) {
            result[resultLen++] = char1;
        }
        
        // Update count
        chars[0].count -= use;
        
        // If we still have char1 left, we need a separator
        if (chars[0].count > 0 && charCount > 1) {
            // Use second largest character as separator
            result[resultLen++] = chars[1].ch;
            chars[1].count--;
            
            // Remove characters with zero count
            if (chars[1].count == 0) {
                for (int i = 1; i < charCount - 1; i++) {
                    chars[i] = chars[i + 1];
                }
                charCount--;
            }
        } else {
            // Remove first character if no count left
            if (chars[0].count == 0) {
                for (int i = 0; i < charCount - 1; i++) {
                    chars[i] = chars[i + 1];
                }
                charCount--;
            } else {
                // No separator available, we're done
                break;
            }
        }
    }
    
    result[resultLen] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to count frequencies, O(k log k) for heap operations where k ≤ 26, total construction is O(n)

⚡ Linearithmic

Space Complexity

O(k)

O(k) space for heap and frequency counting where k ≤ 26 (alphabet size)

✓ Linear Space

28.4K Views

Medium-High Frequency

~18 min Avg. Time

892 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

Optimal: Max Heap + Greedy (One Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler