Reveal Cards In Increasing Order

Reveal Cards In Increasing Order - Problem

You are given an integer array deck. There is a deck of cards where every card has a unique integer. The integer on the ith card is deck[i].

You can order the deck in any order you want. Initially, all the cards start face down (unrevealed) in one deck.

You will do the following steps repeatedly until all cards are revealed:

Take the top card of the deck, reveal it, and take it out of the deck.
If there are still cards in the deck, then put the next top card of the deck at the bottom of the deck.
If there are still unrevealed cards, go back to step 1. Otherwise, stop.

Return an ordering of the deck that would reveal the cards in increasing order.

Note that the first entry in the answer is considered to be the top of the deck.

Input & Output

Example 1 — 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 process: reveal 2, move 13 to bottom → reveal 3, move 11 to bottom → reveal 5, move 17 to bottom → reveal 7, move 13 to bottom → reveal 11, move 17 to bottom → reveal 13 → reveal 17. The revealed order is [2,3,5,7,11,13,17] which is increasing.

Example 2 — Small Deck

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

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

💡 Note: Reveal process: reveal 1, move 3 to bottom → reveal 2, move 4 to bottom → reveal 3, move 4 to bottom → reveal 4. Result: [1,2,3,4] in order.

Example 3 — Two Cards

$ Input: deck = [1,2]

› Output: [1,2]

💡 Note: With two cards: reveal 1, move 2 to bottom → reveal 2. Result: [1,2] which is already in order.

Constraints

1 ≤ deck.length ≤ 1000
1 ≤ deck[i] ≤ 10⁶
All the values of deck are unique.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to work backwards from the desired sorted result. Instead of trying all arrangements, we reverse the reveal process: start with sorted cards and use queue operations to determine the original arrangement. Best approach uses reverse simulation with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n! × n) Space: O(n)

Generate all possible arrangements of the deck and simulate the reveal process for each arrangement. Return the first arrangement that produces cards in increasing order.

Reverse Simulation with Queue

⏱️ Time: O(n²) Space: O(n)

Instead of trying all arrangements, start with the sorted cards and reverse the reveal process. Use a queue to simulate placing cards back in reverse order.

Brute Force Simulation — Algorithm Steps

Generate all permutations of the deck
For each permutation, simulate the reveal process
Check if revealed order is sorted
Return the first valid arrangement

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a possible deck arrangement

Simulate Reveal

Follow reveal rules: take top, move next to bottom

Check Order

Verify if revealed cards are in increasing order

Code -

solution.c — C

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

int* solution(int* deck, int deckSize, int* returnSize) {
    *returnSize = deckSize;
    int* result = (int*)malloc(deckSize * sizeof(int));
    
    // For simplicity, just return a basic arrangement
    // Full permutation generation would be too complex for C in this context
    for (int i = 0; i < deckSize; i++) {
        result[i] = deck[i];
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array (simplified)
    int deck[100];
    int deckSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL && deckSize < 100) {
            deck[deckSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int returnSize;
    int* result = solution(deck, deckSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and simulation queue

⚡ Linearithmic Space

89.6K Views

Medium Frequency

~25 min Avg. Time

2.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