Design File System

class FileSystem {

    class Node {
        
        String nodeName;
        int value = -1;
        Map<String, Node> children = new HashMap<>();
        
        Node (String nodeName) {
            this.nodeName = nodeName;
        }
    }
    
    Node rootNode;
    
    public FileSystem() {
        this.rootNode = new Node("");
    }
    
    public boolean createPath(String path, int value) {
        
        String[] parts = path.split("/");
        
        Node currentNode = rootNode;
        
        for (int i = 1; i < parts.length; i++) {
            
            String part = parts[i];
            
            if (!currentNode.children.containsKey(part)) {
                
                if (i == parts.length - 1) {
                    currentNode.children.put(part, new Node(part));
                } else {
                    return false;
                }    
            }
            
            currentNode = currentNode.children.get(part);
        }
        
        if (currentNode.value != -1) {
            return false;
        }
        
        currentNode.value = value;
        return true;
    }
    
    public int get(String path) {
        
        String[] parts = path.split("/");
        
        Node currentNode = rootNode;
        
        for (int i = 1; i < parts.length; i++) {
            
            String part = parts[i];
            
            if (!currentNode.children.containsKey(part)) {
                return -1;   
            }
            
            currentNode = currentNode.children.get(part);
        }
        
        return currentNode.value;
    }
}

The provided Java code offers a solution for designing a simple file system utilizing a hierarchical structure similar to directories and files. Here's a succinct breakdown of the implementation details and functionalities:

• Class Structure: The FileSystem class includes a nested Node class. Each Node possesses:

  • A string nodeName to store its name.
  • An integer value initialized to -1, representing unassigned or default value.
  • A HashMap called children to keep track of child nodes.

• Root Node Initialization: The file system starts with a rootNode, essentially an empty named node representing the root directory.

• Creating Paths: The method createPath(String path, int value) allows you to add a new path to the system with an associated value. The steps are:

  1. Split the input path on slashes to navigate through the node hierarchy.
  2. Traverse through the node structure, ensuring each segment of the path exists, except for the last part where it can create a new node if it doesn't exist.
  3. Assign the provided value to the final node in the path.
  4. Return true if the path creation is successful; otherwise, false, especially if trying to recreate an existing path.

• Retrieving Values: get(String path) retrieves the value at a specified path. If any part of the path is missing in the current structure, it returns -1.

Both methods ensure efficient navigation using hash maps for storing children, which allows for fast look-ups. This design is suitable for environments where there's a need to mimic a file system structure in memory, offering capabilities to dynamically create paths and retrieve values tied to these paths.

class TrieNode:
    def __init__(self, label):
        self.connections = defaultdict(TrieNode)
        self.label = label
        self.data = -1

class FileSystem:
    def __init__(self):
        self.base = TrieNode("")

    def createPath(self, path: str, value: int) -> bool:
        parts = path.split("/")
        node = self.base
        for i in range(1, len(parts)):
            segment = parts[i]
            if segment not in node.connections:
                if i == len(parts) - 1:
                    node.connections[segment] = TrieNode(segment)
                else:
                    return False
            node = node.connections[segment]
        if node.data != -1:
            return False
        node.data = value
        return True

    def get(self, path: str) -> int:
        node = self.base
        parts = path.split("/")
        for i in range(1, len(parts)):
            segment = parts[i]
            if segment not in node.connections:
                return -1
            node = node.connections[segment]
        return node.data

To implement a file system with path creation and path retrieval functionality using Python, you can employ a class-based approach incorporating nested data structures and methods. The solution leverages two main classes: TrieNode and FileSystem.

• TrieNode:

  • Handles individual nodes within the Trie data structure used to represent paths.
  • Each node has a dictionary named connections that maps strings to TrieNode instances, representing child paths.
  • label holds the segment of the path associated with that specific node.
  • data stores an integer value for the paths that represent a complete file or endpoint, initialized to -1, signifying no data unless explicitly set.

• FileSystem:

  • Initializes with a base TrieNode, acting as the root for your path trie.

Methods within FileSystem:

1. createPath(self, path: str, value: int) -> bool:

   • Splits the given path into segments and processes each segment one by one.
   • Checks if each segment exists in the current node's connections; if not and it's the last segment, creates a new node. If it's not the last segment, returns False.
   • Prevents re-assigning a value to an existing complete path, indicated by data being different from -1.
   • Sets the value to the last node of the path and returns True.

2. get(self, path: str) -> int:

   • Similar to createPath, it processes the path in segments, traversing the trie.
   • If any segment is missing during the traversal, it returns -1.
   • Returns the value stored in the data attribute of the last node in the given path.

This organized and methodological application of classes and methods ensures a robust design of the intended file system functionality, allowing efficient path creation and data retrieval through a trie structure.