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

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

✓ Brute Force - Direct Counting

⏱️ Time: O(n×m×k) Space: O(m×k)

First collect all unique tables and food items, then for each combination, iterate through all orders to count how many times that table ordered that food item.

Hash Map - Single Pass Counting

⏱️ Time: O(n + m log m + k log k) Space: O(m×k)

Process each order once, using a hash map to track table-food combinations and their counts. Then format the result by sorting tables and foods.

Brute Force - Direct Counting — Algorithm Steps

Step 1: Extract all unique table numbers and food items
Step 2: For each table-food pair, count occurrences by scanning all orders
Step 3: Build result table with sorted tables and alphabetical food items

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Unique Items

Extract all unique tables (3,5) and foods (Burger,Donut,Pizza)

Brute Force Count

For each combination like Table 3 + Pizza, scan all orders to count occurrences

Build Result Table

Create sorted table with counts for each table-food pair

Code -

solution.c — C

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

#define MAX_ORDERS 1000
#define MAX_STRING 100
#define MAX_TABLES 100
#define MAX_FOODS 100

static char orders[MAX_ORDERS][3][MAX_STRING];
static int tables[MAX_TABLES];
static char foods[MAX_FOODS][MAX_STRING];
static char result[MAX_TABLES + 1][MAX_FOODS + 1][MAX_STRING];

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

int compareString(const void *a, const void *b) {
    return strcmp((char*)a, (char*)b);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int ordersSize = 0;
    int tablesSize = 0;
    int foodsSize = 0;
    
    // Parse JSON manually
    int i = 0;
    int len = strlen(line);
    
    // Skip to first '['
    while (i < len && line[i] != '[') i++;
    i++; // skip outer '['
    
    while (i < len) {
        if (line[i] == '[') {
            i++; // skip inner '['
            
            // Parse three strings
            for (int field = 0; field < 3; field++) {
                // Skip whitespace and comma
                while (i < len && (line[i] == ' ' || line[i] == ',' || line[i] == '\n')) i++;
                
                if (line[i] == '"') {
                    i++; // skip opening quote
                    int pos = 0;
                    while (i < len && line[i] != '"') {
                        orders[ordersSize][field][pos++] = line[i++];
                    }
                    orders[ordersSize][field][pos] = '\0';
                    i++; // skip closing quote
                }
            }
            
            // Skip to closing bracket
            while (i < len && line[i] != ']') i++;
            i++; // skip ']'
            
            ordersSize++;
        } else if (line[i] == ']') {
            break;
        } else {
            i++;
        }
    }
    
    // Extract unique tables and foods
    for (int ord = 0; ord < ordersSize; ord++) {
        int table = atoi(orders[ord][1]);
        
        // Check if table already exists
        int found = 0;
        for (int t = 0; t < tablesSize; t++) {
            if (tables[t] == table) {
                found = 1;
                break;
            }
        }
        if (!found) {
            tables[tablesSize++] = table;
        }
        
        // Check if food already exists
        found = 0;
        for (int f = 0; f < foodsSize; f++) {
            if (strcmp(foods[f], orders[ord][2]) == 0) {
                found = 1;
                break;
            }
        }
        if (!found) {
            strcpy(foods[foodsSize++], orders[ord][2]);
        }
    }
    
    // Sort tables and foods
    qsort(tables, tablesSize, sizeof(int), compareInt);
    qsort(foods, foodsSize, sizeof(foods[0]), compareString);
    
    // Build result
    int resultRows = 0;
    
    // Add header
    strcpy(result[resultRows][0], "Table");
    for (int f = 0; f < foodsSize; f++) {
        strcpy(result[resultRows][f + 1], foods[f]);
    }
    resultRows++;
    
    // For each table, count food items
    for (int t = 0; t < tablesSize; t++) {
        sprintf(result[resultRows][0], "%d", tables[t]);
        
        for (int f = 0; f < foodsSize; f++) {
            int count = 0;
            // Brute force: scan all orders
            for (int ord = 0; ord < ordersSize; ord++) {
                if (atoi(orders[ord][1]) == tables[t] && strcmp(orders[ord][2], foods[f]) == 0) {
                    count++;
                }
            }
            sprintf(result[resultRows][f + 1], "%d", count);
        }
        resultRows++;
    }
    
    // Print result in JSON format
    printf("[");
    for (int r = 0; r < resultRows; r++) {
        printf("[");
        for (int c = 0; c <= foodsSize; c++) {
            printf("\"%s\"", result[r][c]);
            if (c < foodsSize) printf(",");
        }
        printf("]");
        if (r < resultRows - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m×k)

For each table-food combination (m×k), we scan all n orders

✓ Linear Growth

Space Complexity

O(m×k)

Store result table with 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

Display Table of Food Orders in a Restaurant - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Direct Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler