Transaction history in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the transaction list.

LLD

class TransactionHistory:
    def __init__(self):
        self.transactions = [1]

Drag options to blanks, or click blank then click option'

ANone

B{}

C[]

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using a dictionary {} instead of a list.

Initializing with None or 0.

We use an empty list [] to store transactions in order.

2fill in blank

medium

Complete the code to add a transaction to the history.

LLD

def add_transaction(self, transaction):
    self.transactions.[1](transaction)

Drag options to blanks, or click blank then click option'

Ainsert

Bappend

Cremove

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using remove or pop which delete items.

Using insert without specifying index.

We use append to add a new transaction at the end of the list.

3fill in blank

hard

Fix the error in the method to get the last transaction.

LLD

def get_last_transaction(self):
    if not self.transactions:
        return None
    return self.transactions[[1]]

Drag options to blanks, or click blank then click option'

A-1

B0

C1

Dlen(self.transactions)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 returns the first transaction.

Using len(self.transactions) causes index error.

Index -1 accesses the last item in a list in Python.

4fill in blank

hard

Fill both blanks to filter transactions by minimum amount.

LLD

def filter_transactions(self, min_amount):
    return [t for t in self.transactions if t.[1] >= [2]]

Drag options to blanks, or click blank then click option'

Aamount

Bmin_amount

Cdate

Dstatus

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing wrong attributes like date or status.

Using wrong variable names.

We compare each transaction's amount to the min_amount parameter.

5fill in blank

hard

Fill all three blanks to create a dictionary of transaction IDs to amounts for completed transactions.

LLD

def get_completed_transactions(self):
    return {t.[1]: t.[2] for t in self.transactions if t.[3] == 'completed'}

Drag options to blanks, or click blank then click option'

Atransaction_id

Bamount

Cstatus

Ddate

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong keys or values in the dictionary.

Filtering by wrong attributes.

We map each transaction's transaction_id to its amount only if its status is 'completed'.

Practice

1. What is the main purpose of a transaction history in a system?

easy

A. To record all important actions with details for tracking

B. To speed up the system by caching data

C. To delete old data automatically

D. To encrypt user passwords

Solution

1. Step 1: Understand the role of transaction history

   Transaction history stores records of actions with details like timestamps and IDs.

2. Step 2: Identify the correct purpose

   This helps users and systems track past events clearly and reliably.

3. Final Answer:

   To record all important actions with details for tracking -> Option A

4. Quick Check:

   Transaction history purpose = record actions [OK]

Hint: Transaction history = record actions with details [OK]

Common Mistakes:

• Confusing transaction history with caching
• Thinking it deletes data automatically
• Mixing it with security features like encryption

2. Which of the following is the correct way to uniquely identify each transaction in a history system?

easy

A. Using a timestamp only

B. Using a unique transaction ID

C. Using the user's name

D. Using the transaction amount

Solution

1. Step 1: Identify unique identifiers in transaction history

   Unique transaction IDs ensure each record is distinct and traceable.

2. Step 2: Compare options

   Timestamps alone can repeat; user names and amounts are not unique identifiers.

3. Final Answer:

   Using a unique transaction ID -> Option B

4. Quick Check:

   Unique ID = unique transaction record [OK]

Hint: Unique transaction ID ensures distinct records [OK]

Common Mistakes:

• Assuming timestamp alone is unique
• Using user name as unique key
• Using transaction amount as identifier

3. Given this simplified transaction record list:

transactions = [
  {"id": "t1", "time": "2024-01-01T10:00:00Z"},
  {"id": "t2", "time": "2024-01-01T09:00:00Z"},
  {"id": "t3", "time": "2024-01-01T11:00:00Z"}
]

What is the correct order of transaction IDs if sorted by time ascending?

medium

A. ["t1", "t2", "t3"]

B. ["t2", "t3", "t1"]

C. ["t3", "t1", "t2"]

D. ["t2", "t1", "t3"]

Solution

1. Step 1: Analyze timestamps for each transaction

   t2 = 09:00, t1 = 10:00, t3 = 11:00 in UTC time.

2. Step 2: Sort transactions by ascending time

   Order is t2 (earliest), then t1, then t3 (latest).

3. Final Answer:

   ["t2", "t1", "t3"] -> Option D

4. Quick Check:

   Sorted by time ascending = [t2, t1, t3] [OK]

Hint: Sort by timestamp ascending for correct order [OK]

Common Mistakes:

• Sorting by ID instead of time
• Confusing ascending with descending order
• Ignoring timestamp format

4. You have this code snippet to add a transaction record:

def add_transaction(history, transaction):
    if transaction['id'] not in [t['id'] for t in history]:
        history.append(transaction)
    else:
        print("Duplicate transaction")

history = [{"id": "t1"}]
add_transaction(history, {"id": "t1"})

What is the output when running this code?

medium

A. Duplicate transaction

B. KeyError exception

C. No output, transaction added

D. TypeError exception

Solution

1. Step 1: Check if transaction ID exists in history

   The code checks if 't1' is already in the list of IDs in history.

2. Step 2: Since 't1' exists, print duplicate message

   The else branch runs and prints "Duplicate transaction".

3. Final Answer:

   Duplicate transaction -> Option A

4. Quick Check:

   Duplicate ID detected = print message [OK]

Hint: Check for existing ID before adding to avoid duplicates [OK]

Common Mistakes:

• Assuming transaction is added anyway
• Expecting an exception instead of print
• Confusing list comprehension syntax

5. You want to design a scalable transaction history system for millions of users. Which approach best ensures fast retrieval of a user's transactions sorted by time?

hard

A. Store transactions in separate files per day without indexing

B. Store all transactions in one big list and scan it every time

C. Use a database with an index on user ID and timestamp

D. Keep transactions only in memory without persistence

Solution

1. Step 1: Consider scalability and retrieval speed

   Scanning one big list or files without index is slow for millions of users.

2. Step 2: Use database indexing on user ID and timestamp

   This allows fast queries to get transactions per user sorted by time efficiently.

3. Step 3: Avoid in-memory only storage for persistence and scale

   Memory-only storage risks data loss and limits scale.

4. Final Answer:

   Use a database with an index on user ID and timestamp -> Option C

5. Quick Check:

   Indexing = fast retrieval at scale [OK]

Hint: Index on user ID and timestamp for fast queries [OK]

Common Mistakes:

• Scanning large lists for each query
• Ignoring indexing benefits
• Relying on memory-only storage