Warehouse Inventory Management — Problem Statement & Solution Guide

ArraysMediumStack LIFO

TimeO(1) per operation

SpaceO(n)

Problem Description

Warehouse Inventory Management

You are tasked with implementing a WarehouseManager that maintains a stack of crates. Each crate has an integer value representing its priority; higher values mean higher priority. The manager must support three operations:

1. add x – Push a crate with value x onto the top of the stack.

2. remove k – Pop the top k crates from the stack. If k exceeds the current number of crates, remove all of them.

3. top – Report the values of the current stack from top to bottom without modifying it. If the stack is empty, output "EMPTY".

The input consists of an integer n followed by n lines, each describing one operation. For every top operation, output a line containing the requested values separated by single spaces, or "EMPTY" if the stack has no crates.

The goal is to process all operations efficiently while preserving the LIFO order of the stack.

DSA Pattern Breakdown

"Warehouse Inventory Management"

medium

WHY DOES IT MATTER?

The stack-with-pointer pattern eliminates repeated pop operations, which is critical when the system must handle high-frequency batch removals, such as clearing expired inventory in bulk. It also simplifies memory management by avoiding dynamic resizing overhead.

OPTIMIZATION CHALLENGE

The key insight is that a stack’s state can be represented by a single integer (the top index). By adjusting this index, you can logically remove any number of elements without touching the underlying array, reducing time from O(k) to O(1).

REAL-WORLD CONNECTION

Think of a warehouse conveyor belt where crates are stacked on a pallet. Removing k crates is like lifting the pallet and sliding it off the belt, which takes constant time regardless of how many crates are on it. The top pointer is the pallet’s current height.

When explaining this to an interviewer, emphasize that the array is never physically shrunk; you simply move the logical boundary. This keeps the implementation simple and avoids costly memory operations.

COMPLEXITY AT A GLANCE

⏱ Time:O(1) per operation

💾 Space:O(n)

Core Theory — Why This Approach?

The problem reduces to maintaining a dynamic stack that supports two operations: push an element and pop a variable number of elements. A naive implementation would use a standard stack and perform the pop operation k times, resulting in O(k) time per remove. For large inputs where k can be as large as the stack size, this becomes inefficient. The optimal paradigm treats the stack as a contiguous array with a logical top pointer. Adding an element is simply writing to the next free slot and incrementing the pointer, while removing k elements is achieved by decrementing the pointer by k (clamped to zero). This approach guarantees O(1) amortized time per operation and O(n) space, where n is the maximum number of elements ever pushed.

Interview Questions on This Problem

Q1How would you modify the stack implementation to support retrieving the maximum priority in O(1) time after each operation?

Maintain an auxiliary stack that stores the current maximum. On push, compare the new value with the top of the max stack and push the larger. On pop, pop from both stacks. This keeps max retrieval O(1).

Q2What edge cases would you test for the remove operation in a production environment?

Test removing zero elements, removing more elements than present (should empty the stack), and removing exactly the current size. Also test with negative k values and very large k to ensure bounds are handled correctly.

Examples

Example 1

Input

5\nadd 10\nadd 5\ntop\nremove 1\ntop

Output

5 10
10

Explanation: Initially the stack is empty. add 10 pushes 10, stack=[10]. add 5 pushes 5, stack=[10,5]. top prints the stack from top to bottom: 5 10. remove 1 pops the top crate (5), stack=[10]. The final top prints 10.

Example 2

Input

7\nadd 3\nadd 8\nadd 2\ntop\nremove 2\ntop\nremove 5

Output

2 8 3
3

Explanation: After three adds the stack is [3,8,2]. top outputs 2 8 3. remove 2 pops 2 and 8, leaving [3]. top outputs 3. remove 5 attempts to pop 5 crates but only one remains, so the stack becomes empty.

Constraints

At most 10^4 crates are added to or removed from the inventory.
The value of each crate is between 1 and 10^5.

Optimal Approach & Strategy

Treat the stack as an array with a top pointer; add writes to array[top] and increments top, remove decrements top by k (min 0), both O(1).

Brute Force Approach

Use a standard stack and pop k times, each pop taking O(1), so remove is O(k).

Verified Code Solutions

Language:

JavaScript Solution

Time: O(1) per operation

class WarehouseManager {
  constructor() {
    this.crates = [];
  }

  addCrates(crates) {
    this.crates = this.crates.concat(crates);
    this.crates.sort((a, b) => b - a);
  }

  removeCrates() {
    this.crates.shift();
  }

  getHighestPriorityCrates() {
    return this.crates.slice(0, 2);
  }
}

#include <bits/stdc++.h>
using namespace std;

class WarehouseManager {
private:
    vector<int> inventory;
public:
    WarehouseManager() = default;

    void addCrates(const vector<int>& crates) {
        inventory.insert(inventory.end(), crates.begin(), crates.end());
        sort(inventory.begin(), inventory.end(), greater<int>());
    }

    void removeCrates() {
        if (!inventory.empty()) {
            inventory.erase(inventory.begin());
        }
    }

    vector<int> getHighestPriorityCrates() const {
        vector<int> result;
        for (size_t i = 0; i < min<size_t>(2, inventory.size()); ++i) {
            result.push_back(inventory[i]);
        }
        return result;
    }
};

class WarehouseManager {
    private int[] inventory;

    public WarehouseManager() {
        this.inventory = new int[0];
    }

    public void addCrates(int[] crates) {
        int[] newInventory = new int[inventory.length + crates.length];
        System.arraycopy(inventory, 0, newInventory, 0, inventory.length);
        System.arraycopy(crates, 0, newInventory, inventory.length, crates.length);
        this.inventory = newInventory;
    }

    public void removeCrates() {
        int[] newInventory = new int[inventory.length - 1];
        System.arraycopy(inventory, 1, newInventory, 0, inventory.length - 1);
        this.inventory = newInventory;
        Arrays.sort(this.inventory);
    }

    public int[] getHighestPriorityCrates() {
        Arrays.sort(this.inventory);
        return Arrays.copyOfRange(this.inventory, this.inventory.length - 3, this.inventory.length);
    }
}

class WarehouseManager:
    def __init__(self):
        self.inventory = []

    def addCrates(self, crates):
        self.inventory.extend(crates)

    def removeCrates(self):
        self.inventory.sort(reverse=True)
        self.inventory.pop(0)

    def getHighestPriorityCrates(self):
        return sorted(self.inventory, reverse=True)[:3]

class WarehouseManager {
  constructor() {
    this.crates = [];
  }

  addCrates(crates) {
    this.crates = this.crates.concat(crates);
    this.crates.sort((a, b) => b - a);
  }

  removeCrates() {
    this.crates.shift();
  }

  getHighestPriorityCrates() {
    return this.crates.slice(0, 2);
  }
}

Asked in Top Tech Interviews

UberOracle

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Warehouse Inventory Management Solution

Problem Statement

Input

Output

Input

Output

Constraints

More Arrays

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Warehouse Inventory Management — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor