chore: add day20

This commit is contained in:
xuu 2023-12-21 13:18:43 -07:00
parent 13888edaff
commit efc30cf5b7
Signed by: xuu
GPG Key ID: 8B3B0604F164E04F
4 changed files with 433 additions and 11 deletions

View File

View File

@ -0,0 +1,58 @@
%vg -> lf, vd
%dr -> kg
%cn -> mv, pt
%rq -> bk, gr
%vp -> lp, bk
%kg -> lv
%lv -> jc, tp
%sj -> rm, vd
%jc -> tp, qr
%km -> tp, dr
%jx -> cn
&vd -> tf, lf, nb, cx, hx, lr
%lp -> jt, bk
%vj -> ps
broadcaster -> km, lr, xh, rf
%dj -> pt, gc
%cg -> vd, hx
&ln -> tg
%fl -> pt, sk
%lm -> tr, bk
%lr -> vd, vg
&pt -> vq, rf, cm, jx, rg
%cx -> gp
%gp -> vd, sj
&db -> tg
%st -> vd
%jt -> bk
%jh -> lm, bk
%xf -> bd, tp
%gc -> cm, pt
&tp -> dr, km, kg, db, vj, qr
%ps -> xf, tp
%rf -> pt, dj
%lf -> nb
%bd -> tp, gg
%dk -> tp, vj
%mn -> jh, bk
&tg -> rx
%ql -> bk, zx
%tr -> bk, vp
%sk -> pt
%nb -> cg
%sb -> vd, cx
%qr -> dk
%xh -> bk, ql
%rg -> sd
%hx -> sb
%sd -> pt, jx
%gr -> bk, mn
%gg -> tp
%zx -> rq
&bk -> xh, ln, zx
%rm -> st, vd
%hq -> fl, pt
&vq -> tg
%cm -> rg
&tf -> tg
%mv -> pt, hq

View File

@ -4,8 +4,11 @@ import (
"bufio" "bufio"
_ "embed" _ "embed"
"fmt" "fmt"
"os"
"strings"
aoc "go.sour.is/advent-of-code" aoc "go.sour.is/advent-of-code"
"golang.org/x/exp/maps"
) )
// var log = aoc.Log // var log = aoc.Log
@ -20,11 +23,357 @@ type result struct {
func (r result) String() string { return fmt.Sprintf("%#v", r) } func (r result) String() string { return fmt.Sprintf("%#v", r) }
func run(scan *bufio.Scanner) (*result, error) { func run(scan *bufio.Scanner) (*result, error) {
var forever bool
for scan.Scan() { if os.Getenv("AOC_FOREVER") == "1" {
_ = scan.Text() forever = true
} }
return &result{}, nil m := &machine{}
receivers := make(map[string][]string)
m.Add("rx", &rx{})
for scan.Scan() {
text := scan.Text()
name, text, _ := strings.Cut(text, " -> ")
dest := strings.Split(text, ", ")
switch {
case name == "broadcaster":
m.Add(name, &broadcaster{dest: dest})
case strings.HasPrefix(name, "%"):
name = strings.TrimPrefix(name, "%")
m.Add(name, &flipflop{name: name, dest: dest})
case strings.HasPrefix(name, "&"):
name = strings.TrimPrefix(name, "&")
m.Add(name, &conjuction{name: name, dest: dest})
}
for _, d := range dest {
receivers[d] = append(receivers[d], name)
}
}
m.Setup(receivers)
result := &result{}
if forever {
i := 0
defer func() {
if p := recover(); p != nil {
fmt.Printf("## Press %d FINISH %v ##", i, p)
os.Exit(1)
}
}()
for {
if i%12345 == 0 {
fmt.Printf("## Press %d ##\r", i)
}
m.Push(i)
i++
}
}
for i := 0; i < 4_0000; i++ {
// fmt.Printf("\n## Press %d ##\n\n", i)
if i == 1000 {
result.valuePT1 = m.highPulses * m.lowPulses
}
m.Push(i)
}
// fmt.Println("\n## SUMMARY ##")
// fmt.Println("Sent", LOW, m.lowPulses)
// fmt.Println("Sent", HIGH, m.highPulses)
var lvalues []int
for _, p := range m.m {
if p, ok := p.(*conjuction); ok && in(p.name, []string{"bk","tp","pt","vd"}) {
var values []int
for k, v := range p.pushes {
for i, h := range makeHistory(v) {
if i == 1 && len(h) > 3 && h[0] > 0 { //&& all(h[0], h[1:]...) {
fmt.Println(p.name, k, i, h[0])
values = append(values, h[0])
}
}
}
max := aoc.Max(values[0], values...)
fmt.Println(p.name, "MAX", max, values)
lvalues = append(lvalues, max)
}
}
result.valuePT2 = aoc.LCM(lvalues...)
fmt.Println("tg", "LCM", result.valuePT2, lvalues)
// trace("rx", receivers)
return result, nil
}
type signal bool
const (
LOW signal = false
HIGH signal = true
)
func (m signal) String() string {
if m {
return " >>-HIGH-> "
}
return " >>-LOW-> "
}
type message struct {
signal
from, to string
}
func (m message) String() string {
return fmt.Sprint(m.from, m.signal, m.to)
}
type pulser interface {
Pulse(message)
SetMachine(*machine)
}
type machine struct {
m map[string]pulser
press int
queue []message
hwm int
stop bool
highPulses int
lowPulses int
}
func (m *machine) Add(name string, p pulser) {
if m.m == nil {
m.m = make(map[string]pulser)
}
p.SetMachine(m)
m.m[name] = p
}
func (m *machine) Send(msgs ...message) {
m.queue = append(m.queue, msgs...)
for _, msg := range msgs {
// fmt.Println(msg)
if msg.signal {
m.highPulses++
} else {
m.lowPulses++
}
}
}
func (m *machine) Push(i int) {
m.press = i
m.Send(generate(LOW, "button", "broadcaster")...)
m.processQueue(i)
}
func (m *machine) processQueue(i int) {
// look for work and process up to the queue length. repeat.
hwm := 0
for hwm < len(m.queue) {
end := len(m.queue)
for ; hwm < end; hwm++ {
msg := m.queue[hwm]
if p, ok := m.m[msg.to]; ok {
// fmt.Println(i, "S:", m.m[msg.from], msg.signal, "R:", p)
p.Pulse(msg)
}
}
hwm = 0
copy(m.queue, m.queue[end:])
m.queue = m.queue[:len(m.queue)-end]
// fmt.Println("")
}
}
func (m *machine) Setup(receivers map[string][]string) {
for name, recv := range receivers {
if p, ok := m.m[name]; ok {
if p, ok := p.(interface{ Receive(...string) }); ok {
p.Receive(recv...)
}
}
}
}
func (m *machine) Stop() {
m.stop = true
}
type IsModule struct {
*machine
}
func (p *IsModule) SetMachine(m *machine) { p.machine = m }
type broadcaster struct {
dest []string
IsModule
}
func (b *broadcaster) Pulse(msg message) {
b.Send(generate(msg.signal, "broadcaster", b.dest...)...)
}
func (b *broadcaster) String() string { return "br" }
type flipflop struct {
name string
state signal
dest []string
IsModule
}
func (b *flipflop) Pulse(msg message) {
if !msg.signal {
b.state = !b.state
b.Send(generate(b.state, b.name, b.dest...)...)
}
}
func (b *flipflop) String() string {
return fmt.Sprintf("%s(%v)", b.name, b.state)
}
type conjuction struct {
name string
state map[string]signal
dest []string
pushes map[string][]int
activate []int
last map[string]int
max map[string]int
lcm int
IsModule
}
func (b *conjuction) Receive(names ...string) {
if b.state == nil {
b.state = make(map[string]signal)
b.last = make(map[string]int)
b.max = make(map[string]int)
b.pushes = make(map[string][]int)
}
for _, name := range names {
b.state[name] = false
b.max[name] = int(^uint(0)>>1)
b.pushes[name] = []int{}
}
}
func (b *conjuction) Pulse(msg message) {
if b.state == nil {
b.state = make(map[string]signal)
b.last = make(map[string]int)
b.max = make(map[string]int)
}
b.state[msg.from] = msg.signal
if msg.signal {
b.pushes[msg.from] = append(b.pushes[msg.from], b.press)
b.last[msg.from] = b.press - b.last[msg.from]
// vals := maps.Values(b.max)
// if aoc.Min(vals[0], vals...) != 0 {
// if lcm := aoc.LCM(vals...); lcm > 0 {
// fmt.Printf("\nfound loop %s = %d %v\n", b.name, lcm, vals)
// }
// }
}
if all(HIGH, maps.Values(b.state)...) {
b.activate = append(b.activate, b.press)
b.Send(generate(LOW, b.name, b.dest...)...)
return
}
b.Send(generate(HIGH, b.name, b.dest...)...)
}
func (b *conjuction) String() string {
return fmt.Sprintf("%s(%v)", b.name, b.state)
}
type rx struct {
IsModule
}
func (rx *rx) Pulse(msg message) {
if !msg.signal {
panic("pulse received")
}
}
func (rx *rx) String() string { return "rx" }
func all[T ~int|~bool](match T, lis ...T) bool {
if len(lis) == 0 {
return true
}
for _, b := range lis {
if b != match {
return false
}
}
return true
}
func generate(t signal, from string, destinations ...string) []message {
msgs := make([]message, len(destinations))
for i, to := range destinations {
msgs[i] = message{signal: t, from: from, to: to}
}
return msgs
}
func in(n string, haystack []string) bool {
for _, h := range haystack {
if n == h {
return true
}
}
return false
}
func makeHistory(in []int) [][]int {
var history [][]int
history = append(history, in)
for {
var diffs []int
current := history[len(history)-1]
if len(current) == 0 { return nil }
for i := range current[1:] {
diffs = append(diffs, current[i+1]-current[i])
}
history = append(history, diffs)
if len(diffs) == 0 || aoc.Max(diffs[0], diffs[1:]...) == 0 && aoc.Min(diffs[0], diffs[1:]...) == 0 {
break
}
}
return history
} }

View File

@ -10,21 +10,36 @@ import (
"github.com/matryer/is" "github.com/matryer/is"
) )
//go:embed example.txt //go:embed example1.txt
var example []byte var example1 []byte
//go:embed example2.txt
var example2 []byte
//go:embed input.txt //go:embed input.txt
var input []byte var input []byte
func TestExample(t *testing.T) { func TestExample1(t *testing.T) {
is := is.New(t) is := is.New(t)
scan := bufio.NewScanner(bytes.NewReader(example)) scan := bufio.NewScanner(bytes.NewReader(example1))
result, err := run(scan) result, err := run(scan)
is.NoErr(err) is.NoErr(err)
t.Log(result) t.Log(result)
is.Equal(result.valuePT1, 0) is.Equal(result.valuePT1, 32000000)
is.Equal(result.valuePT2, 0)
}
func TestExample2(t *testing.T) {
is := is.New(t)
scan := bufio.NewScanner(bytes.NewReader(example2))
result, err := run(scan)
is.NoErr(err)
t.Log(result)
is.Equal(result.valuePT1, 11687500)
is.Equal(result.valuePT2, 0) is.Equal(result.valuePT2, 0)
} }
@ -36,6 +51,6 @@ func TestSolution(t *testing.T) {
is.NoErr(err) is.NoErr(err)
t.Log(result) t.Log(result)
is.Equal(result.valuePT1, 0) is.Equal(result.valuePT1, 819397964)
is.Equal(result.valuePT2, 0) is.Equal(result.valuePT2, 0)
} }