Invalid Transactions

Invalid Transactions - Problem

A transaction is possibly invalid if:

The amount exceeds $1000, or
It occurs within (and including) 60 minutes of another transaction with the same name in a different city

You are given an array of strings transactions where transactions[i] consists of comma-separated values representing the name, time (in minutes), amount, and city of the transaction.

Return a list of transactions that are possibly invalid. You may return the answer in any order.

Input & Output

Example 1 — Basic Invalid Transactions

$ Input: transactions = ["alice,20,800,mtv","alice,50,100,beijing"]

› Output: ["alice,20,800,mtv","alice,50,100,beijing"]

💡 Note: Both transactions are invalid: alice made transactions in different cities (mtv vs beijing) within 60 minutes (time difference = 30 minutes ≤ 60)

Example 2 — Amount Limit Violation

$ Input: transactions = ["alice,20,800,mtv","alice,50,1200,beijing"]

› Output: ["alice,20,800,mtv","alice,50,1200,beijing"]

💡 Note: alice,50,1200,beijing is invalid due to amount > $1000. alice,20,800,mtv is invalid due to location conflict within 60 minutes

Example 3 — Valid Transactions

$ Input: transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]

› Output: ["bob,50,1200,mtv"]

💡 Note: alice's transaction is valid (amount ≤ 1000, no conflicts). bob's transaction is invalid due to amount > $1000

Constraints

transactions.length == n
1 ≤ n ≤ 1000
Each transactions[i] takes the form "{name},{time},{amount},{city}"
Each {name} and {city} consist of lowercase English letters, and have lengths between 1 and 10
Each {time} is given as integers between 0 and 1000
Each {amount} is given as integers between 0 and 2000

Visualization

Tap to expand

Asked in

a Amazon 12 G Google 8 M Microsoft 6 f Facebook 4

The key insight is to check two violation conditions: amount exceeding $1000 and same person in different cities within 60 minutes. Best approach uses hash map grouping to organize transactions by person name first. Time: O(n²), Space: O(n)

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Binary Search Answer

⏱️ Time: N/A Space: N/A

Brute Force - Compare All Pairs

⏱️ Time: O(n²) Space: O(1)

For each transaction, check if amount > 1000 or if there exists another transaction with same name, different city, and within 60 minutes. Compare every pair of transactions.

Hash Map - Group by Name

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

Use a hash map to group transactions by person name. For each group, check amount limits and time/location conflicts more efficiently by avoiding unnecessary comparisons between different people.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    long long la = *(long long*)a;
    long long lb = *(long long*)b;
    return (la > lb) - (la < lb);
}

long long solution(int* coins, int coinsSize, int k) {
    if (coinsSize == 0) return 0;
    
    long long* amounts = malloc(k * 1000 * sizeof(long long));
    int count = 0;
    
    int maxCoin = coins[0];
    for (int i = 1; i < coinsSize; i++) {
        if (coins[i] > maxCoin) maxCoin = coins[i];
    }
    long long limit = (long long)k * maxCoin * 2;
    
    for (int i = 0; i < coinsSize; i++) {
        long long multiple = coins[i];
        while (multiple <= limit && count < k * 1000 - 1) {
            amounts[count++] = multiple;
            multiple += coins[i];
        }
    }
    
    qsort(amounts, count, sizeof(long long), compare);
    
    // Remove duplicates
    int uniqueCount = 0;
    if (count > 0) {
        amounts[0] = amounts[0];
        uniqueCount = 1;
        for (int i = 1; i < count; i++) {
            if (amounts[i] != amounts[uniqueCount-1]) {
                amounts[uniqueCount++] = amounts[i];
            }
        }
    }
    
    long long result = amounts[k-1];
    free(amounts);
    return result;
}

int main() {
    int coins[1000];
    int coinsSize = 0;
    int k;
    
    char line[10000];
    if (fgets(line, sizeof(line), stdin) != NULL) {
        char* ptr = strchr(line, '[');
        if (ptr) {
            ptr++; // Skip [
            char* end = strchr(ptr, ']');
            if (end) *end = '\0';
            
            char* token = strtok(ptr, ",");
            while (token && coinsSize < 1000) {
                while (*token == ' ') token++; // Skip spaces
                if (*token != '\0') {
                    coins[coinsSize++] = atoi(token);
                }
                token = strtok(NULL, ",");
            }
        }
    }
    
    scanf("%d", &k);
    
    printf("%lld\n", solution(coins, coinsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 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