Practice/Stripe/Account Balance Manager

Account Balance Manager

CodingMust

Problem Overview

You are building an account balance management system for a payment platform. The system processes financial transactions across multiple accounts and needs to handle various business rules around balance validation and fund coverage.

The problem is divided into three progressive parts:

• Balance Aggregation: Process transactions and return final account balances
• Transaction Validation: Reject transactions that would cause negative balances
• Platform Account Coverage: Use a designated platform account to cover insufficient funds

Important Notes

• There are multiple parts to this problem -- ask the interviewer how many parts there are to better manage your time
• Start with the simplest approach and extend it as parts get more complex
• Write your own test cases and ensure your code compiles and runs correctly

Input Format

You will receive a list of transactions, where each transaction is a dictionary with an account_id string and an amount integer (positive for deposits, negative for withdrawals):

transactions = [ {"account_id": "account_A", "amount": 100}, {"account_id": "account_B", "amount": 50}, {"account_id": "account_A", "amount": -30}, {"account_id": "account_B", "amount": -80}, ]

Part 1: Balance Aggregation

Implement a function get_account_balances(transactions) that processes all transactions and returns the final balance for each account that has a positive balance.

Example

` transactions = [ {"account_id": "account_A", "amount": 100}, {"account_id": "account_B", "amount": 50}, {"account_id": "account_A", "amount": -30}, {"account_id": "account_C", "amount": 200}, {"account_id": "account_B", "amount": -50}, ]

get_account_balances(transactions)

Returns: {"account_A": 70, "account_C": 200}

Calculation:

account_A: 100 - 30 = 70 (positive, included)

account_B: 50 - 50 = 0 (zero, excluded)

account_C: 200 (positive, included)

`

Requirements

• Process transactions in order
• Aggregate amounts by account ID
• Return only accounts with balance greater than 0
• Return as a dictionary mapping account_id to balance

Part 2: Transaction Validation

Extend your solution to validate each transaction before processing. A transaction should be rejected if it would cause the account balance to become negative. Return both the final balances and the list of rejected transactions.

Implement process_transactions(transactions) that returns a tuple of (balances, rejected_transactions).

Example

` transactions = [ {"account_id": "account_A", "amount": 100}, {"account_id": "account_A", "amount": -150}, # Would make balance -50 {"account_id": "account_B", "amount": 50}, {"account_id": "account_A", "amount": -80}, # Valid: 100 - 80 = 20 {"account_id": "account_B", "amount": -100}, # Would make balance -50 ]

process_transactions(transactions)

Returns: (

{"account_A": 20, "account_B": 50},

[

{"account_id": "account_A", "amount": -150},

{"account_id": "account_B", "amount": -100},

]

)

Processing:

1. account_A +100 -> balance: 100 ACCEPTED

2. account_A -150 -> would be -50 REJECTED

3. account_B +50 -> balance: 50 ACCEPTED

4. account_A -80 -> balance: 20 ACCEPTED

5. account_B -100 -> would be -50 REJECTED

`

Requirements

• Process transactions in order
• Reject any transaction that would make the account balance negative
• Deposits (positive amounts) are always accepted
• Return rejected transactions in the order they were encountered
• Include accounts with zero balance in the result

Part 3: Platform Account Coverage

The platform can now provide financial assistance. When a transaction would cause a negative balance, instead of rejecting it, the system should transfer funds from a designated platform account to cover the shortfall.

Implement process_with_coverage(transactions, platform_account_id) that returns the total amount of funds transferred from the platform account to cover all shortfalls.

Example

` transactions = [ {"account_id": "platform", "amount": 1000}, {"account_id": "account_A", "amount": 100}, {"account_id": "account_A", "amount": -150}, # Needs 50 coverage {"account_id": "account_B", "amount": 50}, {"account_id": "account_B", "amount": -100}, # Needs 50 coverage {"account_id": "account_A", "amount": -30}, # Needs 30 coverage ]

process_with_coverage(transactions, "platform")

Returns: 130

Processing:

1. platform +1000 -> platform balance: 1000

2. account_A +100 -> account_A balance: 100

3. account_A -150 -> would be -50, cover 50 from platform

account_A balance: 0, platform balance: 950, total_coverage: 50

4. account_B +50 -> account_B balance: 50

5. account_B -100 -> would be -50, cover 50 from platform

account_B balance: 0, platform balance: 900, total_coverage: 100

6. account_A -30 -> would be -30, cover 30 from platform

account_A balance: 0, platform balance: 870, total_coverage: 130

`

Requirements

• Platform account is specified by an additional parameter
• When a transaction would cause negative balance, transfer exactly enough from the platform account to bring balance to zero
• The transaction should still be processed (balance ends at 0)
• Return the total amount of coverage provided
• Assume the platform account always has sufficient funds