add day-11 + benchmarks

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)
+			}
+		})
+	}
+}