Rearrange String k Distance Apart - Practice Coding Problems

Rearrange String k Distance Apart - Problem

Hash Table String Greedy Sorting Heap (Priority Queue) Counting Hard

You're given a string s and an integer k. Your task is to rearrange the characters in the string such that no two identical characters are closer than k positions apart.

This is like organizing a seating arrangement where certain people need to be separated by at least k seats! If it's impossible to create such an arrangement, return an empty string "".

Key Challenge: You need to strategically place the most frequent characters first while ensuring they maintain the required distance.

Example: For string "aabbcc" with k=3, one valid arrangement could be "abcabc" - notice how each 'a' is 3 positions apart, same for 'b' and 'c'.

Input & Output

example_1.py — Basic case with k=3

$ Input: s = "aabbcc", k = 3

› Output: "abcabc"

💡 Note: Each character appears twice, and with k=3, we need at least 3 positions between same characters. The arrangement 'abcabc' satisfies this: 'a' appears at positions 0 and 3 (distance = 3), 'b' at 1 and 4 (distance = 3), 'c' at 2 and 5 (distance = 3).

example_2.py — Impossible case

$ Input: s = "aaadbbcc", k = 2

› Output: ""

💡 Note: Character 'a' appears 3 times, but with k=2 and string length 8, we can only place 'a' at most at positions 0, 2, 4, 6 - that's 4 possible positions for 3 occurrences. However, the arrangement is still impossible due to the distribution of other characters.

example_3.py — Edge case k=0

$ Input: s = "aaab", k = 0

› Output: "aaab"

💡 Note: When k=0 or k=1, no rearrangement constraints apply, so we can return the original string or any permutation. The original string itself is valid.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ s.length
s consists of lowercase English letters only
If multiple valid arrangements exist, return any one of them

Visualization

Tap to expand

Priority Queue: Always seat largest remaining VIP group2. Cooldown System: Track when each group can be seated again3. Availability Check: Move groups from cooldown back to priority list4. Impossibility Detection: If no group available, arrangement fails✅ Success MetricsAll VIP groups seated with proper k=3 social distancingGroup A: positions 0↔3 (distance=3) ✓Groups B,C: positions 1↔4, 2↔5 (distance=3) ✓k=3

Understanding the Visualization

Count VIP Guests

Count how many of each VIP type we need to seat (character frequencies)

Priority Seating

Always seat the most numerous VIP group first (max heap by frequency)

Cooldown Period

After seating a VIP, they enter a cooldown - can't be seated again for k positions

Cycle Management

As cooldown expires, VIPs become available for seating again

Key Takeaway

🎯 Key Insight: By prioritizing the most frequent characters (largest VIP groups) and using a systematic cooldown mechanism, we maximize our chances of successful arrangement while maintaining required distances.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a greedy approach with priority queue to always place the most frequent character first, combined with a cooldown mechanism to track when each character can be used again. This ensures maximum utilization while respecting the k-distance constraint, achieving O(n log k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy + Priority Queue (Optimal)	O(n log k)	O(k)	Use priority queue to place most frequent characters first with cooldown tracking
Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check each one

Greedy + Priority Queue (Optimal) — Algorithm Steps

Count frequency of each character in the string
Create a max-heap based on character frequencies
Use a cooldown queue to track when characters can be used again
At each position, place the most frequent available character
Move characters from cooldown back to heap when ready
If no character is available at any position, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Count & Heapify

Count character frequencies and build max heap

Select Most Frequent

Always pick the most frequent available character

Cooldown Management

Place used characters in cooldown, return ready ones to heap

Repeat Until Done

Continue until all positions filled or impossible

Code -

solution.c — C

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

#define MAX_CHARS 256

typedef struct {
    char ch;
    int freq;
} CharFreq;

typedef struct {
    char ch;
    int availableTime;
} CooldownItem;

int compareFreq(const void *a, const void *b) {
    return ((CharFreq*)b)->freq - ((CharFreq*)a)->freq;
}

char* rearrangeString(char* s, int k) {
    int len = strlen(s);
    if (k <= 1) {
        char* result = malloc((len + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    // Count frequencies
    int freq[MAX_CHARS] = {0};
    for (int i = 0; i < len; i++) {
        freq[s[i]]++;
    }
    
    // Create array of character frequencies
    CharFreq chars[MAX_CHARS];
    int charCount = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            chars[charCount].ch = (char)i;
            chars[charCount].freq = freq[i];
            charCount++;
        }
    }
    
    char* result = malloc((len + 1) * sizeof(char));
    CooldownItem cooldown[MAX_CHARS];
    int cooldownSize = 0;
    
    for (int pos = 0; pos < len; pos++) {
        // Move ready characters back
        for (int i = 0; i < cooldownSize; i++) {
            if (cooldown[i].availableTime <= pos) {
                char ch = cooldown[i].ch;
                if (freq[ch] > 0) {
                    chars[charCount].ch = ch;
                    chars[charCount].freq = freq[ch];
                    charCount++;
                }
                // Remove from cooldown
                for (int j = i; j < cooldownSize - 1; j++) {
                    cooldown[j] = cooldown[j + 1];
                }
                cooldownSize--;
                i--;
            }
        }
        
        // Sort to get max frequency
        qsort(chars, charCount, sizeof(CharFreq), compareFreq);
        
        if (charCount == 0) {
            result[0] = '\0';
            return result;
        }
        
        // Place most frequent character
        char ch = chars[0].ch;
        result[pos] = ch;
        freq[ch]--;
        
        // Remove from chars array
        for (int i = 0; i < charCount - 1; i++) {
            chars[i] = chars[i + 1];
        }
        charCount--;
        
        // Add to cooldown if needed
        if (freq[ch] > 0) {
            cooldown[cooldownSize].ch = ch;
            cooldown[cooldownSize].availableTime = pos + k;
            cooldownSize++;
        }
    }
    
    result[len] = '\0';
    return result;
}

int main() {
    char s[1000];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    // Remove quotes
    memmove(s, s + 1, strlen(s));
    s[strlen(s) - 1] = '\0';
    scanf("%d", &k);
    
    char* result = rearrangeString(s, k);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

n characters to process, each heap operation takes O(log k) where k is number of unique characters

⚡ Linearithmic

Space Complexity

O(k)

Space for character frequency map, heap, and cooldown queue, where k is number of unique characters

✓ Linear Space

31.7K Views

Medium-High Frequency

~25 min Avg. Time

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

Greedy + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler