1418. Display Table of Food Orders in a Restaurant LeetCode Solution

In this guide, you will get 1418. Display Table of Food Orders in a Restaurant LeetCode Solution with the best time and space complexity. The solution to Display Table of Food Orders in a Restaurant problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Display Table of Food Orders in a Restaurant solution in C++
Display Table of Food Orders in a Restaurant solution in Java
Display Table of Food Orders in a Restaurant solution in Python
Additional Resources

1418. Display Table of Food Orders in a Restaurant LeetCode Solution image

Problem Statement of Display Table of Food Orders in a Restaurant

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”]]
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
customerNamei and foodItemi consist of lowercase and uppercase English letters and the space character.
tableNumberi is a valid integer between 1 and 500.

Complexity Analysis

Time Complexity: O(|\texttt{orders}| + \texttt{table}\log\texttt{table} + \texttt{food}\log\texttt{food})
Space Complexity: O(|\texttt{orders}|)

1418. Display Table of Food Orders in a Restaurant LeetCode Solution in C++

class Solution {
 public:
  vector<vector<string>> displayTable(vector<vector<string>>& orders) {
    vector<vector<string>> ans{{"Table"}};
    unordered_map<string, int> tableNumberToRowIndex;
    unordered_map<string, int> foodItemToColIndex;

    // Create the first row and column of ans.
    for (const vector<string>& order : orders) {
      const string& tableNumber = order[1];
      const string& foodItem = order[2];
      // Initialize indices with 0s.
      tableNumberToRowIndex[tableNumber] = 0;
      foodItemToColIndex[foodItem] = 0;
    }
    for (const auto& [tableNumber, _] : tableNumberToRowIndex)
      ans.push_back({tableNumber});
    for (const auto& [foodItem, _] : foodItemToColIndex)
      ans[0].push_back(foodItem);

    // Sort the first row and the column, except ans[0][0].
    sort(ans[0].begin() + 1, ans[0].end());
    ranges::sort(ans.begin() + 1, ans.end(), ranges::less{},
                 [](const vector<string>& cols) { return stoi(cols[0]); });

    // Set the indices after sorting.
    for (int i = 0; i < tableNumberToRowIndex.size(); ++i)
      tableNumberToRowIndex[ans[i + 1][0]] = i;
    for (int i = 0; i < foodItemToColIndex.size(); ++i)
      foodItemToColIndex[ans[0][i + 1]] = i;

    // Get all the counts of each food item in each table.
    vector<vector<int>> count;
    for (int i = 0; i < tableNumberToRowIndex.size(); ++i)
      count.push_back(vector<int>(foodItemToColIndex.size()));
    for (const vector<string>& order : orders) {
      const string& tableNumber = order[1];
      const string& foodItem = order[2];
      const int rowIndex = tableNumberToRowIndex[tableNumber];
      const int colIndex = foodItemToColIndex[foodItem];
      ++count[rowIndex][colIndex];
    }

    // Set the counts to `ans`.
    for (int i = 0; i < tableNumberToRowIndex.size(); ++i)
      for (int j = 0; j < foodItemToColIndex.size(); ++j)
        ans[i + 1].push_back(to_string(count[i][j]));

    return ans;
  }
};
/* code provided by PROGIEZ */