Reveal Cards In Increasing Order - Practice Coding Problems

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

Understanding the Visualization

Initial Deck

Cards arranged face-down: [2,13,3,11,5,17,7]

Reveal Process

Take top, reveal it, move next top to bottom

Final Result

Revealed cards: [2,3,5,7,11,13,17] in order

Key Takeaway

🎯 Key Insight: Work backwards from sorted order using reverse queue operations

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

Approach	Time	Space	Notes
✓ Reverse Simulation with Queue	O(n²)	O(n)	Work backwards from the desired sorted result using queue operations
Brute Force Simulation	O(n! × n)	O(n)	Try all permutations until we find one that reveals cards in increasing order

Reverse Simulation with Queue — Algorithm Steps

Sort the deck to get target reveal order
Start with empty result queue
For each card (from largest to smallest), add to front of queue
If queue has multiple cards, move last card to front
Return final queue as the arrangement

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Cards

Get target reveal order: [2,3,5,7,11,13,17]

Process Backwards

Start from largest, add to front and rotate

Final Arrangement

Result deck that reveals in correct order

Code -

solution.c — C

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

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

int* solution(int* deck, int deckSize, int* returnSize) {
    *returnSize = deckSize;
    int* result = (int*)malloc(deckSize * sizeof(int));
    
    // Sort deck to get target order
    int* sortedDeck = (int*)malloc(deckSize * sizeof(int));
    memcpy(sortedDeck, deck, deckSize * sizeof(int));
    qsort(sortedDeck, deckSize, sizeof(int), compare);
    
    // Work backwards (simplified approach)
    int* temp = (int*)malloc(deckSize * sizeof(int));
    int tempSize = 0;
    
    for (int i = deckSize - 1; i >= 0; i--) {
        // Move last to front if temp has elements
        if (tempSize > 0) {
            int last = temp[tempSize - 1];
            for (int j = tempSize - 1; j > 0; j--) {
                temp[j] = temp[j - 1];
            }
            temp[0] = last;
        }
        
        // Add current card to front
        for (int j = tempSize; j > 0; j--) {
            temp[j] = temp[j - 1];
        }
        temp[0] = sortedDeck[i];
        tempSize++;
    }
    
    memcpy(result, temp, deckSize * sizeof(int));
    
    free(sortedDeck);
    free(temp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    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 iterations, each potentially moving n elements in queue operations

⚠ Quadratic Growth

Space Complexity

O(n)

Queue to store the result arrangement

⚡ 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

Reverse Simulation with Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler