The Users That Are Eligible for Discount - Practice Coding Problems

The Users That Are Eligible for Discount - Problem

Database Easy

Identify Discount-Eligible Users

You're working for an e-commerce platform that wants to reward loyal customers with discounts. Given a database of user purchases, your task is to find all users who made at least one purchase within a specific time window with a minimum spending threshold.

You have access to a Purchases table with the following structure:

Column Name	Type
user_id	int
time_stamp	datetime
amount	int

Eligibility Criteria:
A user qualifies for a discount if they made at least one purchase during the inclusive time period [startDate, endDate] where the purchase amount was at least minAmount.

Important: Dates should be treated as the start of the day (e.g., '2022-03-05' means '2022-03-05 00:00:00').

Goal: Return the user IDs of all eligible users, sorted in ascending order.

Input & Output

example_1.sql — Basic Eligibility Check

$ Input: Purchases = [[1,'2022-04-20',500],[2,'2022-03-15',300],[1,'2022-05-01',200],[3,'2022-04-25',600]] startDate = '2022-04-01', endDate = '2022-04-30', minAmount = 400

› Output: [1, 3]

💡 Note: User 1 has a purchase on 2022-04-20 with amount 500 (≥400). User 3 has a purchase on 2022-04-25 with amount 600 (≥400). User 2's purchase is outside the date range.

example_2.sql — No Eligible Users

$ Input: Purchases = [[1,'2022-03-10',100],[2,'2022-03-15',200]] startDate = '2022-04-01', endDate = '2022-04-30', minAmount = 300

› Output: []

💡 Note: No purchases fall within the specified date range, so no users are eligible for discount.

example_3.sql — Multiple Purchases Same User

$ Input: Purchases = [[1,'2022-04-10',100],[1,'2022-04-15',500],[1,'2022-04-20',200]] startDate = '2022-04-01', endDate = '2022-04-30', minAmount = 400

› Output: [1]

💡 Note: User 1 appears multiple times but only needs one qualifying purchase (500 on 2022-04-15) to be eligible.

Constraints

1 ≤ purchases.length ≤ 10⁴
1 ≤ user_id ≤ 1000
1 ≤ amount ≤ 10⁶
time_stamp format: 'YYYY-MM-DD'
startDate ≤ endDate

Visualization

Tap to expand

Understanding the Visualization

Receive Purchase Records

Start with all purchase transactions from the database

Apply Date Filter

Check if purchase timestamp falls within [startDate, endDate]

Apply Amount Filter

Verify that purchase amount meets minimum threshold

Collect Eligible Users

Add qualifying users to our discount-eligible list

Return Sorted Results

Output unique user IDs in ascending order

Key Takeaway

🎯 Key Insight: We only need to find ONE qualifying purchase per user to mark them as eligible - this allows us to use a Set data structure to automatically handle duplicates while scanning through the data just once!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

This is a database filtering problem that can be solved efficiently with a single pass approach. The key insight is to scan through all purchase records once, applying the date range and minimum amount filters simultaneously, then collect unique eligible user IDs. The optimal solution has O(n) time complexity where n is the number of purchase records.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force SQL Query	O(n)	O(k)	Check each purchase record individually against all criteria

Brute Force SQL Query — Algorithm Steps

Scan every row in the Purchases table
For each row, check if time_stamp is within [startDate, endDate]
Check if amount >= minAmount
If both conditions are met, include the user_id
Remove duplicates and sort the results

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan All Records

Go through each purchase record in the table

Apply Filters

Check date range and minimum amount criteria

Collect Eligible Users

Add qualifying users to result set

Remove Duplicates

Ensure each user appears only once

Sort Results

Sort user IDs in ascending order

Code -

solution.c — C

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

typedef struct {
    int user_id;
    char time_stamp[20];
    int amount;
} Purchase;

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* solution(Purchase* purchases, int n, char* start_date, char* end_date, int min_amount, int* return_size) {
    int* eligible = (int*)malloc(n * sizeof(int));
    int unique[1000] = {0}; // Assuming user_ids < 1000
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        if (strcmp(purchases[i].time_stamp, start_date) >= 0 &&
            strcmp(purchases[i].time_stamp, end_date) <= 0 &&
            purchases[i].amount >= min_amount) {
            
            if (!unique[purchases[i].user_id]) {
                unique[purchases[i].user_id] = 1;
                eligible[count++] = purchases[i].user_id;
            }
        }
    }
    
    qsort(eligible, count, sizeof(int), compare);
    *return_size = count;
    return eligible;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all purchase records

✓ Linear Growth

Space Complexity

O(k)

Space for storing distinct eligible user IDs (k <= n)

✓ Linear Space

38.2K Views

Medium Frequency

~15 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force SQL Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler