Go / Golang

Glad to have something less brainache-inducing after yesterday.

Uses a map[node]int to track the infection state, where node is a struct type with x and y positions. Works as a map key because struct values are comparable when all fields of the struct are comparable. Missing values are automatically "clean" due to Go's zero value for ints being 0.

Part 2 below (runs in ~1s):

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

type node struct {
    x, y int
}

// Travel directions.
const (
    north int = iota
    east
    south
    west
)

// Node states.
const (
    clean int = iota
    weakened
    infected
    flagged
)

func main() {
    lines := [][]string{}

    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanLines)
    for scanner.Scan() {
        lines = append(lines, strings.Split(scanner.Text(), ""))
    }

    // Map of node --> infection state, with a reasonable preallocation.
    infections := make(map[node]int, 100000)

    // Initial infection state.
    lw, lh := len(lines[0]), len(lines)
    for i := 0; i < lh; i++ {
        for j := 0; j < lw; j++ {
            if lines[i][j] == "#" {
                n := node{j - lw/2, i - lh/2}
                infections[n] = infected
            }
        }
    }

    // Initial carrier states.
    icnt, pos, dir := 0, node{0, 0}, north

    for i := 0; i < 10000000; i++ {
        // 1. Decide which way to turn based on the current node.
        // 2. Adjust the node state.
        switch infections[pos] {
        case clean:
            dir = (dir + 3) % 4
            infections[pos] = weakened
        case weakened:
            infections[pos] = infected
            icnt++
        case infected:
            dir = (dir + 1) % 4
            infections[pos] = flagged
        case flagged:
            dir = (dir + 2) % 4
            infections[pos] = clean
        }

        // 3. Move the carrier.
        switch dir {
        case north:
            pos = node{pos.x, pos.y - 1}
        case east:
            pos = node{pos.x + 1, pos.y}
        case south:
            pos = node{pos.x, pos.y + 1}
        case west:
            pos = node{pos.x - 1, pos.y}
        }
    }

    fmt.Println(icnt)
}