Implement banking, knapsack, and pagination tasks

Problem A — Banking system command processor

Implement an in-memory banking system that processes a sequence of commands in timestamp order.

Entities

• Account identified by a unique string accountId .
• Balance is a non-negative integer amount.

Commands (examples shown; you may define an equivalent input format)

1. CREATE accountId
   • Create a new account with balance 0.
   • If the account already exists, the command should be handled deterministically (e.g., ignore or error).
2. DEPOSIT accountId amount
   • Add amount to the account.
3. TRANSFER fromId toId amount
   • Move funds from fromId to toId if sufficient funds exist.
4. TOP_SPENDERS k
   • Return the top k accounts ranked by total outgoing spend (e.g., sum of successful TRANSFER amounts sent by the account). Define deterministic tie-breaking (e.g., by accountId ).
5. SCHEDULE_PAYMENT fromId toId amount executeAt
   • Schedule a delayed transfer to run at time executeAt .
   • Scheduled payments should execute automatically at/after their scheduled time when processing later commands.
6. CANCEL_PAYMENT paymentId
   • Cancel a previously scheduled payment if it has not executed.
7. MERGE targetId sourceId
   • Merge sourceId into targetId :
     • targetId receives sourceId ’s remaining balance.
     • Define what happens to scheduled payments involving sourceId (e.g., re-point to targetId , or cancel), and ensure the behavior is consistent.
8. BALANCE accountId
   • Output the current balance.

Output

Return outputs for query-like commands (e.g., TOP_SPENDERS, BALANCE, possibly errors) in the order encountered.

Notes / constraints

• Assume up to large numbers of commands; aim for efficient data structures.
• Clearly define edge-case behavior (invalid accounts, negative amounts, cancel-after-execute, merge semantics, etc.).

Problem B — Max-fee transaction packing (0/1 knapsack)

You are given N transactions, each with:

• id (unique identifier)
• size (positive integer)
• fee (non-negative integer)

You have a fixed block size limit of 100 (i.e., total size of chosen transactions must be <= 100).

Task

Choose a subset of transactions to maximize total fee.

Output

• Return the maximum achievable total fee.
• If required, also return one optimal chosen set of id s with a deterministic tie-break rule (e.g., smallest number of transactions; then lexicographically smallest list of ids).

Problem C — Design and implement a pagination utility

Design an interface and implement a pagination helper over an in-memory collection.

Requirements

• Input: a list/array of items (you can assume strings or objects with id ).
• Support pageSize and returning items page-by-page.
• Your design should specify function/class signatures (e.g., getPage(pageNumber) , or cursor-based next(cursor) returning (items, nextCursor) ), including inputs/outputs.

Constraints / considerations

• Handle edge cases (empty list, last page, invalid page token).
• Discuss tradeoffs between offset-based pagination and cursor-based pagination.
• If you choose cursor-based pagination, define how the cursor is generated and validated.