Minimum Number of Operations to Reinitialize a Permutation

Minimum Number of Operations to Reinitialize a Permutation - Problem

The Card Shuffle Challenge

Imagine you have a deck of n cards arranged in perfect order from 0 to n-1. You perform a special shuffling technique that follows these rules:

Even positions (0, 2, 4, ...): Take cards from the first half of the deck
Odd positions (1, 3, 5, ...): Take cards from the second half of the deck

More precisely, after each shuffle:

Position i (where i % 2 == 0) gets the card from position i / 2
Position i (where i % 2 == 1) gets the card from position n / 2 + (i - 1) / 2

Your mission: Find the minimum number of shuffles needed to restore the deck to its original order [0, 1, 2, ..., n-1].

Example: With n = 4, starting with [0, 1, 2, 3]:
• After 1 shuffle: [0, 2, 1, 3]
• After 2 shuffles: [0, 1, 2, 3] ← Back to original!

The answer is 2 operations.

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 1

💡 Note: Starting with [0, 1]: After 1 operation we get [0, 1] back (arr[0] = perm[0], arr[1] = perm[1]). The transformation doesn't change anything for n=2.

example_2.py — Standard Case

$ Input: n = 4

› Output: 2

💡 Note: Starting with [0, 1, 2, 3]: After 1st operation → [0, 2, 1, 3] (arr[0]=perm[0], arr[1]=perm[2], arr[2]=perm[1], arr[3]=perm[3]). After 2nd operation → [0, 1, 2, 3] (back to original).

example_3.py — Larger Case

$ Input: n = 6

› Output: 4

💡 Note: Starting with [0, 1, 2, 3, 4, 5]: The permutation goes through 4 transformations before returning to the original state. Position 1 follows the cycle: 1 → 2 → 4 → 3 → 1.

Constraints

2 ≤ n ≤ 1000
n is even
The answer is guaranteed to be positive (non-zero)

Visualization

Tap to expand

Understanding the Visualization

Pick Position 1

Choose position 1 as our tracker (position 0 never moves)

Apply Forward Mapping

Use the transformation rules to see where position 1 goes next

Follow the Cycle

Keep applying the transformation until we loop back to position 1

Count Steps

The number of steps in the cycle is our answer

Key Takeaway

🎯 Key Insight: By tracking just one position's cycle, we solve the entire permutation problem in optimal time and space!

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses cycle detection by tracking only position 1's movement through the permutation. Since the shuffle creates deterministic cycles, when position 1 returns to itself, all positions have returned to their original places. This reduces the problem from O(n²) simulation to O(k) cycle tracking where k is typically much smaller than n.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(k × n)	O(n)	Simulate each shuffle operation until we return to the original permutation
Cycle Tracking (Optimal)	O(k)	O(1)	Track only position 1's cycle since when it returns, all positions have returned

Simulation Approach — Algorithm Steps

Start with the initial permutation [0, 1, 2, ..., n-1]
Keep a copy of the original for comparison
In each operation, create a new array following the shuffle rules
Check if the new array matches the original
If not, repeat with the new array
Count the number of operations until we return to original

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with [0, 1, 2, 3]

First Shuffle

Apply transformation rules to get [0, 2, 1, 3]

Check Result

Compare with original - not equal, continue

Second Shuffle

Apply rules again to get [0, 1, 2, 3]

Success!

Back to original after 2 operations

Code -

solution.c — C

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

int reinitializePermutation(int n) {
    int* original = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        original[i] = i;
    }
    
    int* perm = (int*)malloc(n * sizeof(int));
    memcpy(perm, original, n * sizeof(int));
    int operations = 0;
    
    while (1) {
        int* arr = (int*)malloc(n * sizeof(int));
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) {
                arr[i] = perm[i / 2];
            } else {
                arr[i] = perm[n / 2 + (i - 1) / 2];
            }
        }
        
        operations++;
        free(perm);
        perm = arr;
        
        if (memcmp(perm, original, n * sizeof(int)) == 0) {
            free(perm);
            free(original);
            return operations;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

Where k is the number of operations needed (could be up to n) and we perform O(n) work in each operation

✓ Linear Growth

Space Complexity

O(n)

Need to store the current permutation and create new arrays in each step

⚡ Linearithmic Space

28.4K Views

Medium Frequency

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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler