Display Table of Food Orders in a Restaurant

Display Table of Food Orders in a Restaurant - Problem

Array Hash Table String Sorting Ordered Set Medium

You're building a restaurant management system that needs to display order summaries. Given an array of customer orders, create a display table that shows how many of each food item was ordered at each table.

Input Format: Each order is represented as [customerName, tableNumber, foodItem]

Output Format: A 2D table where:

First row is the header: ["Table", "food1", "food2", ...] (food items in alphabetical order)
Each subsequent row: ["tableNum", count1, count2, ...] (tables in numerical order)
Customer names are not included in the final table

Example: If orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"]], the output shows table 12 ordered 3 Fried Chicken items.

Input & Output

example_1.py — Basic Restaurant Orders

$ Input: orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]]

› Output: [["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]]

💡 Note: Table 3 has 2 Ceviche and 1 Fried Chicken. Table 5 has 1 Ceviche and 1 Water. Table 10 has 1 Beef Burrito. Foods are sorted alphabetically, tables numerically.

example_2.py — Single Table Multiple Items

$ Input: orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]

› Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]

💡 Note: Table 1 ordered 2 Canadian Waffles, Table 12 ordered 3 Fried Chicken. Customer names don't appear in final table.

example_3.py — Edge Case: Single Order

$ Input: orders = [["Laura","2","Bean Burrito"]]

› Output: [["Table","Bean Burrito"],["2","1"]]

💡 Note: Minimal case: one customer, one table, one food item results in a 2x2 table with header and single data row.

Constraints

1 ≤ orders.length ≤ 5 × 10⁴
orders[i].length == 3
1 ≤ customerNameᵢ.length, foodItemᵢ.length ≤ 20
customerNameᵢ and foodItemᵢ consist of lowercase and uppercase English letters and the space character
tableNumberᵢ is a valid integer between 1 and 500

Visualization

Tap to expand

Understanding the Visualization

Collect Order Slips

Each slip has customer name, table number, and food item

Group by Table

Sort slips by table number, counting food items per table

Create Summary Board

Display table shows quantities needed per table (no customer names)

Organize Layout

Foods in alphabetical columns, tables in numerical rows for easy reading

Key Takeaway

🎯 Key Insight: Nested hash maps (table → food → count) enable single-pass processing with O(1) lookups, making this optimal for restaurant order management where quick aggregation is essential.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a single-pass hash table approach with nested maps (table → food → count) to efficiently count orders while collecting unique items. Key insights: O(1) lookups eliminate the need for repeated scanning, and proper sorting of foods alphabetically and tables numerically produces the required output format.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n² + f log f + t log t)	O(f + t)	Scan orders multiple times to find unique items, then count each combination
One-Pass Hash Table (Optimal)	O(n + f log f + t log t)	O(n + f + t)	Single pass using nested hash maps to count orders and collect unique items simultaneously

Brute Force (Multiple Passes) — Algorithm Steps

Scan all orders to collect unique food items
Scan all orders to collect unique table numbers
Sort food items alphabetically and table numbers numerically
For each table-food combination, scan orders again to count occurrences
Build the result table with header and counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan for Foods

First pass: collect all unique food items

Scan for Tables

Second pass: collect all unique table numbers

Sort Collections

Sort foods alphabetically, tables numerically

Count Combinations

For each table-food pair, scan entire order list again

Code -

solution.c — C

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

// Note: This is a simplified C version focusing on the algorithm
// Full implementation would require dynamic memory management
char*** displayTable(char*** orders, int ordersSize, int* returnSize, int** returnColumnSizes) {
    // This would require complex string and memory management in C
    // For educational purposes, showing the algorithm structure
    
    // Step 1: Collect unique foods and tables (simplified)
    // Step 2: Sort collections
    // Step 3: Build result table by counting occurrences
    
    // Allocate result array
    char*** result = malloc(sizeof(char**) * 100); // simplified allocation
    *returnSize = 0;
    
    // Implementation details omitted for brevity in C
    // Real implementation would need proper string handling
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + f log f + t log t)

n² for counting each table-food combination, f log f for sorting foods, t log t for sorting tables

⚠ Quadratic Growth

Space Complexity

O(f + t)

Space for storing unique food items (f) and table numbers (t)

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler