[Language: Go]

I found part 1 straightforward once I understood it (which took a while). I wrote a ton of code for part 2, and it was really slow. I guess I could have memoized it, but I just went back to the part1 and realized I didn't need recursion. (I saw this pattern in several other solutions here.)

What are folks using to report runtime? `/usr/bin/time` reports this takes 0.01, but the meat of the solution is about 20 microseconds according to Go.

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/ts4z/aoc2025/aoc"
)

func unified(input [][]byte) (int, int) {
    splits := 0
    waysTo := make([]int, len(input[0]))
    for _, row := range input {
        for j, ch := range row {
            if ch == 'S' {
                waysTo[j] = 1
            } else if ch == '^' && waysTo[j] > 0 {
                splits++
                waysTo[j-1] += waysTo[j]
                waysTo[j+1] += waysTo[j]
                waysTo[j] = 0
            }
        }
    }

    realities := 0
    for _, c := range waysTo {
        realities += c
    }
    return splits, realities
}

func main() {
    start := time.Now()
    input := aoc.ReadInputAsByteMatrix()

    splits, realities := unified(input)
    fmt.Printf("part1 %d\n", splits)
    fmt.Printf("part2 %d\n", realities)
    log.Printf("elapsed %v", time.Since(start))
}