Drop Type 1 Orders for Customers With Type 0 Orders

Drop Type 1 Orders for Customers With Type 0 Orders - Problem

Database Medium

Drop Type 1 Orders for Customers With Type 0 Orders

You are working with an e-commerce database that tracks customer orders. Each order has a unique ID, belongs to a customer, and has a specific order type (either 0 or 1).

Your task is to implement a priority filtering system where:

Type 0 orders have higher priority than Type 1 orders
If a customer has at least one Type 0 order, we should exclude all their Type 1 orders from the results
If a customer has only Type 1 orders, we include all their orders

Think of this as a VIP customer system where Type 0 represents premium orders and Type 1 represents regular orders. Once a customer places a premium order, we only show their premium activity.

Goal: Filter the orders table based on the priority rules above and return the filtered results.

Input & Output

example_1.py — Python

$ Input: orders = [[1,1,0],[2,1,1],[3,2,1],[4,3,0],[5,3,1]]

› Output: [[1,1,0],[3,2,1],[4,3,0]]

💡 Note: Customer 1 has both Type 0 (order 1) and Type 1 (order 2) orders, so we only include the Type 0 order. Customer 2 has only Type 1 orders, so we include all (order 3). Customer 3 has both types, so we only include Type 0 (order 4).

example_2.py — Python

$ Input: orders = [[1,1,1],[2,1,1],[3,2,1]]

› Output: [[1,1,1],[2,1,1],[3,2,1]]

💡 Note: All customers (1 and 2) only have Type 1 orders, so we include all orders in the result.

example_3.py — Python

$ Input: orders = [[1,1,0],[2,2,0],[3,3,0]]

› Output: [[1,1,0],[2,2,0],[3,3,0]]

💡 Note: All customers only have Type 0 orders, so we include all orders. Since they don't have Type 1 orders, there's nothing to filter out.

Constraints

1 ≤ orders.length ≤ 10⁴
orders[i].length == 3
1 ≤ order_id, customer_id ≤ 1000
order_type is either 0 or 1
order_id is unique for each order

Visualization

Tap to expand

Understanding the Visualization

Scan Reservations

Process each reservation and categorize customers by their status

Identify VIP Status

Keep track of which customers have made VIP reservations (Type 0)

Apply Priority Rules

For VIP customers, show only VIP reservations. For regular customers, show all reservations

Key Takeaway

🎯 Key Insight: Use hash table grouping to efficiently categorize customers and apply priority rules in a single pass through the data.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a one-pass hash table approach to group orders by customer while categorizing them by type. Key insight: once we know a customer has Type 0 orders, we can immediately exclude their Type 1 orders. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build customer groups and filter simultaneously in a single pass
Brute Force (Multiple Scans)	O(n²)	O(1)	Scan the table multiple times for each customer to check order types
Two-Pass Hash Table	O(n)	O(k)	First pass to identify customers with Type 0 orders, second pass to filter results

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash map to group orders by customer_id
In a single pass, categorize each order by customer and type
For each customer, store Type 0 and Type 1 orders separately
After processing all orders, iterate through customers
For each customer: if they have Type 0 orders, output only Type 0; otherwise output all orders

Visualization

Tap to expand

Step-by-Step Walkthrough

Single Pass

Group orders by customer while scanning

Customer Groups

Each customer has Type 0 and Type 1 buckets

Apply Rules

Output Type 0 if exists, otherwise all Type 1

Code -

solution.c — C

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

#define MAX_CUSTOMERS 1000
#define MAX_ORDERS 1000

struct CustomerOrders {
    int type0[MAX_ORDERS][3];
    int type1[MAX_ORDERS][3];
    int type0Count;
    int type1Count;
};

int** solution(int** orders, int ordersSize, int* returnSize) {
    // Group orders by customer in a single pass
    struct CustomerOrders customerOrdersMap[MAX_CUSTOMERS];
    int customerExists[MAX_CUSTOMERS] = {0};
    
    // Initialize
    for (int i = 0; i < MAX_CUSTOMERS; i++) {
        customerOrdersMap[i].type0Count = 0;
        customerOrdersMap[i].type1Count = 0;
    }
    
    for (int i = 0; i < ordersSize; i++) {
        int customerId = orders[i][1];
        int orderType = orders[i][2];
        
        customerExists[customerId] = 1;
        
        if (orderType == 0) {
            int idx = customerOrdersMap[customerId].type0Count++;
            customerOrdersMap[customerId].type0[idx][0] = orders[i][0];
            customerOrdersMap[customerId].type0[idx][1] = orders[i][1];
            customerOrdersMap[customerId].type0[idx][2] = orders[i][2];
        } else {
            int idx = customerOrdersMap[customerId].type1Count++;
            customerOrdersMap[customerId].type1[idx][0] = orders[i][0];
            customerOrdersMap[customerId].type1[idx][1] = orders[i][1];
            customerOrdersMap[customerId].type1[idx][2] = orders[i][2];
        }
    }
    
    // Build result based on rules
    int** result = malloc(ordersSize * sizeof(int*));
    int resultSize = 0;
    
    for (int customerId = 0; customerId < MAX_CUSTOMERS; customerId++) {
        if (!customerExists[customerId]) continue;
        
        struct CustomerOrders* customerOrders = &customerOrdersMap[customerId];
        if (customerOrders->type0Count > 0) { // Customer has Type 0 orders
            for (int i = 0; i < customerOrders->type0Count; i++) {
                result[resultSize] = malloc(3 * sizeof(int));
                result[resultSize][0] = customerOrders->type0[i][0];
                result[resultSize][1] = customerOrders->type0[i][1];
                result[resultSize][2] = customerOrders->type0[i][2];
                resultSize++;
            }
        } else { // Customer has only Type 1 orders
            for (int i = 0; i < customerOrders->type1Count; i++) {
                result[resultSize] = malloc(3 * sizeof(int));
                result[resultSize][0] = customerOrders->type1[i][0];
                result[resultSize][1] = customerOrders->type1[i][1];
                result[resultSize][2] = customerOrders->type1[i][2];
                resultSize++;
            }
        }
    }
    
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n orders to build groups, then O(k) to output results where k ≤ n

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all orders grouped by customer, worst case is O(n) space

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Drop Type 1 Orders for Customers With Type 0 Orders

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler