In-Memory Unix File System

Problem Overview

Design an in-memory Unix-like file system. The interview is reported as a two-part coding question and is similar in spirit to LeetCode 588: Design In-Memory FileSystem.

Problem Statement

Implement an in-memory file system similar to a Unix-like file system. The file system should support the following operations:

1. Create a file: Create a file with a given name and content.
2. Delete a file: Delete a file with a given name.
3. Read a file: Read the content of a file with a given name.
4. List directory: List all files in a given directory.
5. Read directory: Read the content of a directory.

Constraints

• Assume there is no file system access.
• Assume there is no concurrent access.
• Assume all file operations are valid (e.g., no need to handle invalid file names or paths).

Examples

1. Create a file:

   • Input: createFile("/file1", "content")
   • Output: True (indicating the file was successfully created)

2. Delete a file:

   • Input: deleteFile("/file1")
   • Output: True (indicating the file was successfully deleted)

3. Read a file:

   • Input: readFile("/file1")
   • Output: "content" (the content of the file)

4. List directory:

   • Input: listDirectory("/")
   • Output: ["file1"] (list of files in the root directory)

5. Read directory:

   • Input: readDirectory("/file1")
   • Output: "content" (the content of the directory, if it exists)

Hints

• Use a trie data structure to efficiently store and retrieve file paths.
• Consider using a hash map to store file contents for quick access.

Solution

`python class TrieNode: def init(self): self.children = {} self.is_file = False self.content = ""

class FileSystem: def init(self): self.root = TrieNode()

def create_file(self, path, content):
    node = self.root
    for part in path.split("/"):
        if part not in node.children:
            node.children[part] = TrieNode()
        node = node.children[part]
    node.is_file = True
    node.content = content
    return True

def delete_file(self, path):
    node = self.root
    for part in path.split("/"):
        if part not in node.children:
            return False
        node = node.children[part]
    if not node.is_file:
        return False
    node.is_file = False
    node.content = ""
    return True

def read_file(self, path):
    node = self.root
    for part in path.split("/"):
        if part not in node.children:
            return None
        node = node.children[part]
    if not node.is_file:
        return None
    return node.content

def list_directory(self, path):
    node = self.root
    for part in path.split("/"):
        if part not in node.children:
            return []
        node = node.children[part]
    return list(node.children.keys())

def read_directory(self, path):
    node = self.root
    for part in path.split("/"):
        if part not in node.children:
            return None
        node = node.children[part]
    if node.is_file:
        return node.content
    return " ".join(node.children.keys())

Example usage:

fs = FileSystem() fs.create_file("/file1", "content") print(fs.read_file("/file1")) # Output: "content" fs.delete_file("/file1") print(fs.read_file("/file1")) # Output: None `

This solution uses a trie data structure to efficiently store and retrieve file paths, and a hash map to store file contents for quick access. The create_file, delete_file, read_file, list_directory, and read_directory methods implement the required operations of the in-memory file system.