onyx_online/aoc2024
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/aoc2024.git synced 2025-02-22 18:25:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

add day-17 + benchmarks

Browse Source
This commit is contained in:
onyx-and-iris 2024-12-18 15:02:35 +00:00
parent a0a25639cc
commit 6cb3fd1654
19 changed files with 721 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
day-17/benchmark Normal file
View File

@ -0,0 +1,15 @@
goos: linux
goarch: amd64
pkg: github.com/onyx-and-iris/aoc2024/day-17
cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
BenchmarkSolve-12 1000000000 0.002182 ns/op
BenchmarkSolve-12 1000000000 0.001786 ns/op
BenchmarkSolve-12 1000000000 0.001724 ns/op
BenchmarkSolve-12 1000000000 0.001759 ns/op
BenchmarkSolve-12 1000000000 0.002150 ns/op
BenchmarkSolve-12 1000000000 0.001757 ns/op
BenchmarkSolve-12 1000000000 0.001747 ns/op
BenchmarkSolve-12 1000000000 0.001807 ns/op
BenchmarkSolve-12 1000000000 0.001720 ns/op
BenchmarkSolve-12 1000000000 0.001692 ns/op
ok github.com/onyx-and-iris/aoc2024/day-17 0.139s

41
day-17/cmd/cli/main.go Normal file
View File

@ -0,0 +1,41 @@
/********************************************************************************
Advent of Code 2024 - day-17
********************************************************************************/
package main
import (
"embed"
"flag"
"fmt"
"slices"
log "github.com/sirupsen/logrus"
problems "github.com/onyx-and-iris/aoc2024/day-17"
)
//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: %s\nsolution two: %d\n", one, two)
}

7
day-17/go.mod Normal file
View File

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

16
day-17/go.sum Normal file
View File

@ -0,0 +1,16 @@
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/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
golang.org/x/sys v0.12.0/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-17/internal/one/benchmark Normal file
View File

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

108
day-17/internal/one/computer.go Normal file
View File

@ -0,0 +1,108 @@
package one
import (
"math"
)
type computer struct {
registers map[string]int
instructionMap map[int]instructionFn
}
func newComputer(registers map[string]int) *computer {
c := &computer{
registers: registers,
}
c.instructionMap = map[int]instructionFn{
0: c.adv,
1: c.bxl,
2: c.bst,
3: c.jnz,
4: c.bxc,
5: c.out,
6: c.bdv,
7: c.cdv,
}
return c
}
func (c *computer) run(program []int) []int {
results := []int{}
var ptr int
for ptr < len(program) {
opcode := program[ptr]
jump, doJump, out, doStore := c.performOperation(c.instructionMap[opcode], operand(program[ptr+1]))
if doJump {
ptr = jump
} else {
ptr += 2
}
if doStore {
results = append(results, out)
}
}
return results
}
func (c *computer) performOperation(fn instructionFn, operand operand) (int, bool, int, bool) {
return fn(operand)
}
func (c *computer) adv(operand operand) (int, bool, int, bool) {
c.registers["A"] /= int(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) bxl(operand operand) (int, bool, int, bool) {
c.registers["B"] ^= int(operand)
return 0, false, 0, false
}
func (c *computer) bst(operand operand) (int, bool, int, bool) {
c.registers["B"] = c.combo(operand) % 8
return 0, false, 0, false
}
func (c *computer) jnz(operand operand) (int, bool, int, bool) {
if c.registers["A"] == 0 {
return 0, false, 0, false
}
return int(operand), true, 0, false
}
func (c *computer) bxc(operand operand) (int, bool, int, bool) {
c.registers["B"] ^= c.registers["C"]
return 0, false, 0, false
}
func (c *computer) out(operand operand) (int, bool, int, bool) {
return 0, false, c.combo(operand) % 8, true
}
func (c *computer) bdv(operand operand) (int, bool, int, bool) {
c.registers["B"] = c.registers["A"] / int(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) cdv(operand operand) (int, bool, int, bool) {
c.registers["C"] = c.registers["A"] / int(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) combo(operand operand) int {
switch operand {
case 0, 1, 2, 3:
return int(operand)
case 4:
return c.registers["A"]
case 5:
return c.registers["B"]
case 6:
return c.registers["C"]
default:
return 0
}
}

94
day-17/internal/one/computer_internal_test.go Normal file
View File

@ -0,0 +1,94 @@
package one
import (
"slices"
"testing"
)
func TestComputerRunProgram1(t *testing.T) {
tt := map[string]struct {
registers map[string]int
program []int
}{
"register C contains 9 with program 2,6, should set register B to 1": {
registers: map[string]int{
"A": 0,
"B": 0,
"C": 9,
},
program: []int{2, 6},
},
}
c := newComputer(nil)
for name, tc := range tt {
t.Run(name, func(t *testing.T) {
c.registers = tc.registers
c.run(tc.program)
if c.registers["B"] != 1 {
t.Errorf("register B got: %v, expected %v", c.registers["B"], 1)
}
})
}
}
func TestComputerRunProgram2(t *testing.T) {
tt := map[string]struct {
registers map[string]int
program []int
expected []int
}{
"register A contains 10 with program 5,0,5,1,5,4, should output 0,1,2": {
registers: map[string]int{
"A": 10,
"B": 0,
"C": 0,
},
program: []int{5, 0, 5, 1, 5, 4},
expected: []int{0, 1, 2},
},
}
c := newComputer(nil)
for name, tc := range tt {
t.Run(name, func(t *testing.T) {
c.registers = tc.registers
got := c.run(tc.program)
if !slices.Equal(got, tc.expected) {
t.Errorf("output: %q, expected %q", got, tc.expected)
}
})
}
}
func TestComputerRunProgram3(t *testing.T) {
tt := map[string]struct {
registers map[string]int
program []int
expected []int
}{
"register A contains 2024 with program 0, 1, 5, 4, 3, 0, should leave 0 in register A and output 4, 2, 5, 6, 7, 7, 7, 7, 3, 1, 0": {
registers: map[string]int{
"A": 2024,
"B": 0,
"C": 0,
},
program: []int{0, 1, 5, 4, 3, 0},
expected: []int{4, 2, 5, 6, 7, 7, 7, 7, 3, 1, 0},
},
}
c := newComputer(nil)
for name, tc := range tt {
t.Run(name, func(t *testing.T) {
c.registers = tc.registers
got := c.run(tc.program)
if c.registers["A"] != 0 {
t.Errorf("register A got: %v, expected %v", c.registers["A"], 0)
}
if !slices.Equal(got, tc.expected) {
t.Errorf("output got: %v, expected %v", got, tc.expected)
}
})
}
}

31
day-17/internal/one/solve.go Normal file
View File

@ -0,0 +1,31 @@
package one
import (
"bytes"
"strconv"
"strings"
)
type operand int
type instructionFn func(operand) (int, bool, int, bool)
func Solve(buf []byte) (string, error) {
r := bytes.NewReader(buf)
registers, program, err := parseLines(r)
if err != nil {
return "", err
}
computer := newComputer(registers)
results := computer.run(program)
var sb strings.Builder
for i, n := range results {
sb.WriteString(strconv.Itoa(n))
if i < len(results)-1 {
sb.WriteRune(',')
}
}
return sb.String(), nil
}

15
day-17/internal/one/solve_internal_test.go Normal file
View File

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

49
day-17/internal/one/util.go Normal file
View File

@ -0,0 +1,49 @@
package one
import (
"bufio"
"io"
"regexp"
"strconv"
"strings"
)
var (
reRegister = regexp.MustCompile(`Register (?P<identifier>[A-Z]): (?P<value>[0-9]+)`)
reProgram = regexp.MustCompile(`Program: (?P<instructions>[0-9,]+)`)
)
func parseLines(r io.Reader) (map[string]int, []int, error) {
registers := make(map[string]int)
var instructions []int
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
switch line := line; {
case reRegister.MatchString(line):
m := reRegister.FindStringSubmatch(line)
registers[m[1]] = mustConv(m[2])
case reProgram.MatchString(line):
m := reProgram.FindStringSubmatch(line)
for _, n := range strings.Split(m[1], ",") {
instructions = append(instructions, mustConv(n))
}
}
}
if err := scanner.Err(); err != nil {
return nil, nil, err
}
return registers, instructions, nil
}
func mustConv(s string) int {
n, err := strconv.Atoi(s)
if err != nil {
panic(err)
}
return n
}

6
day-17/internal/two/benchmark Normal file
View File

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

114
day-17/internal/two/computer.go Normal file
View File

@ -0,0 +1,114 @@
package two
import (
"math"
)
type computer struct {
registers map[string]int64
instructionMap map[int64]instructionFn
}
func newComputer(registers map[string]int64) *computer {
c := &computer{
registers: registers,
}
c.instructionMap = map[int64]instructionFn{
0: c.adv,
1: c.bxl,
2: c.bst,
3: c.jnz,
4: c.bxc,
5: c.out,
6: c.bdv,
7: c.cdv,
}
return c
}
func (c *computer) bumpRegisters(next int64) {
c.registers["A"] = next
c.registers["B"] = 0
c.registers["C"] = 0
}
func (c *computer) run(program []int64) []int64 {
results := []int64{}
var ptr int
for ptr < len(program) {
opcode := program[ptr]
jump, doJump, out, doStore := c.performOperation(c.instructionMap[opcode], operand(program[ptr+1]))
if doJump {
ptr = jump
} else {
ptr += 2
}
if doStore {
results = append(results, out)
}
}
return results
}
func (c *computer) performOperation(fn instructionFn, operand operand) (int, bool, int64, bool) {
return fn(operand)
}
func (c *computer) adv(operand operand) (int, bool, int64, bool) {
c.registers["A"] /= int64(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) bxl(operand operand) (int, bool, int64, bool) {
c.registers["B"] ^= int64(operand)
return 0, false, 0, false
}
func (c *computer) bst(operand operand) (int, bool, int64, bool) {
c.registers["B"] = c.combo(operand) % 8
return 0, false, 0, false
}
func (c *computer) jnz(operand operand) (int, bool, int64, bool) {
if c.registers["A"] == 0 {
return 0, false, 0, false
}
return int(operand), true, 0, false
}
func (c *computer) bxc(operand operand) (int, bool, int64, bool) {
c.registers["B"] ^= c.registers["C"]
return 0, false, 0, false
}
func (c *computer) out(operand operand) (int, bool, int64, bool) {
return 0, false, c.combo(operand) % 8, true
}
func (c *computer) bdv(operand operand) (int, bool, int64, bool) {
c.registers["B"] = c.registers["A"] / int64(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) cdv(operand operand) (int, bool, int64, bool) {
c.registers["C"] = c.registers["A"] / int64(math.Pow(2, float64(c.combo(operand))))
return 0, false, 0, false
}
func (c *computer) combo(operand operand) int64 {
switch operand {
case 0, 1, 2, 3:
return int64(operand)
case 4:
return int64(c.registers["A"])
case 5:
return int64(c.registers["B"])
case 6:
return int64(c.registers["C"])
default:
return 0
}
}

33
day-17/internal/two/computer_internal_test.go Normal file
View File

@ -0,0 +1,33 @@
package two
import (
"slices"
"testing"
)
func TestComputerRunProgram1(t *testing.T) {
tt := map[string]struct {
registers map[string]int64
program []int64
}{
"register C contains 9 with program 2,6, should set register B to 1": {
registers: map[string]int64{
"A": 117440,
"B": 0,
"C": 0,
},
program: []int64{0, 3, 5, 4, 3, 0},
},
}
c := newComputer(nil)
for name, tc := range tt {
t.Run(name, func(t *testing.T) {
c.registers = tc.registers
got := c.run(tc.program)
if !slices.Equal(got, tc.program) {
t.Errorf("output: %q, expected %q", got, tc.program)
}
})
}
}

57
day-17/internal/two/solve.go Normal file
View File

@ -0,0 +1,57 @@
package two
import (
"bytes"
"math"
"slices"
)
type operand int
type instructionFn func(operand) (int, bool, int64, bool)
func Solve(buf []byte) (int64, error) {
r := bytes.NewReader(buf)
_, program, err := parseLines(r)
if err != nil {
return 0, err
}
computer := newComputer(make(map[string]int64))
a := lowestA(program, computer)
return a, nil
}
func lowestA(program []int64, computer *computer) int64 {
var a int64 = 1
computer.bumpRegisters(a)
var results []int64
for {
results = computer.run(program)
if slices.Equal(results, program) {
return a
}
if len(program) > len(results) {
a *= 2
computer.bumpRegisters(a)
continue
}
if len(program) == len(results) {
for j := len(program) - 1; j >= 0; j-- {
if program[j] != results[j] {
a += int64(math.Pow(8, float64(j)))
break
}
}
}
if len(program) < len(results) {
a /= 2
}
computer.bumpRegisters(a)
}
}

15
day-17/internal/two/solve_internal_test.go Normal file
View File

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

49
day-17/internal/two/util.go Normal file
View File

@ -0,0 +1,49 @@
package two
import (
"bufio"
"io"
"regexp"
"strconv"
"strings"
)
var (
reRegister = regexp.MustCompile(`Register (?P<identifier>[A-Z]): (?P<value>[0-9]+)`)
reProgram = regexp.MustCompile(`Program: (?P<instructions>[0-9,]+)`)
)
func parseLines(r io.Reader) (map[string]int64, []int64, error) {
registers := make(map[string]int64)
var instructions []int64
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
switch line := line; {
case reRegister.MatchString(line):
m := reRegister.FindStringSubmatch(line)
registers[m[1]] = mustConv(m[2])
case reProgram.MatchString(line):
m := reProgram.FindStringSubmatch(line)
for _, n := range strings.Split(m[1], ",") {
instructions = append(instructions, mustConv(n))
}
}
}
if err := scanner.Err(); err != nil {
return nil, nil, err
}
return registers, instructions, nil
}
func mustConv(s string) int64 {
n, err := strconv.Atoi(s)
if err != nil {
panic(err)
}
return int64(n)
}

30
day-17/makefile Normal file
View File

@ -0,0 +1,30 @@
program = day-17
GO = go
SRC_DIR := src
BIN_DIR := bin
EXE := $(BIN_DIR)/$(program)
.DEFAULT_GOAL := build
.PHONY: fmt vet build bench clean
fmt:
$(GO) fmt ./...
vet: fmt
$(GO) vet ./...
build: vet | $(BIN_DIR)
$(GO) build -o $(EXE) ./$(SRC_DIR)
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-17/solve.go Normal file
View File

@ -0,0 +1,20 @@
package dayseventeen
import (
"github.com/onyx-and-iris/aoc2024/day-17/internal/one"
"github.com/onyx-and-iris/aoc2024/day-17/internal/two"
)
func Solve(buf []byte) (string, int64, error) {
answerOne, err := one.Solve(buf)
if err != nil {
return "", 0, err
}
answerTwo, err := two.Solve(buf)
if err != nil {
return "", 0, err
}
return answerOne, answerTwo, nil
}

15
day-17/solve_internal_test.go Normal file
View File

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