From 6cb3fd16547209655b2082ec982f1e47f6fc6e74 Mon Sep 17 00:00:00 2001 From: onyx-and-iris Date: Wed, 18 Dec 2024 15:02:35 +0000 Subject: [PATCH] add day-17 + benchmarks --- day-17/benchmark | 15 +++ day-17/cmd/cli/main.go | 41 +++++++ day-17/go.mod | 7 ++ day-17/go.sum | 16 +++ day-17/internal/one/benchmark | 6 + day-17/internal/one/computer.go | 108 +++++++++++++++++ day-17/internal/one/computer_internal_test.go | 94 +++++++++++++++ day-17/internal/one/solve.go | 31 +++++ day-17/internal/one/solve_internal_test.go | 15 +++ day-17/internal/one/util.go | 49 ++++++++ day-17/internal/two/benchmark | 6 + day-17/internal/two/computer.go | 114 ++++++++++++++++++ day-17/internal/two/computer_internal_test.go | 33 +++++ day-17/internal/two/solve.go | 57 +++++++++ day-17/internal/two/solve_internal_test.go | 15 +++ day-17/internal/two/util.go | 49 ++++++++ day-17/makefile | 30 +++++ day-17/solve.go | 20 +++ day-17/solve_internal_test.go | 15 +++ 19 files changed, 721 insertions(+) create mode 100644 day-17/benchmark create mode 100644 day-17/cmd/cli/main.go create mode 100644 day-17/go.mod create mode 100644 day-17/go.sum create mode 100644 day-17/internal/one/benchmark create mode 100644 day-17/internal/one/computer.go create mode 100644 day-17/internal/one/computer_internal_test.go create mode 100644 day-17/internal/one/solve.go create mode 100644 day-17/internal/one/solve_internal_test.go create mode 100644 day-17/internal/one/util.go create mode 100644 day-17/internal/two/benchmark create mode 100644 day-17/internal/two/computer.go create mode 100644 day-17/internal/two/computer_internal_test.go create mode 100644 day-17/internal/two/solve.go create mode 100644 day-17/internal/two/solve_internal_test.go create mode 100644 day-17/internal/two/util.go create mode 100644 day-17/makefile create mode 100644 day-17/solve.go create mode 100644 day-17/solve_internal_test.go diff --git a/day-17/benchmark b/day-17/benchmark new file mode 100644 index 0000000..cfefd46 --- /dev/null +++ b/day-17/benchmark @@ -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 diff --git a/day-17/cmd/cli/main.go b/day-17/cmd/cli/main.go new file mode 100644 index 0000000..a9c7677 --- /dev/null +++ b/day-17/cmd/cli/main.go @@ -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) +} diff --git a/day-17/go.mod b/day-17/go.mod new file mode 100644 index 0000000..5765268 --- /dev/null +++ b/day-17/go.mod @@ -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 diff --git a/day-17/go.sum b/day-17/go.sum new file mode 100644 index 0000000..8d5c188 --- /dev/null +++ b/day-17/go.sum @@ -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= diff --git a/day-17/internal/one/benchmark b/day-17/internal/one/benchmark new file mode 100644 index 0000000..7eb7dc5 --- /dev/null +++ b/day-17/internal/one/benchmark @@ -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 diff --git a/day-17/internal/one/computer.go b/day-17/internal/one/computer.go new file mode 100644 index 0000000..3e6a9ee --- /dev/null +++ b/day-17/internal/one/computer.go @@ -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 + } +} diff --git a/day-17/internal/one/computer_internal_test.go b/day-17/internal/one/computer_internal_test.go new file mode 100644 index 0000000..c0cef7d --- /dev/null +++ b/day-17/internal/one/computer_internal_test.go @@ -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) + } + }) + } +} diff --git a/day-17/internal/one/solve.go b/day-17/internal/one/solve.go new file mode 100644 index 0000000..86fad61 --- /dev/null +++ b/day-17/internal/one/solve.go @@ -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 +} diff --git a/day-17/internal/one/solve_internal_test.go b/day-17/internal/one/solve_internal_test.go new file mode 100644 index 0000000..e5fd7ea --- /dev/null +++ b/day-17/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) +} diff --git a/day-17/internal/one/util.go b/day-17/internal/one/util.go new file mode 100644 index 0000000..093fc70 --- /dev/null +++ b/day-17/internal/one/util.go @@ -0,0 +1,49 @@ +package one + +import ( + "bufio" + "io" + "regexp" + "strconv" + "strings" +) + +var ( + reRegister = regexp.MustCompile(`Register (?P[A-Z]): (?P[0-9]+)`) + reProgram = regexp.MustCompile(`Program: (?P[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 +} diff --git a/day-17/internal/two/benchmark b/day-17/internal/two/benchmark new file mode 100644 index 0000000..2d3fa53 --- /dev/null +++ b/day-17/internal/two/benchmark @@ -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 diff --git a/day-17/internal/two/computer.go b/day-17/internal/two/computer.go new file mode 100644 index 0000000..15e792f --- /dev/null +++ b/day-17/internal/two/computer.go @@ -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 + } +} diff --git a/day-17/internal/two/computer_internal_test.go b/day-17/internal/two/computer_internal_test.go new file mode 100644 index 0000000..14a754b --- /dev/null +++ b/day-17/internal/two/computer_internal_test.go @@ -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) + } + }) + } +} diff --git a/day-17/internal/two/solve.go b/day-17/internal/two/solve.go new file mode 100644 index 0000000..c0627c1 --- /dev/null +++ b/day-17/internal/two/solve.go @@ -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) + } +} diff --git a/day-17/internal/two/solve_internal_test.go b/day-17/internal/two/solve_internal_test.go new file mode 100644 index 0000000..ecb05d5 --- /dev/null +++ b/day-17/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) +} diff --git a/day-17/internal/two/util.go b/day-17/internal/two/util.go new file mode 100644 index 0000000..e3ba8e4 --- /dev/null +++ b/day-17/internal/two/util.go @@ -0,0 +1,49 @@ +package two + +import ( + "bufio" + "io" + "regexp" + "strconv" + "strings" +) + +var ( + reRegister = regexp.MustCompile(`Register (?P[A-Z]): (?P[0-9]+)`) + reProgram = regexp.MustCompile(`Program: (?P[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) +} diff --git a/day-17/makefile b/day-17/makefile new file mode 100644 index 0000000..e4f8952 --- /dev/null +++ b/day-17/makefile @@ -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) diff --git a/day-17/solve.go b/day-17/solve.go new file mode 100644 index 0000000..25c5ccd --- /dev/null +++ b/day-17/solve.go @@ -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 +} diff --git a/day-17/solve_internal_test.go b/day-17/solve_internal_test.go new file mode 100644 index 0000000..62fed18 --- /dev/null +++ b/day-17/solve_internal_test.go @@ -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) +}