onyx_online/aoc2024
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/aoc2024.git synced 2026-04-08 18:13:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

implement using custom sort function on an update struct

Browse Source 
rerun benchmarks
This commit is contained in:
onyx-and-iris
2024-12-09 01:05:54 +00:00
parent 965e704d39
commit 6b7f79b6f0
7 changed files with 85 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
day-05/internal/two/benchmark
View File

@@ -2,5 +2,5 @@ goos: linux
goarch: amd64
pkg: github.com/onyx-and-iris/aoc2024/day-05/internal/two
cpu: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz
BenchmarkSolve-12 1000000000 0.01270 ns/op
ok github.com/onyx-and-iris/aoc2024/day-05/internal/two 0.083s
BenchmarkSolve-12 1000000000 0.0004492 ns/op
ok github.com/onyx-and-iris/aoc2024/day-05/internal/two 0.008s

48
day-05/internal/two/solve.go
View File

@@ -4,62 +4,26 @@ import (
"bytes"
"slices"
log "github.com/sirupsen/logrus"
"github.com/onyx-and-iris/aoc2024/day-05/internal/util"
)
func Solve(buf []byte) (int, error) {
r := bytes.NewReader(buf)
data, err := util.ParseLines(r)
updates, orderings, err := util.ParseLines(r)
if err != nil {
return 0, err
}
var sum int
for i, products := range data[1] {
inOrder := true
for _, product := range products {
for _, rulesets := range data[0] {
if !slices.Contains(rulesets, product) {
continue
}
for _, update := range updates {
beforeSort := slices.Clone(update.Pages)
update.Sort(orderings)
indx1, indx2 := slices.Index(products, rulesets[0]), slices.Index(products, rulesets[1])
if indx1 != -1 && indx2 != -1 && indx2 < indx1 {
inOrder = false
break
}
}
if !inOrder {
break
}
}
if !inOrder {
sum += midOfFixedOrder(data[1][i], data[0])
if slices.Compare(beforeSort, update.Pages) != 0 {
sum += update.Pages[len(update.Pages)/2]
}
}
return sum, nil
}
func midOfFixedOrder(products []int, rulesets [][]int) int {
log.Debugf("unordered products: %v", products)
for {
var sorts int
for _, ruleset := range rulesets {
indx1, indx2 := slices.Index(products, ruleset[0]), slices.Index(products, ruleset[1])
if indx1 != -1 && indx2 != -1 && indx2 < indx1 {
products[indx1], products[indx2] = products[indx2], products[indx1]
sorts++
}
}
if sorts == 0 {
break
}
}
return products[len(products)/2]
}