Design a Tiered Expiring Item Store

Question

Design a class that implements a tiered expiring item store with methods to store and retrieve items based on specific conditions.

Codemia · Accepted Answer

To design a tiered expiring item store, we need to implement a class that allows us to store items in different tiers based on their expiration times and weights. The store should have methods to add items and retrieve them while adhering to specific rules: items must be retrieved from the highest available tier, only if they are not expired, and if the tier has at least 50% of its capacity remaining.

The class will have the following key components:
- **Item Class**: Represents an item with attributes for weight, expiration timestamp, and tier level.
- **TieredStore Class**: Manages multiple tiers, each containing a list of items. Each tier will track its capacity and items.
- **Methods**: `store(item)`, `retrieve()`, and a helper method to check if an item is expired.

The `store(item)` method will add an item to the appropriate tier based on its weight and expiration time. The `retrieve()` method will iterate through the tiers from highest to lowest, checking for expired items and ensuring that at least 50% of the tier's capacity is available. If an item meets the criteria, it will be returned. We will use a priority queue to manage items efficiently based on their weights.

This design allows for efficient retrieval and storage but may require optimization for large datasets. We can consider using a more sophisticated data structure, like a balanced tree, to maintain order and facilitate quick access. Additionally, handling concurrent access might necessitate implementing locking mechanisms or using concurrent data structures.

Here is a basic implementation of the tiered expiring item store:
```python
import time
from collections import defaultdict

class Item:
    def __init__(self, weight, expiration, tier):
        self.weight = weight
        self.expiration = expiration
        self.tier = tier

class TieredStore:
    def __init__(self):
        self.tiers = defaultdict(list)
        self.capacity = defaultdict(int)

def store(self, item):
        self.tiers[item.tier].append(item)
        self.capacity[item.tier] += 1

def retrieve(self):
        for tier in sorted(self.tiers.keys(), reverse=True):
            items = [item for item in self.tiers[tier] if item.expiration > time.time()]
            if len(items) >= self.capacity[tier] * 0.5:
                return max(items, key=lambda x: x.weight)
        return None
```
This code provides a basic structure and logic for the tiered expiring item store.

Design a Tiered Expiring Item Store

Akuna Capital

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

Akuna Capital Software Engineer Interview Guide

Related Questions

Design a scalable Search System

Design a Video Streaming for Rippling

Design a Load Balancing Service

Design a Image Processing Service

Build a high-throughput Image Processing Pipeline