Initial commit

2022/07/code.go

@@ -0,0 +1,260 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/jpillora/puzzler/harness/aoc"
+)
+
+func main() {
+	aoc.Harness(run)
+}
+
+func run(part2 bool, input string) any {
+	if input == "" {
+		return "skip"
+	}
+	var e *exec
+	execs := []*exec{}
+	for _, line := range strings.Split(strings.TrimSpace(input), "\n") {
+		if strings.HasPrefix(line, "$ ") {
+			command := strings.Split(line[2:], " ")
+			e = &exec{command: command}
+			execs = append(execs, e)
+		} else {
+			e.output = append(e.output, line)
+		}
+	}
+	fs := newFileSystem()
+	for _, e := range execs {
+		fs.simulate(e)
+	}
+	const draw = false
+	if draw {
+		fmt.Println(fs.root.tree())
+	}
+	if part2 {
+		return fs.MinDeleteFor(updateSize)
+	}
+	return fs.root.Size100KB()
+}
+
+type exec struct {
+	command []string
+	output  []string
+}
+
+func (e exec) prog() string {
+	return e.command[0]
+}
+
+func (e exec) arg(i int) string {
+	return e.command[1+i]
+}
+
+type fileSystem struct {
+	root  *dir
+	wd    *dir
+	total int64
+}
+
+const updateSize = 30000000
+
+func newFileSystem() *fileSystem {
+	root := newDir("", nil)
+	return &fileSystem{
+		root:  root,
+		wd:    root,
+		total: 70000000,
+	}
+}
+
+func (fs *fileSystem) simulate(e *exec) {
+	switch e.prog() {
+	case "cd":
+		fs.changeDir(e.arg(0))
+	case "ls":
+		fs.listDir(e.output)
+	default:
+		panic("unknown command")
+	}
+}
+
+func (fs *fileSystem) unused() int64 {
+	return fs.total - fs.root.Size()
+}
+
+func (fs *fileSystem) changeDir(target string) {
+	switch target {
+	case "/":
+		fs.wd = fs.root
+	case "..":
+		if fs.wd.parent == nil {
+			panic("nil parent")
+		}
+		fs.wd = fs.wd.parent
+	default:
+		fs.wd = fs.wd.subDir(target)
+	}
+}
+
+func (fs fileSystem) listDir(output []string) {
+	for _, line := range output {
+		pair := strings.SplitN(line, " ", 2)
+		name := pair[1]
+		if pair[0] == "dir" {
+			fs.wd.subDir(name)
+			continue
+		}
+		size, err := strconv.ParseInt(pair[0], 10, 64)
+		if err != nil {
+			panic(err)
+		}
+		fs.wd.file(name, size)
+	}
+}
+
+func (fs fileSystem) MinDeleteFor(target int64) int64 {
+	required := target - fs.unused()
+	if required < 0 {
+		panic("no min required")
+	}
+	min := int64(math.MaxInt64)
+	fs.root.forEach(func(d *dir) {
+		s := d.Size()
+		if s < required {
+			return
+		}
+		// d is a candidate
+		if s < min {
+			min = s
+		}
+	})
+	if min == math.MaxInt64 {
+		panic("no min found")
+	}
+	return min
+}
+
+type dir struct {
+	name     string
+	children map[string]any
+	parent   *dir
+}
+
+func newDir(name string, parent *dir) *dir {
+	return &dir{
+		name:     name,
+		children: map[string]any{},
+		parent:   parent,
+	}
+}
+
+func (d *dir) subDir(name string) *dir {
+	x, ok := d.children[name]
+	if !ok {
+		dir := newDir(name, d)
+		d.children[name] = dir
+		return dir
+	}
+	dir, ok := x.(*dir)
+	if !ok {
+		panic("file/dir mismatch")
+	}
+	return dir
+}
+
+func (d dir) tree() string {
+	sb := strings.Builder{}
+	fmt.Fprintf(&sb, "%s (%d) {\n", d.path(), d.Size())
+	for _, c := range d.children {
+		var out string
+		switch v := c.(type) {
+		case *dir:
+			out = v.tree()
+		case *file:
+			out = v.String()
+		default:
+			panic("invalid child")
+		}
+		ls := strings.Split(out, "\n")
+		for i := range ls {
+			ls[i] = "  " + ls[i]
+		}
+		indented := strings.Join(ls, "\n")
+		sb.WriteString(indented)
+		sb.WriteRune('\n')
+	}
+	sb.WriteString("}")
+	return sb.String()
+}
+
+func (d *dir) file(name string, size int64) {
+	d.children[name] = &file{
+		name: name,
+		size: size,
+	}
+}
+
+func (d *dir) path() string {
+	if d.name == "" {
+		return "/"
+	}
+	p := []string{d.name}
+	w := d.parent
+	for w != nil {
+		p = append([]string{w.name}, p...)
+		w = w.parent
+	}
+	return strings.Join(p, "/")
+}
+
+func (d dir) Size() int64 {
+	sum := int64(0)
+	for _, c := range d.children {
+		switch v := c.(type) {
+		case *dir:
+			sum += v.Size()
+		case *file:
+			sum += v.size
+		default:
+			panic("invalid child")
+		}
+	}
+	return sum
+}
+
+func (d *dir) forEach(fn func(*dir)) {
+	fn(d)
+	for _, c := range d.children {
+		sub, ok := c.(*dir)
+		if !ok {
+			continue
+		}
+		sub.forEach(fn)
+	}
+}
+
+func (d dir) Size100KB() int64 {
+	const limit = 100000
+	sum := int64(0)
+	d.forEach(func(sub *dir) {
+		size := sub.Size()
+		if size < limit {
+			sum += size
+		}
+	})
+	return sum
+}
+
+type file struct {
+	name string
+	size int64
+}
+
+func (f file) String() string {
+	return fmt.Sprintf("%s (%d)", f.name, f.size)
+}