Orderly Queue - Practice Coding Problems

Orderly Queue - Problem

Imagine you have a queue of characters from a string, and you're allowed to make strategic moves to rearrange them. You are given a string s and an integer k. In each move, you can choose one of the first k characters from the current string and move it to the end.

Your goal is to find the lexicographically smallest string possible after performing any number of these moves. Think of it as optimizing a queue where you have limited access to only the first k positions!

Example: If s = "cba" and k = 1, you can only move the first character to the end. Starting with "cba" → "bac" → "acb" → "cba" (cycle), the smallest possible is "acb".

However, if k ≥ 2, you gain much more flexibility and can potentially achieve any permutation of the characters!

Input & Output

example_1.py — Basic case with k=1

$ Input: s = "cba", k = 1

› Output: "acb"

💡 Note: With k=1, we can only move the first character to the end. Starting with "cba": move 'c' → "bac", move 'b' → "acb", move 'a' → "cba" (back to start). The lexicographically smallest is "acb".

example_2.py — Case with k≥2

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

› Output: "aaabc"

💡 Note: With k=3, we can access the first 3 characters for moves. Since k≥2, we can achieve any permutation of the string. The lexicographically smallest permutation is sorting the characters: "aaabc".

example_3.py — Edge case with single character

$ Input: s = "a", k = 1

› Output: "a"

💡 Note: With only one character, no matter what moves we make, the result is always "a".

Constraints

1 ≤ s.length ≤ 1000
1 ≤ k ≤ s.length
s consists of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Analyze Access Level

If k≥2, you have flexible access and can achieve any arrangement

Choose Strategy

Flexible access (k≥2): sort alphabetically. Limited access (k=1): try all rotations

Apply Transformation

Execute the chosen strategy efficiently

Return Result

Return the lexicographically smallest possible string

Key Takeaway

🎯 Key Insight: The value of k determines the power of rearrangement - k≥2 gives unlimited permutation power, while k=1 restricts to rotations only.

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 15

The optimal solution uses a key mathematical insight: when k ≥ 2, we can achieve any permutation through strategic moves, so we simply sort the string. When k = 1, we can only achieve rotations, so we find the lexicographically smallest rotation. This reduces time complexity from exponential to O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Possible States)	O(n! × n)	O(n! × n)	Generate all possible strings by simulating every possible move sequence
Mathematical Insight (Optimal)	O(n log n)	O(n)	Use mathematical properties: k≥2 allows any permutation, k=1 only allows rotations

Brute Force (Generate All Possible States) — Algorithm Steps

Start with the initial string in a set of visited states
For each unprocessed state, generate all possible next states by moving first k characters
Add new states to the queue for further processing
Continue until no new states can be generated
Return the lexicographically smallest string from all reachable states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original string

Generate Moves

For each state, try moving first k characters to end

Track Visited

Keep track of all seen states to avoid cycles

Find Minimum

Return the lexicographically smallest state found

Code -

solution.c — C

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

#define MAX_STATES 100000
#define MAX_LEN 1000

typedef struct {
    char states[MAX_STATES][MAX_LEN];
    int count;
} StateSet;

int contains(StateSet* set, char* str) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->states[i], str) == 0) {
            return 1;
        }
    }
    return 0;
}

void add(StateSet* set, char* str) {
    if (!contains(set, str) && set->count < MAX_STATES) {
        strcpy(set->states[set->count], str);
        set->count++;
    }
}

char* orderlyQueue(char* s, int k) {
    StateSet visited = {.count = 0};
    char queue[MAX_STATES][MAX_LEN];
    int front = 0, rear = 0;
    
    strcpy(queue[rear++], s);
    add(&visited, s);
    
    while (front < rear) {
        char* current = queue[front++];
        int len = strlen(current);
        
        for (int i = 0; i < k && i < len; i++) {
            char newString[MAX_LEN];
            strncpy(newString, current, i);
            strcpy(newString + i, current + i + 1);
            newString[len - 1] = current[i];
            newString[len] = '\0';
            
            if (!contains(&visited, newString) && rear < MAX_STATES) {
                strcpy(queue[rear++], newString);
                add(&visited, newString);
            }
        }
    }
    
    char* result = visited.states[0];
    for (int i = 1; i < visited.count; i++) {
        if (strcmp(visited.states[i], result) < 0) {
            result = visited.states[i];
        }
    }
    
    return result;
}

int main() {
    char s[MAX_LEN];
    int k;
    scanf("\"%s\"", s);
    scanf("%d", &k);
    
    char* result = orderlyQueue(s, k);
    printf("\"%s\"\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

In worst case, we might need to explore all permutations (n!) and each string comparison takes O(n)

⚠ Quadratic Growth

Space Complexity

O(n! × n)

We might need to store all possible permutations, each taking O(n) space

⚠ Quadratic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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 (Generate All Possible States) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler