Reveal Cards In Increasing Order - Practice Coding Problems

Reveal Cards In Increasing Order - Problem

Imagine you have a deck of cards with unique numbers, and you want to arrange them in a special way. You'll follow a specific reveal pattern:

Reveal the top card (remove it)
Move the next top card to the bottom
Repeat until all cards are revealed

Your goal is to arrange the initial deck such that when you follow this reveal pattern, the cards come out in increasing numerical order.

Example: If you want cards to be revealed as [2, 3, 5, 7], you need to figure out how to initially arrange the deck [2, 5, 3, 7] so that the reveal process produces the desired sequence.

Given an array deck representing the cards, return the initial arrangement that will reveal the cards in sorted order.

Input & Output

example_1.py — Basic Case

$ Input: deck = [17,13,11,2,3,5,7]

› Output: [2,13,3,11,5,17,7]

💡 Note: When we follow the reveal pattern with this arrangement, we get [2,3,5,7,11,13,17] in increasing order. The algorithm sorts the input and uses reverse simulation to find the required initial arrangement.

example_2.py — Small Case

$ Input: deck = [1,2,3,4]

› Output: [1,3,2,4]

💡 Note: Starting with [1,3,2,4]: reveal 1, move 3 to bottom → [2,4,3]; reveal 2, move 4 to bottom → [3,4]; reveal 3, move 4 to bottom → [4]; reveal 4. Final sequence: [1,2,3,4] ✓

example_3.py — Edge Case

$ Input: deck = [1]

› Output: [1]

💡 Note: With only one card, no rearrangement is needed. The single card is revealed immediately, maintaining the sorted order.

Constraints

1 ≤ deck.length ≤ 1000
1 ≤ deck[i] ≤ 10⁶
All values in deck are unique
The deck array represents cards with distinct integer values

Visualization

Tap to expand

Understanding the Visualization

Setup the Target

Sort cards to know the desired reveal sequence: [2,3,5,7]

Work Backwards

Process cards from largest (7) to smallest (2)

Reverse the Magic

For each card: move bottom to top, then place card on top

Perfect Arrangement

The result [2,5,3,7] will reveal cards in sorted order!

Key Takeaway

🎯 Key Insight: Instead of trying all arrangements, reverse the reveal process to directly construct the solution. Work backwards from the target sequence using queue operations!

Asked in

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

The optimal approach uses reverse simulation with a queue data structure. Instead of trying all possible arrangements, we work backwards from the target sorted sequence. For each card (processing from largest to smallest), we reverse the reveal operations: move the bottom card to the top, then place the current card on top. This directly constructs the required initial arrangement in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n! × n)	O(n!)	Try all permutations and simulate the reveal process
Reverse Simulation (Optimal)	O(n log n)	O(n)	Work backwards from the target sequence using queue operations

Brute Force Simulation — Algorithm Steps

Sort the input deck to get target reveal sequence
Generate all permutations of the deck
For each permutation, simulate the reveal process
Check if revealed sequence matches target sequence
Return the permutation that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of the deck

Simulate Each

For each arrangement, simulate the reveal process

Check Result

Compare revealed sequence with target sorted sequence

Return Match

Return the arrangement that produces correct sequence

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

void simulateReveal(int* arrangement, int size, int* revealed) {
    int queue[1000];
    int front = 0, rear = 0;
    
    for (int i = 0; i < size; i++) {
        queue[rear++] = arrangement[i];
    }
    
    int revealedCount = 0;
    while (front < rear) {
        revealed[revealedCount++] = queue[front++];
        if (front < rear) {
            queue[rear++] = queue[front++];
        }
    }
}

int arraysEqual(int* a, int* b, int size) {
    for (int i = 0; i < size; i++) {
        if (a[i] != b[i]) return 0;
    }
    return 1;
}

void generatePermutations(int* arr, int size, int start, int** result, int* count) {
    if (start == size) {
        for (int i = 0; i < size; i++) {
            result[*count][i] = arr[i];
        }
        (*count)++;
        return;
    }
    
    for (int i = start; i < size; i++) {
        swap(&arr[start], &arr[i]);
        generatePermutations(arr, size, start + 1, result, count);
        swap(&arr[start], &arr[i]);
    }
}

int* deckRevealedIncreasing(int* deck, int deckSize, int* returnSize) {
    int* target = (int*)malloc(deckSize * sizeof(int));
    for (int i = 0; i < deckSize; i++) {
        target[i] = deck[i];
    }
    qsort(target, deckSize, sizeof(int), compare);
    
    // Allocate memory for permutations
    int factorial = 1;
    for (int i = 1; i <= deckSize; i++) factorial *= i;
    
    int** perms = (int**)malloc(factorial * sizeof(int*));
    for (int i = 0; i < factorial; i++) {
        perms[i] = (int*)malloc(deckSize * sizeof(int));
    }
    
    int permCount = 0;
    int* tempDeck = (int*)malloc(deckSize * sizeof(int));
    for (int i = 0; i < deckSize; i++) {
        tempDeck[i] = deck[i];
    }
    
    generatePermutations(tempDeck, deckSize, 0, perms, &permCount);
    
    int* revealed = (int*)malloc(deckSize * sizeof(int));
    
    for (int i = 0; i < permCount; i++) {
        simulateReveal(perms[i], deckSize, revealed);
        if (arraysEqual(revealed, target, deckSize)) {
            int* result = (int*)malloc(deckSize * sizeof(int));
            for (int j = 0; j < deckSize; j++) {
                result[j] = perms[i][j];
            }
            *returnSize = deckSize;
            
            // Clean up
            for (int j = 0; j < factorial; j++) {
                free(perms[j]);
            }
            free(perms);
            free(target);
            free(tempDeck);
            free(revealed);
            
            return result;
        }
    }
    
    // Clean up
    for (int i = 0; i < factorial; i++) {
        free(perms[i]);
    }
    free(perms);
    free(target);
    free(tempDeck);
    free(revealed);
    
    *returnSize = deckSize;
    return deck;
}

int main() {
    int deck[100];
    int size = 0;
    
    // Simple input parsing
    printf("Enter deck size: ");
    scanf("%d", &size);
    printf("Enter deck elements: ");
    for (int i = 0; i < size; i++) {
        scanf("%d", &deck[i]);
    }
    
    int returnSize;
    int* result = deckRevealedIncreasing(deck, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) permutations, each taking O(n) time to simulate

⚠ Quadratic Growth

Space Complexity

O(n!)

Storing all permutations in worst case

⚠ Quadratic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler