Build an In-Memory File Vault with Duplicate-Name Handling

Question

Design and implement an in-memory file vault that can store files with potentially duplicate names while ensuring proper handling of these duplicates.

Codemia · Accepted Answer

To build an in-memory file vault, we need to support the following functionalities:
1. **Add a file**: Store a file with a unique identifier or name.
2. **Retrieve a file**: Access a file by its name or identifier.
3. **Delete a file**: Remove a file from the vault.
4. **Handle duplicates**: If a file with the same name is added, we need to either overwrite the existing file, store it with a version number, or maintain a list of files with the same name.

We can use a dictionary (hash map) to store files, where the key is the file name and the value is a list of file objects. This allows us to handle duplicates easily. Each file object can contain attributes like content, size, and a unique identifier. The structure would look like this:
```python
class File:
    def __init__(self, name, content, identifier):
        self.name = name
        self.content = content
        self.identifier = identifier
```
The vault can be implemented as:
```python
class FileVault:
    def __init__(self):
        self.files = {}
```

Here is how we can implement the core functionalities:
1. **Add a file**:
```python
    def add_file(self, name, content):
        identifier = uuid.uuid4()
        new_file = File(name, content, identifier)
        if name in self.files:
            self.files[name].append(new_file)
        else:
            self.files[name] = [new_file]
```
2. **Retrieve a file**:
```python
    def get_file(self, name):
        return self.files.get(name, None)
```
3. **Delete a file**:
```python
    def delete_file(self, name, identifier):
        if name in self.files:
            self.files[name] = [f for f in self.files[name] if f.identifier != identifier]
            if not self.files[name]:
                del self.files[name]
```

The time complexity for adding, retrieving, and deleting files is O(1) on average due to the hash map implementation. However, the worst-case complexity can be O(n) if there are many files with the same name, as we may need to search through the list of files. The space complexity is O(n) where n is the number of files stored in the vault.

Some edge cases to consider include:
- **Empty file names**: We should validate that file names are not empty before adding them.
- **Large files**: Ensure that the system can handle large file sizes without running out of memory.
- **Concurrency**: If multiple threads access the vault simultaneously, we need to implement locking mechanisms to prevent data corruption.

Build an In-Memory File Vault with Duplicate-Name Handling

Harvey

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

Harvey 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