Dinner Plate Stacks - Practice Coding Problems

Dinner Plate Stacks - Problem

Imagine you're managing a cafeteria where plates are organized in stacks. You have an infinite number of stacks arranged in a row, numbered from 0 (leftmost) onwards. Each stack has the same maximum capacity.

Your task is to implement a DinnerPlates class that efficiently manages these stacks:

Push operation: Always add new plates to the leftmost stack that has space
Pop operation: Always remove plates from the rightmost non-empty stack
Pop at specific stack: Remove a plate from any specific stack by its index

The challenge is to handle these operations efficiently while maintaining the correct ordering and dealing with gaps that form when plates are removed from middle stacks.

Example: With capacity=2, after pushing [1,2,3,4,5] you get: Stack0=[1,2], Stack1=[3,4], Stack2=[5]. If you pop from Stack1, it becomes Stack0=[1,2], Stack1=[3], Stack2=[5], and the next push should fill Stack1 again, not create Stack3.

Input & Output

basic_operations.py — Python

$ Input: DinnerPlates(2) push(1), push(2), push(3), push(4), push(5) pop(), pop(), popAtStack(0), push(20), push(21)

› Output: [null, null, null, null, null, null, 5, 4, 2, null, null] Final state: Stack0=[1], Stack1=[20,21], Stack2=[]

💡 Note: With capacity 2: push creates Stack0=[1,2], Stack1=[3,4], Stack2=[5]. Pop removes 5 and 4. PopAtStack(0) removes 2. Push(20) goes to Stack1, Push(21) fills Stack1.

gap_filling.py — Python

$ Input: DinnerPlates(2) push(1), push(2), popAtStack(1), push(2) popAtStack(1), push(99)

› Output: [null, null, null, -1, null, -1, null] Final state: Stack0=[1,99], Stack1=[]

💡 Note: Push creates Stack0=[1,2]. PopAtStack(1) on empty returns -1. Push(2) creates Stack1=[2]. PopAtStack(1) removes 2. Push(99) fills Stack0 gap.

single_capacity.py — Python

$ Input: DinnerPlates(1) push(1), push(2), push(3), pop(), pop(), pop()

› Output: [null, null, null, null, 3, 2, 1] Final state: All stacks empty

💡 Note: With capacity 1, each push creates new stack: Stack0=[1], Stack1=[2], Stack2=[3]. Pop operations remove from rightmost: 3, then 2, then 1.

Constraints

1 ≤ capacity ≤ 2 × 10⁴
1 ≤ val ≤ 2 × 10⁴
0 ≤ index ≤ 10⁵
At most 2 × 10⁵ calls will be made to push, pop, and popAtStack
Time limit: All operations should be efficient for large inputs

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Initialize empty stack array, min-heap for tracking available positions, and rightmost pointer for quick access

Smart Push

Use min-heap to instantly find leftmost available stack, avoiding linear scan through potentially thousands of stacks

Efficient Pop

Rightmost pointer enables instant access to the last non-empty stack, no searching required

Gap Management

When middle stacks become available, they're immediately added to heap for future use, ensuring optimal space utilization

Key Takeaway

🎯 Key Insight: The optimal solution elegantly combines two data structures: a min-heap provides O(log n) access to the leftmost available stack, while a rightmost pointer enables O(1) pop operations. This hybrid approach transforms a potentially O(n) problem into an efficient logarithmic solution.

Asked in

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

The optimal solution uses a min-heap to track available stack indices for efficient push operations and maintains a rightmost pointer for O(1) pop operations. Key insights: 1) Min-heap ensures we always find the leftmost available stack in O(log n), 2) Rightmost tracking eliminates the need to scan for non-empty stacks, 3) Proper heap cleanup prevents invalid indices from accumulating.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan)	O(n)	O(n × capacity)	Scan all stacks linearly for each operation
Priority Queue Optimization (Optimal)	O(log n)	O(n)	Use min-heap for available stacks and track rightmost for O(1) operations

Brute Force (Linear Scan) — Algorithm Steps

Initialize a list to store all stacks
For push: iterate from index 0 to find first stack with space
For pop: iterate from rightmost index to find first non-empty stack
For popAtStack: directly access the specified stack
Handle edge cases like empty stacks and invalid indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty stack array

Push Operation

Scan from left to find first available stack

Pop Operation

Scan from right to find first non-empty stack

PopAtStack

Directly access the specified stack

Code -

solution.c — C

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

#define MAX_STACKS 100000

typedef struct {
    int capacity;
    int** stacks;
    int* stackSizes;
    int numStacks;
} DinnerPlates;

DinnerPlates* dinnerPlatesCreate(int capacity) {
    DinnerPlates* obj = (DinnerPlates*)malloc(sizeof(DinnerPlates));
    obj->capacity = capacity;
    obj->stacks = (int**)calloc(MAX_STACKS, sizeof(int*));
    obj->stackSizes = (int*)calloc(MAX_STACKS, sizeof(int));
    obj->numStacks = 0;
    return obj;
}

void dinnerPlatesPush(DinnerPlates* obj, int val) {
    // Find leftmost stack with space
    for (int i = 0; i < obj->numStacks; i++) {
        if (obj->stackSizes[i] < obj->capacity) {
            if (!obj->stacks[i]) {
                obj->stacks[i] = (int*)malloc(obj->capacity * sizeof(int));
            }
            obj->stacks[i][obj->stackSizes[i]] = val;
            obj->stackSizes[i]++;
            return;
        }
    }
    // No space found, create new stack
    obj->stacks[obj->numStacks] = (int*)malloc(obj->capacity * sizeof(int));
    obj->stacks[obj->numStacks][0] = val;
    obj->stackSizes[obj->numStacks] = 1;
    obj->numStacks++;
}

int dinnerPlatesPop(DinnerPlates* obj) {
    // Find rightmost non-empty stack
    while (obj->numStacks > 0 && obj->stackSizes[obj->numStacks - 1] == 0) {
        obj->numStacks--;
    }
    
    if (obj->numStacks == 0) {
        return -1;
    }
    
    int lastIdx = obj->numStacks - 1;
    int val = obj->stacks[lastIdx][obj->stackSizes[lastIdx] - 1];
    obj->stackSizes[lastIdx]--;
    return val;
}

int dinnerPlatesPopAtStack(DinnerPlates* obj, int index) {
    if (index >= obj->numStacks || obj->stackSizes[index] == 0) {
        return -1;
    }
    int val = obj->stacks[index][obj->stackSizes[index] - 1];
    obj->stackSizes[index]--;
    return val;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each push and pop operation requires scanning through potentially n stacks

✓ Linear Growth

Space Complexity

O(n × capacity)

Space needed to store all stacks and their elements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

967 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 (Linear Scan) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler