Implement a Transactional Parcel-Tracking Store

Question

The question asks the candidate to implement a transactional parcel-tracking system based on a given class structure, progressing through multiple levels of functionality.

Codemia · Accepted Answer

To implement the transactional parcel-tracking system, I will first analyze the requirements for each level of functionality. I will start with Level 1, which focuses on counting parcel events, and build the solution incrementally. This will allow me to ensure that each part of the system is functioning correctly before moving on to the next level.

The core of the implementation will involve creating classes to represent parcels and their events. I will maintain a dictionary to track the count of events for each parcel. The basic structure will include:

- A `Parcel` class with attributes for parcel ID and event count.
- A method to add events to the parcel.
- A method to retrieve the event count.

Here is a simplified version of the code:

```python
class Parcel:
    def __init__(self, parcel_id):
        self.parcel_id = parcel_id
        self.event_count = 0

def add_event(self):
        self.event_count += 1

def get_event_count(self):
        return self.event_count
```

This code initializes a parcel and allows for event counting.

The time complexity for adding an event is O(1) since it involves a simple increment operation. The space complexity is also O(1) for each parcel instance, as we only store the parcel ID and the event count. As more parcels are added, the overall space complexity will grow linearly with the number of parcels.

To ensure the implementation is robust, I will write unit tests for each method in the `Parcel` class. This will include tests for adding events and retrieving counts. For example:

```python
import unittest

class TestParcel(unittest.TestCase):
    def test_event_count(self):
        parcel = Parcel('123')
        parcel.add_event()
        self.assertEqual(parcel.get_event_count(), 1)
        parcel.add_event()
        self.assertEqual(parcel.get_event_count(), 2)

if __name__ == '__main__':
    unittest.main()
```

These tests will validate the functionality of the parcel tracking system.

While implementing the solution, I will consider edge cases such as:
- Adding events for non-existent parcels.
- Handling negative event counts (if applicable).
- Ensuring thread safety if the system is to be used in a concurrent environment. I will implement error handling to manage these scenarios gracefully.

Implement a Transactional Parcel-Tracking Store

Klaviyo

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Approach

Algorithm

Submit Your Answer

Klaviyo 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