Shuffle an Array - Practice Coding Problems

Shuffle an Array - Problem

🎲 Shuffle an Array - Random Permutation Generator

You are given an integer array nums and need to design an algorithm that can randomly shuffle the array while ensuring that all permutations are equally likely.

Challenge: Create a Solution class that maintains the original array and provides two key operations:

Reset: Restore the array to its original configuration
Shuffle: Generate a truly random permutation where each arrangement has equal probability

Key Requirements:

Each of the n! possible permutations should have probability 1/n!
The shuffle should be unbiased - no arrangement should be favored over others
Must be efficient for repeated shuffle operations

Example: For array [1,2,3], each of the 6 permutations [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] should appear with equal likelihood over many shuffles.

Input & Output

example_1.py — Basic Usage

$ Input: nums = [1, 2, 3] solution = Solution(nums) solution.shuffle() solution.reset() solution.shuffle()

› Output: [3, 1, 2] (example) [1, 2, 3] [1, 3, 2] (example)

💡 Note: The shuffle() method returns a random permutation. Each call produces a potentially different result. reset() always returns the original array [1,2,3].

example_2.py — Single Element

$ Input: nums = [1] solution = Solution(nums) solution.shuffle() solution.reset()

› Output: [1] [1]

💡 Note: With only one element, there's only one possible permutation. Both shuffle() and reset() return [1].

example_3.py — Larger Array

$ Input: nums = [1, 2, 3, 4, 5] solution = Solution(nums) solution.shuffle() solution.reset()

› Output: [4, 1, 5, 2, 3] (example) [1, 2, 3, 4, 5]

💡 Note: With 5 elements, there are 5! = 120 possible permutations. The Fisher-Yates algorithm ensures each has equal 1/120 probability.

Visualization

Tap to expand

Understanding the Visualization

Start from End

Begin with the last element in the array. This represents the bottom card in our deck.

Random Selection

Generate a random index from 0 to current position (inclusive). This chooses which card to swap with.

Swap Elements

Exchange the current element with the randomly selected element. This ensures randomness.

Move Backward

Move to the previous position and repeat. Each position gets exactly one chance to be swapped.

Perfect Shuffle

After processing all positions, every permutation has exactly 1/n! probability.

Key Takeaway

🎯 Key Insight: The Fisher-Yates shuffle achieves perfect randomness by making exactly n sequential random decisions, ensuring each of the n! permutations has equal probability 1/n! while using only O(n) time and O(1) extra space.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each swap is O(1)

✓ Linear Growth

Space Complexity

O(n)

Only need to store original array copy for reset functionality

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 50
-10⁶ ≤ nums[i] ≤ 10⁶
At most 10⁴ calls will be made to reset and shuffle combined
All elements in nums are unique

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 31 f Facebook 24

The optimal solution uses the Fisher-Yates shuffle algorithm which achieves perfect uniform distribution in O(n) time and O(1) extra space. The key insight is that by making exactly n random decisions (one for each position), we can generate any permutation with equal probability 1/n! without needing to store all possible arrangements.

Common Approaches

Approach	Time	Space	Notes
✓ Fisher-Yates Shuffle (Optimal)	O(n)	O(n)	Modern Fisher-Yates algorithm that shuffles in-place with perfect uniformity
Brute Force (Generate All Permutations)	O(n!)	O(n! × n)	Generate all possible permutations and randomly select one

Fisher-Yates Shuffle (Optimal) — Algorithm Steps

Start from the last element (index n-1)
Generate random index j between 0 and current index i (inclusive)
Swap element at index i with element at index j
Move to previous element (i--) and repeat
Continue until reaching the first element

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from End

Begin with last element, pick random position to swap

Random Swap

Swap current element with randomly chosen element

Move Left

Continue with next element to the left

Complete

Finish when reaching the first element

Code -

solution.c — C

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

typedef struct {
    int* original;
    int* array;
    int size;
} Solution;

Solution* solutionCreate(int* nums, int numsSize) {
    srand(time(NULL));
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    
    obj->size = numsSize;
    obj->original = (int*)malloc(numsSize * sizeof(int));
    obj->array = (int*)malloc(numsSize * sizeof(int));
    
    // Keep original copy and working array
    memcpy(obj->original, nums, numsSize * sizeof(int));
    memcpy(obj->array, nums, numsSize * sizeof(int));
    
    return obj;
}

int* solutionReset(Solution* obj, int* retSize) {
    *retSize = obj->size;
    memcpy(obj->array, obj->original, obj->size * sizeof(int));
    return obj->array;
}

int* solutionShuffle(Solution* obj, int* retSize) {
    *retSize = obj->size;
    
    // Fisher-Yates shuffle algorithm
    for (int i = obj->size - 1; i > 0; i--) {
        // Pick random index from 0 to i (inclusive)
        int j = rand() % (i + 1);
        // Swap elements at positions i and j
        int temp = obj->array[i];
        obj->array[i] = obj->array[j];
        obj->array[j] = temp;
    }
    
    return obj->array;
}

void solutionFree(Solution* obj) {
    free(obj->original);
    free(obj->array);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each swap is O(1)

✓ Linear Growth

Space Complexity

O(n)

Only need to store original array copy for reset functionality

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 50
-10⁶ ≤ nums[i] ≤ 10⁶
At most 10⁴ calls will be made to reset and shuffle combined
All elements in nums are unique

73.2K Views

Medium Frequency

~15 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

🎲 Shuffle an Array - Random Permutation Generator

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Fisher-Yates Shuffle (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler