2024 day 4 update

2024/02/02.go

@@ -24,15 +24,14 @@ func solve(input [][]int) int {
 }
 
 func isSafe(ints []int) bool {
-	increasing := ints[1] > ints[0]
+	shouldIncrease := ints[1] > ints[0]
 	for i := 1; i < len(ints); i++ {
-		if ints[i] == ints[i-1] {
+		distance := math.Abs(ints[i] - ints[i-1])
+		if distance < 1 || distance > 3 {
 			return false
 		}
-		if increasing != (ints[i] > ints[i-1]) {
-			return false
-		}
-		if math.Abs(ints[i]-ints[i-1]) > 3 {
+		increases := ints[i] > ints[i-1]
+		if shouldIncrease != increases {
 			return false
 		}
 	}

2024/04/01.go

@@ -14,15 +14,13 @@ func solve(input space.Grid[byte]) int {
 	count := 0
 	for cell := range input.Cells() {
 		for _, dir := range slices.Concat(space.Directions, space.Diagonals) {
-			cell := cell
 			found := true
 			for i := range word {
-				nextCell := input.Get(cell)
+				nextCell := input.Get(cell.Move(dir.Multiply(i)))
 				if nextCell == nil || *nextCell != word[i] {
 					found = false
 					break
 				}
-				cell = cell.Move(dir)
 			}
 			if found {
 				count++

pkg/grid/grid.go

@@ -4,6 +4,7 @@ import (
 	"slices"
 )
 
+// Deprecated. Use space.Grid instead.
 type Grid[T any] map[[2]int]*T
 
 func (g Grid[T]) Set(x, y int, cell T) {

pkg/lists/queue.go

@@ -28,6 +28,7 @@ func (q *Queue[T]) Seq(yield func(T) bool) {
 	}
 }
 
+// TODO: fix the failing cases when using ll
 //type Queue[T any] struct {
 //	linked Linked[T]
 //}

pkg/ll/ll.go

@@ -1,5 +1,6 @@
 package ll
 
+// Deprecated. Use lists.DoublyLinked instead.
 type Double[T any] struct {
 	Val  T
 	Prev *Double[T]

pkg/space/space.go

@@ -38,6 +38,10 @@ func (d *Direction) Add(b Direction) Direction {
 	return Direction{d[0] + b[0], d[1] + b[1]}
 }
 
+func (d *Direction) Multiply(n int) Direction {
+	return Direction{d[0] * n, d[1] * n}
+}
+
 var (
 	North = Direction{0, -1}
 	South = Direction{0, 1}