Asked in: CITYBANK
Image of the Question
All Testcases Passed ✔
Solution
import heapq
def solution(balances, requests):
balances = [0]+balances[::]
timeaddition = 24*60*60
// ... rest of solution available after purchaseExplanation
```
To solve this problem, start by carefully understanding the sequence of events and constraints involved in processing requests on bank accounts.
---
Step 1: Understand the Problem Setting
You have a list of initial balances, where each index corresponds to a unique account (1-based indexing). You then receive a sequence of timestamped requests, strictly ordered by time, which are either deposits or withdrawals on specific accounts.
Key rules:
- Deposit requests add money immediately to the account.
- Withdrawal requests subtract money immediately if the account has sufficient balance; otherwise, they are invalid.
- Withdrawals also generate a cashback of 2% of the withdrawn amount (rounded down), credited exactly 24 hours (86400 seconds) after the withdrawal timestamp.
- If a cashback and a deposit/withdrawal happen at the same timestamp, cashback is processed first.
Invalid requests occur if:
- The account number does not exist.
- A withdrawal is requested for more money than is available.
If an invalid request is encountered, processing stops immediately and the output is [-request_id], where request_id is the 1-based index of the invalid request.
If all requests are valid, output the balances immediately after processing the last request, ignoring any cashback that would occur after that time.
---
Step 2: Data Structures and Event Handling
Since cashback happens 24 hours after a withdrawal, you need a mechanism to schedule these future cashback deposits.
One way to do this is to maintain a priority queue or a sorted structure keyed by cashback timestamps. Before processing each incoming request at timestamp T, first process all pending cashback events scheduled at timestamps ≤ T, applying them to their respective accounts.
Remember that cashback happens before any other event at the same timestamp, so if a cashback and a request share the same timestamp, apply cashback first.
---
Step 3: Processing the Requests Sequentially
Iterate over the requests in order:
- Before processing the current request, process all cashback events with timestamps ≤ current request timestamp. For each, add the cashback amount to the relevant account balance.
- Parse the current request, extract the type (deposit/withdraw), timestamp, account id, and amount.
- Validate the account id (must be between 1 and the number of accounts).
- For deposits, simply add the amount to the account balance.
- For withdrawals, check if the balance in the account is sufficient; if not, return an invalid request result immediately. If sufficient, subtract the amount from the balance, and schedule a cashback event at timestamp + 86400 seconds. The cashback amount is floor(2% of withdrawn amount).
---
Step 4: Handling Cashback Events
To efficiently process cashback events:
- Keep cashback events sorted by timestamp, or use a priority queue (min-heap) to quickly access the earliest pending cashback.
- Before each request processing, pop all cashback events with timestamps ≤ current request timestamp, and apply them.
- After processing all requests, no cashback after the last request timestamp is applied, so ignore them.
---
Step 5: Corner Cases and Edge Conditions
- Requests must be processed strictly in the order they appear because timestamps are strictly increasing.
- When a cashback and a request share the same timestamp, cashback must be applied first before processing the request.
- Be careful with rounding down the cashback amount.
- Invalid account numbers can appear anytime.
- If a withdrawal is invalid, immediately stop processing further requests and output the negative index.
---
Step 6: Final Output
If all requests are valid, return the final balances immediately after processing the last request, ignoring cashback that has not yet happened.
If an invalid request was encountered, return the negative index of that request (1-based).
---
Step 7: Summary of Approach
- Use a data structure to keep track of scheduled cashback events (timestamp, account, amount).
- Iterate through requests in order; before each, process all applicable cashback events.
- Validate accounts and balances at each request.
- Schedule cashback for withdrawals.
- Stop immediately on invalid request and return appropriate output.
- After processing all requests, output current balances.
This approach ensures the problem's temporal dependencies are respected and invalid requests are detected early, with cashback timing handled precisely.
```