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

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