add day-11 + benchmarks

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