-
Notifications
You must be signed in to change notification settings - Fork 0
/
588.go
111 lines (95 loc) · 2.82 KB
/
588.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package p588
import (
"bytes"
"sort"
"strings"
)
/**
Design an in-memory file system to simulate the following functions:
ls: Given a path in string format. If it is a file path, return a list that only contains this file's name. If it is a directory path, return the list of file and directory names in this directory. Your output (file and directory names together) should in lexicographic order.
mkdir: Given a directory path that does not exist, you should make a new directory according to the path. If the middle directories in the path don't exist either, you should create them as well. This function has void return type.
addContentToFile: Given a file path and file content in string format. If the file doesn't exist, you need to create that file containing given content. If the file already exists, you need to append given content to original content. This function has void return type.
readContentFromFile: Given a file path, return its content in string format.
**/
type node struct {
name string
isDir bool
content *bytes.Buffer
children map[string]*node
}
type FileSystem struct {
root *node
}
func (this *FileSystem) lookUp(path string, mk bool) *node {
path = strings.TrimLeft(path, "/")
paths := strings.Split(path, "/")
if len(path) == 0 {
paths = nil
}
cur := this.root
for _, p := range paths {
if cur.isDir && cur.children == nil {
cur.children = make(map[string]*node)
}
if v, ok := cur.children[p]; ok {
cur = v
} else if mk {
nd := &node{p, true, nil, nil}
cur.children[p] = nd
cur = nd
} else {
cur = nil
break
}
}
return cur
}
func Constructor() FileSystem {
return FileSystem{root: &node{"", true, nil, make(map[string]*node)}}
}
func (this *FileSystem) Ls(path string) []string {
nd := this.lookUp(path, false)
var res []string
if nd == nil {
//pass
} else if nd.isDir {
res = make([]string, 0, len(nd.children))
for p := range nd.children {
res = append(res, p)
}
sort.Strings(res)
} else {
res = []string{nd.name}
}
return res
}
func (this *FileSystem) Mkdir(path string) {
// paths := strings.Split(path, "/")
nd := this.lookUp(path, true)
if nd.children == nil {
nd.children = make(map[string]*node)
}
}
func (this *FileSystem) AddContentToFile(filePath string, content string) {
nd := this.lookUp(filePath, true)
nd.isDir = false
if nd.content == nil {
nd.content = new(bytes.Buffer)
}
nd.content.WriteString(content)
}
func (this *FileSystem) ReadContentFromFile(filePath string) string {
nd := this.lookUp(filePath, false)
if nd == nil || nd.isDir {
return ""
}
return nd.content.String()
}
/**
* Your FileSystem object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Ls(path);
* obj.Mkdir(path);
* obj.AddContentToFile(filePath,content);
* param_4 := obj.ReadContentFromFile(filePath);
*/