Implement a Transactional In-Memory Table

Question

The question asks the candidate to implement a simplified transactional in-memory table with specific operations for managing rows and cells.

Codemia · Accepted Answer

To implement a transactional in-memory table, we need to support the following operations: creating and deleting rows, updating cells, finding and replacing values, displaying the table, and managing transactions with begin and commit functionalities.

We can represent the table using a nested dictionary structure in Python, where the outer dictionary maps row names to inner dictionaries that map column names to their respective values. This allows for efficient access and modification of cells. Additionally, we will need a mechanism to track changes made during a transaction.

Here is a basic implementation of the required functionalities:

```python
class TransactionalTable:
    def __init__(self):
        self.table = {}
        self.transaction_log = []
        self.in_transaction = False

def createRow(self, rowName):
        self.table[rowName] = {}

def deleteRow(self, rowName):
        if rowName in self.table:
            del self.table[rowName]

def updateCell(self, rowName, columnName, newVal):
        if rowName in self.table:
            self.table[rowName][columnName] = newVal
            if self.in_transaction:
                self.transaction_log.append((rowName, columnName, newVal))

def findAndReplace(self, findString, replaceString):
        for row in self.table.values():
            for col in row:
                if row[col] == findString:
                    row[col] = replaceString
                    if self.in_transaction:
                        self.transaction_log.append((row, col, replaceString))

def showTable(self):
        return self.table

def beginTransaction(self):
        self.in_transaction = True
        self.transaction_log = []

def commitTransaction(self):
        self.in_transaction = False
        self.transaction_log = []
```

This implementation provides the basic functionality required for the transactional in-memory table.

This design is simple and effective for small to medium-sized datasets. However, as the size of the table grows, performance may degrade, particularly for operations like findAndReplace. To scale this design, we could consider implementing indexing or using more advanced data structures to optimize search operations.

Implement a Transactional In-Memory Table

Addepar

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Requirements

High-Level Design

Submit Your Answer

Addepar Software Engineer Interview Guide

Related Questions

Binary Search on graph

Count kth largest element in array

Find connected components in string

Merge Three Sorted strings

Binary Search on string