Shuffle String - Practice Coding Problems

Shuffle String - Problem

Array String Easy

Shuffle String is a fundamental array manipulation problem that tests your understanding of index mapping and string reconstruction.

You are given a string s and an integer array indices of the same length. The task is to rearrange the characters of the string according to the position mapping defined by the indices array.

Specifically, the character at position i in the original string should be moved to position indices[i] in the shuffled result.

Goal: Return the shuffled string after applying the position transformations.

Example: If s = "codeleet" and indices = [4,5,6,7,0,2,1,3], then:
• Character 'c' at index 0 goes to position indices[0] = 4
• Character 'o' at index 1 goes to position indices[1] = 5
• And so on...

The result would be "leetcode".

Input & Output

example_1.py — Basic String Shuffle

$ Input: s = "codeleet", indices = [4,5,6,7,0,2,1,3]

› Output: "leetcode"

💡 Note: Character 'c' at index 0 goes to position 4, 'o' at index 1 goes to position 5, 'd' at index 2 goes to position 6, etc. The final rearranged string spells "leetcode".

example_2.py — Simple Pattern

$ Input: s = "abc", indices = [0,1,2]

› Output: "abc"

💡 Note: Each character stays in its original position since indices[i] = i for all positions. No shuffling occurs.

example_3.py — Complete Reversal

$ Input: s = "aiohn", indices = [3,1,4,2,0]

› Output: "nihao"

💡 Note: Characters are rearranged according to the indices mapping: 'a'→pos3, 'i'→pos1, 'o'→pos4, 'h'→pos2, 'n'→pos0, forming "nihao".

Constraints

s.length == indices.length
1 ≤ s.length ≤ 100
s contains only lowercase English letters
0 ≤ indices[i] < s.length
All values of indices are unique (it's a permutation)

Visualization

Tap to expand

Understanding the Visualization

Setup

Musicians line up with their destination tickets

Direct Placement

Each musician moves directly to their assigned seat

Result

Final orchestra arrangement is complete

Key Takeaway

🎯 Key Insight: Since each character knows exactly where to go (via indices), we can place them directly in O(n) time without any searching!

Asked in

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

The optimal solution uses direct character placement in O(n) time. Since we know exactly where each character should go (given by the indices array), we can place each character directly at its target position in a single pass, avoiding any searching or complex logic.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Position Search)	O(n²)	O(n)	For each result position, search through indices array to find which character belongs there
Direct Mapping (Optimal)	O(n)	O(n)	Directly place each character in its final position using the indices mapping

Brute Force (Position Search) — Algorithm Steps

Create result array of same length as input string
For each position i in result (0 to n-1)
Search through indices array to find j where indices[j] == i
Place character s[j] at result position i
Convert result array back to string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty result array

Search Position 0

Look through indices to find who goes to position 0

Search Position 1

Look through indices to find who goes to position 1

Continue

Repeat for all positions

Code -

solution.c — C

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

char* restoreString(char* s, int* indices, int n) {
    char* result = (char*)malloc((n + 1) * sizeof(char));
    result[n] = '\0';
    
    // For each result position
    for (int i = 0; i < n; i++) {
        // Find which original position maps to result position i
        for (int j = 0; j < n; j++) {
            if (indices[j] == i) {
                result[i] = s[j];
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char s[] = "codeleet";
    int indices[] = {4,5,6,7,0,2,1,3};
    int n = 8;
    
    char* result = restoreString(s, indices, n);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we search through n indices to find the mapping

⚠ Quadratic Growth

Space Complexity

O(n)

Only space needed is for the result string/array

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~8 min Avg. Time

1.9K 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 (Position Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler