Product, Cart, Order classes in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identify the primary responsibility of the Order class

In a simple e-commerce system, what is the main responsibility of the Order class?

A Store details about a completed purchase including products, quantities, and payment status

B Calculate discounts and promotions for products in the cart

C Handle adding and removing products before checkout

D Manage the list of products a user wants to buy and their quantities

💡 Hint

Think about what happens after a user completes their purchase.

The Order class represents a finalized purchase. It stores the products bought, their quantities, and payment or shipping status. The Cart manages products before purchase.

❓ Architecture

intermediate

Choose the best class to calculate total price

Which class should be responsible for calculating the total price of all products including quantities and discounts?

A Product class, because it knows the price of each item

B Order class, because it represents the finalized purchase

C Cart class, because it holds all products and their quantities before purchase

D A separate PricingService class, to keep pricing logic outside data classes

💡 Hint

Consider where the products and quantities are managed before checkout.

The Cart class holds products and quantities before purchase, so it is best placed to calculate the total price including discounts. Product only knows single item price, Order is finalized, and PricingService is optional.

❓ scaling

advanced

Scaling the Cart for many users simultaneously

When many users add products to their carts at the same time, which design approach best ensures performance and data consistency?

A Store carts only in the database and query on every user action

B Use a global lock to allow only one cart update at a time

C Store all carts in a single shared database table with row-level locking

D Keep each user's cart in a separate in-memory cache instance with periodic database sync

💡 Hint

Think about fast access and avoiding bottlenecks for many users.

Using in-memory cache per user reduces database load and improves speed. Periodic sync ensures data persistence. Single table locking or global locks cause bottlenecks. Querying DB on every action is slow.

❓ tradeoff

advanced

Tradeoff between storing product details in Cart vs referencing Product IDs

What is a key tradeoff when the Cart stores full product details versus only product IDs with quantities?

A Storing full details increases data duplication but allows faster access without extra queries

B Storing only IDs causes data duplication but reduces database queries

C Storing full details reduces memory usage but requires more network calls

D Storing only IDs increases data duplication and slows down price calculations

💡 Hint

Consider data duplication and access speed.

Storing full product details in Cart duplicates data but avoids extra lookups, improving speed. Storing only IDs saves space but requires fetching product info separately.

❓ component

expert

Estimate capacity for Order processing system

Your e-commerce system expects 10,000 orders per minute at peak. Each order has on average 5 products. Estimate the minimum number of database writes per second needed to store orders and order items.

A Approximately 50,000 writes per second

B Approximately 3,000 writes per second

C Approximately 833 writes per second

D Approximately 10,000 writes per second

💡 Hint

Calculate total writes considering one write per order and one per product item.

10,000 orders/min ≈ 167 orders/sec. Each order: 1 write (order) + 5 writes (items) ≈ 1,000 writes/sec base. With overhead (logs, updates, etc.), approximately 3,000 writes/sec. Closest is C.

Practice

1. Which class is responsible for storing the details like product ID, name, and price?

easy

A. Product class

B. Cart class

C. Order class

D. User class

Solution

1. Step 1: Understand the role of Product class

   The Product class stores item details such as ID, name, and price.

2. Step 2: Compare with other classes

   The Cart class holds selected products and quantities, and Order class records purchased items and status, not product details.

3. Final Answer:

   Product class -> Option A

4. Quick Check:

   Product details = Product class [OK]

Hint: Product details belong to Product class only [OK]

Common Mistakes:

• Confusing Cart with Product class
• Thinking Order stores product details
• Assuming User class stores product info

2. Which of the following is the correct way to add a product to a cart in a typical class design?

easy

A. order.addProduct(product, quantity)

B. product.addToCart(cart, quantity)

C. cart.addProduct(product, quantity)

D. cart.createOrder(product, quantity)

Solution

1. Step 1: Identify the class responsible for holding selected products

   The Cart class holds selected products and their quantities before purchase.

2. Step 2: Check method naming conventions

   Adding a product to a cart is typically done by calling a method on the Cart object, like addProduct(product, quantity).

3. Final Answer:

   cart.addProduct(product, quantity) -> Option C

4. Quick Check:

   Adding product to cart = cart.addProduct() [OK]

Hint: Add products via Cart methods, not Product or Order [OK]

Common Mistakes:

• Calling addToCart on Product class
• Using Order class to add products before purchase
• Confusing method names like createOrder in Cart

3. Given the following code snippet, what will be the total cost stored in the Order after checkout?

product1 = Product(id=1, name='Pen', price=2)
product2 = Product(id=2, name='Notebook', price=5)
cart = Cart()
cart.addProduct(product1, 3)
cart.addProduct(product2, 2)
order = Order(cart)
order.checkout()

medium

A. 16

B. 19

C. 10

D. 7

Solution

1. Step 1: Calculate total cost from cart products and quantities

   Pen price = 2, quantity = 3 -> 2 * 3 = 6
   Notebook price = 5, quantity = 2 -> 5 * 2 = 10
   Total = 6 + 10 = 16

2. Step 2: Check if any additional charges or taxes apply

   No extra charges mentioned, so total cost should be 16.

3. Final Answer:

   16 -> Option A

4. Quick Check:

   2*3 + 5*2 = 16 [OK]

Hint: Multiply price by quantity, then sum all products [OK]

Common Mistakes:

• Adding quantities instead of multiplying by price
• Mixing product prices and quantities incorrectly
• Ignoring one product's cost

4. Identify the error in this Order class method that calculates total cost:

class Order:
    def __init__(self, cart):
        self.cart = cart
        self.total = 0
    def calculate_total(self):
        for product, qty in self.cart.items():
            self.total += product.price * qty
        return self.total

medium

A. Returning total instead of printing it

B. Using self.cart.items() instead of self.cart.products.items()

C. Multiplying price by quantity incorrectly

D. Not resetting self.total before calculation

Solution

1. Step 1: Analyze total calculation logic

   The method adds product price times quantity to self.total in a loop.

2. Step 2: Check for accumulation errors

   Since self.total is not reset before calculation, repeated calls will add to previous total, causing incorrect sums.

3. Final Answer:

   Not resetting self.total before calculation -> Option D

4. Quick Check:

   Reset total before sum to avoid accumulation [OK]

Hint: Reset totals before summing to avoid repeated addition errors [OK]

Common Mistakes:

• Assuming cart.items() is invalid without context
• Thinking multiplication is wrong when it is correct
• Confusing return with print for output

5. You want to design a system where a Cart can hold multiple Products with quantities, and an Order records the purchased items and status. Which design choice best supports scalability and clear responsibility?

hard

A. Make Cart store product IDs only; Order stores full product details and quantities

B. Make Cart hold Product objects with quantities; Order copies Cart items and tracks status separately

C. Make Product class hold quantity and add methods to update Cart and Order directly

D. Make Order class inherit from Cart and add status and total cost fields

Solution

1. Step 1: Understand separation of concerns

   Cart should hold selected products and quantities before purchase. Order should record purchased items and status separately.

2. Step 2: Evaluate design options for scalability and clarity

   Make Cart hold Product objects with quantities; Order copies Cart items and tracks status separately keeps Cart holding Product objects with quantities, and Order copies these items to keep a snapshot and track status, which is clean and scalable.

3. Final Answer:

   Make Cart hold Product objects with quantities; Order copies Cart items and tracks status separately -> Option B

4. Quick Check:

   Separate Cart and Order responsibilities for scalability [OK]

Hint: Keep Cart and Order responsibilities separate and clear [OK]

Common Mistakes:

• Making Order inherit Cart causing tight coupling
• Storing only product IDs in Cart losing details
• Putting quantity in Product class mixing concerns