Is Customers Who Bought Products A and B but Not C easy or hard?

The problem is generally rated Medium because it requires combining multiple SQL concepts. You must enforce both presence (A and B purchased) and absence (C never purchased) conditions within grouped data. Understanding GROUP BY with HAVING or NOT EXISTS is essential to solving it correctly.

Customers Who Bought Products A and B but Not C Python/Java solution

This problem is primarily solved using SQL rather than Python or Java because it operates on relational tables. The correct solution involves writing a query that groups purchases by customer and filters based on product conditions. Platforms like LeetCode typically expect a MySQL or PostgreSQL query.

How to solve Customers Who Bought Products A and B but Not C in O(n)?

Use GROUP BY customer_id and compute conditional counts for each product using expressions such as SUM(product='A'), SUM(product='B'), and SUM(product='C'). The HAVING clause ensures A and B counts are positive while C is zero. The database performs a single pass aggregation, resulting in O(n) time complexity.

What is the best approach for Customers Who Bought Products A and B but Not C?

Conditional aggregation with GROUP BY and HAVING is the most common solution. You group purchases by customer and count occurrences of products A, B, and C. The HAVING clause filters customers where A and B counts are greater than zero and C count equals zero. This approach runs in O(n) time over the purchase table.

Is Customers Who Bought Products A and B but Not C asked at Google/Amazon/Meta?

SQL filtering and aggregation problems like this commonly appear in database interview rounds at companies such as Amazon, Meta, and Google. Candidates are expected to demonstrate strong knowledge of GROUP BY, HAVING, and EXISTS queries. Variations of this problem frequently appear in analytics and data engineering interviews.

What data structure is used in Customers Who Bought Products A and B but Not C?

The problem relies on relational database operations rather than traditional in-memory data structures. Internally, the database engine uses hash aggregation or sorting to group rows by customer_id. The logic is implemented using SQL constructs like GROUP BY, HAVING, LEFT JOIN, and conditional aggregation.

What is the time complexity of Customers Who Bought Products A and B but Not C?

Most SQL solutions run in O(n) time where n is the number of purchase records. The database scans the table once and groups rows by customer_id. Aggregation operations like SUM or COUNT are applied during grouping. Space complexity is typically O(n) due to grouping state.

Description Solution Video 13:56

1398. Customers Who Bought Products A and B but Not C

Medium71.2% acceptance1 companyPremium elsewhere, free here

Table: Customers

+---------------------+---------+
| Column Name         | Type    |
+---------------------+---------+
| customer_id         | int     |
| customer_name       | varchar |
+---------------------+---------+
customer_id is the column with unique values for this table.
customer_name is the name of the customer.

Table: Orders

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| order_id      | int     |
| customer_id   | int     |
| product_name  | varchar |
+---------------+---------+
order_id is the column with unique values for this table.
customer_id is the id of the customer who bought the product "product_name".

Write a solution to report the customer_id and customer_name of customers who bought products "A", "B" but did not buy the product "C" since we want to recommend them to purchase this product.

Return the result table ordered by customer_id.

The result format is in the following example.

Example 1:

Input: 
Customers table:
+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
| 1           | Daniel        |
| 2           | Diana         |
| 3           | Elizabeth     |
| 4           | Jhon          |
+-------------+---------------+
Orders table:
+------------+--------------+---------------+
| order_id   | customer_id  | product_name  |
+------------+--------------+---------------+
| 10         |     1        |     A         |
| 20         |     1        |     B         |
| 30         |     1        |     D         |
| 40         |     1        |     C         |
| 50         |     2        |     A         |
| 60         |     3        |     A         |
| 70         |     3        |     B         |
| 80         |     3        |     D         |
| 90         |     4        |     C         |
+------------+--------------+---------------+
Output: 
+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
| 3           | Elizabeth     |
+-------------+---------------+
Explanation: Only the customer_id with id 3 bought the product A and B but not the product C.

Asked at 1 company

Topics

Database

13:56

Still stuck?Read the written solution, or watch a walkthrough.

Open solution

LanguageLoading editor…

1class Solution:
  def solve(self):
      pass


Starter codePython 3Spaces: 4

Examples

Case 1

Input

{"headers":{"Customers":["customer_id","customer_name"],"Orders":["order_id","customer_id","product_name"]},"rows":{"Customers":[[1,"Daniel"],[2,"Diana"],[3,"Elizabeth"],[4,"Jhon"]],"Orders":[[10,1,"A"],[20,1,"B"],[30,1,"D"],[40,1,"C"],[50,2,"A"],[60,3,"A"],[70,3,"B"],[80,3,"D"],[90,4,"C"]]}}

Your code is saved on this device.Solution