add day-11 + benchmarks

day-11/.gitignore

@@ -0,0 +1 @@
+internal/stack

day-11/benchmark

@@ -0,0 +1,15 @@
+goos: linux
+goarch: amd64
+pkg: github.com/onyx-and-iris/aoc2024/day-11
+cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
+BenchmarkSolve-12    	1000000000	         0.07126 ns/op
+BenchmarkSolve-12    	1000000000	         0.07114 ns/op
+BenchmarkSolve-12    	1000000000	         0.07102 ns/op
+BenchmarkSolve-12    	1000000000	         0.07157 ns/op
+BenchmarkSolve-12    	1000000000	         0.07201 ns/op
+BenchmarkSolve-12    	1000000000	         0.07461 ns/op
+BenchmarkSolve-12    	1000000000	         0.07305 ns/op
+BenchmarkSolve-12    	1000000000	         0.07548 ns/op
+BenchmarkSolve-12    	1000000000	         0.07503 ns/op
+BenchmarkSolve-12    	1000000000	         0.07202 ns/op
+ok  	github.com/onyx-and-iris/aoc2024/day-11	6.636s

day-11/cmd/cli/main.go

@@ -0,0 +1,41 @@
+/********************************************************************************
+    Advent of Code 2024 - day-11
+********************************************************************************/
+
+package main
+
+import (
+	"embed"
+	"flag"
+	"fmt"
+	"slices"
+
+	log "github.com/sirupsen/logrus"
+
+	problems "github.com/onyx-and-iris/aoc2024/day-11"
+)
+
+//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)
+}

day-11/go.mod

@@ -0,0 +1,7 @@
+module github.com/onyx-and-iris/aoc2024/day-11
+
+go 1.23.3
+
+require github.com/sirupsen/logrus v1.9.3
+
+require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect

day-11/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=

day-11/internal/one/benchmark

@@ -0,0 +1,6 @@
+goos: linux
+goarch: amd64
+pkg: github.com/onyx-and-iris/aoc2024/day-11/internal/one
+cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
+BenchmarkSolve-12    	1000000000	         0.03508 ns/op
+ok  	github.com/onyx-and-iris/aoc2024/day-11/internal/one	0.244s

day-11/internal/one/solve.go

@@ -0,0 +1,55 @@
+package one
+
+import (
+	"bytes"
+
+	log "github.com/sirupsen/logrus"
+
+	"github.com/onyx-and-iris/aoc2024/day-11/internal/queue"
+)
+
+const blinks = 25
+const magic = 2024
+
+func Solve(buf []byte) (int, error) {
+	r := bytes.NewReader(buf)
+	numbers, err := parseLines(r)
+	if err != nil {
+		return 0, err
+	}
+
+	old := queue.New[int]()
+	for _, n := range numbers {
+		old.Enqueue(n)
+	}
+	log.Debug(old)
+
+	for range blinks {
+		next := queue.New[int]()
+		for !old.IsEmpty() {
+			n := old.Dequeue()
+			left, right, ok := applyRules(n)
+			if ok {
+				next.Enqueue(left)
+			}
+			next.Enqueue(right)
+		}
+
+		old = next
+		log.Debug(old)
+	}
+
+	return old.Len(), nil
+}
+
+func applyRules(num int) (int, int, bool) {
+	switch num := num; {
+	case num == 0:
+		return 0, 1, false
+	case lenItoa(num)%2 == 0:
+		left, right := splitNumber(num)
+		return left, right, true
+	default:
+		return 0, num * magic, false
+	}
+}

day-11/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)
+}

day-11/internal/one/util.go

@@ -0,0 +1,55 @@
+package one
+
+import (
+	"bufio"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+)
+
+func parseLines(r io.Reader) ([]int, error) {
+	var numbers []int
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		numbers = numbersFromString(scanner.Text())
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return numbers, nil
+}
+
+func numbersFromString(s string) []int {
+	splitted := strings.Fields(s)
+
+	var nums []int
+	for _, part := range splitted {
+		nums = append(nums, mustConv(part))
+	}
+	return nums
+}
+
+func mustConv(s string) int {
+	n, err := strconv.Atoi(s)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func splitNumber(n int) (int, int) {
+	factor := int(math.Pow10(lenItoa(n) / 2))
+
+	right := n % factor
+	left := int(n / factor)
+
+	return left, right
+}
+
+func lenItoa(n int) int {
+	return len(strconv.Itoa(n))
+}

day-11/internal/one/util_internal_test.go

@@ -0,0 +1,32 @@
+package one
+
+import "testing"
+
+func TestSplitNumber(t *testing.T) {
+	tt := map[string]struct {
+		number        int
+		expectedLeft  int
+		expectedRight int
+		expectedOk    bool
+	}{
+		"number is 99, expect 9 and 9": {
+			number:        99,
+			expectedLeft:  9,
+			expectedRight: 9,
+		},
+		"number is 2024, expect 20 and 24": {
+			number:        2024,
+			expectedLeft:  20,
+			expectedRight: 24,
+		},
+	}
+
+	for name, tc := range tt {
+		t.Run(name, func(t *testing.T) {
+			left, right := splitNumber(tc.number)
+			if left != tc.expectedLeft && right != tc.expectedRight {
+				t.Errorf("expected left %d got %d, right %d got %d", tc.expectedLeft, left, tc.expectedRight, right)
+			}
+		})
+	}
+}

day-11/internal/queue/queue.go

@@ -0,0 +1,43 @@
+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
+}
+
+func (q *ConcurrentQueue[T]) Len() int {
+	return len(q.items)
+}

day-11/internal/two/benchmark

@@ -0,0 +1,6 @@
+goos: linux
+goarch: amd64
+pkg: github.com/onyx-and-iris/aoc2024/day-11/internal/two
+cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
+BenchmarkSolve-12    	1000000000	         0.03833 ns/op
+ok  	github.com/onyx-and-iris/aoc2024/day-11/internal/two	0.322s

day-11/internal/two/result.go

@@ -0,0 +1,29 @@
+package two
+
+import "fmt"
+
+const (
+	flip = iota
+	split
+	multiply
+)
+
+type result struct {
+	kind  int
+	left  int
+	right int
+}
+
+func (r result) String() string {
+	var kindStr string
+	switch r.kind {
+	case flip:
+		kindStr = "flip"
+	case split:
+		kindStr = "split"
+	case multiply:
+		kindStr = "multiply"
+	}
+
+	return fmt.Sprintf("kind: %s left: %d right: %d", kindStr, r.left, r.right)
+}

day-11/internal/two/solve.go

@@ -0,0 +1,70 @@
+package two
+
+import (
+	"bytes"
+
+	log "github.com/sirupsen/logrus"
+)
+
+const blinks = 75
+const magic = 2024
+
+func Solve(buf []byte) (int, error) {
+	r := bytes.NewReader(buf)
+	numbers, err := parseLines(r)
+	if err != nil {
+		return 0, err
+	}
+
+	old := make(map[int]int)
+	for _, n := range numbers {
+		old[n]++
+	}
+	log.Debug(old)
+
+	memo := make(map[int]result)
+	for range blinks {
+		next := make(map[int]int)
+		visited := make(map[int]int)
+
+		for stone, count := range old {
+			var r result
+			_, ok := visited[stone]
+			if !ok {
+				r = applyRules(stone)
+				memo[stone] = r
+			}
+			visited[stone] += count
+
+			switch r.kind {
+			case flip, multiply:
+				next[r.right] += visited[stone]
+			case split:
+				next[r.left] += visited[stone]
+				next[r.right] += visited[stone]
+			}
+		}
+
+		old = next
+		log.Debug(old)
+	}
+
+	var totalCount int
+	for _, count := range old {
+		totalCount += count
+	}
+
+	return totalCount, nil
+}
+
+func applyRules(num int) result {
+	switch num := num; {
+	case num == 0:
+		return result{flip, 0, 1}
+	case lenItoa(num)%2 == 0:
+		left, right := splitNumber(num)
+		return result{split, left, right}
+	default:
+		return result{multiply, 0, num * magic}
+	}
+}

day-11/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)
+}

day-11/internal/two/util.go

@@ -0,0 +1,55 @@
+package two
+
+import (
+	"bufio"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+)
+
+func parseLines(r io.Reader) ([]int, error) {
+	var numbers []int
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		numbers = numbersFromString(scanner.Text())
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return numbers, nil
+}
+
+func numbersFromString(s string) []int {
+	splitted := strings.Fields(s)
+
+	var nums []int
+	for _, part := range splitted {
+		nums = append(nums, mustConv(part))
+	}
+	return nums
+}
+
+func mustConv(s string) int {
+	n, err := strconv.Atoi(s)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func splitNumber(n int) (int, int) {
+	factor := int(math.Pow10(lenItoa(n) / 2))
+
+	left := int(n / factor)
+	right := n % factor
+
+	return left, right
+}
+
+func lenItoa(n int) int {
+	return len(strconv.Itoa(n))
+}

day-11/makefile

@@ -0,0 +1,33 @@
+program = day-11
+
+GO = go
+SRC_DIR := src
+BIN_DIR := bin
+
+EXE := $(BIN_DIR)/$(program)
+
+.DEFAULT_GOAL := build
+
+.PHONY: fmt vet build test bench clean
+fmt:        
+	$(GO) fmt ./...
+
+vet: fmt        
+	$(GO) vet ./...
+
+build: vet | $(BIN_DIR)
+	$(GO) build -o $(EXE) ./$(SRC_DIR)
+
+test:
+	$(GO) test -v ./...
+
+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)

day-11/solve.go

@@ -0,0 +1,20 @@
+package dayeleven
+
+import (
+	"github.com/onyx-and-iris/aoc2024/day-11/internal/one"
+	"github.com/onyx-and-iris/aoc2024/day-11/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
+}

day-11/solve_internal_test.go

@@ -0,0 +1,15 @@
+package dayeleven
+
+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)
+}