Formatted question description: https://leetcode.ca/all/1418.html

1418. Display Table of Food Orders in a Restaurant

Level

Medium

Description

Given the array orders, which represents the orders that customers have done in a restaurant. More specifically orders[i]=[customerName_i,tableNumber_i,foodItem_i] where customerName_i is the name of the customer, tableNumber_i is the table customer sit at, and foodItem_i 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"]]
Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]] 
Explanation: 
For the table 1: Adam and Brianna order "Canadian Waffles".
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
  • customerName_i and foodItem_i consist of lowercase and uppercase English letters and the space character.
  • tableNumber_i is a valid integer between 1 and 500.

Solution

Use a map to store each table and the orders of the table, where the orders are also stored in a map. The orders map contains each item and the count. Use a set to store all items that exist at least once. Loop over orders. For each order, obtain the table number and the item, and update the table’s orders map using the item. After all orders are checked, obtain all the items and sort them, and combine “Table” and all the items to form the header. Then for each table, obtain all the orders of the table, and set the counts of the items. Sort the tables’ display list according to the table numbers. Then add each table’s display list to the result list.

  • class Solution {
        public List<List<String>> displayTable(List<List<String>> orders) {
            Set<String> itemSet = new HashSet<String>();
            Map<Integer, Map<String, Integer>> tableOrdersMap = new HashMap<Integer, Map<String, Integer>>();
            for (List<String> order : orders) {
                int tableNumber = Integer.parseInt(order.get(1));
                String foodItem = order.get(2);
                itemSet.add(foodItem);
                Map<String, Integer> ordersMap = tableOrdersMap.getOrDefault(tableNumber, new HashMap<String, Integer>());
                int count = ordersMap.getOrDefault(foodItem, 0) + 1;
                ordersMap.put(foodItem, count);
                tableOrdersMap.put(tableNumber, ordersMap);
            }
            List<List<String>> displayList = new ArrayList<List<String>>();
            List<String> itemList = new ArrayList<String>(itemSet);
            Collections.sort(itemList);
            Map<String, Integer> itemIndexMap = new HashMap<String, Integer>();
            List<String> header = new ArrayList<String>();
            header.add("Table");
            int size = itemList.size();
            for (int i = 0; i < size; i++) {
                String item = itemList.get(i);
                header.add(item);
                itemIndexMap.put(item, i + 1);
            }
            displayList.add(header);
            List<List<String>> bodyList = new ArrayList<List<String>>();
            Set<Integer> tableSet = tableOrdersMap.keySet();
            for (int tableNumber : tableSet) {
                List<String> curLine = new ArrayList<String>();
                curLine.add(String.valueOf(tableNumber));
                for (int i = 0; i < size; i++)
                    curLine.add("0");
                Map<String, Integer> ordersMap = tableOrdersMap.get(tableNumber);
                Set<String> curItemSet = ordersMap.keySet();
                for (String item : curItemSet) {
                    int count = ordersMap.get(item);
                    int index = itemIndexMap.get(item);
                    curLine.set(index, String.valueOf(count));
                }
                bodyList.add(curLine);
            }
            Collections.sort(bodyList, new Comparator<List<String>>() {
                public int compare(List<String> list1, List<String> list2) {
                    int tableNumber1 = Integer.parseInt(list1.get(0));
                    int tableNumber2 = Integer.parseInt(list2.get(0));
                    return tableNumber1 - tableNumber2;
                }
            });
            int tablesCount = bodyList.size();
            for (int i = 0; i < tablesCount; i++)
                displayList.add(bodyList.get(i));
            return displayList;
        }
    }
    
  • Todo
    
  • class Solution:
        def displayTable(self, orders: List[List[str]]) -> List[List[str]]:
            count = collections.defaultdict(dict)
            foods = set()
            tables = set()
            for order in orders:
                foods.add(order[2])
                tables.add(int(order[1]))
            foods = sorted(list(foods))
            cols = ["Table", ] + foods
            res = []
            res.append(cols)
            for order in orders:
                if order[2] not in count[order[1]]:
                    count[order[1]][order[2]] = 0
                count[order[1]][order[2]] += 1
            for table in sorted(list(tables)):
                table = str(table)
                tc = count[table]
                line = [table,]
                for food in foods:
                    if food not in tc:
                        line.append("0")
                    else:
                        line.append(str(tc[food]))
                res.append(line)
            return res
    

All Problems

All Solutions