onyx_online/aoc2024
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/aoc2024.git synced 2025-04-19 19:23:47 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: onyx_online:aafe39aa85518e32f415c54444a1865088611e89
Branches Tags
onyx_online:main
..
compare: onyx_online:c12cc2c38e3e9394bae325a8a5a8496f13d1f8b5
Branches Tags
onyx_online:main

No commits in common. "aafe39aa85518e32f415c54444a1865088611e89" and "c12cc2c38e3e9394bae325a8a5a8496f13d1f8b5" have entirely different histories.
aafe39aa85 ... c12cc2c38e

19 changed files with 0 additions and 526 deletions
Show Stats Expand all files Collapse all files

1
day-11/.gitignore vendored
View File

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

15
day-11/benchmark
View File

@ -1,15 +0,0 @@
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

41
day-11/cmd/cli/main.go
View File

@ -1,41 +0,0 @@
/********************************************************************************
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)
}

7
day-11/go.mod
View File

@ -1,7 +0,0 @@
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

15
day-11/go.sum
View File

@ -1,15 +0,0 @@
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=

6
day-11/internal/one/benchmark
View File

@ -1,6 +0,0 @@
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

55
day-11/internal/one/solve.go
View File

@ -1,55 +0,0 @@
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
}
}

15
day-11/internal/one/solve_internal_test.go
View File

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

55
day-11/internal/one/util.go
View File

@ -1,55 +0,0 @@
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))
}

32
day-11/internal/one/util_internal_test.go
View File

@ -1,32 +0,0 @@
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)
}
})
}
}

43
day-11/internal/queue/queue.go
View File

@ -1,43 +0,0 @@
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)
}

6
day-11/internal/two/benchmark
View File

@ -1,6 +0,0 @@
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

29
day-11/internal/two/result.go
View File

@ -1,29 +0,0 @@
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)
}

68
day-11/internal/two/solve.go
View File

@ -1,68 +0,0 @@
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)
for stone, count := range old {
var r result
r, ok := memo[stone]
if !ok {
r = applyRules(stone)
memo[stone] = r
}
switch r.kind {
case flip, multiply:
next[r.right] += count
case split:
next[r.left] += count
next[r.right] += count
}
}
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}
}
}

15
day-11/internal/two/solve_internal_test.go
View File

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

55
day-11/internal/two/util.go
View File

@ -1,55 +0,0 @@
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))
}

33
day-11/makefile
View File

@ -1,33 +0,0 @@
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)

20
day-11/solve.go
View File

@ -1,20 +0,0 @@
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
}

15
day-11/solve_internal_test.go
View File

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