1166. Design File System

You are asked to design a file system that allows you to create new paths and associate them with different values.

The format of a path is one or more concatenated strings of the form: / followed by one or more lowercase English letters. For example, "/leetcode" and "/leetcode/problems" are valid paths while an empty string "" and "/" are not.

Implement the FileSystem class:

  • bool createPath(string path, int value) Creates a new path and associates a value to it if possible and returns true. Returns false if the path already exists or its parent path doesn't exist.
  • int get(string path) Returns the value associated with path or returns -1 if the path doesn't exist.

 

Example 1:

Input: 
["FileSystem","createPath","get"]
[[],["/a",1],["/a"]]
Output: 
[null,true,1]
Explanation: 
FileSystem fileSystem = new FileSystem();

fileSystem.createPath("/a", 1); // return true
fileSystem.get("/a"); // return 1

Example 2:

Input: 
["FileSystem","createPath","createPath","get","createPath","get"]
[[],["/leet",1],["/leet/code",2],["/leet/code"],["/c/d",1],["/c"]]
Output: 
[null,true,true,2,false,-1]
Explanation: 
FileSystem fileSystem = new FileSystem();

fileSystem.createPath("/leet", 1); // return true
fileSystem.createPath("/leet/code", 2); // return true
fileSystem.get("/leet/code"); // return 2
fileSystem.createPath("/c/d", 1); // return false because the parent path "/c" doesn't exist.
fileSystem.get("/c"); // return -1 because this path doesn't exist.

 

Constraints:

  • The number of calls to the two functions is less than or equal to 104 in total.
  • 2 <= path.length <= 100
  • 1 <= value <= 109

Rust Solution

use std::collections::HashMap;

#[derive(Default)]
struct FileSystem {
    paths: HashMap<String, i32>,
}

impl FileSystem {
    fn new() -> Self {
        FileSystem {
            paths: HashMap::new(),
        }
    }

    fn create_path(&mut self, path: String, value: i32) -> bool {
        let index = path.rfind('/').unwrap();
        let parent = &path[0..index];
        if !self.paths.contains_key(&path) && (parent.is_empty() || self.paths.contains_key(parent))
        {
            self.paths.insert(path, value);
            true
        } else {
            false
        }
    }

    fn get(&self, path: String) -> i32 {
        *self.paths.get(&path).unwrap_or(&-1)
    }
}

#[test]
fn test() {
    let mut fs = FileSystem::new();
    assert_eq!(fs.create_path("/leet".to_string(), 1), true);
    assert_eq!(fs.create_path("/leet/code".to_string(), 2), true);
    assert_eq!(fs.get("/leet/code".to_string()), 2);
    assert_eq!(fs.create_path("/c/d".to_string(), 2), false);
    assert_eq!(fs.get("/c".to_string()), -1);
}

Having problems with this solution? Click here to submit an issue on github.