Invalid Transactions

You're given a list of card transactions. Each one is a string "name,time,amount,city": the person's name, the time in minutes, the amount, and the city where it happened.

A transaction is suspicious if either of these is true:

• its amount is greater than 1000, or
• the same person made another transaction in a different city at most 60 minutes before or after it (the gap |t1 - t2| ≤ 60).

Both transactions in a too-close pair are suspicious. Return every suspicious transaction string, in any order. If the same string appears twice in the input and is suspicious, include it twice.

The amount rule is a check on one record at a time. The city rule is the interesting one: it only ever compares transactions that share a name. So parse every string once into (name, time, amount, city, index), group by name, and only compare inside each group.

Track suspicion by index, not by string, so a transaction is reported once even if it fails both rules, and duplicate strings are each reported. With n at most 1000, comparing every pair inside a group is fast enough. If you want better, sort each group by time and only look at neighbours within the 60-minute window.

from collections import defaultdict


def invalid_transactions(transactions: list[str]) -> list[str]:
    parsed = []
    for t in transactions:
        name, time, amount, city = t.split(",")
        parsed.append((name, int(time), int(amount), city))

    bad = [amount > 1000 for _, _, amount, _ in parsed]
    by_name = defaultdict(list)
    for i, (name, _, _, _) in enumerate(parsed):
        by_name[name].append(i)

    for group in by_name.values():
        for a in range(len(group)):
            i = group[a]
            for b in range(a + 1, len(group)):
                j = group[b]
                if parsed[i][3] != parsed[j][3] and abs(parsed[i][1] - parsed[j][1]) <= 60:
                    bad[i] = bad[j] = True

    return [t for t, flag in zip(transactions, bad) if flag]

function invalidTransactions(transactions) {
  const parsed = transactions.map((t) => {
    const [name, time, amount, city] = t.split(',');
    return { name, time: Number(time), amount: Number(amount), city };
  });

  const bad = parsed.map((p) => p.amount > 1000);
  const byName = new Map();
  parsed.forEach((p, i) => {
    if (!byName.has(p.name)) byName.set(p.name, []);
    byName.get(p.name).push(i);
  });

  for (const group of byName.values()) {
    for (let a = 0; a < group.length; a++) {
      const i = group[a];
      for (let b = a + 1; b < group.length; b++) {
        const j = group[b];
        if (parsed[i].city !== parsed[j].city && Math.abs(parsed[i].time - parsed[j].time) <= 60) {
          bad[i] = bad[j] = true;
        }
      }
    }
  }

  return transactions.filter((_, i) => bad[i]);
}

Clarify the rules before coding: is the window inclusive, are both members of a pair invalid, and should duplicates be reported twice. Interviewers use this problem to see whether you read requirements carefully, so asking is a plus.

Then structure the code: one parse step, one boolean array of "invalid" flags indexed by position, and a final pass that maps flags back to strings. Saying "I mark by index so each transaction is reported exactly once" shows you have thought about the double-counting trap.