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

Given an array orders representing customer orders in a restaurant, where each order is in the format [customerName, tableNumber, foodItem].

Return the restaurant's "display table" showing how many of each food item each table ordered. The display table should have:

First column: "Table" (table numbers)
Remaining columns: Food items in alphabetical order
Rows sorted by table number in numerically increasing order
Each cell shows the count of that food item for that table

Note: Customer names are not included in the output table.

Input & Output

Example 1 — Basic Restaurant Orders

$ Input: orders = [["David","3","Pizza"],["Corina","5","Burger"],["David","3","Pizza"],["Amos","5","Donut"]]

› Output: [["Table","Burger","Donut","Pizza"],["3","0","0","2"],["5","1","1","0"]]

💡 Note: Table 3 ordered 2 Pizzas, Table 5 ordered 1 Burger and 1 Donut. Foods are sorted alphabetically: Burger, Donut, Pizza. Tables are sorted numerically: 3, 5.

Example 2 — Single Table Multiple Items

$ Input: orders = [["Alice","2","Salad"],["Bob","2","Salad"],["Charlie","2","Pasta"]]

› Output: [["Table","Pasta","Salad"],["2","1","2"]]

💡 Note: Only table 2 with orders: 1 Pasta and 2 Salads. Foods sorted alphabetically: Pasta comes before Salad.

Example 3 — Multiple Tables Single Items

$ Input: orders = [["John","1","Coffee"],["Jane","2","Coffee"],["Jim","3","Coffee"]]

› Output: [["Table","Coffee"],["1","1"],["2","1"],["3","1"]]

💡 Note: Three tables each ordered 1 Coffee. Tables sorted numerically: 1, 2, 3.

Constraints

1 ≤ orders.length ≤ 5 × 10⁴
orders[i].length == 3
1 ≤ customerName_i.length, foodItem_i.length ≤ 20
customerName_i and foodItem_i consist of lowercase and uppercase English letters and spaces
tableNumber_i is a valid integer

Visualization

Tap to expand

Understanding the Visualization

Input Orders

Array of [customer, table, food] orders from restaurant

Count & Group

Group orders by table and food item, count occurrences

Format Table

Create sorted display table with table numbers and food counts

Key Takeaway

🎯 Key Insight: Use hash maps to count table-food combinations efficiently, then sort both dimensions for the final display table

Asked in

a Amazon 15 G Google 8 M Microsoft 6

The key insight is to use hash maps for efficient counting of table-food combinations in a single pass, then format the result with proper sorting. The optimal approach uses nested hash maps to count orders efficiently. Time: O(n + m log m + k log k), Space: O(m×k) where n=orders, m=tables, k=foods.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map - Single Pass Counting	O(n + m log m + k log k)	O(m×k)	Use nested hash maps to count orders in a single pass, then build the result table
Brute Force - Direct Counting	O(n×m×k)	O(m×k)	For each table and food combination, scan all orders to count occurrences

Hash Map - Single Pass Counting — Algorithm Steps

Step 1: Create hash maps to track table-food counts and collect unique items
Step 2: Process each order once, updating counts in hash map
Step 3: Sort tables and foods, then build result table from hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Maps

Create nested maps: table -> food -> count

Single Pass Count

Process each order once, updating counts in hash map

Format Result

Sort tables and foods, then build result table from hash map

Code -

solution.c — C

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

// Note: C implementation is complex for this problem due to dynamic arrays and JSON parsing
// This is a simplified version showing the hash map approach structure

char*** solution(char*** orders, int ordersSize, int* returnSize, int** returnColumnSizes) {
    // Use hash table (can implement with arrays or linked lists)
    // Single pass through orders to count table-food combinations
    // Sort tables and foods
    // Build result table
    
    *returnSize = 0; // Set actual size
    return NULL; // Return actual result
}

int main() {
    // Read and parse JSON input
    // Call solution
    // Print result in JSON format
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m log m + k log k)

Process n orders once, then sort m tables and k foods

⚡ Linearithmic

Space Complexity

O(m×k)

Hash map stores counts for m tables and k food items

✓ Linear Space

18.0K Views

Medium Frequency

~25 min Avg. Time

450 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

Hash Map - Single Pass Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler