chore(aoc): add FibHeap DecreaseKey

Reviewed-on: #18

.gitea/workflows/test.yml

@@ -28,6 +28,6 @@ jobs:
         go-version: 1.21.3
 
     - name: Test
-      run: go test --race -cover ./...
+      run: go test -timeout 240s -race -cover ./...
 
     - run: echo "🍏 This job's status is ${{ job.status }}."

aoc_test.go

@@ -0,0 +1,377 @@
+package aoc_test
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+
+	"github.com/matryer/is"
+	aoc "go.sour.is/advent-of-code"
+)
+
+func TestReverse(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.Reverse([]int{1, 2, 3, 4}), []int{4, 3, 2, 1})
+}
+
+func TestLCM(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.LCM([]int{}...), 0)
+	is.Equal(aoc.LCM(5), 5)
+	is.Equal(aoc.LCM(5, 3), 15)
+	is.Equal(aoc.LCM(5, 3, 2), 30)
+}
+
+func TestReadStringToInts(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.ReadStringToInts([]string{"1", "2", "3"}), []int{1, 2, 3})
+}
+
+func TestRepeat(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.Repeat(5, 3), []int{5, 5, 5})
+}
+
+func TestPower2(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.Power2(0), 1)
+	is.Equal(aoc.Power2(1), 2)
+	is.Equal(aoc.Power2(2), 4)
+}
+
+func TestABS(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(aoc.ABS(1), 1)
+	is.Equal(aoc.ABS(0), 0)
+	is.Equal(aoc.ABS(-1), 1)
+}
+
+func TestTranspose(t *testing.T) {
+	is := is.New(t)
+
+	is.Equal(
+		aoc.Transpose(
+			[][]int{
+				{1, 1},
+				{0, 0},
+				{1, 1},
+			},
+		),
+		[][]int{
+			{1, 0, 1},
+			{1, 0, 1},
+		},
+	)
+}
+
+func TestList(t *testing.T) {
+	is := is.New(t)
+
+	lis := aoc.NewList[int](nil)
+	lis.Add(5, 0)
+
+	a, _ := lis.Head().Value()
+
+	is.Equal(a, 5)
+}
+
+func TestPriorityQueue(t *testing.T) {
+	is := is.New(t)
+
+	type elem [2]int
+	less := func(b, a *elem) bool {
+		return (*a)[0] < (*b)[0]
+	}
+
+	pq := aoc.PriorityQueue(less)
+
+	pq.Insert(&elem{1, 4})
+	pq.Insert(&elem{3, 2})
+	pq.Insert(&elem{2, 3})
+	pq.Insert(&elem{4, 1})
+
+	v := pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{4, 1})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{3, 2})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{2, 3})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{1, 4})
+
+	v = pq.ExtractMin()
+	is.True(v == nil)
+}
+
+func TestSet(t *testing.T) {
+	is := is.New(t)
+
+	s := aoc.Set(1, 2, 3)
+	is.True(!s.Has(0))
+	is.True(s.Has(1))
+	is.True(s.Has(2))
+	is.True(s.Has(3))
+	is.True(!s.Has(4))
+
+	s.Add(4)
+	is.True(s.Has(4))
+
+	items := s.Items()
+	sort.Ints(items)
+	is.Equal(items, []int{1, 2, 3, 4})
+}
+
+func ExamplePriorityQueue() {
+	type memo struct {
+		pt    int
+		score int
+	}
+	less := func(a, b *memo) bool { return a.score < b.score }
+
+	adj := map[int][][2]int{
+		0: {{1, 2}, {2, 6}},
+		1: {{3, 5}},
+		2: {{3, 8}},
+		3: {{4, 10}, {5, 15}},
+		4: {{6, 2}},
+		5: {{6, 6}},
+	}
+
+	pq := aoc.PriorityQueue(less)
+	visited := aoc.Set([]int{}...)
+	dist := aoc.DefaultMap[int](int(^uint(0) >> 1))
+
+	dist.Set(0, 0)
+	pq.Insert(&memo{0, 0})
+
+	for !pq.IsEmpty() {
+		m := pq.ExtractMin()
+
+		u := m.pt
+		if visited.Has(u) {
+			continue
+		}
+		visited.Add(u)
+
+		du, _ := dist.Get(u)
+
+		for _, edge := range adj[u] {
+			v, w := edge[0], edge[1]
+			dv, _ := dist.Get(v)
+
+			if !visited.Has(v) && du+w < dv {
+				dist.Set(v, du+w)
+				pq.Insert(&memo{v, du + w})
+			}
+		}
+	}
+
+	items := dist.Items()
+	sort.Slice(items, func(i, j int) bool { return items[i].K < items[j].K })
+	for _, v := range items {
+		fmt.Printf("point %d is %d steps away.\n", v.K, v.V)
+	}
+
+	// Output:
+	// point 0 is 0 steps away.
+	// point 1 is 2 steps away.
+	// point 2 is 6 steps away.
+	// point 3 is 7 steps away.
+	// point 4 is 17 steps away.
+	// point 5 is 22 steps away.
+	// point 6 is 19 steps away.
+}
+
+func TestStack(t *testing.T) {
+	is := is.New(t)
+
+	s := aoc.Stack(1, 2, 3, 4)
+	is.True(!s.IsEmpty())
+	is.Equal(s.Pop(), 4)
+	is.Equal(s.Pop(), 3)
+	is.Equal(s.Pop(), 2)
+	is.Equal(s.Pop(), 1)
+	is.True(s.IsEmpty())
+	s.Push(4, 3, 2, 1)
+	is.True(!s.IsEmpty())
+	is.Equal(s.Pop(), 1)
+	is.Equal(s.Pop(), 2)
+	is.Equal(s.Pop(), 3)
+	is.Equal(s.Pop(), 4)
+	is.True(s.IsEmpty())
+}
+
+func TestGraph(t *testing.T) {
+	is := is.New(t)
+
+	var adjacencyList = map[int][]int{
+		2: {3, 5, 1},
+		1: {2, 4},
+		3: {6, 2},
+		4: {1, 5, 7},
+		5: {2, 6, 8, 4},
+		6: {3, 0, 9, 5},
+		7: {4, 8},
+		8: {5, 9, 7},
+		9: {6, 0, 8},
+	}
+
+	g := aoc.Graph(aoc.WithAdjacencyList[int, int](adjacencyList))
+	is.Equal(g.Neighbors(1), []int{2, 4})
+	is.Equal(map[int][]int(g.AdjacencyList()), adjacencyList)
+}
+
+func ExampleFibHeap() {
+	type memo struct {
+		pt    int
+		score int
+	}
+	less := func(a, b *memo) bool { return (*a).score < (*b).score }
+
+	adj := map[int][][2]int{
+		0: {{1, 2}, {2, 6}},
+		1: {{3, 5}},
+		2: {{3, 8}},
+		3: {{4, 10}, {5, 15}},
+		4: {{6, 2}},
+		5: {{6, 6}},
+	}
+
+	pq := aoc.FibHeap(less)
+	visited := aoc.Set([]int{}...)
+	dist := aoc.DefaultMap[int](int(^uint(0) >> 1))
+
+	dist.Set(0, 0)
+	pq.Insert(&memo{0, 0})
+
+	for !pq.IsEmpty() {
+		m := pq.ExtractMin()
+
+		u := m.pt
+		if visited.Has(u) {
+			continue
+		}
+		visited.Add(u)
+
+		du, _ := dist.Get(u)
+
+		for _, edge := range adj[u] {
+			v, w := edge[0], edge[1]
+			dv, _ := dist.Get(v)
+
+			if !visited.Has(v) && du+w < dv {
+				dist.Set(v, du+w)
+				pq.Insert(&memo{v, du + w})
+			}
+		}
+	}
+
+	items := dist.Items()
+	sort.Slice(items, func(i, j int) bool { return items[i].K < items[j].K })
+	for _, v := range items {
+		fmt.Printf("point %d is %d steps away.\n", v.K, v.V)
+	}
+
+	// Output:
+	// point 0 is 0 steps away.
+	// point 1 is 2 steps away.
+	// point 2 is 6 steps away.
+	// point 3 is 7 steps away.
+	// point 4 is 17 steps away.
+	// point 5 is 22 steps away.
+	// point 6 is 19 steps away.
+}
+
+func TestFibHeap(t *testing.T) {
+	is := is.New(t)
+
+	type elem [2]int
+	less := func(a, b *elem) bool {
+		return (*a)[0] < (*b)[0]
+	}
+
+	pq := aoc.FibHeap(less)
+
+	pq.Insert(&elem{1, 4})
+	pq.Insert(&elem{3, 2})
+	pq.Insert(&elem{2, 3})
+	pq.Insert(&elem{4, 1})
+
+	v := pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{1, 4})
+
+	pq.Insert(&elem{5, 8})
+	pq.Insert(&elem{6, 7})
+	pq.Insert(&elem{7, 6})
+	pq.Insert(&elem{8, 5})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{2, 3})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{3, 2})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{4, 1})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{5, 8})
+
+	m := aoc.FibHeap(less)
+	m.Insert(&elem{1, 99})
+	m.Insert(&elem{12, 9})
+	m.Insert(&elem{11, 10})
+	m.Insert(&elem{10, 11})
+	m.Insert(&elem{9, 12})
+
+	pq.Merge(m)
+
+	v = pq.Find(func(t *elem) bool {
+		return (*t)[0] == 6
+	})
+	is.Equal(v, &elem{6, 7})
+
+	v = pq.Find(func(t *elem) bool {
+		return (*t)[0] == 12
+	})
+	is.Equal(v, &elem{12, 9})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{1, 99})
+
+	pq.DecreaseKey(
+		func(t *elem) bool { return t[0] == 12 },
+		func(t *elem) { t[0] = 3 },
+	)
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{3, 9})
+
+	var keys []int
+	for !pq.IsEmpty() {
+		v := pq.ExtractMin()
+		fmt.Println(v)
+		keys = append(keys, v[0])
+	}
+	is.Equal(keys, []int{6, 7, 8, 9, 10, 11})
+}

day01/main_test.go

@@ -30,7 +30,6 @@ func TestExample1(t *testing.T) {
 	is.Equal(result.sum, 142)
 }
 
-
 func TestExample2(t *testing.T) {
 	is := is.New(t)
 	scan := bufio.NewScanner(bytes.NewReader(example2))

day14/main_test.go

@@ -43,4 +43,3 @@ func TestSolution(t *testing.T) {
 	is.Equal(result.valuePT1, 110407)
 	is.Equal(result.valuePT2, 87273)
 }
-

day16/main.go

@@ -32,15 +32,15 @@ func run(scan *bufio.Scanner) (*result, error) {
 
 	options := make([]int, 2*(rows+cols)+2)
 	i := 0
-	for j:=0; j<=rows-1; j++ {
+	for j := 0; j <= rows-1; j++ {
 		options[i+0] = runCycle(m, ray{[2]int{j, -1}, RT})
 		options[i+1] = runCycle(m, ray{[2]int{j, cols}, LF})
-		i+=2
+		i += 2
 	}
-	for j:=0; j<=cols-1; j++ {
+	for j := 0; j <= cols-1; j++ {
 		options[i+0] = runCycle(m, ray{[2]int{-1, j}, DN})
 		options[i+1] = runCycle(m, ray{[2]int{rows, j}, UP})
-		i+=2
+		i += 2
 	}
 
 	// fmt.Println(options)
@@ -96,7 +96,6 @@ func (m *Map) Get(p [2]int) rune {
 	return (*m)[p[0]][p[1]]
 }
 
-
 func runCycle(m Map, r ray) int {
 	current := r
 

day17/main.go

@@ -8,7 +8,7 @@ import (
 	aoc "go.sour.is/advent-of-code"
 )
 
-// var log = aoc.Log
+var log = aoc.Log
 
 func main() { aoc.MustResult(aoc.Runner(run)) }
 
@@ -20,40 +20,206 @@ type result struct {
 func (r result) String() string { return fmt.Sprintf("%#v", r) }
 
 func run(scan *bufio.Scanner) (*result, error) {
-	var m Map
+	var m aoc.Map[int16, rune]
-	var pq aoc.PriorityQueue[int, uint]
 
 	for scan.Scan() {
 		text := scan.Text()
 		m = append(m, []rune(text))
 	}
+	log("start day 17")
 
-	rows := len(m)
+	result := result{}
-	cols := len(m[0])
+	result.valuePT1 = search(m, 1, 3, seenFn)
+	log("result from part 1 = ", result.valuePT1)
 
-	END := [2]int{rows-1, cols-1}
+	result.valuePT2 = search(m, 4, 10, nil)
+	log("result from part 2 = ", result.valuePT2)
 
-	return &result{}, nil
+	return &result, nil
 }
 
-var (
+type Point = aoc.Point[int16]
-	ZERO = [2]int{0, 0}
+type Map = aoc.Map[int16, rune]
 
-	UP = [2]int{-1, 0}
+// rotate for changing direction
-	DN = [2]int{1, 0}
+type rotate int8
-	LF = [2]int{0, -1}
+
-	RT = [2]int{0, 1}
+const (
+	CW  rotate = 1
+	CCW rotate = -1
 )
 
-type Map [][]rune
+// diretion of path steps
+type direction int8
 
-func (m *Map) Get(p [2]int) rune {
+var (
-	if p[0] < 0 || p[0] >= len((*m)) {
+	U = Point{-1, 0}
-		return 0
+	R = Point{0, 1}
-	}
+	D = Point{1, 0}
-	if p[1] < 0 || p[1] >= len((*m)[0]) {
+	L = Point{0, -1}
-		return 0
+)
-	}
 
-	return (*m)[p[0]][p[1]]
+var directions = []Point{U, R, D, L}
+
+var directionIDX = func() map[Point]direction {
+	m := make(map[Point]direction, len(directions))
+	for k, v := range directions {
+		m[v] = direction(k)
+	}
+	return m
+}()
+
+// position on the map
+type position struct {
+	loc       Point
+	direction Point
+	steps     int8
+}
+
+func (p position) step() position {
+	return position{p.loc.Add(p.direction), p.direction, p.steps + 1}
+}
+func (p position) rotateAndStep(towards rotate) position {
+	d := directions[(int8(directionIDX[p.direction])+int8(towards)+4)%4]
+	return position{p.loc.Add(d), d, 1}
+}
+
+// implements FindPath graph interface
+type graph struct {
+	min, max int8
+	m        Map
+	target   Point
+	reads    int
+	seenFn   func(a position) position
+}
+
+// Neighbors returns valid steps from given position. if at target returns none.
+func (g *graph) Neighbors(current position) []position {
+	var nbs []position
+
+	if current.steps == 0 {
+		return []position{
+			{R, R, 1},
+			{D, D, 1},
+		}
+	}
+
+	if current.loc == g.target {
+		return nil
+	}
+
+	if left := current.rotateAndStep(CCW); current.steps >= g.min && g.m.Valid(left.loc) {
+		nbs = append(nbs, left)
+	}
+
+	if right := current.rotateAndStep(CW); current.steps >= g.min && g.m.Valid(right.loc) {
+		nbs = append(nbs, right)
+	}
+
+	if forward := current.step(); current.steps < g.max && g.m.Valid(forward.loc) {
+		nbs = append(nbs, forward)
+	}
+
+	return nbs
+}
+
+// Cost calculates heat cost to neighbor from map
+func (g *graph) Cost(a, b position) int16 {
+	g.reads++
+	_, r, _ := g.m.Get(b.loc)
+	return int16(r - '0')
+}
+
+// Potential calculates distance to target
+// func (g *graph) Potential(a position) int16 {
+// 	return aoc.ManhattanDistance(a.loc, g.target)
+// }
+
+// Target returns true when target reached. receives node and cost.
+func (g *graph) Target(a position, c int16) bool {
+	if a.loc == g.target && a.steps >= g.min && a.steps <= g.max {
+		return true
+	}
+	return false
+}
+
+// Seen attempt at simplifying the seen to use horizontal/vertical and no steps.
+// It returns correct for part1 but not part 2..
+func (g *graph) Seen(a position) position {
+	if g.seenFn != nil {
+		return g.seenFn(a)
+	}
+	return a
+}
+
+func seenFn(a position) position {
+	if a.direction == U {
+		a.direction = D
+	}
+	if a.direction == L {
+		a.direction = R
+	}
+	// a.steps = 0
+	return a
+}
+
+func search(m Map, minSteps, maxSteps int8, seenFn func(position) position) int {
+	rows, cols := m.Size()
+	start := Point{}
+	target := Point{rows - 1, cols - 1}
+
+	g := graph{min: minSteps, max: maxSteps, m: m, target: target, seenFn: seenFn}
+
+	cost, path, closed := aoc.FindPath[int16, position](&g, position{loc: start}, position{loc: target})
+
+	log("total map reads = ", g.reads, "cost = ", cost)
+	printGraph(m, path, closed, g.seenFn)
+
+	return int(cost)
+}
+
+// printGraph with the path/cost overlay
+func printGraph(m Map, path []position, closed map[position]int16, seenFn func(a position) position) {
+	pts := make(map[Point]position, len(path))
+	for _, pt := range path {
+		pts[pt.loc] = pt
+	}
+
+	clpt := make(map[position]position, len(closed))
+	for pt := range closed {
+		clpt[position{loc: pt.loc, steps: pt.steps}] = pt
+	}
+
+	for r, row := range m {
+		// if r == 0 {
+		// 	for c := range row {
+		// 		if c == 0 {
+		// 			fmt.Print("     ")
+		// 		}
+		// 		fmt.Printf("% 5d", c)
+		// 	}
+		// 	fmt.Println("")
+		// }
+		for c := range row {
+			// if c == 0 {
+			// 	fmt.Printf("% 5d", r)
+			// }
+
+			if pt, ok := pts[Point{int16(r), int16(c)}]; ok {
+				if seenFn != nil {
+					pt = seenFn(pt)
+				}
+				_ = pt
+				// fmt.Printf("% 5d", closed[pt])
+				fmt.Print("*")
+
+				continue
+			}
+
+			// fmt.Print(" ....")
+			fmt.Print(" ")
+		}
+		fmt.Println("")
+	}
+	fmt.Println("")
 }

day17/main_test.go

@@ -25,7 +25,7 @@ func TestExample(t *testing.T) {
 
 	t.Log(result)
 	is.Equal(result.valuePT1, 102)
-	is.Equal(result.valuePT2, 0)
+	is.Equal(result.valuePT2, 94)
 }
 
 func TestSolution(t *testing.T) {
@@ -36,6 +36,6 @@ func TestSolution(t *testing.T) {
 	is.NoErr(err)
 
 	t.Log(result)
-	is.Equal(result.valuePT1, 0)
+	is.Equal(result.valuePT1, 843)
-	is.Equal(result.valuePT2, 0)
+	is.Equal(result.valuePT2, 1017)
 }

day18/example.txt

@@ -0,0 +1,14 @@
+R 6 (#70c710)
+D 5 (#0dc571)
+L 2 (#5713f0)
+D 2 (#d2c081)
+R 2 (#59c680)
+D 2 (#411b91)
+L 5 (#8ceee2)
+U 2 (#caa173)
+L 1 (#1b58a2)
+U 2 (#caa171)
+R 2 (#7807d2)
+U 3 (#a77fa3)
+L 2 (#015232)
+U 2 (#7a21e3)

day18/input.txt

@@ -0,0 +1,766 @@
+R 4 (#0a7a60)
+U 8 (#4453b3)
+R 6 (#8e4f70)
+U 2 (#4453b1)
+R 4 (#0feb00)
+U 4 (#355591)
+R 8 (#2a09c0)
+U 4 (#544c71)
+R 4 (#472930)
+U 2 (#199e33)
+R 3 (#3d8df0)
+U 5 (#199e31)
+R 7 (#45de50)
+U 4 (#57a941)
+L 7 (#671c70)
+U 5 (#5e5e81)
+R 4 (#2e9b60)
+U 8 (#490881)
+L 7 (#1846f0)
+U 3 (#304101)
+L 4 (#1846f2)
+D 2 (#58f3f1)
+L 9 (#2e9b62)
+D 2 (#56dcd1)
+L 2 (#671c72)
+D 9 (#275fd1)
+L 4 (#76b7b2)
+U 9 (#5b9641)
+L 4 (#1d3212)
+U 10 (#3d1841)
+L 3 (#5ad5e2)
+D 6 (#010211)
+L 5 (#13ec52)
+D 8 (#166471)
+L 3 (#53ebc0)
+D 5 (#0fdba1)
+L 4 (#54e450)
+D 9 (#440a21)
+L 3 (#49b242)
+D 5 (#2f0171)
+L 6 (#447332)
+D 4 (#182561)
+L 8 (#1aaaa2)
+D 6 (#0996a1)
+L 4 (#1c1212)
+D 6 (#5780d1)
+L 7 (#0fc1d2)
+D 7 (#36cb41)
+L 3 (#505552)
+D 7 (#8d8b81)
+R 4 (#2bf742)
+D 7 (#152791)
+R 5 (#760492)
+D 3 (#11a991)
+R 3 (#5debc0)
+D 10 (#59f211)
+L 4 (#66d342)
+D 8 (#1fc6b1)
+R 4 (#66d340)
+D 6 (#72dff1)
+L 2 (#3f1b10)
+D 4 (#2fca13)
+L 10 (#2d0162)
+D 5 (#8b5e53)
+L 6 (#2d0160)
+U 2 (#317053)
+L 2 (#650c20)
+U 7 (#2bed01)
+R 10 (#409ed0)
+U 2 (#166713)
+L 10 (#939350)
+U 6 (#166711)
+L 4 (#38a180)
+D 3 (#1d95f1)
+L 6 (#11ea60)
+D 5 (#931dc1)
+R 6 (#11bf70)
+D 7 (#536051)
+L 3 (#995b60)
+D 2 (#254e91)
+L 3 (#332fd2)
+U 6 (#7669f1)
+L 3 (#574642)
+U 6 (#1778a1)
+L 3 (#1a00c2)
+U 5 (#2eaa81)
+L 3 (#1cf8e2)
+U 6 (#0c71a1)
+L 6 (#868472)
+U 3 (#0a9fd1)
+R 9 (#104c02)
+U 4 (#082451)
+L 7 (#850d02)
+U 6 (#082453)
+L 7 (#322552)
+U 3 (#1339d1)
+L 6 (#8e11d2)
+U 4 (#6c5691)
+R 6 (#1dda10)
+U 3 (#25e5c3)
+R 7 (#370670)
+U 4 (#9324f1)
+L 3 (#451030)
+U 7 (#1f1021)
+L 7 (#0ba3c0)
+U 5 (#8a10a3)
+L 8 (#67db30)
+U 5 (#282473)
+L 4 (#0cd350)
+U 4 (#25e5c1)
+R 3 (#6b4ee0)
+U 4 (#333cf1)
+R 5 (#02b610)
+D 4 (#4e7cc1)
+R 3 (#92abb0)
+U 5 (#2f6ff1)
+R 5 (#483360)
+U 5 (#7b1cd1)
+L 8 (#3a5d50)
+U 3 (#1d2461)
+R 8 (#3b2fd0)
+U 5 (#630763)
+R 6 (#5033c0)
+U 3 (#252523)
+R 7 (#08eeb0)
+U 8 (#516633)
+L 7 (#156240)
+U 4 (#2db063)
+L 3 (#791070)
+D 5 (#2920a3)
+L 3 (#0dafe0)
+U 5 (#4185b3)
+L 5 (#7ac0e0)
+U 2 (#5a6cd3)
+L 2 (#3ca790)
+U 7 (#755403)
+L 4 (#3b0740)
+U 5 (#2004a3)
+L 3 (#2db4f0)
+U 6 (#602a23)
+R 5 (#32c1c0)
+D 2 (#000f53)
+R 5 (#388360)
+D 7 (#24d9e3)
+R 4 (#4703a0)
+D 3 (#2f1133)
+R 3 (#4703a2)
+U 11 (#52e853)
+R 5 (#278132)
+D 11 (#0665e3)
+R 3 (#239112)
+U 6 (#8f0ad1)
+R 5 (#447de2)
+U 6 (#8f0ad3)
+R 6 (#636122)
+U 2 (#187283)
+R 3 (#5aae62)
+U 10 (#1d8833)
+L 5 (#476db0)
+U 5 (#136393)
+L 7 (#29e6b0)
+U 5 (#136391)
+R 7 (#3ba060)
+U 3 (#635e23)
+L 5 (#2042f0)
+U 3 (#181643)
+L 6 (#5af952)
+U 8 (#28d0b1)
+L 2 (#4a98f2)
+U 9 (#28d0b3)
+L 6 (#27a572)
+D 3 (#3d7213)
+L 4 (#516842)
+D 11 (#21ef63)
+L 5 (#38e342)
+D 2 (#1118b3)
+L 3 (#560502)
+D 9 (#1118b1)
+R 2 (#1c39a2)
+D 2 (#303ab3)
+R 6 (#716ba0)
+D 6 (#780a93)
+L 8 (#77ec30)
+U 2 (#780a91)
+L 3 (#271100)
+U 10 (#5882f3)
+L 4 (#2050c2)
+D 3 (#434843)
+L 3 (#7d9572)
+D 2 (#3129b3)
+L 5 (#21fb12)
+D 5 (#8c2c33)
+L 4 (#57bf92)
+D 6 (#2730b3)
+L 4 (#6a3902)
+D 8 (#4656a3)
+L 5 (#60ac80)
+D 4 (#43b863)
+R 9 (#3d69a0)
+D 8 (#3ca913)
+L 2 (#411d80)
+D 3 (#725383)
+L 8 (#4a98d0)
+D 9 (#274553)
+L 5 (#580d60)
+U 5 (#568223)
+L 6 (#473af0)
+U 5 (#827593)
+L 7 (#251dc2)
+U 5 (#0fcea3)
+L 8 (#5ae3d2)
+U 3 (#4efa11)
+R 9 (#389852)
+U 2 (#7f7f91)
+R 6 (#618342)
+U 3 (#441143)
+L 7 (#886df2)
+U 3 (#26a093)
+L 8 (#886df0)
+U 4 (#63c7d3)
+L 3 (#04f842)
+D 10 (#0fcea1)
+L 6 (#388e62)
+U 10 (#3ae7f3)
+L 3 (#2a6880)
+U 6 (#3bfd53)
+L 6 (#73a0c0)
+U 5 (#3bfd51)
+L 4 (#0d18a0)
+U 2 (#19da93)
+L 6 (#120600)
+U 8 (#233b53)
+L 6 (#2e1050)
+U 3 (#4b2aa3)
+L 4 (#5f9930)
+U 10 (#6e65f1)
+R 6 (#1eefa0)
+U 9 (#50b9d3)
+R 2 (#548ed0)
+U 9 (#50b9d1)
+R 7 (#8bd9f0)
+U 4 (#5ae473)
+R 6 (#0b0490)
+U 10 (#186891)
+R 4 (#764830)
+U 7 (#33b0e1)
+R 5 (#363c90)
+U 8 (#7bd631)
+R 7 (#031e30)
+U 7 (#095881)
+R 3 (#640e50)
+D 5 (#02e7f3)
+R 7 (#0922f0)
+D 7 (#6b7af3)
+R 9 (#0922f2)
+D 3 (#62e543)
+R 3 (#21e320)
+U 9 (#5ead81)
+R 7 (#01fd70)
+D 9 (#3b0cf1)
+R 2 (#2758a0)
+D 5 (#7279b1)
+R 8 (#5c7dc0)
+D 7 (#3c8db1)
+R 4 (#3c3740)
+U 2 (#26b151)
+R 6 (#11eb12)
+U 4 (#587921)
+R 6 (#11eb10)
+U 4 (#320051)
+R 4 (#038630)
+U 3 (#6a2e61)
+R 2 (#4ff680)
+U 5 (#3c57f1)
+R 9 (#0b2440)
+U 8 (#497533)
+L 6 (#704680)
+U 11 (#549113)
+R 6 (#23b470)
+U 4 (#9e0641)
+R 7 (#1aeec0)
+D 7 (#4a6331)
+R 2 (#547d80)
+D 5 (#457a71)
+R 9 (#7daa90)
+D 4 (#16d7b1)
+L 6 (#266810)
+D 3 (#363561)
+L 5 (#5312b2)
+D 4 (#42c301)
+R 5 (#9a0952)
+D 7 (#42c303)
+R 7 (#7d1df2)
+D 4 (#51e321)
+R 5 (#609422)
+D 4 (#3b8f01)
+R 6 (#644792)
+U 4 (#2d8b11)
+R 7 (#22bbc2)
+D 7 (#6b39b1)
+R 5 (#680e72)
+U 2 (#7f9f31)
+R 3 (#0e9b52)
+U 3 (#3086c1)
+R 3 (#5a60c0)
+U 6 (#53b6e3)
+R 7 (#8117d0)
+U 7 (#53b6e1)
+R 3 (#2cb930)
+U 3 (#1bffd1)
+R 6 (#4539f0)
+U 8 (#680411)
+R 4 (#6032c0)
+U 6 (#255061)
+R 3 (#5562a0)
+U 6 (#088071)
+R 3 (#3bf2f0)
+U 5 (#52bdb1)
+L 6 (#070500)
+U 5 (#69e001)
+R 6 (#070502)
+U 3 (#071051)
+R 2 (#036000)
+U 4 (#0ea8a1)
+R 5 (#05e4d0)
+U 3 (#674de1)
+R 3 (#804250)
+D 6 (#3ffca1)
+R 4 (#23dcb2)
+D 6 (#9f9841)
+L 5 (#45f210)
+D 9 (#15efc1)
+R 5 (#45f212)
+D 4 (#969551)
+L 9 (#23dcb0)
+D 2 (#41bea1)
+L 4 (#2f2a32)
+D 4 (#71ffd1)
+R 3 (#5c0bb2)
+D 7 (#6f3501)
+R 4 (#2b0a72)
+D 4 (#7b3571)
+R 3 (#1c67d2)
+U 11 (#42f011)
+R 3 (#51ae62)
+D 3 (#75fcf1)
+R 3 (#1f4742)
+D 4 (#2813f1)
+R 4 (#3d1812)
+D 2 (#2b1d01)
+R 11 (#1eb302)
+U 3 (#27b0a1)
+R 4 (#227b20)
+U 5 (#34b7e1)
+R 10 (#201220)
+U 7 (#0502f3)
+R 4 (#5ab7f0)
+U 4 (#0502f1)
+R 4 (#5d09b0)
+U 7 (#504a81)
+R 7 (#1e8250)
+U 3 (#715aa1)
+R 6 (#26d290)
+U 6 (#9a12f1)
+L 3 (#18be90)
+U 8 (#037d11)
+L 5 (#647600)
+U 3 (#40b983)
+L 5 (#04e450)
+U 3 (#9a9a43)
+L 8 (#04e452)
+U 6 (#8af153)
+R 8 (#6cbc90)
+U 4 (#04d121)
+L 4 (#285292)
+U 3 (#688d51)
+L 6 (#176332)
+U 4 (#400a91)
+L 5 (#176330)
+U 5 (#43def1)
+R 2 (#285290)
+U 2 (#3e0711)
+R 3 (#7eb9c0)
+U 7 (#36f611)
+R 7 (#666af0)
+D 7 (#381b31)
+R 3 (#298922)
+U 3 (#475671)
+R 6 (#977c12)
+D 4 (#602d01)
+R 6 (#25b0c2)
+D 6 (#7ede81)
+R 3 (#1d58c2)
+D 8 (#873523)
+L 9 (#265ae2)
+D 3 (#57d663)
+R 7 (#1565c2)
+D 8 (#06ed11)
+R 4 (#a348c2)
+D 2 (#06ed13)
+R 8 (#12d052)
+D 4 (#2d3741)
+L 7 (#0ccfd2)
+D 3 (#1fcd61)
+R 4 (#39a4c2)
+D 3 (#44f7f1)
+R 6 (#5c3202)
+D 8 (#2625c1)
+L 8 (#2b08c2)
+D 2 (#20d7e1)
+L 2 (#67b892)
+D 10 (#546471)
+R 7 (#484ef2)
+D 7 (#49bc91)
+R 4 (#91aa72)
+U 11 (#499591)
+R 3 (#0048b2)
+U 7 (#34a7a1)
+R 7 (#514600)
+U 8 (#1cdc43)
+L 7 (#471470)
+U 3 (#8c8393)
+R 3 (#18a780)
+U 5 (#8c8391)
+R 3 (#4e6f80)
+U 3 (#1cdc41)
+R 8 (#428930)
+U 5 (#5dcb51)
+R 3 (#4b21e2)
+U 4 (#0464b1)
+R 9 (#850552)
+D 8 (#464881)
+R 7 (#543852)
+D 3 (#2d3a11)
+R 3 (#081b22)
+D 5 (#0cc731)
+R 7 (#6990e0)
+D 3 (#79d7b1)
+R 3 (#509520)
+D 5 (#438571)
+R 3 (#27d510)
+D 3 (#30d2d3)
+L 8 (#1b7a00)
+D 5 (#8a0da3)
+L 8 (#1b7a02)
+U 5 (#027cb3)
+L 7 (#350130)
+D 8 (#2ff771)
+R 7 (#16dc02)
+D 2 (#68f1c1)
+R 5 (#02f782)
+D 6 (#4e2a41)
+R 11 (#448e32)
+D 5 (#2cfac1)
+L 11 (#417502)
+D 5 (#2cfac3)
+L 4 (#22f022)
+U 9 (#1e9f01)
+L 5 (#543572)
+U 3 (#076e31)
+L 6 (#081b20)
+U 5 (#1ae851)
+L 3 (#823132)
+U 9 (#2d7993)
+L 4 (#5738f2)
+D 8 (#79e273)
+L 4 (#5c9ad2)
+D 8 (#4ed1b3)
+L 3 (#311722)
+D 4 (#0d5493)
+L 6 (#5d63e0)
+D 6 (#178cf3)
+L 5 (#75b1b0)
+D 5 (#178cf1)
+L 6 (#11d550)
+D 6 (#44ed03)
+L 3 (#76a842)
+U 6 (#3b6993)
+L 5 (#184892)
+D 4 (#5c8163)
+L 3 (#14d872)
+U 2 (#261a01)
+L 5 (#2d01e2)
+U 9 (#326ca3)
+L 4 (#59ad32)
+U 8 (#326ca1)
+R 4 (#389ab2)
+U 9 (#261a03)
+L 4 (#50cb42)
+D 4 (#2f8263)
+L 5 (#9f3752)
+D 6 (#4bb383)
+L 4 (#2693f2)
+D 4 (#19dca3)
+R 4 (#475bc2)
+D 6 (#960e13)
+L 7 (#0c90a2)
+D 8 (#3463d3)
+L 6 (#5a82e2)
+D 3 (#5a5c43)
+R 7 (#120bf2)
+D 3 (#5069e3)
+R 3 (#4b47a2)
+D 6 (#635b63)
+R 4 (#66ca10)
+U 4 (#1418f1)
+R 7 (#1d5470)
+D 4 (#1418f3)
+R 8 (#66d4f0)
+D 5 (#3c5533)
+R 4 (#2f6e02)
+D 3 (#2cf5e3)
+R 4 (#633ec2)
+D 7 (#2cf5e1)
+R 7 (#5846b2)
+D 3 (#4f9d63)
+R 4 (#533380)
+D 11 (#13c7e3)
+R 2 (#222b62)
+D 3 (#928ab3)
+R 5 (#222b60)
+U 5 (#0a4793)
+R 5 (#15d3b0)
+U 8 (#363fe1)
+R 4 (#2feb30)
+U 5 (#05d8b1)
+R 3 (#39e030)
+U 3 (#05d8b3)
+R 2 (#3cd780)
+U 8 (#02c781)
+R 5 (#186452)
+D 3 (#37bba1)
+R 5 (#9e1232)
+D 5 (#58e6f1)
+R 5 (#182c30)
+D 5 (#072db1)
+R 5 (#85e600)
+D 4 (#607651)
+R 5 (#186450)
+D 3 (#0aca91)
+L 5 (#0ceb10)
+D 5 (#860001)
+L 6 (#54c8b0)
+U 5 (#393971)
+L 4 (#37c390)
+D 3 (#1f1433)
+L 5 (#3d8790)
+D 6 (#353623)
+R 4 (#78c830)
+D 4 (#6fafa3)
+R 6 (#2b0612)
+D 5 (#31fff3)
+R 7 (#8b49b2)
+D 9 (#6f0ee3)
+R 5 (#4212e0)
+D 6 (#5d11f3)
+R 6 (#648340)
+D 8 (#393743)
+R 6 (#34ddd0)
+U 8 (#346fb3)
+R 5 (#34fc22)
+D 4 (#71c453)
+R 6 (#5048f2)
+D 4 (#0bb993)
+R 4 (#42b9f0)
+D 9 (#5cdf83)
+R 5 (#42b9f2)
+D 3 (#6f3f93)
+R 3 (#3dbae2)
+D 8 (#495363)
+R 9 (#328ba2)
+D 3 (#77afa1)
+R 5 (#575710)
+D 2 (#10d861)
+R 4 (#257822)
+D 4 (#6efe61)
+R 9 (#257820)
+D 5 (#521d01)
+R 5 (#575712)
+D 6 (#494cf1)
+L 5 (#683ab2)
+D 4 (#5e79c3)
+L 3 (#4242a2)
+D 4 (#5e79c1)
+L 7 (#2c3442)
+D 8 (#2fbd23)
+L 5 (#636fb2)
+D 5 (#63bd53)
+L 2 (#299960)
+D 6 (#31ea33)
+R 3 (#51dfb0)
+D 7 (#4e4ec3)
+R 4 (#7b7912)
+D 5 (#4b4bf3)
+R 4 (#54e882)
+D 5 (#7d2193)
+R 3 (#3b77d2)
+D 3 (#826973)
+R 8 (#646ec2)
+D 4 (#076c63)
+L 10 (#674052)
+D 6 (#3676b1)
+L 9 (#3bd890)
+D 4 (#7feb71)
+L 3 (#3bd892)
+D 3 (#27fc21)
+R 8 (#66bba2)
+D 8 (#645c73)
+R 5 (#43e132)
+D 5 (#51d9e3)
+R 8 (#43e130)
+D 6 (#2827f3)
+R 4 (#412c92)
+D 5 (#7e7f63)
+L 4 (#218122)
+D 4 (#546e83)
+L 9 (#82f672)
+D 8 (#6ed383)
+L 3 (#701412)
+D 7 (#47de23)
+L 5 (#46f912)
+D 7 (#0d9ec3)
+L 4 (#515142)
+D 3 (#4699e3)
+L 9 (#2ed562)
+U 6 (#00a273)
+L 9 (#8d7d12)
+U 2 (#6c3a83)
+L 7 (#318fa2)
+U 7 (#0bd473)
+L 2 (#6d5050)
+U 10 (#415673)
+R 3 (#9e8420)
+U 6 (#1ff213)
+R 5 (#0c8bf0)
+U 2 (#479a11)
+R 6 (#977360)
+U 5 (#479a13)
+L 8 (#250680)
+U 2 (#1ff211)
+L 3 (#216630)
+U 3 (#22d143)
+L 3 (#3b4342)
+U 7 (#9d4ff3)
+L 5 (#43aca2)
+U 6 (#29efd3)
+L 3 (#5c6a12)
+D 11 (#134a73)
+L 6 (#2a0982)
+U 11 (#444723)
+L 4 (#47e2e2)
+U 4 (#6855c3)
+L 4 (#06a382)
+U 4 (#2222e3)
+R 3 (#4edc62)
+U 6 (#9a2683)
+R 6 (#131872)
+U 10 (#4f5a23)
+R 4 (#858f70)
+U 5 (#4d4823)
+L 9 (#3f73f0)
+U 3 (#46f5a3)
+L 4 (#935370)
+U 4 (#46f5a1)
+L 5 (#3ca140)
+U 6 (#07b1e3)
+L 5 (#61ecd0)
+U 5 (#654743)
+L 5 (#3cec42)
+U 6 (#30bb83)
+R 3 (#920782)
+U 6 (#1f9323)
+R 8 (#3d8aa2)
+U 8 (#7492c3)
+R 3 (#301cd2)
+U 3 (#32e2f1)
+R 4 (#6936f2)
+U 6 (#32e2f3)
+R 6 (#5112c2)
+U 7 (#535b53)
+L 10 (#61f4d0)
+U 3 (#915863)
+L 2 (#51d540)
+U 5 (#32dee1)
+L 10 (#4ec320)
+U 5 (#406bc1)
+L 2 (#1b3890)
+U 3 (#681181)
+L 6 (#35ed60)
+D 9 (#153fd3)
+L 5 (#323e30)
+U 5 (#381ad3)
+L 3 (#69a550)
+U 3 (#310f63)
+L 4 (#2cbb80)
+U 5 (#3448a3)
+R 6 (#206282)
+U 5 (#202ab1)
+L 6 (#83af82)
+U 4 (#202ab3)
+L 4 (#248d02)
+D 9 (#28a983)
+L 4 (#32cf10)
+D 7 (#249d73)
+R 4 (#2f5c70)
+D 6 (#021c93)
+L 7 (#957782)
+D 6 (#550e53)
+R 5 (#957780)
+D 6 (#50bb13)
+R 9 (#49b7f2)
+U 6 (#096e93)
+R 4 (#769452)
+D 3 (#6dc543)
+R 5 (#2ad352)
+D 7 (#167963)
+L 10 (#673682)
+D 5 (#152883)
+L 10 (#13f332)
+D 3 (#996721)
+L 4 (#4be2a2)
+D 4 (#9c2443)
+L 4 (#2b83b0)
+D 3 (#5d63b3)
+L 9 (#9cfd40)
+D 7 (#49e793)
+L 7 (#0b5422)
+D 8 (#5c51b3)
+L 2 (#6db152)
+D 4 (#215b53)
+L 3 (#38dc12)
+D 8 (#7dad01)
+L 6 (#559e22)
+D 3 (#929d23)
+L 2 (#0f7560)
+D 6 (#448d13)
+L 7 (#73a972)
+D 2 (#2221c3)
+L 3 (#73a970)
+D 5 (#53b553)
+R 10 (#513590)
+D 3 (#293c83)
+L 10 (#58e2e0)
+D 4 (#54dd21)
+L 5 (#1bcdf2)
+D 5 (#4b0b71)
+L 5 (#1bcdf0)
+U 6 (#43b811)
+L 5 (#4df1d0)
+U 6 (#36d6a3)
+R 5 (#3bfb20)
+U 5 (#75de61)
+L 5 (#1e0ec2)
+U 4 (#30b571)
+L 7 (#2dfd20)
+D 5 (#49ad61)
+L 2 (#2dfd22)
+D 11 (#715d41)
+L 3 (#1e0ec0)
+U 4 (#0f2091)
+L 4 (#9d29c0)
+U 9 (#475a73)
+L 2 (#108610)
+U 3 (#1e5423)
+L 8 (#394192)
+U 3 (#0274b3)

day18/main.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"bufio"
+	_ "embed"
+	"fmt"
+	"strconv"
+	"strings"
+
+	aoc "go.sour.is/advent-of-code"
+	"golang.org/x/exp/maps"
+)
+
+// var log = aoc.Log
+
+func main() { aoc.MustResult(aoc.Runner(run)) }
+
+type result struct {
+	valuePT1 int
+	valuePT2 int
+}
+
+func (r result) String() string { return fmt.Sprintf("%#v", r) }
+
+func run(scan *bufio.Scanner) (*result, error) {
+
+	var vecsPT1 []aoc.Vector
+	var vecsPT2 []aoc.Vector
+
+	for scan.Scan() {
+		text := scan.Text()
+
+		if len(text) == 0 {
+			continue
+		}
+
+		v, color := fromLine(text)
+
+		vecsPT1 = append(vecsPT1, v)
+		vecsPT2 = append(vecsPT2, fromColor(color))
+	}
+	return &result{
+		valuePT1: findArea(vecsPT1),
+		valuePT2: findArea(vecsPT2),
+	}, nil
+}
+
+var OFFSET = map[string]aoc.Point[int]{
+	"R": {0, 1},
+	"D": {1, 0},
+	"L": {0, -1},
+	"U": {-1, 0},
+}
+var OFFSET_INDEXES = maps.Values(OFFSET)
+
+func fromLine(text string) (aoc.Vector, string) {
+	v := aoc.Vector{}
+	s, text, _ := strings.Cut(text, " ")
+	v.Offset = OFFSET[s]
+
+	s, text, _ = strings.Cut(text, " ")
+	v.Scale = aoc.Atoi(s)
+
+	_, text, _ = strings.Cut(text, "(#")
+	s, _, _ = strings.Cut(text, ")")
+	return v, s
+}
+
+func fromColor(c string) aoc.Vector {
+	scale, _ := strconv.ParseInt(c[:5], 16, 64)
+	offset := OFFSET_INDEXES[c[5]-'0']
+
+	return aoc.Vector{
+		Offset: offset,
+		Scale:  int(scale),
+	}
+}
+
+func findArea(vecs []aoc.Vector) int {
+	shoelace := []aoc.Point[int]{{0, 0}}
+	borderLength := 0
+
+	for _, vec := range vecs {
+		shoelace = append(shoelace, shoelace[len(shoelace)-1].Add(vec.Point()))
+		borderLength += vec.Scale
+	}
+
+	return aoc.NumPoints(shoelace, borderLength)
+}

day18/main_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+
+	_ "embed"
+
+	"github.com/matryer/is"
+)
+
+//go:embed example.txt
+var example []byte
+
+//go:embed input.txt
+var input []byte
+
+func TestExample(t *testing.T) {
+	is := is.New(t)
+	scan := bufio.NewScanner(bytes.NewReader(example))
+
+	result, err := run(scan)
+	is.NoErr(err)
+
+	t.Log(result)
+	is.Equal(result.valuePT1, 62)
+	is.Equal(result.valuePT2, 952408144115)
+}
+
+func TestSolution(t *testing.T) {
+	is := is.New(t)
+	scan := bufio.NewScanner(bytes.NewReader(input))
+
+	result, err := run(scan)
+	is.NoErr(err)
+
+	t.Log(result)
+	is.True(result.valuePT1 < 68834) // first attempt too high.
+	is.Equal(result.valuePT1, 46334)
+	is.Equal(result.valuePT2, 102000662718092)
+}

day19/main.go

@@ -15,7 +15,7 @@ func main() { aoc.MustResult(aoc.Runner(run)) }
 
 type result struct {
 	valuePT1 int
-	valuePT2 int
+	valuePT2 uint
 }
 
 func (r result) String() string { return fmt.Sprintf("%#v", r) }
@@ -32,8 +32,35 @@ func run(scan *bufio.Scanner) (*result, error) {
 		}
 
 		// Is Part
-		if text[0] == '{' {
+		if p, ok := scanPart(text); ok {
+			parts = append(parts, p)
+			continue
+		}
+
+		if name, r, ok := scanRule(text); ok {
+			workflows[name] = r
+		}
+	}
+
+	var result result
+	result.valuePT1 = solveWorkflow(parts, workflows)
+	result.valuePT2 = solveRanges(workflows)
+
+	return &result, nil
+}
+
+type part struct {
+	x, m, a, s int
+}
+
+func (p part) String() string {
+	return fmt.Sprintf("{x:%v m:%v a:%v s:%v}", p.x, p.m, p.a, p.s)
+}
+func scanPart(text string) (part, bool) {
 	var p part
+
+	// Is Part
+	if text[0] == '{' {
 		for _, s := range strings.Split(text[1:], ",") {
 			a, b, _ := strings.Cut(s, "=")
 			i := aoc.Atoi(b)
@@ -48,10 +75,19 @@ func run(scan *bufio.Scanner) (*result, error) {
 				p.s = i
 			}
 		}
-			parts = append(parts, p)
+		return p, true
-			continue
 	}
+	return p, false
+}
 
+type rule struct {
+	match string
+	op    string
+	value int
+	queue string
+}
+
+func scanRule(text string) (string, []rule, bool) {
 	name, text, _ := strings.Cut(text, "{")
 	var r []rule
 	for _, s := range strings.Split(text, ",") {
@@ -81,66 +117,7 @@ func run(scan *bufio.Scanner) (*result, error) {
 		r = append(r, rule{queue: s})
 		break
 	}
-		workflows[name] = r
+	return name, r, len(r) > 0
-	}
-
-	var rejected []part
-	var accepted []part
-
-	for _, p := range parts {
-		workflow := "in"
-
-nextStep:
-		for workflow != "" {
-			for _, r := range workflows[workflow] {
-				if !r.Match(p) {
-					continue
-				}
-				workflow = r.queue
-
-				if workflow == "A" {
-					accepted = append(accepted, p)
-					workflow = ""
-					break nextStep
-				}
-				if workflow == "R" {
-					rejected = append(rejected, p)
-					workflow = ""
-					break nextStep
-				}
-
-				continue nextStep
-			}
-
-		}
-	}
-
-	fmt.Println("accepted", accepted)
-	fmt.Println("rejected", rejected)
-
-	var result result
-
-	for _, p := range accepted {
-		result.valuePT1 += p.x
-		result.valuePT1 += p.m
-		result.valuePT1 += p.a
-		result.valuePT1 += p.s
-	}
-
-	return &result, nil
-}
-
-type part struct {
-	x, m, a, s int
-}
-func (p part) String() string {
-	return fmt.Sprintf("{x:%v m:%v a:%v s:%v}", p.x,p.m,p.a,p.s)
-}
-type rule struct {
-	match string
-	op    string
-	value int
-	queue string
 }
 func (r rule) Match(p part) bool {
 	var value int
@@ -166,12 +143,113 @@ func (r rule) Match(p part) bool {
 	return false // no match
 }
 
+func solveWorkflow(parts []part, workflows map[string][]rule) int {
+	// var rejected []part
+	var accepted []part
 
-func in(n string, haystack ...string) bool {
+	for _, p := range parts {
-	for _, h := range haystack {
+		workflow := "in"
-		if n == h {
+
-			return true
+	nextStep:
+		for workflow != "" {
+			for _, r := range workflows[workflow] {
+				if !r.Match(p) {
+					continue
+				}
+				workflow = r.queue
+
+				if workflow == "A" {
+					accepted = append(accepted, p)
+					workflow = ""
+					break nextStep
+				}
+				if workflow == "R" {
+					// rejected = append(rejected, p)
+					workflow = ""
+					break nextStep
+				}
+
+				continue nextStep
 			}
 		}
-	return false
+	}
+
+	sum := 0
+	for _, p := range accepted {
+		sum += p.x
+		sum += p.m
+		sum += p.a
+		sum += p.s
+	}
+	return sum
+}
+
+func solveRanges(workflows map[string][]rule) uint {
+
+	pq := aoc.PriorityQueue(func(a, b *queue) bool { return false })
+	pq.Insert(&queue{
+		"in",
+		block{
+			ranger{1, 4000},
+			ranger{1, 4000},
+			ranger{1, 4000},
+			ranger{1, 4000},
+		}})
+
+	var accepted []block
+	// var rejected []block
+
+	for !pq.IsEmpty() {
+		current := pq.ExtractMin()
+		for _, rule := range workflows[current.name] {
+			next := &queue{name: rule.queue, block: current.block}
+
+			switch rule.match {
+			case "x":
+				current.x, next.x = split(current.x, rule.value, rule.op == ">")
+			case "m":
+				current.m, next.m = split(current.m, rule.value, rule.op == ">")
+			case "a":
+				current.a, next.a = split(current.a, rule.value, rule.op == ">")
+			case "s":
+				current.s, next.s = split(current.s, rule.value, rule.op == ">")
+			}
+
+			switch next.name {
+			case "R":
+				// rejected = append(rejected, next.block)
+
+			case "A":
+				accepted = append(accepted, next.block)
+
+			default:
+				pq.Insert(next)
+			}
+		}
+	}
+
+	var sum uint
+	for _, a := range accepted {
+		sum += uint((a.x[1] - a.x[0] + 1) * (a.m[1] - a.m[0] + 1) * (a.a[1] - a.a[0] + 1) * (a.s[1] - a.s[0] + 1))
+	}
+
+	return sum
+}
+
+type ranger [2]int
+type block struct {
+	x, m, a, s ranger
+}
+type queue struct {
+	name string
+	block
+}
+
+func split(a ranger, n int, gt bool) (current ranger, next ranger) {
+	if gt { // x > N => [0,N] [N++,inf]
+		return ranger{a[0], n}, ranger{n + 1, a[1]}
+	}
+
+	// x < N => [N,inf] [0,N--]
+	return ranger{n, a[1]}, ranger{a[0], n - 1}
 }

day19/main_test.go

@@ -25,7 +25,7 @@ func TestExample(t *testing.T) {
 
 	t.Log(result)
 	is.Equal(result.valuePT1, 19114)
-	is.Equal(result.valuePT2, 0)
+	is.Equal(result.valuePT2, uint(167409079868000))
 }
 
 func TestSolution(t *testing.T) {
@@ -37,5 +37,5 @@ func TestSolution(t *testing.T) {
 
 	t.Log(result)
 	is.Equal(result.valuePT1, 377025)
-	is.Equal(result.valuePT2, 0)
+	is.Equal(result.valuePT2, uint(135506683246673))
 }

day20/example1.txt

@@ -0,0 +1,5 @@
+broadcaster -> a, b, c
+%a -> b
+%b -> c
+%c -> inv
+&inv -> a

day20/example2.txt

@@ -0,0 +1,5 @@
+broadcaster -> a
+%a -> inv, con
+&inv -> b
+%b -> con
+&con -> output

day20/input.txt

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

day20/main.go

@@ -0,0 +1,282 @@
+package main
+
+import (
+	"bufio"
+	_ "embed"
+	"fmt"
+	"strings"
+
+	aoc "go.sour.is/advent-of-code"
+	"golang.org/x/exp/maps"
+)
+
+// var log = aoc.Log
+
+func main() { aoc.MustResult(aoc.Runner(run)) }
+
+type result struct {
+	valuePT1 int
+	valuePT2 int
+}
+
+func (r result) String() string { return fmt.Sprintf("%#v", r) }
+
+func run(scan *bufio.Scanner) (*result, error) {
+	m := &machine{}
+	receivers := make(map[string][]string)
+
+	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, &conjunction{name: name, dest: dest})
+		}
+
+		for _, d := range dest {
+			// rx is present so enable pt 2
+			if d == "rx" {
+				m.Add("rx", &rx{})
+			}
+			receivers[d] = append(receivers[d], name)
+		}
+	}
+
+	m.setup(receivers)
+
+	result := &result{}
+
+	for i := 0; i < 10_000; i++ { // need enough presses to find the best LCM values for each conjunction
+		if i == 1000 {
+			result.valuePT1 = m.highPulses * m.lowPulses
+		}
+		m.Push(i)
+	}
+
+	// rx is present.. perform part 2.
+	if rx, ok := receivers["rx"]; ok {
+		tip := m.m[rx[0]].(*conjunction) // panic if missing!
+
+		var lvalues []int
+		for k, v := range tip.pushes {
+			for i, h := range makeHistory(v) {
+				if i == 1 && len(h) > 0 && h[0] > 0 {
+					fmt.Println(tip.name, k, "frequency", h[0])
+					lvalues = append(lvalues, h[0])
+				}
+			}
+		}
+
+		result.valuePT2 = aoc.LCM(lvalues...)
+		fmt.Println(tip.name, "LCM", result.valuePT2, lvalues)
+	}
+	return result, nil
+}
+
+type signal bool
+
+const (
+	LOW  signal = false
+	HIGH signal = true
+)
+
+type message struct {
+	signal
+	from, to string
+}
+
+type machine struct {
+	m map[string]pulser
+
+	queue []message
+
+	press      int
+	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...)
+			}
+		}
+	}
+}
+
+type pulser interface {
+	Pulse(message)
+	SetMachine(*machine)
+}
+
+// IsModule implements the machine registration for each module.
+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...)...)
+}
+
+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...)...)
+	}
+}
+
+type conjunction struct {
+	name  string
+	state map[string]signal
+	dest  []string
+
+	pushes map[string][]int
+
+	IsModule
+}
+
+func (b *conjunction) Receive(names ...string) {
+	if b.state == nil {
+		b.state = make(map[string]signal)
+		b.pushes = make(map[string][]int)
+	}
+	for _, name := range names {
+		b.state[name] = false
+		b.pushes[name] = []int{}
+	}
+}
+func (b *conjunction) Pulse(msg message) {
+	b.state[msg.from] = msg.signal
+
+	if msg.signal {
+		// collect frequency of pushes to esti,ate rate
+		b.pushes[msg.from] = append(b.pushes[msg.from], b.press)
+	}
+
+	if all(HIGH, maps.Values(b.state)...) {
+		b.Send(generate(LOW, b.name, b.dest...)...)
+		return
+	}
+	b.Send(generate(HIGH, b.name, b.dest...)...)
+}
+
+type rx struct {
+	IsModule
+}
+
+func (rx *rx) Pulse(msg message) {
+	if !msg.signal {
+		panic("pulse received") // will never happen...
+	}
+}
+
+// helper funcs
+func all[T comparable](match T, lis ...T) bool {
+	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
+}
+
+// makeHistory from day 9
+func makeHistory(in []int) [][]int {
+	var history [][]int
+	history = append(history, in)
+
+	// for {
+	var diffs []int
+
+	current := history[len(history)-1]
+
+	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
+}

day20/main_test.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+
+	_ "embed"
+
+	"github.com/matryer/is"
+)
+
+//go:embed example1.txt
+var example1 []byte
+
+//go:embed example2.txt
+var example2 []byte
+
+//go:embed input.txt
+var input []byte
+
+func TestExample1(t *testing.T) {
+	is := is.New(t)
+	scan := bufio.NewScanner(bytes.NewReader(example1))
+
+	result, err := run(scan)
+	is.NoErr(err)
+
+	t.Log(result)
+	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)
+}
+
+func TestSolution(t *testing.T) {
+	is := is.New(t)
+	scan := bufio.NewScanner(bytes.NewReader(input))
+
+	result, err := run(scan)
+	is.NoErr(err)
+
+	t.Log(result)
+	is.Equal(result.valuePT1, 819397964)
+	is.Equal(result.valuePT2, 252667369442479)
+}

grids.go

@@ -0,0 +1,174 @@
+package aoc
+
+import (
+	"cmp"
+	"sort"
+)
+
+type Vector struct {
+	Offset Point[int]
+	Scale  int
+}
+
+func (v Vector) Point() Point[int] {
+	return v.Offset.Scale(v.Scale)
+}
+
+type Point[T integer] [2]T
+
+func (p Point[T]) Add(a Point[T]) Point[T] {
+	return Point[T]{p[0] + a[0], p[1] + a[1]}
+}
+func (p Point[T]) Scale(m T) Point[T] {
+	return Point[T]{p[0] * m, p[1] * m}
+}
+func (p Point[T]) Less(b Point[T]) bool {
+	if p[0] != b[0] {
+		return p[0] < b[0]
+	}
+	return p[1] < b[1]
+}
+
+func Transpose[T any](matrix [][]T) [][]T {
+	rows, cols := len(matrix), len(matrix[0])
+
+	m := make([][]T, cols)
+	for i := range m {
+		m[i] = make([]T, rows)
+	}
+
+	for i := 0; i < cols; i++ {
+		for j := 0; j < rows; j++ {
+			m[i][j] = matrix[j][i]
+		}
+	}
+	return m
+}
+
+// NumPoints the number of the points inside an outline plus the number of points in the outline
+func NumPoints(outline []Point[int], borderLength int) int {
+	// shoelace - find the float area in a shape
+	sum := 0
+	for _, p := range Pairwise(outline) {
+		row1, col1 := p[0][0], p[0][1]
+		row2, col2 := p[1][0], p[1][1]
+
+		sum += row1*col2 - row2*col1
+	}
+	area := sum / 2
+
+	// pick's theorem - find the number of points in a shape given its area
+	return (ABS(area) - borderLength/2 + 1) + borderLength
+}
+
+type Map[I integer, T any] [][]T
+
+func (m *Map[I, T]) Get(p Point[I]) (Point[I], T, bool) {
+	var zero T
+	if !m.Valid(p) {
+		return [2]I{0, 0}, zero, false
+	}
+
+	return p, (*m)[p[0]][p[1]], true
+}
+func (m *Map[I, T]) Size() (I, I) {
+	if m == nil || len(*m) == 0 {
+		return 0, 0
+	}
+	return I(len(*m)), I(len((*m)[0]))
+}
+func (m *Map[I, T]) Valid(p Point[I]) bool {
+	rows, cols := m.Size()
+	return p[0] >= 0 && p[0] < rows && p[1] >= 0 && p[1] < cols
+}
+
+type adjacencyList[V any, C comparable] map[C][]V
+type graph[V any, W cmp.Ordered, C comparable] map[C]*vertex[V, W]
+type graphOption[V any, W cmp.Ordered, C comparable] func(g *graph[V, W, C])
+type vertex[V any, W cmp.Ordered] struct {
+	Value V
+	Edges edges[V, W]
+}
+
+func (v *vertex[V, W]) Neighbors() []V {
+	var nbs []V
+	sort.Sort(v.Edges)
+	for _, e := range v.Edges {
+		nbs = append(nbs, e.Vertex.Value)
+	}
+	return nbs
+}
+
+type edge[V any, W cmp.Ordered] struct {
+	Vertex *vertex[V, W]
+	Weight W
+}
+type edges[V any, W cmp.Ordered] []edge[V, W]
+
+func (e edges[V, W]) Len() int           { return len(e) }
+func (e edges[V, W]) Less(i, j int) bool { return e[i].Weight < e[j].Weight }
+func (e edges[V, W]) Swap(i, j int)      { e[i], e[j] = e[j], e[i] }
+
+func Graph[V any, W cmp.Ordered, C comparable](opts ...graphOption[V, W, C]) *graph[V, W, C] {
+	g := make(graph[V, W, C])
+	for _, opt := range opts {
+		opt(&g)
+	}
+	return &g
+}
+func (g *graph[V, W, C]) AddVertex(id C, value V) {
+	(*g)[id] = &vertex[V,W]{Value: value}
+}
+func (g *graph[V, W, C]) AddEdge(from, to C, w W) {
+	if g == nil {
+		return
+	}
+	if _, ok := (*g)[from]; !ok {
+		return
+	}
+	if _, ok := (*g)[to]; !ok {
+		return
+	}
+
+	(*g)[from].Edges = append((*g)[from].Edges, edge[V,W]{(*g)[to], w})
+}
+func (g *graph[V, W, C]) Neighbors(v C) []V {
+	if g == nil {
+		return nil
+	}
+
+	return (*g)[v].Neighbors()
+}
+func (g *graph[V, W, C]) AdjacencyList() adjacencyList[V, C] {
+	m := make(map[C][]V)
+	for id, v := range *g {
+		if len(v.Edges) == 0 {
+			continue
+		}
+		m[id] = v.Neighbors()
+	}
+	return m
+}
+
+func WithAdjacencyList[W cmp.Ordered, C comparable](list adjacencyList[C, C]) graphOption[C, W, C] {
+	var zeroW W
+	return func(g *graph[C, W, C]) {
+		for vertex, edges := range list {
+			if _, ok := (*g)[vertex]; !ok {
+				g.AddVertex(vertex, vertex)
+			}
+
+			// add edges to vertex
+			for _, edge := range edges {
+				// add edge as vertex, if not added
+				if _, ok := (*g)[edge]; !ok {
+					g.AddVertex(edge, edge)
+				}
+
+				g.AddEdge(vertex, edge, zeroW) // no weights in this adjacency list
+			}
+		}
+	}
+}
+
+// func GraphFromMap()

itertools.go

@@ -0,0 +1,56 @@
+package aoc
+
+import (
+	"strconv"
+)
+
+func Atoi(s string) int {
+	i, _ := strconv.Atoi(s)
+	return i
+}
+
+func Repeat[T any](s T, i int) []T {
+	lis := make([]T, i)
+	for i := range lis {
+		lis[i] = s
+	}
+	return lis
+}
+
+func Reduce[T, U any](fn func(int, T, U) U, u U, list ...T) U {
+	for i, t := range list {
+		u = fn(i, t, u)
+	}
+	return u
+}
+
+func Reverse[T any](arr []T) []T {
+	for i := 0; i < len(arr)/2; i++ {
+		arr[i], arr[len(arr)-i-1] = arr[len(arr)-i-1], arr[i]
+	}
+	return arr
+}
+
+func SliceMap[T, U any](fn func(T) U, in ...T) []U {
+	lis := make([]U, len(in))
+	for i := range lis {
+		lis[i] = fn(in[i])
+	}
+	return lis
+}
+func SliceIMap[T, U any](fn func(int, T) U, in ...T) []U {
+	lis := make([]U, len(in))
+	for i := range lis {
+		lis[i] = fn(i, in[i])
+	}
+	return lis
+}
+
+// Pairwise iterates over a list pairing i, i+1
+func Pairwise[T any](arr []T) [][2]T {
+	var pairs [][2]T
+	for i := range arr[:len(arr)-1] {
+		pairs = append(pairs, [2]T{arr[i], arr[i+1]})
+	}
+	return pairs
+}

lists.go

@@ -0,0 +1,100 @@
+package aoc
+
+import "fmt"
+
+type Node[T any] struct {
+	value T
+	pos   int
+	left  *Node[T]
+}
+
+func (n *Node[T]) add(a *Node[T]) *Node[T] {
+	if a == nil {
+		return n
+	}
+
+	if n == nil {
+		return a
+	}
+
+	n.left = a
+	return a
+}
+
+func (n *Node[T]) Value() (value T, ok bool) {
+	if n == nil {
+		return
+	}
+	return n.value, true
+}
+
+func (n *Node[T]) Position() int {
+	if n == nil {
+		return -1
+	}
+	return n.pos
+}
+func (n *Node[T]) SetPosition(i int) {
+	if n == nil {
+		return
+	}
+	n.pos = i
+}
+func (n *Node[T]) Next() *Node[T] {
+	if n == nil {
+		return nil
+	}
+	return n.left
+}
+
+func (n *Node[T]) String() string {
+	if n == nil {
+		return "EOL"
+	}
+	return fmt.Sprintf("node %v", n.value)
+}
+
+type List[T any] struct {
+	head *Node[T]
+	n    *Node[T]
+	p    map[int]*Node[T]
+}
+
+func NewList[T any](a *Node[T]) *List[T] {
+	lis := &List[T]{
+		head: a,
+		n:    a,
+		p:    make(map[int]*Node[T]),
+	}
+	lis.add(a)
+
+	return lis
+}
+func (l *List[T]) Add(value T, pos int) {
+	a := &Node[T]{value: value, pos: pos}
+	l.add(a)
+}
+func (l *List[T]) add(a *Node[T]) {
+	if l.head == nil {
+		l.head = a
+	}
+	if a == nil {
+		return
+	}
+
+	l.n = l.n.add(a)
+	l.p[a.pos] = a
+}
+func (l *List[T]) Get(pos int) *Node[T] {
+	return l.p[pos]
+}
+func (l *List[T]) GetN(pos ...int) []*Node[T] {
+	lis := make([]*Node[T], len(pos))
+	for i, p := range pos {
+		lis[i] = l.p[p]
+	}
+	return lis
+}
+func (l *List[T]) Head() *Node[T] {
+	return l.head
+}

math.go

@@ -0,0 +1,96 @@
+package aoc
+
+import "cmp"
+
+type uinteger interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
+}
+type sinteger interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+type integer interface {
+	sinteger | uinteger
+}
+
+type float interface {
+	complex64 | complex128 | float32 | float64
+}
+type number interface{ integer | float }
+
+// greatest common divisor (GCD) via Euclidean algorithm
+func GCD[T integer](a, b T) T {
+	for b != 0 {
+		t := b
+		b = a % b
+		a = t
+	}
+	return a
+}
+
+// find Least Common Multiple (LCM) via GCD
+func LCM[T integer](integers ...T) T {
+	if len(integers) == 0 {
+		return 0
+	}
+	if len(integers) == 1 {
+		return integers[0]
+	}
+
+	a, b := integers[0], integers[1]
+	result := a * b / GCD(a, b)
+
+	for _, c := range integers[2:] {
+		result = LCM(result, c)
+	}
+
+	return result
+}
+
+func Sum[T number](arr ...T) T {
+	var acc T
+	for _, a := range arr {
+		acc += a
+	}
+	return acc
+}
+func SumFunc[T any, U number](fn func(T) U, input ...T) U {
+	return Sum(SliceMap(fn, input...)...)
+}
+func SumIFunc[T any, U number](fn func(int, T) U, input ...T) U {
+	return Sum(SliceIMap(fn, input...)...)
+}
+
+func Power2(n int) int {
+	if n == 0 {
+		return 1
+	}
+	p := 2
+	for ; n > 1; n-- {
+		p *= 2
+	}
+	return p
+}
+
+func ABS[I integer](i I) I {
+	if i < 0 {
+		return -i
+	}
+	return i
+}
+
+func Max[T cmp.Ordered](a T, v ...T) T {
+	for _, b := range v {
+		if b > a {
+			a = b
+		}
+	}
+	return a
+}
+func Min[T cmp.Ordered](a T, v ...T) T {
+	for _, b := range v {
+		if b < a {
+			a = b
+		}
+	}
+	return a
+}

runner.go

@@ -0,0 +1,94 @@
+package aoc
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+	"strings"
+	"time"
+)
+
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to `file`")
+
+func Runner[R any, F func(*bufio.Scanner) (R, error)](run F) (R, error) {
+	if len(os.Args) < 2 {
+		Log("Usage:", filepath.Base(os.Args[0]), "FILE")
+		os.Exit(22)
+	}
+
+	inputFilename := os.Args[1]
+	os.Args = append(os.Args[:1], os.Args[2:]...)
+
+	flag.Parse()
+	Log(cpuprofile, memprofile, *cpuprofile, *memprofile)
+	if *cpuprofile != "" {
+		Log("enabled cpu profile")
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal("could not create CPU profile: ", err)
+		}
+		defer f.Close() // error handling omitted for example
+		Log("write cpu profile to", f.Name())
+		if err := pprof.StartCPUProfile(f); err != nil {
+			log.Fatal("could not start CPU profile: ", err)
+		}
+		defer pprof.StopCPUProfile()
+	}
+
+	if *memprofile != "" {
+		Log("enabled mem profile")
+		defer func() {
+			f, err := os.Create(*memprofile)
+			if err != nil {
+				log.Fatal("could not create memory profile: ", err)
+			}
+			Log("write mem profile to", f.Name())
+			defer f.Close() // error handling omitted for example
+			runtime.GC()    // get up-to-date statistics
+			if err := pprof.WriteHeapProfile(f); err != nil {
+				log.Fatal("could not write memory profile: ", err)
+			}
+		}()
+	}
+
+
+	input, err := os.Open(inputFilename)
+	if err != nil {
+		Log(err)
+		os.Exit(1)
+	}
+
+	scan := bufio.NewScanner(input)
+
+	return run(scan)
+}
+
+func MustResult[T any](result T, err error) {
+	if err != nil {
+		fmt.Println("ERR", err)
+		os.Exit(1)
+	}
+
+	Log("result", result)
+}
+
+func Log(v ...any) {
+	fmt.Fprint(os.Stderr, time.Now(), ": ")
+	fmt.Fprintln(os.Stderr, v...)
+}
+func Logf(format string, v ...any) {
+	if !strings.HasSuffix(format, "\n") {
+		format += "\n"
+	}
+	fmt.Fprintf(os.Stderr, format, v...)
+}
+
+func ReadStringToInts(fields []string) []int {
+	return SliceMap(Atoi, fields...)
+}

search.go

@@ -0,0 +1,348 @@
+package aoc
+
+import (
+	"math/bits"
+	"sort"
+)
+
+type priorityQueue[T any] struct {
+	elems        []*T
+	less         func(a, b *T) bool
+	maxDepth     int
+	totalEnqueue int
+	totalDequeue int
+}
+
+// PriorityQueue implements a simple slice based queue.
+// less is the function for sorting. reverse a and b to reverse the sort.
+// T is the item
+// U is a slice of T
+func PriorityQueue[T any](less func(a, b *T) bool) *priorityQueue[T] {
+	return &priorityQueue[T]{less: less}
+}
+func (pq *priorityQueue[T]) Insert(elem *T) {
+	pq.totalEnqueue++
+
+	pq.elems = append(pq.elems, elem)
+	pq.maxDepth = max(pq.maxDepth, len(pq.elems))
+}
+func (pq *priorityQueue[T]) IsEmpty() bool {
+	return len(pq.elems) == 0
+}
+func (pq *priorityQueue[T]) ExtractMin() *T {
+	pq.totalDequeue++
+
+	var elem *T
+	if pq.IsEmpty() {
+		return elem
+	}
+
+	sort.Slice(pq.elems, func(i, j int) bool { return pq.less(pq.elems[j], pq.elems[i]) })
+	pq.elems, elem = pq.elems[:len(pq.elems)-1], pq.elems[len(pq.elems)-1]
+	return elem
+}
+
+type stack[T any] []T
+
+func Stack[T any](a ...T) *stack[T] {
+	var s stack[T] = a
+	return &s
+}
+func (s *stack[T]) Push(a ...T) {
+	if s == nil {
+		return
+	}
+	*s = append(*s, a...)
+}
+func (s *stack[T]) IsEmpty() bool {
+	return s == nil || len(*s) == 0
+}
+func (s *stack[T]) Pop() T {
+	var a T
+	if s.IsEmpty() {
+		return a
+	}
+	a, *s = (*s)[len(*s)-1], (*s)[:len(*s)-1]
+	return a
+}
+
+// ManhattanDistance the distance between two points measured along axes at right angles.
+func ManhattanDistance[T integer](a, b Point[T]) T {
+	return ABS(a[0]-b[0]) + ABS(a[1]-b[1])
+}
+
+type pather[C number, N comparable] interface {
+	// Neighbors returns all neighbors to node N that should be considered next.
+	Neighbors(N) []N
+
+	// Cost returns
+	Cost(a, b N) C
+
+	// Target returns true when target reached. receives node and cost.
+	Target(N, C) bool
+
+	// OPTIONAL:
+	// Add heuristic for running as A* search.
+	// Potential(N) C
+
+	// Seen modify value used by seen pruning.
+	// Seen(N) N
+
+}
+
+// FindPath uses the A* path finding algorithem.
+// g is the graph source that implements the pather interface.
+//
+//	C is an numeric type for calculating cost/potential
+//	N is the node values. is comparable for storing in visited table for pruning.
+//
+// start, end are nodes that dileniate the start and end of the search path.
+// The returned values are the calculated cost and the path taken from start to end.
+func FindPath[C integer, N comparable](g pather[C, N], start, end N) (C, []N, map[N]C) {
+	var zero C
+
+	var seenFn = func(a N) N { return a }
+	if s, ok := g.(interface{ Seen(N) N }); ok {
+		seenFn = s.Seen
+	}
+
+	var potentialFn = func(N) C { var zero C; return zero }
+	if p, ok := g.(interface{ Potential(N) C }); ok {
+		potentialFn = p.Potential
+	}
+
+	type node struct {
+		cost      C
+		potential C
+		parent    *node
+		position  N
+	}
+
+	newPath := func(n *node) []N {
+		var path []N
+		for n.parent != nil {
+			path = append(path, n.position)
+			n = n.parent
+		}
+		path = append(path, n.position)
+
+		Reverse(path)
+		return path
+	}
+
+	less := func(a, b *node) bool {
+		return a.cost+a.potential < b.cost+b.potential
+	}
+
+	closed := make(map[N]C)
+	open := FibHeap(less)
+
+	open.Insert(&node{position: start, potential: potentialFn(start)})
+	closed[start] = zero
+
+	for !open.IsEmpty() {
+		current := open.ExtractMin()
+		for _, nb := range g.Neighbors(current.position) {
+			next := &node{
+				position:  nb,
+				parent:    current,
+				cost:      g.Cost(current.position, nb) + current.cost,
+				potential: potentialFn(nb),
+			}
+
+			seen := seenFn(nb)
+			cost, ok := closed[seen]
+			if !ok || next.cost < cost {
+				open.Insert(next)
+				closed[seen] = next.cost
+			}
+
+			if next.potential == zero && g.Target(next.position, next.cost) {
+				return next.cost, newPath(next), closed
+			}
+		}
+	}
+	return zero, nil, closed
+}
+
+type fibTree[T any] struct {
+	value  *T
+	parent *fibTree[T]
+	child  []*fibTree[T]
+	mark   bool
+}
+
+func (t *fibTree[T]) Value() *T { return t.value }
+func (t *fibTree[T]) addAtEnd(n *fibTree[T]) {
+	n.parent = t
+	t.child = append(t.child, n)
+}
+
+type fibHeap[T any] struct {
+	trees []*fibTree[T]
+	least *fibTree[T]
+	count uint
+	less  func(a, b *T) bool
+}
+
+func FibHeap[T any](less func(a, b *T) bool) *fibHeap[T] {
+	return &fibHeap[T]{less: less}
+}
+
+func (h *fibHeap[T]) GetMin() *T {
+	return h.least.value
+}
+
+func (h *fibHeap[T]) IsEmpty() bool { return h.least == nil }
+
+func (h *fibHeap[T]) Insert(v *T) {
+	ntree := &fibTree[T]{value: v}
+	h.trees = append(h.trees, ntree)
+	if h.least == nil || h.less(v, h.least.value) {
+		h.least = ntree
+	}
+	h.count++
+}
+
+func (h *fibHeap[T]) ExtractMin() *T {
+	smallest := h.least
+	if smallest != nil {
+		// Remove smallest from root trees.
+		for i := range h.trees {
+			pos := h.trees[i]
+			if pos == smallest {
+				h.trees[i] = h.trees[len(h.trees)-1]
+				h.trees = h.trees[:len(h.trees)-1]
+				break
+			}
+		}
+
+		// Add children to root
+		h.trees = append(h.trees, smallest.child...)
+		smallest.child = smallest.child[:0]
+
+		h.least = nil
+		if len(h.trees) > 0 {
+			h.consolidate()
+		}
+
+		h.count--
+		return smallest.value
+	}
+	return nil
+}
+
+func (h *fibHeap[T]) consolidate() {
+	aux := make([]*fibTree[T], bits.Len(h.count)+1)
+	for _, x := range h.trees {
+		order := len(x.child)
+
+		// consolidate the larger roots under smaller roots of same order until we have at most one tree per order.
+		for aux[order] != nil {
+			y := aux[order]
+			if h.less(y.value, x.value) {
+				x, y = y, x
+			}
+			x.addAtEnd(y)
+			aux[order] = nil
+			order++
+		}
+		aux[order] = x
+	}
+
+	h.trees = h.trees[:0]
+	// move ordered trees to root and find least node.
+	for _, k := range aux {
+		if k != nil {
+			k.parent = nil
+			h.trees = append(h.trees, k)
+			if h.least == nil || h.less(k.value, h.least.value) {
+				h.least = k
+			}
+		}
+	}
+}
+
+func (h *fibHeap[T]) Merge(a *fibHeap[T]) {
+	h.trees = append(h.trees, a.trees...)
+	h.count += a.count
+	if h.least == nil || a.least != nil && h.less(a.least.value, h.least.value) {
+		h.least = a.least
+	}
+}
+
+func (h *fibHeap[T]) find(fn func(*T) bool) *fibTree[T] {
+	var st []*fibTree[T]
+	st = append(st, h.trees...)
+	var tr *fibTree[T]
+
+	for len(st) > 0 {
+		tr, st = st[0], st[1:]
+		ro := *tr.value
+		if fn(&ro) {
+			break
+		}
+		st = append(st, tr.child...)
+	}
+
+	return tr
+}
+
+func (h *fibHeap[T]) Find(fn func(*T) bool) *T {
+	if needle := h.find(fn); needle != nil {
+		return needle.value
+	}
+
+	return nil
+}
+
+func (h *fibHeap[T]) DecreaseKey(find func(*T) bool, decrease func(*T)) {
+	needle := h.find(find)
+	if needle == nil {
+		return
+	}
+	decrease(needle.value)
+
+	if h.less(needle.value, h.least.value) {
+		h.least = needle
+	}
+
+	if parent := needle.parent; parent != nil {
+		if h.less(needle.value, parent.value) {
+			h.cut(needle)
+			h.cascadingCut(parent)
+		}
+	}
+}
+
+func (h *fibHeap[T]) cut(x *fibTree[T]) {
+	parent := x.parent
+	for i := range parent.child {
+		pos := parent.child[i]
+		if pos == x {
+			parent.child[i] = parent.child[len(parent.child)-1]
+			parent.child = parent.child[:len(parent.child)-1]
+			break
+		}
+	}
+
+	x.parent = nil
+	x.mark = false
+	h.trees = append(h.trees, x)
+
+	if h.less(x.value, h.least.value) {
+		h.least = x
+	}
+}
+
+func (h *fibHeap[T]) cascadingCut(y *fibTree[T]) {
+	if y.parent != nil {
+		if !y.mark {
+			y.mark = true
+			return
+		}
+
+		h.cut(y)
+		h.cascadingCut(y.parent)
+	}
+}

set.go

@@ -0,0 +1,68 @@
+package aoc
+
+import "golang.org/x/exp/maps"
+
+type set[T comparable] map[T]struct{}
+
+func Set[T comparable](arr ...T) set[T] {
+	m := make(set[T], len(arr))
+	for _, a := range arr {
+		m[a] = struct{}{}
+	}
+	return m
+}
+func (m *set[T]) Add(a T) {
+	(*m)[a] = struct{}{}
+}
+func (m *set[T]) Items() []T {
+	return maps.Keys(*m)
+}
+func (m *set[T]) Has(a T) bool {
+	var ok bool
+	_, ok = (*m)[a]
+	return ok
+}
+
+type defaultMap[K comparable, V any] struct {
+	m map[K]V
+	d V
+}
+
+func DefaultMap[K comparable, V any](d V) *defaultMap[K, V] {
+	return &defaultMap[K, V]{
+		make(map[K]V),
+		d,
+	}
+}
+
+func (m *defaultMap[K, V]) Set(k K, v V) {
+	m.m[k] = v
+}
+func (m *defaultMap[K, V]) Get(k K) (V, bool) {
+	if v, ok := m.m[k]; ok {
+		return v, true
+	}
+	return m.d, false
+}
+
+type pair[K, V any] struct {
+	K K
+	V V
+}
+
+func (m *defaultMap[K, V]) Items() []pair[K, V] {
+	var items = make([]pair[K, V], 0, len(m.m))
+	for k, v := range m.m {
+		items = append(items, pair[K, V]{k, v})
+	}
+	return items
+}
+
+func In[C comparable](n C, haystack ...C) bool {
+	for _, h := range haystack {
+		if n == h {
+			return true
+		}
+	}
+	return false
+}

tools.go

@@ -1,395 +0,0 @@
-package aoc
-
-import (
-	"bufio"
-	"cmp"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-func Runner[R any, F func(*bufio.Scanner) (R, error)](run F) (R, error) {
-	if len(os.Args) != 2 {
-		Log("Usage:", filepath.Base(os.Args[0]), "FILE")
-		os.Exit(22)
-	}
-
-	input, err := os.Open(os.Args[1])
-	if err != nil {
-		Log(err)
-		os.Exit(1)
-	}
-
-	scan := bufio.NewScanner(input)
-	return run(scan)
-}
-
-func MustResult[T any](result T, err error) {
-	if err != nil {
-		fmt.Println("ERR", err)
-		os.Exit(1)
-	}
-
-	Log("result", result)
-}
-
-func Log(v ...any) { fmt.Fprintln(os.Stderr, v...) }
-func Logf(format string, v ...any) {
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-	fmt.Fprintf(os.Stderr, format, v...)
-}
-
-func Reverse[T any](arr []T) []T {
-	for i := 0; i < len(arr)/2; i++ {
-		arr[i], arr[len(arr)-i-1] = arr[len(arr)-i-1], arr[i]
-	}
-	return arr
-}
-
-type uinteger interface{
-	uint | uint8 | uint16 | uint32 | uint64
-}
-type sinteger interface{
-	int | int8 | int16 | int32 | int64
-}
-type integer interface {
-	sinteger | uinteger
-}
-
-// type float interface {
-// 	complex64 | complex128 | float32 | float64
-// }
-// type number interface{ integer | float }
-
-// greatest common divisor (GCD) via Euclidean algorithm
-func GCD[T integer](a, b T) T {
-	for b != 0 {
-		t := b
-		b = a % b
-		a = t
-	}
-	return a
-}
-
-// find Least Common Multiple (LCM) via GCD
-func LCM[T integer](integers ...T) T {
-	if len(integers) == 0 {
-		return 0
-	}
-	if len(integers) == 1 {
-		return integers[0]
-	}
-
-	a, b := integers[0], integers[1]
-	result := a * b / GCD(a, b)
-
-	for _, c := range integers[2:] {
-		result = LCM(result, c)
-	}
-
-	return result
-}
-
-func ReadStringToInts(fields []string) []int {
-	return SliceMap(Atoi, fields...)
-}
-
-type Node[T any] struct {
-	value T
-	pos   int
-	left  *Node[T]
-}
-
-func (n *Node[T]) add(a *Node[T]) *Node[T] {
-	if a == nil {
-		return n
-	}
-
-	if n == nil {
-		return a
-	}
-
-	n.left = a
-	return a
-}
-
-func (n *Node[T]) Value() (value T, ok bool) {
-	if n == nil {
-		return
-	}
-	return n.value, true
-}
-
-func (n *Node[T]) Position() int {
-	if n == nil {
-		return -1
-	}
-	return n.pos
-}
-func (n *Node[T]) SetPosition(i int) {
-	if n == nil {
-		return
-	}
-	n.pos = i
-}
-func (n *Node[T]) Next() *Node[T] {
-	if n == nil {
-		return nil
-	}
-	return n.left
-}
-
-func (n *Node[T]) String() string {
-	if n == nil {
-		return "EOL"
-	}
-	return fmt.Sprintf("node %v", n.value)
-}
-
-type List[T any] struct {
-	head *Node[T]
-	n    *Node[T]
-	p    map[int]*Node[T]
-}
-
-func NewList[T any](a *Node[T]) *List[T] {
-	lis := &List[T]{
-		head: a,
-		n:    a,
-		p:    make(map[int]*Node[T]),
-	}
-	lis.add(a)
-
-	return lis
-}
-func (l *List[T]) Add(value T, pos int) {
-	a := &Node[T]{value: value, pos: pos}
-	l.add(a)
-}
-func (l *List[T]) add(a *Node[T]) {
-	if l.head == nil {
-		l.head = a
-	}
-	if a == nil {
-		return
-	}
-
-	l.n = l.n.add(a)
-	l.p[a.pos] = a
-}
-func (l *List[T]) Get(pos int) *Node[T] {
-	return l.p[pos]
-}
-func (l *List[T]) GetN(pos ...int) []*Node[T] {
-	lis := make([]*Node[T], len(pos))
-	for i, p := range pos {
-		lis[i] = l.p[p]
-	}
-	return lis
-}
-func (l *List[T]) Head() *Node[T] {
-	return l.head
-}
-
-func SliceMap[T, U any](fn func(T) U, in ...T) []U {
-	lis := make([]U, len(in))
-	for i := range lis {
-		lis[i] = fn(in[i])
-	}
-	return lis
-}
-func SliceIMap[T, U any](fn func(int, T) U, in ...T) []U {
-	lis := make([]U, len(in))
-	for i := range lis {
-		lis[i] = fn(i, in[i])
-	}
-	return lis
-}
-
-func Atoi(s string) int {
-	i, _ := strconv.Atoi(s)
-	return i
-}
-
-func Repeat[T any](s T, i int) []T {
-	lis := make([]T, i)
-	for i := range lis {
-		lis[i] = s
-	}
-	return lis
-}
-
-func Sum[T integer](arr ...T) T {
-	var acc T
-	for _, a := range arr {
-		acc += a
-	}
-	return acc
-}
-func SumFunc[T any, U integer](fn func(T) U, input ...T) U {
-	return Sum(SliceMap(fn, input...)...)
-}
-func SumIFunc[T any, U integer](fn func(int, T) U, input ...T) U {
-	return Sum(SliceIMap(fn, input...)...)
-}
-
-func Power2(n int) int {
-	if n == 0 {
-		return 1
-	}
-	p := 2
-	for ; n > 1; n-- {
-		p *= 2
-	}
-	return p
-}
-
-func ABS(i int) int {
-	if i < 0 {
-		return -i
-	}
-	return i
-}
-
-func Transpose[T any](matrix [][]T) [][]T {
-	rows, cols := len(matrix), len(matrix[0])
-
-	m := make([][]T, cols)
-	for i := range m {
-		m[i] = make([]T, rows)
-	}
-
-	for i := 0; i < cols; i++ {
-		for j := 0; j < rows; j++ {
-			m[i][j] = matrix[j][i]
-		}
-	}
-	return m
-}
-
-func Reduce[T, U any](fn func(int, T, U) U, u U, list ...T) U {
-	for i, t := range list {
-		u = fn(i, t, u)
-	}
-	return u
-}
-
-func Max[T cmp.Ordered](a T, v ...T) T {
-	for _, b := range v {
-		if b > a {
-			a = b
-		}
-	}
-	return a
-}
-func Min[T cmp.Ordered](a T, v ...T) T {
-	for _, b := range v {
-		if b < a {
-			a = b
-		}
-	}
-	return a
-}
-
-type PQElem[T any, I integer] struct {
-	Value    T
-	Priority I
-}
-type PQList[T any, I integer] []PQElem[T, I]
-
-func (pq PQList[T, I]) Len() int {
-	return len(pq)
-}
-func (pq PQList[T, I]) Less(i int, j int) bool {
-	return pq[i].Priority < pq[j].Priority
-}
-func (pq PQList[T, I]) Swap(i int, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-}
-
-var _ sort.Interface = (*PQList[rune, int])(nil)
-
-type PriorityQueue[T any, I integer] struct {
-	elem PQList[T, I]
-}
-
-func (pq *PriorityQueue[T, I]) Enqueue(elem T, priority I) {
-	pq.elem = append(pq.elem, PQElem[T, I]{elem, priority})
-	sort.Sort(pq.elem)
-}
-func (pq *PriorityQueue[T, I]) IsEmpty() bool {
-	return len(pq.elem) == 0
-}
-func (pq *PriorityQueue[T, I]) Dequeue() (T, bool) {
-	var elem T
-	if pq.IsEmpty() {
-		return elem, false
-	}
-
-	elem, pq.elem = pq.elem[0].Value, pq.elem[1:]
-	return elem, true
-}
-
-type Vertex[V comparable, I integer] struct {
-	to    V
-	score I
-}
-type graph[V comparable, I uinteger] struct {
-	adj map[V][]Vertex[V, I]
-}
-func Graph[V comparable, I uinteger](size int) *graph[V,I] {
-	return &graph[V,I]{
-		adj:  make(map[V][]Vertex[V,I], size),
-	}
-}
-func (g *graph[V,I]) AddEdge(u, v V, w I) {
-	g.adj[u] = append(g.adj[u], Vertex[V, I]{to: v, score: w})
-	g.adj[v] = append(g.adj[v], Vertex[V, I]{to: u, score: w})
-}
-func (g *graph[V,I]) Dijkstra(src V) {
-	pq := PriorityQueue[V,I]{}
-	dist := make(map[V]I, len(g.adj))
-	visited := make(map[V]bool, len(g.adj))
-	var INF I
-	INF = ^INF>>1
-
-	pq.Enqueue(src, 0)
-	dist[src] = 0
-
-	for !pq.IsEmpty() {
-		u, _ := pq.Dequeue()
-
-		if _, ok := visited[u]; ok {
-			continue
-		}
-		visited[u] = true
-
-		for _, v := range g.adj[u] {
-			_, ok := visited[v.to]
-			var du, dv I
-			if d, inf := dist[u]; !inf {
-				du=INF
-			} else {
-				du = d
-			}
-			if d, inf := dist[v.to]; !inf {
-				dv=INF
-			} else {
-				dv = d
-			} 
-
-			if !ok && du + v.score < dv {
-				dist[v.to] = du + v.score
-				pq.Enqueue(v.to, du + v.score)
-			}
-		}
-	}
-	for v, w := range dist {
-		fmt.Printf("%v, %v\n", v, w)
-	}
-}

tools_test.go

@@ -1,93 +0,0 @@
-package aoc_test
-
-import (
-	"testing"
-
-	"github.com/matryer/is"
-	aoc "go.sour.is/advent-of-code"
-)
-
-func TestReverse(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.Reverse([]int{1, 2, 3, 4}), []int{4, 3, 2, 1})
-}
-
-func TestLCM(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.LCM([]int{}...), 0)
-	is.Equal(aoc.LCM(5), 5)
-	is.Equal(aoc.LCM(5, 3), 15)
-	is.Equal(aoc.LCM(5, 3, 2), 30)
-}
-
-func TestReadStringToInts(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.ReadStringToInts([]string{"1", "2", "3"}), []int{1, 2, 3})
-}
-
-func TestRepeat(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.Repeat(5, 3), []int{5, 5, 5})
-}
-
-func TestPower2(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.Power2(0), 1)
-	is.Equal(aoc.Power2(1), 2)
-	is.Equal(aoc.Power2(2), 4)
-}
-
-func TestABS(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(aoc.ABS(1), 1)
-	is.Equal(aoc.ABS(0), 0)
-	is.Equal(aoc.ABS(-1), 1)
-}
-
-func TestTranspose(t *testing.T) {
-	is := is.New(t)
-
-	is.Equal(
-		aoc.Transpose(
-			[][]int{
-				{1, 1},
-				{0, 0},
-				{1, 1},
-			},
-		),
-		[][]int{
-			{1, 0, 1},
-			{1, 0, 1},
-		},
-	)
-}
-
-func TestList(t *testing.T) {
-	is := is.New(t)
-
-	lis := aoc.NewList[int](nil)
-	lis.Add(5, 0)
-
-	a, _ := lis.Head().Value()
-
-	is.Equal(a, 5)
-}
-
-func TestGraph(t *testing.T) {
-	g := aoc.Graph[int, uint](7)
-	g.AddEdge(0, 1, 2)
-	g.AddEdge(0, 2, 6)
-	g.AddEdge(1, 3, 5)
-	g.AddEdge(2, 3, 8)
-	g.AddEdge(3, 4, 10)
-	g.AddEdge(3, 5, 15)
-	g.AddEdge(4, 6, 2)
-	g.AddEdge(5, 6, 6)
-	g.Dijkstra(0)
-}