diff --git a/day-12/.gitignore b/day-12/.gitignore new file mode 100644 index 0000000..ec245fc --- /dev/null +++ b/day-12/.gitignore @@ -0,0 +1 @@ +concurrent.go \ No newline at end of file diff --git a/day-12/benchmark b/day-12/benchmark new file mode 100644 index 0000000..292f1e3 --- /dev/null +++ b/day-12/benchmark @@ -0,0 +1,15 @@ +goos: linux +goarch: amd64 +pkg: github.com/onyx-and-iris/aoc2024/day-12 +cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz +BenchmarkSolve-12 1000000000 0.06633 ns/op +BenchmarkSolve-12 1000000000 0.06764 ns/op +BenchmarkSolve-12 1000000000 0.06829 ns/op +BenchmarkSolve-12 1000000000 0.06724 ns/op +BenchmarkSolve-12 1000000000 0.06793 ns/op +BenchmarkSolve-12 1000000000 0.06676 ns/op +BenchmarkSolve-12 1000000000 0.06812 ns/op +BenchmarkSolve-12 1000000000 0.06883 ns/op +BenchmarkSolve-12 1000000000 0.06690 ns/op +BenchmarkSolve-12 1000000000 0.06747 ns/op +ok github.com/onyx-and-iris/aoc2024/day-12 6.115s diff --git a/day-12/cmd/cli/main.go b/day-12/cmd/cli/main.go new file mode 100644 index 0000000..40b4929 --- /dev/null +++ b/day-12/cmd/cli/main.go @@ -0,0 +1,41 @@ +/******************************************************************************** + Advent of Code 2024 - day-12 +********************************************************************************/ + +package main + +import ( + "embed" + "flag" + "fmt" + "slices" + + log "github.com/sirupsen/logrus" + + problems "github.com/onyx-and-iris/aoc2024/day-12" +) + +//go:embed testdata +var files embed.FS + +func main() { + filename := flag.String("f", "input.txt", "input file") + loglevel := flag.Int("l", int(log.InfoLevel), "log level") + flag.Parse() + + if slices.Contains(log.AllLevels, log.Level(*loglevel)) { + log.SetLevel(log.Level(*loglevel)) + } + + data, err := files.ReadFile(fmt.Sprintf("testdata/%s", *filename)) + if err != nil { + log.Fatal(err) + } + + one, two, err := problems.Solve(data) + if err != nil { + log.Fatal(err) + } + + fmt.Printf("solution one: %d\nsolution two: %d\n", one, two) +} diff --git a/day-12/go.mod b/day-12/go.mod new file mode 100644 index 0000000..aa95c4a --- /dev/null +++ b/day-12/go.mod @@ -0,0 +1,7 @@ +module github.com/onyx-and-iris/aoc2024/day-12 + +go 1.23.3 + +require github.com/sirupsen/logrus v1.9.3 + +require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect diff --git a/day-12/go.sum b/day-12/go.sum new file mode 100644 index 0000000..21f9bfb --- /dev/null +++ b/day-12/go.sum @@ -0,0 +1,15 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/day-12/internal/one/benchmark b/day-12/internal/one/benchmark new file mode 100644 index 0000000..4ac8c87 --- /dev/null +++ b/day-12/internal/one/benchmark @@ -0,0 +1,6 @@ +goos: linux +goarch: amd64 +pkg: github.com/onyx-and-iris/aoc2024/day-12/internal/one +cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz +BenchmarkSolve-12 1000000000 0.03239 ns/op +ok github.com/onyx-and-iris/aoc2024/day-12/internal/one 0.236s diff --git a/day-12/internal/one/direction.go b/day-12/internal/one/direction.go new file mode 100644 index 0000000..bbb6473 --- /dev/null +++ b/day-12/internal/one/direction.go @@ -0,0 +1,8 @@ +package one + +const ( + N = iota + E + S + W +) diff --git a/day-12/internal/one/explore.go b/day-12/internal/one/explore.go new file mode 100644 index 0000000..960261a --- /dev/null +++ b/day-12/internal/one/explore.go @@ -0,0 +1,37 @@ +package one + +import ( + "github.com/onyx-and-iris/aoc2024/day-12/internal/queue" +) + +func explore(start point, graph *graph) path { + queue := queue.New[point]() + queue.Enqueue(start) + visited := make(map[point]struct{}) + var perimeter int + + for !queue.IsEmpty() { + current := queue.Dequeue() + + _, ok := visited[current] + if ok { + continue + } + visited[current] = struct{}{} + + for _, n := range neighbours(current) { + if graph.isOutOfBounds(n) { + perimeter++ + continue + } + + if graph.valueAt(n) != graph.valueAt(current) { + perimeter++ + continue + } + queue.Enqueue(n) + } + } + + return path{visited, perimeter} +} diff --git a/day-12/internal/one/graph.go b/day-12/internal/one/graph.go new file mode 100644 index 0000000..c016ac1 --- /dev/null +++ b/day-12/internal/one/graph.go @@ -0,0 +1,46 @@ +package one + +import ( + "slices" + "strings" + + log "github.com/sirupsen/logrus" +) + +type point struct { + x int + y int +} + +func newPoint(x, y int) point { + return point{x, y} +} + +type graph struct { + data []string +} + +func newGraph() *graph { + return &graph{} +} + +func (g *graph) String() string { + return strings.Join(g.data, "\n") +} + +func (g *graph) isOutOfBounds(p point) bool { + return p.x < 0 || p.y < 0 || p.y >= len(g.data) || p.x >= len(g.data[p.y]) +} + +func (g *graph) valueAt(p point) rune { + return rune(g.data[p.y][p.x]) +} + +func (g *graph) debug(visited map[point]struct{}) string { + log.Debugf("path for %s", string(g.valueAt(firstPointFromMap(visited)))) + temp := slices.Clone(g.data) + for point := range visited { + temp[point.y] = replaceAtIndex(temp[point.y], 'x', point.x) + } + return strings.Join(temp, "\n") +} diff --git a/day-12/internal/one/neighbours.go b/day-12/internal/one/neighbours.go new file mode 100644 index 0000000..a9753ef --- /dev/null +++ b/day-12/internal/one/neighbours.go @@ -0,0 +1,10 @@ +package one + +func neighbours(p point) [4]point { + return [4]point{ + {p.x, p.y - 1}, // N + {p.x + 1, p.y}, // E + {p.x, p.y + 1}, // S + {p.x - 1, p.y}, // W + } +} diff --git a/day-12/internal/one/path.go b/day-12/internal/one/path.go new file mode 100644 index 0000000..f3eb2a5 --- /dev/null +++ b/day-12/internal/one/path.go @@ -0,0 +1,6 @@ +package one + +type path struct { + visited map[point]struct{} + perimeter int +} diff --git a/day-12/internal/one/solve.go b/day-12/internal/one/solve.go new file mode 100644 index 0000000..b03850b --- /dev/null +++ b/day-12/internal/one/solve.go @@ -0,0 +1,42 @@ +package one + +import ( + "bytes" + + log "github.com/sirupsen/logrus" +) + +func Solve(buf []byte) (int, error) { + r := bytes.NewReader(buf) + graph, err := parseLines(r) + if err != nil { + return 0, err + } + + var totalCost int + totalAreaVisited := make(map[point]struct{}) + for i := 0; i < len(graph.data); i++ { + for j := 0; j < len(graph.data[i]); j++ { + start := newPoint(j, i) + if graph.isOutOfBounds(start) { + continue + } + + _, ok := totalAreaVisited[start] + if ok { + continue + } + totalAreaVisited[start] = struct{}{} + + path := explore(start, graph) + log.Debugf("\n%s\n", graph.debug(path.visited)) + totalCost += len(path.visited) * path.perimeter + + for point := range path.visited { + totalAreaVisited[point] = struct{}{} + } + } + } + + return totalCost, nil +} diff --git a/day-12/internal/one/solve_internal_test.go b/day-12/internal/one/solve_internal_test.go new file mode 100644 index 0000000..e5fd7ea --- /dev/null +++ b/day-12/internal/one/solve_internal_test.go @@ -0,0 +1,15 @@ +package one + +import ( + _ "embed" + "os" + "testing" +) + +//go:embed testdata/input.txt +var data []byte + +func BenchmarkSolve(b *testing.B) { + os.Stdout, _ = os.Open(os.DevNull) + Solve(data) +} diff --git a/day-12/internal/one/util.go b/day-12/internal/one/util.go new file mode 100644 index 0000000..e0a6bc9 --- /dev/null +++ b/day-12/internal/one/util.go @@ -0,0 +1,35 @@ +package one + +import ( + "bufio" + "io" + "maps" +) + +func parseLines(r io.Reader) (*graph, error) { + graph := newGraph() + + scanner := bufio.NewScanner(r) + for scanner.Scan() { + graph.data = append(graph.data, scanner.Text()) + } + + if err := scanner.Err(); err != nil { + return nil, err + } + + return graph, nil +} + +func replaceAtIndex(s string, r rune, i int) string { + out := []rune(s) + out[i] = r + return string(out) +} + +func firstPointFromMap(visited map[point]struct{}) point { + for k := range maps.Keys(visited) { + return k + } + panic("unable to fetch points from map") +} diff --git a/day-12/internal/queue/queue.go b/day-12/internal/queue/queue.go new file mode 100644 index 0000000..b38c5f3 --- /dev/null +++ b/day-12/internal/queue/queue.go @@ -0,0 +1,39 @@ +package queue + +import "sync" + +type ConcurrentQueue[T comparable] struct { + items []T + lock sync.Mutex + cond *sync.Cond +} + +func New[T comparable]() *ConcurrentQueue[T] { + q := &ConcurrentQueue[T]{} + q.cond = sync.NewCond(&q.lock) + return q +} + +func (q *ConcurrentQueue[T]) Enqueue(item T) { + q.lock.Lock() + defer q.lock.Unlock() + + q.items = append(q.items, item) + q.cond.Signal() +} + +func (q *ConcurrentQueue[T]) Dequeue() T { + q.lock.Lock() + defer q.lock.Unlock() + + for len(q.items) == 0 { + q.cond.Wait() + } + item := q.items[0] + q.items = q.items[1:] + return item +} + +func (q *ConcurrentQueue[T]) IsEmpty() bool { + return len(q.items) == 0 +} diff --git a/day-12/internal/two/benchmark b/day-12/internal/two/benchmark new file mode 100644 index 0000000..f8d353c --- /dev/null +++ b/day-12/internal/two/benchmark @@ -0,0 +1,6 @@ +goos: linux +goarch: amd64 +pkg: github.com/onyx-and-iris/aoc2024/day-12/internal/two +cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz +BenchmarkSolve-12 1000000000 0.03596 ns/op +ok github.com/onyx-and-iris/aoc2024/day-12/internal/two 0.251s diff --git a/day-12/internal/two/explore.go b/day-12/internal/two/explore.go new file mode 100644 index 0000000..ab945d9 --- /dev/null +++ b/day-12/internal/two/explore.go @@ -0,0 +1,35 @@ +package two + +import "github.com/onyx-and-iris/aoc2024/day-12/internal/queue" + +func exploreAreaSequentially(start point, graph *graph) path { + queue := queue.New[point]() + queue.Enqueue(start) + visited := make(map[point]struct{}) + var perimeter int + + for !queue.IsEmpty() { + current := queue.Dequeue() + + _, ok := visited[current] + if ok { + continue + } + visited[current] = struct{}{} + + for _, n := range neighbours(current) { + if graph.isOutOfBounds(n) { + perimeter++ + continue + } + + if graph.valueAt(n) != graph.valueAt(current) { + perimeter++ + continue + } + queue.Enqueue(n) + } + } + + return path{visited, perimeter} +} diff --git a/day-12/internal/two/graph.go b/day-12/internal/two/graph.go new file mode 100644 index 0000000..bca6d13 --- /dev/null +++ b/day-12/internal/two/graph.go @@ -0,0 +1,48 @@ +package two + +import ( + "slices" + "strings" +) + +type point struct { + x int + y int +} + +func newPoint(x, y int) point { + return point{x, y} +} + +type graph struct { + data []string +} + +func newGraph() *graph { + return &graph{} +} + +func (g *graph) String() string { + return strings.Join(g.data, "\n") +} + +func (g *graph) isOutOfBounds(p point) bool { + return p.x < 0 || p.y < 0 || p.y >= len(g.data) || p.x >= len(g.data[p.y]) +} + +func (g *graph) valueAt(p point) rune { + return rune(g.data[p.y][p.x]) +} + +func (g *graph) sameKind(p, q point) bool { + return g.valueAt(p) == g.valueAt(q) +} + +func (g *graph) debug(visited map[point]struct{}) *graph { + temp := newGraph() + temp.data = slices.Clone(g.data) + for point := range visited { + temp.data[point.y] = replaceAtIndex(temp.data[point.y], -1, point.x) + } + return temp +} diff --git a/day-12/internal/two/neighbours.go b/day-12/internal/two/neighbours.go new file mode 100644 index 0000000..3d86295 --- /dev/null +++ b/day-12/internal/two/neighbours.go @@ -0,0 +1,17 @@ +package two + +const ( + N = iota + E + S + W +) + +func neighbours(p point) [4]point { + return [4]point{ + {p.x, p.y - 1}, // N + {p.x + 1, p.y}, // E + {p.x, p.y + 1}, // S + {p.x - 1, p.y}, // W + } +} diff --git a/day-12/internal/two/path.go b/day-12/internal/two/path.go new file mode 100644 index 0000000..6b51a68 --- /dev/null +++ b/day-12/internal/two/path.go @@ -0,0 +1,6 @@ +package two + +type path struct { + visited map[point]struct{} + perimeter int +} diff --git a/day-12/internal/two/solve.go b/day-12/internal/two/solve.go new file mode 100644 index 0000000..77d5b48 --- /dev/null +++ b/day-12/internal/two/solve.go @@ -0,0 +1,133 @@ +package two + +import ( + "bytes" + + log "github.com/sirupsen/logrus" +) + +func Solve(buf []byte) (int, error) { + r := bytes.NewReader(buf) + graph, err := parseLines(r) + if err != nil { + return 0, err + } + + var totalCost int + totalAreaVisited := make(map[point]struct{}) + for i := 0; i < len(graph.data); i++ { + for j := 0; j < len(graph.data[i]); j++ { + start := newPoint(j, i) + if graph.isOutOfBounds(start) { + continue + } + + _, ok := totalAreaVisited[start] + if ok { + continue + } + totalAreaVisited[start] = struct{}{} + + path := exploreAreaSequentially(start, graph) + numSides := analyzeSides(graph.valueAt(firstPointFromMap(path.visited)), graph, path) + + totalCost += len(path.visited) * numSides + for point := range path.visited { + totalAreaVisited[point] = struct{}{} + } + } + } + + return totalCost, nil +} + +func analyzeSides(kind rune, graph *graph, path path) int { + log.Debugf("graph for values %s\n%s\n", string(kind), graph.debug(path.visited)) + + var corners int + for current := range path.visited { + ns := neighbours(current) + + if isCorner(graph, current, ns[N], ns[E]) { + corners++ + } + + if isCorner(graph, current, ns[S], ns[E]) { + corners++ + } + + if isCorner(graph, current, ns[N], ns[W]) { + corners++ + } + + if isCorner(graph, current, ns[S], ns[W]) { + corners++ + } + + corners += isInnerCorner(graph, current, ns) + } + + log.Debugf("this path has %d corners", corners) + + return corners +} + +func isCorner(graph *graph, current, p, q point) bool { + if graph.isOutOfBounds(p) && graph.isOutOfBounds(q) { + return true + } + + if !graph.isOutOfBounds(p) { + if graph.isOutOfBounds(q) && !graph.sameKind(p, current) { + return true + } + } + + if !graph.isOutOfBounds(q) { + if graph.isOutOfBounds(p) && !graph.sameKind(q, current) { + return true + } + } + + if !graph.isOutOfBounds(p) && !graph.isOutOfBounds(q) { + if !graph.sameKind(p, current) && !graph.sameKind(q, current) { + return true + } + } + + return false +} + +func isInnerCorner(graph *graph, current point, ns [4]point) int { + var corners int + + if !graph.isOutOfBounds(ns[N]) && !graph.isOutOfBounds(ns[E]) { + if graph.sameKind(ns[N], current) && graph.sameKind(ns[E], current) && + !graph.sameKind(point{current.x + 1, current.y - 1}, current) { + corners++ + } + } + + if !graph.isOutOfBounds(ns[N]) && !graph.isOutOfBounds(ns[W]) { + if graph.sameKind(ns[N], current) && graph.sameKind(ns[W], current) && + !graph.sameKind(point{current.x - 1, current.y - 1}, current) { + corners++ + } + } + + if !graph.isOutOfBounds(ns[S]) && !graph.isOutOfBounds(ns[E]) { + if graph.sameKind(ns[S], current) && graph.sameKind(ns[E], current) && + !graph.sameKind(point{current.x + 1, current.y + 1}, current) { + corners++ + } + } + + if !graph.isOutOfBounds(ns[S]) && !graph.isOutOfBounds(ns[W]) { + if graph.sameKind(ns[S], current) && graph.sameKind(ns[W], current) && + !graph.sameKind(point{current.x - 1, current.y + 1}, current) { + corners++ + } + } + + return corners +} diff --git a/day-12/internal/two/solve_internal_test.go b/day-12/internal/two/solve_internal_test.go new file mode 100644 index 0000000..ecb05d5 --- /dev/null +++ b/day-12/internal/two/solve_internal_test.go @@ -0,0 +1,15 @@ +package two + +import ( + _ "embed" + "os" + "testing" +) + +//go:embed testdata/input.txt +var data []byte + +func BenchmarkSolve(b *testing.B) { + os.Stdout, _ = os.Open(os.DevNull) + Solve(data) +} diff --git a/day-12/internal/two/util.go b/day-12/internal/two/util.go new file mode 100644 index 0000000..ff9eb91 --- /dev/null +++ b/day-12/internal/two/util.go @@ -0,0 +1,35 @@ +package two + +import ( + "bufio" + "io" + "maps" +) + +func parseLines(r io.Reader) (*graph, error) { + graph := newGraph() + + scanner := bufio.NewScanner(r) + for scanner.Scan() { + graph.data = append(graph.data, scanner.Text()) + } + + if err := scanner.Err(); err != nil { + return nil, err + } + + return graph, nil +} + +func replaceAtIndex(s string, r rune, i int) string { + out := []rune(s) + out[i] = r + return string(out) +} + +func firstPointFromMap(visited map[point]struct{}) point { + for k := range maps.Keys(visited) { + return k + } + panic("unable to fetch points from map") +} diff --git a/day-12/makefile b/day-12/makefile new file mode 100644 index 0000000..6dd94ae --- /dev/null +++ b/day-12/makefile @@ -0,0 +1,30 @@ +program = day-12 + +GO = go +SRC_DIR := src +BIN_DIR := bin + +EXE := $(BIN_DIR)/$(program) + +.DEFAULT_GOAL := build + +.PHONY: fmt vet build bench clean +fmt: + $(GO) fmt ./... + +vet: fmt + $(GO) vet ./... + +build: vet | $(BIN_DIR) + $(GO) build -o $(EXE) ./$(SRC_DIR) + +bench: + $(GO) test ./internal/one/ -bench=. > internal/one/benchmark + $(GO) test ./internal/two/ -bench=. > internal/two/benchmark + $(GO) test . -count=10 -bench=. > benchmark + +$(BIN_DIR): + @mkdir -p $@ + +clean: + @rm -rv $(BIN_DIR) diff --git a/day-12/solve.go b/day-12/solve.go new file mode 100644 index 0000000..5e6eeca --- /dev/null +++ b/day-12/solve.go @@ -0,0 +1,20 @@ +package daytwelve + +import ( + "github.com/onyx-and-iris/aoc2024/day-12/internal/one" + "github.com/onyx-and-iris/aoc2024/day-12/internal/two" +) + +func Solve(buf []byte) (int, int, error) { + answerOne, err := one.Solve(buf) + if err != nil { + return 0, 0, err + } + + answerTwo, err := two.Solve(buf) + if err != nil { + return 0, 0, err + } + + return answerOne, answerTwo, nil +} diff --git a/day-12/solve_internal_test.go b/day-12/solve_internal_test.go new file mode 100644 index 0000000..1472b12 --- /dev/null +++ b/day-12/solve_internal_test.go @@ -0,0 +1,15 @@ +package daytwelve + +import ( + _ "embed" + "os" + "testing" +) + +//go:embed testdata/input.txt +var data []byte + +func BenchmarkSolve(b *testing.B) { + os.Stdout, _ = os.Open(os.DevNull) + Solve(data) +}