Bank system

import heapq
from bisect import bisect_right


class Bank:
    """Accounts with payments, delayed cashback and balance history.
    Every method takes the time first; times strictly increase across calls."""

    def __init__(self, cashback_percent, cashback_delay):
        self.percent = cashback_percent
        self.delay = cashback_delay
        self.balance = {}            # account -> current balance
        self.history = {}            # account -> [(time, balance after a change)]
        self.pending = []            # heap of (due, seq, account, amount)
        self.payments = 0

    def _record(self, t, acc, delta):
        self.balance[acc] += delta
        self.history[acc].append((t, self.balance[acc]))

    def _process_due(self, now):
        # Runs first in every method: effects due at or before now happen first,
        # each at its own due time, so history stays in time order.
        while self.pending and self.pending[0][0] <= now:
            due, _, acc, amount = heapq.heappop(self.pending)
            self._record(due, acc, amount)

    def open(self, t, acc):
        self._process_due(t)
        if acc in self.balance:
            return False
        self.balance[acc] = 0
        self.history[acc] = [(t, 0)]
        return True

    def deposit(self, t, acc, amount):
        self._process_due(t)
        if acc not in self.balance:
            return None
        self._record(t, acc, amount)
        return self.balance[acc]

    def pay(self, t, acc, amount):
        self._process_due(t)
        if acc not in self.balance or self.balance[acc] < amount:
            return None                                  # validate first, change nothing
        self._record(t, acc, -amount)
        self.payments += 1
        cashback = amount * self.percent // 100          # whole units, rounded down
        if cashback > 0:
            heapq.heappush(self.pending, (t + self.delay, self.payments, acc, cashback))
        return f"p{self.payments}"

    def get_balance(self, t, acc):
        self._process_due(t)
        return self.balance.get(acc)

    def balance_at(self, t, acc, at):
        self._process_due(t)
        entries = self.history.get(acc, [])
        i = bisect_right(entries, (at, float("inf"))) - 1   # last change at or before `at`
        return entries[i][1] if i >= 0 else None

#include <algorithm>
#include <functional>
#include <optional>
#include <queue>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;

// Accounts with payments, delayed cashback and balance history.
// Every method takes the time first; times strictly increase across calls.
class Bank {
    long long percent, delay;
    unordered_map<string, long long> balance;                          // account -> current balance
    unordered_map<string, vector<pair<long long, long long>>> history; // account -> (time, balance after)
    using Due = tuple<long long, long long, string, long long>;        // (due, seq, account, amount)
    priority_queue<Due, vector<Due>, greater<>> pending;
    long long payments = 0;

    void record(long long t, const string& acc, long long delta) {
        balance[acc] += delta;
        history[acc].push_back({t, balance[acc]});
    }

    // Runs first in every method: effects due at or before now happen first,
    // each at its own due time, so history stays in time order.
    void process_due(long long now) {
        while (!pending.empty() && get<0>(pending.top()) <= now) {
            auto [due, seq, acc, amount] = pending.top();
            pending.pop();
            record(due, acc, amount);
        }
    }

public:
    Bank(long long cashback_percent, long long cashback_delay)
        : percent(cashback_percent), delay(cashback_delay) {}

    bool open(long long t, const string& acc) {
        process_due(t);
        if (balance.count(acc)) return false;
        balance[acc] = 0;
        history[acc] = {{t, 0}};
        return true;
    }

    optional<long long> deposit(long long t, const string& acc, long long amount) {
        process_due(t);
        if (!balance.count(acc)) return nullopt;
        record(t, acc, amount);
        return balance[acc];
    }

    optional<string> pay(long long t, const string& acc, long long amount) {
        process_due(t);
        auto it = balance.find(acc);
        if (it == balance.end() || it->second < amount) return nullopt;   // validate first, change nothing
        record(t, acc, -amount);
        payments++;
        long long cashback = amount * percent / 100;                       // whole units, rounded down
        if (cashback > 0) pending.push({t + delay, payments, acc, cashback});
        return "p" + to_string(payments);
    }

    optional<long long> get_balance(long long t, const string& acc) {
        process_due(t);
        auto it = balance.find(acc);
        if (it == balance.end()) return nullopt;
        return it->second;
    }

    optional<long long> balance_at(long long t, const string& acc, long long at) {
        process_due(t);
        auto it = history.find(acc);
        if (it == history.end()) return nullopt;
        auto& entries = it->second;
        // the last change at or before `at`
        auto pos = upper_bound(entries.begin(), entries.end(), at,
                               [](long long x, const pair<long long, long long>& e) { return x < e.first; });
        if (pos == entries.begin()) return nullopt;
        return prev(pos)->second;
    }
};

import java.util.*;

// Accounts with payments, delayed cashback and balance history.
// Every method takes the time first; times strictly increase across calls.
class Bank {
    private record Due(long due, long seq, String account, long amount) {}

    private final long percent, delay;
    private final Map<String, Long> balance = new HashMap<>();             // account -> current balance
    private final Map<String, List<long[]>> history = new HashMap<>();     // account -> {time, balance after}
    private final PriorityQueue<Due> pending = new PriorityQueue<>(
            Comparator.comparingLong(Due::due).thenComparingLong(Due::seq));
    private long payments = 0;

    Bank(long cashbackPercent, long cashbackDelay) {
        this.percent = cashbackPercent;
        this.delay = cashbackDelay;
    }

    private void record(long t, String acc, long delta) {
        long now = balance.merge(acc, delta, Long::sum);
        history.get(acc).add(new long[]{t, now});
    }

    // Runs first in every method: effects due at or before now happen first,
    // each at its own due time, so history stays in time order.
    private void processDue(long now) {
        while (!pending.isEmpty() && pending.peek().due() <= now) {
            Due d = pending.poll();
            record(d.due(), d.account(), d.amount());
        }
    }

    boolean open(long t, String acc) {
        processDue(t);
        if (balance.containsKey(acc)) return false;
        balance.put(acc, 0L);
        history.put(acc, new ArrayList<>(List.of(new long[]{t, 0})));
        return true;
    }

    Long deposit(long t, String acc, long amount) {
        processDue(t);
        if (!balance.containsKey(acc)) return null;
        record(t, acc, amount);
        return balance.get(acc);
    }

    String pay(long t, String acc, long amount) {
        processDue(t);
        Long current = balance.get(acc);
        if (current == null || current < amount) return null;     // validate first, change nothing
        record(t, acc, -amount);
        payments++;
        long cashback = amount * percent / 100;                   // whole units, rounded down
        if (cashback > 0) pending.add(new Due(t + delay, payments, acc, cashback));
        return "p" + payments;
    }

    Long getBalance(long t, String acc) {
        processDue(t);
        return balance.get(acc);
    }

    Long balanceAt(long t, String acc, long at) {
        processDue(t);
        List<long[]> entries = history.get(acc);
        if (entries == null) return null;
        int lo = 0, hi = entries.size();                          // the last change at or before `at`
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (entries.get(mid)[0] <= at) lo = mid + 1;
            else hi = mid;
        }
        return lo == 0 ? null : entries.get(lo - 1)[1];
    }
}