solve p1

d21/d21.go

@@ -4,13 +4,13 @@ import (
 	"bufio"
 	"fmt"
 	"os"
-	"slices"
 	"strconv"
 )
 
 func main() {
     reader := bufio.NewReader(os.Stdin)
     var lines [][]byte
+    var extra [][]int
     x, y, i := 0, 0, 0
 
     if len(os.Args) != 2 {
@@ -35,13 +35,14 @@ func main() {
                 }
             }
             lines = append(lines, line)
+            extra = append(extra, make([]int, len(line)))
         } else {
             break
         }
         i++
     }
 
-    recurse(lines, x, y, n, make([]int, 0))
+    recurse(lines, x, y, n)
     sum := 0
     for _, line := range lines {
         fmt.Print(string(line))
@@ -54,34 +55,39 @@ func main() {
     fmt.Printf("x %d y %d n %d result %d\n", x, y, n, sum)
 }
 
-func recurse(grid [][]byte, x int, y int, d int, stack []int) {
-    if x < 0 || y < 0 || y >= len(grid) || x >= len(grid[0]) {
-        return
-    }
+func recurse(grid [][]byte, x int, y int, d int) {
 
-    if grid[y][x] == '#' || grid[y][x] == '\n' {
-        return
-    }
 
-    // We have int tuples at home. Int tuples at home:
-    if slices.Contains(stack, x << 16 | y) {
-        return
-    }
-    if d != 0 {
-        tmp := make([]int, len(stack) + 1)
-        copy(tmp, stack)
-        tmp = append(tmp, x << 16 | y)
-        recurse(grid, x + 1, y, d - 1, tmp)
-        recurse(grid, x - 1, y, d - 1, tmp)
-        recurse(grid, x, y + 1, d - 1, tmp)
-        recurse(grid, x, y - 1, d - 1, tmp)
-        if d % 2 == 0 {
-            grid[y][x] = 'O'
-        } else {
-            grid[y][x] = 'P'
+    q := []int{x, y, d}
+
+    for len(q) > 0 {
+        cx := q[0] // we have queue of int triples at home.
+        cy := q[1] // queue of int triples at home.
+        cd := q[2]
+        q = q[3:]
+        if cx < 0 || cy < 0 || cy >= len(grid) || cx >= len(grid[0]) {
+            continue
         }
-        return
-    }
 
-    grid[y][x] = 'o'
+        if grid[cy][cx] == '#' || grid[cy][cx] == '\n' {
+            continue
+        }
+
+        if grid[cy][cx] == 'O' || grid[cy][cx] == 'P' {
+            continue
+        }
+
+        if cd == -1 {
+            continue
+        }
+        grid[cy][cx] = min(byte('O' + cd % 2), max(grid[cy][cx], 'P')) // cursed hack. 'O' + 1 = 'P'. no ternaries.
+        q = append(q, cx + 1, cy, cd - 1)
+        q = append(q, cx - 1, cy, cd - 1)
+        q = append(q, cx, cy + 1, cd - 1)
+        q = append(q, cx, cy - 1, cd - 1)
+
+    }
+    // if extra[y][x] >= d && (extra[y][x] % 2 != d % 2) {
+    //     return
+    // }
 }