Shopping Cart - Problem

You are tasked with implementing a Shopping Cart system that supports the following operations:

add_item(item_id, name, price, quantity) - Add an item to the cart with given details
remove_item(item_id) - Remove an item completely from the cart
update_quantity(item_id, new_quantity) - Update the quantity of an existing item
calculate_total() - Calculate and return the total price of all items in the cart

Your task is to implement the ShoppingCart class and process a series of operations, then return the final total.

Input: An array of operation strings in the format ["operation_type:param1,param2,..."]

Output: The final total price after all operations (rounded to 2 decimal places)

Input & Output

Example 1 — Basic Shopping Cart Operations

$ Input: operations = ["add_item:A001,Apple,2.50,2", "add_item:B002,Bread,3.00,1", "update_quantity:A001,3", "add_item:C003,Milk,4.00,1"]

› Output: 14.50

💡 Note: Add 2 apples ($2.50 each), add 1 bread ($3.00), update apples to 3 total, add 1 milk ($4.00). Total: $2.50×3 + $3.00×1 + $4.00×1 = $14.50

Example 2 — Adding Same Item Multiple Times

$ Input: operations = ["add_item:A001,Apple,2.50,1", "add_item:A001,Apple,2.50,2"]

› Output: 7.50

💡 Note: Add 1 apple, then add 2 more apples with same ID. Total quantity becomes 3. Total: $2.50×3 = $7.50

Example 3 — Remove Item Operation

$ Input: operations = ["add_item:A001,Apple,2.50,2", "add_item:B002,Bread,3.00,1", "remove_item:A001"]

› Output: 3.00

💡 Note: Add apples and bread, then remove all apples. Only bread remains: $3.00×1 = $3.00

Constraints

1 ≤ operations.length ≤ 1000
Item IDs are unique strings
0.01 ≤ price ≤ 1000.00
1 ≤ quantity ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 85 S Shopify 72 e eBay 58 W Walmart 45

The key insight is to use a hash map for O(1) item lookups by ID instead of linear searching through arrays. Best approach uses hash map storage with direct access. Time: O(n), Space: O(m) where n is operations and m is unique items.

Common Approaches

✓ Brute Force with Array Storage

⏱️ Time: O(n × m) Space: O(m)

Use an array to store all cart items. For every operation (add, remove, update), search through the entire array linearly to find the target item by ID.

Hash Map Optimization

⏱️ Time: O(n) Space: O(m)

Store cart items in a hash map keyed by item ID for instant access. Maintain a running total that updates with each operation instead of recalculating every time.

Brute Force with Array Storage — Algorithm Steps

Step 1: Store all items in a simple array/list
Step 2: For each operation, scan entire array to find item by ID
Step 3: Perform the operation (add, remove, update)
Step 4: Calculate total by summing all items

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Items

Keep all cart items in a simple array

Linear Search

For each operation, scan entire array to find target item

Calculate Total

Sum up price × quantity for all items

Code -

solution.c — C

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

struct Item {
    char id[50];
    char name[50];
    double price;
    int quantity;
};

double solution(char operations[][200], int n) {
    struct Item cart[100];
    int cartSize = 0;
    
    for (int i = 0; i < n; i++) {
        char *opType = strtok(operations[i], ":");
        char *params = strtok(NULL, ":");
        
        if (strcmp(opType, "add_item") == 0) {
            char *itemId = strtok(params, ",");
            char *name = strtok(NULL, ",");
            char *priceStr = strtok(NULL, ",");
            char *quantityStr = strtok(NULL, ",");
            
            double price = atof(priceStr);
            int quantity = atoi(quantityStr);
            
            int found = 0;
            for (int j = 0; j < cartSize; j++) {
                if (strcmp(cart[j].id, itemId) == 0) {
                    cart[j].quantity += quantity;
                    found = 1;
                    break;
                }
            }
            if (!found) {
                strcpy(cart[cartSize].id, itemId);
                strcpy(cart[cartSize].name, name);
                cart[cartSize].price = price;
                cart[cartSize].quantity = quantity;
                cartSize++;
            }
        } else if (strcmp(opType, "remove_item") == 0) {
            for (int j = 0; j < cartSize; j++) {
                if (strcmp(cart[j].id, params) == 0) {
                    for (int k = j; k < cartSize - 1; k++) {
                        cart[k] = cart[k + 1];
                    }
                    cartSize--;
                    break;
                }
            }
        } else if (strcmp(opType, "update_quantity") == 0) {
            char *itemId = strtok(params, ",");
            char *quantityStr = strtok(NULL, ",");
            int newQuantity = atoi(quantityStr);
            
            for (int j = 0; j < cartSize; j++) {
                if (strcmp(cart[j].id, itemId) == 0) {
                    cart[j].quantity = newQuantity;
                    break;
                }
            }
        }
    }
    
    double total = 0;
    for (int i = 0; i < cartSize; i++) {
        total += cart[i].price * cart[i].quantity;
    }
    return round(total * 100.0) / 100.0;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for demo
    char operations[50][200];
    int count = 0;
    
    // Extract operations between quotes
    char *ptr = line;
    while ((ptr = strchr(ptr, '"')) != NULL) {
        ptr++;
        char *end = strchr(ptr, '"');
        if (end) {
            int len = end - ptr;
            strncpy(operations[count], ptr, len);
            operations[count][len] = '\0';
            count++;
            ptr = end + 1;
        }
    }
    
    double result = solution(operations, count);
    printf("%.2f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n operations × m items in cart for each linear search

✓ Linear Growth

Space Complexity

O(m)

Array stores up to m items in the cart

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Shopping Cart - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Array Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler