Customers Who Never Order

This challenge focuses on identifying customers who have not placed any orders. This is a common task in customer relationship management and marketing, where businesses often want to re-engage inactive customers or segment their audience. Your goal is to write code that efficiently finds these customers.

Problem Description

You are provided with two datasets: one containing information about customers and another containing information about orders. Your task is to identify and return the names of all customers who have never placed an order.

Key Requirements:

• You will be given two lists (or tables) of data.
• The Customers list will contain unique customer IDs and their corresponding names.
• The Orders list will contain order details, including the customer ID who placed the order.
• You need to find customers present in the Customers list but not present in the Orders list (based on customer ID).
• The output should be a list of the names of these customers.
• The order of the output names does not matter.

Expected Behavior:

The code should iterate through the customer data and compare it against the order data to identify customers with no associated orders.

Edge Cases to Consider:

• What if there are no customers?
• What if there are no orders?
• What if all customers have placed orders?
• What if some customer IDs in the Orders list do not exist in the Customers list? (These should be ignored, as we are only concerned with customers who are in our customer list but have no orders).

Examples

Example 1:

Input:
Customers: [
  {"CustomerID": 1, "Name": "Alice"},
  {"CustomerID": 2, "Name": "Bob"},
  {"CustomerID": 3, "Name": "Charlie"}
]
Orders: [
  {"OrderID": 101, "CustomerID": 1, "Amount": 50.00},
  {"OrderID": 102, "CustomerID": 3, "Amount": 75.00}
]
Output: ["Bob"]
Explanation: Alice placed an order (OrderID 101), and Charlie placed an order (OrderID 102). Bob is in the Customers list but has no corresponding entry in the Orders list.

Example 2:

Input:
Customers: [
  {"CustomerID": 1, "Name": "David"},
  {"CustomerID": 2, "Name": "Eve"}
]
Orders: [
  {"OrderID": 201, "CustomerID": 1, "Amount": 100.00},
  {"OrderID": 202, "CustomerID": 2, "Amount": 200.00}
]
Output: []
Explanation: Both David and Eve have placed orders.

Example 3:

Input:
Customers: [
  {"CustomerID": 1, "Name": "Frank"},
  {"CustomerID": 2, "Name": "Grace"}
]
Orders: []
Output: ["Frank", "Grace"]
Explanation: There are no orders, so all customers are considered to have never ordered.

Constraints

• The number of customers will be between 0 and 10,000, inclusive.
• The number of orders will be between 0 and 100,000, inclusive.
• Customer IDs and OrderIDs will be positive integers.
• Customer names will be strings.
• The CustomerID in the Orders list will always correspond to a CustomerID present in the Customers list, or it can be an invalid ID that should be ignored (as per Problem Description).
• Your solution should aim for an efficient time complexity, ideally better than O(N*M) where N is the number of customers and M is the number of orders.

Notes

• Consider using a data structure that allows for efficient lookups of customer IDs who have placed orders.
• Think about how to store and access customer information to easily retrieve their names.
• The problem statement implies that you should only consider customers explicitly listed in the Customers dataset.

FUNCTION FindCustomersWhoNeverOrder(Customers, Orders):
  // Customers is a list of dictionaries/objects, each with "CustomerID" and "Name"
  // Orders is a list of dictionaries/objects, each with "OrderID" and "CustomerID"

  // Create a set to store CustomerIDs that have placed orders for efficient lookups
  orderedCustomerIDs = CREATE_SET()

  // Iterate through the Orders to populate the set of ordered CustomerIDs
  FOR EACH order IN Orders:
    IF order.CustomerID IS VALID: // Ensure we only consider valid customer IDs
      ADD order.CustomerID TO orderedCustomerIDs

  // Create a list to store the names of customers who have never ordered
  customersWhoNeverOrderedNames = CREATE_LIST()

  // Iterate through the Customers to find those not in the orderedCustomerIDs set
  FOR EACH customer IN Customers:
    IF customer.CustomerID IS NOT IN orderedCustomerIDs:
      ADD customer.Name TO customersWhoNeverOrderedNames

  RETURN customersWhoNeverOrderedNames