# 1418. Display Table of Food Orders in a Restaurant

## Description

Given the array orders, which represents the orders that customers have done in a restaurant. More specifically orders[i]=[customerNamei,tableNumberi,foodItemi] where customerNamei is the name of the customer, tableNumberi is the table customer sit at, and foodItemi is the item customer orders.

Return the restaurant's “display table. The “display table” is a table whose row entries denote how many of each food item each table ordered. The first column is the table number and the remaining columns correspond to each food item in alphabetical order. The first row should be a header whose first column is “Table”, followed by the names of the food items. Note that the customer names are not part of the table. Additionally, the rows should be sorted in numerically increasing order.

Example 1:

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"]]
Explanation:
The displaying table looks like:
Table,Beef Burrito,Ceviche,Fried Chicken,Water
3    ,0           ,2      ,1            ,0
5    ,0           ,1      ,0            ,1
10   ,1           ,0      ,0            ,0
For the table 3: David orders "Ceviche" and "Fried Chicken", and Rous orders "Ceviche".
For the table 5: Carla orders "Water" and "Ceviche".
For the table 10: Corina orders "Beef Burrito".


Example 2:

Input: orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
Explanation:
For the table 12: James, Ratesh and Amadeus order "Fried Chicken".


Example 3:

Input: orders = [["Laura","2","Bean Burrito"],["Jhon","2","Beef Burrito"],["Melissa","2","Soda"]]
Output: [["Table","Bean Burrito","Beef Burrito","Soda"],["2","1","1","1"]]


Constraints:

• 1 <= orders.length <= 5 * 10^4
• orders[i].length == 3
• 1 <= customerNamei.length, foodItemi.length <= 20
• customerNamei and foodItemi consist of lowercase and uppercase English letters and the space character.
• tableNumberi is a valid integer between 1 and 500.

## Solutions

• class Solution {
public List<List<String>> displayTable(List<List<String>> orders) {
Set<Integer> tables = new HashSet<>();
Set<String> foods = new HashSet<>();
Map<String, Integer> mp = new HashMap<>();
for (List<String> order : orders) {
int table = Integer.parseInt(order.get(1));
String food = order.get(2);
String key = table + "." + food;
mp.put(key, mp.getOrDefault(key, 0) + 1);
}
List<Integer> t = new ArrayList<>(tables);
List<String> f = new ArrayList<>(foods);
Collections.sort(t);
Collections.sort(f);
List<List<String>> res = new ArrayList<>();
List<String> title = new ArrayList<>();
for (int table : t) {
List<String> tmp = new ArrayList<>();
for (String food : f) {
tmp.add(String.valueOf(mp.getOrDefault(table + "." + food, 0)));
}
}
return res;
}
}

• class Solution {
public:
vector<vector<string>> displayTable(vector<vector<string>>& orders) {
unordered_set<int> tables;
unordered_set<string> foods;
unordered_map<string, int> mp;
for (auto& order : orders) {
int table = stoi(order[1]);
string food = order[2];
tables.insert(table);
foods.insert(food);
++mp[order[1] + "." + food];
}
vector<int> t;
t.assign(tables.begin(), tables.end());
sort(t.begin(), t.end());
vector<string> f;
f.assign(foods.begin(), foods.end());
sort(f.begin(), f.end());
vector<vector<string>> res;
vector<string> title;
title.push_back("Table");
for (auto e : f) title.push_back(e);
res.push_back(title);
for (int table : t) {
vector<string> tmp;
tmp.push_back(to_string(table));
for (string food : f) {
tmp.push_back(to_string(mp[to_string(table) + "." + food]));
}
res.push_back(tmp);
}
return res;
}
};

• class Solution:
def displayTable(self, orders: List[List[str]]) -> List[List[str]]:
tables = set()
foods = set()
mp = Counter()
for _, table, food in orders:
mp[f'{table}.{food}'] += 1
foods = sorted(list(foods))
tables = sorted(list(tables))
res = [['Table'] + foods]
for table in tables:
t = [str(table)]
for food in foods:
t.append(str(mp[f'{table}.{food}']))
res.append(t)
return res


• func displayTable(orders [][]string) [][]string {
tables := make(map[int]bool)
foods := make(map[string]bool)
mp := make(map[string]int)
for _, order := range orders {
table, food := order[1], order[2]
t, _ := strconv.Atoi(table)
tables[t] = true
foods[food] = true
key := table + "." + food
mp[key] += 1
}
var t []int
var f []string
for i := range tables {
t = append(t, i)
}
for i := range foods {
f = append(f, i)
}
sort.Ints(t)
sort.Strings(f)
var res [][]string
var title []string
title = append(title, "Table")
for _, e := range f {
title = append(title, e)
}
res = append(res, title)
for _, table := range t {
var tmp []string
tmp = append(tmp, strconv.Itoa(table))
for _, food := range f {
tmp = append(tmp, strconv.Itoa(mp[strconv.Itoa(table)+"."+food]))
}
res = append(res, tmp)
}
return res
}

• function displayTable(orders: string[][]): string[][] {
const tables: Record<number, Record<string, number>> = {};
const items: Set<string> = new Set();
for (const [_, table, foodItem] of orders) {
const t = +table;
if (!tables[t]) {
tables[t] = {};
}
if (!tables[t][foodItem]) {
tables[t][foodItem] = 0;
}
tables[t][foodItem]++;
}
const sortedItems = Array.from(items).sort();
const ans: string[][] = [];
const header: string[] = ['Table', ...sortedItems];
const sortedTableNumbers = Object.keys(tables)
.map(Number)
.sort((a, b) => a - b);
for (const table of sortedTableNumbers) {
const row: string[] = [table.toString()];
for (const item of sortedItems) {
row.push((tables[table][item] || 0).toString());
}
ans.push(row);
}
return ans;
}