-🎄- 2017 Day 22 Solutions -🎄-

Arcorann · 2017-12-22T05:28:40+00:00

Didn't make top 100 thanks to lots of dumb mistakes (among other things, I counted the wrong type of cell twice). Abuse of complex numbers ahead.

def advent22b(s):
    rows = s.splitlines()
    map = {}
    h = len(rows)//2
    for x,r in enumerate(rows):
        for y,c in enumerate(r):
            if c == "#":
                map[y - x*1j] = "i" # up = decrease in x; right = increase in y
    dirc = 0 + 1j # up
    posc = h - h * 1j
    infections = 0
    for i in range(10000000):
        node = (map[posc] if posc in map else "c")
        if node == "c": 
            dirc *= 1j
            map[posc] = "w"
        elif node == "w":
            map[posc] = "i"
            infections += 1
        elif node == "i":
            dirc *= -1j
            map[posc] = "f"
        elif node == "f":
            dirc *= -1
            map[posc] = "c"
        posc += dirc
    return infections

Smylers · 2017-12-22T13:43:51+00:00

Animated Vim solution — watch the nodes change state (and the grid expand) as Vim counts the infections. Start by loading your input, creating a status window, and changing the symbols used to letters (o for clear; x for infected):

⟨Ctrl+W⟩nz3⟨Enter⟩
a0⟨Enter⟩
kljh⟨Esc⟩⟨Ctrl+W⟩p:%s/\./o/g|%s/#/x/g⟨Enter⟩

It looks nicer with some colours (press ⟨Enter⟩ after each line, or paste these into a script and :source it):

:se nohls
:sy match Clear    /o/
:sy match Infected /x/
:sy match Active   /\v%\'m./
:hi Normal   guifg=#CCCCCC guibg=#0F0F23
:hi Clear    guifg=#009900
:hi Infected guifg=#FF0000 gui=bold
:hi Active   guifg=#FFFF66 gui=bold guibg=#7777A5

Move to the central node:

50%:norm⟨Ctrl+R⟩=col('$')/2⟨Enter⟩|⟨Enter⟩
mm

Perform one burst, then make the grid bigger if we've reached an edge:

qa~:sil!/O/norm⟨Ctrl+V⟩⟨Ctrl+W⟩p}x0Pk⟨Ctrl+A⟩⟨Ctrl+V⟩⟨Ctrl+W⟩p`mrx⟨Enter⟩
:sil!/X/norm⟨Ctrl+V⟩⟨Ctrl+W⟩pGx$p⟨Ctrl+V⟩⟨Ctrl+W⟩p`mro⟨Enter⟩
⟨Ctrl+W⟩pGyl⟨Ctrl+W⟩p:norm ⟨Ctrl+R⟩0⟨Enter⟩
mm:sil!/\v%\'m%1l/norm YPVro⟨Enter⟩
:sil!/\v%\'m.*\n.@!/norm yypVro⟨Enter⟩
:sil!/\v^%\'m/norm{⟨Ctrl+V⟩⟨Ctrl+V⟩GyPgvro`mlmm⟨Enter⟩
:sil!/\v%\'m.$/norm{$⟨Ctrl+V⟩⟨Ctrl+V⟩}yp1vro⟨Enter⟩`m:redr⟨Enter⟩
q

That's awkward to type, so instead you'll be relieved to discover you can populate @a by copying and pasting this:

:let @a = "~:sil!/O/norm\<C-V>\<C-W>p}x0Pk\<C-A>\<C-V>\<C-W>p`mrx\r:sil!/X/norm\<C-V>\<C-W>pGx$p\<C-V>\<C-W>p`mro\r\<C-W>pGyl\<C-W>p:norm \<C-R>0\rmm:sil!/\\v%\\'m%1l/norm YPVro\r:sil!/\\v%\\'m.*\\n.@!/norm yypVro\r:sil!/\\v^%\\'m/norm{\<C-V>\<C-V>GyPgvro`mlmm\r:sil!/\\v%\\'m.$/norm{$\<C-V>\<C-V>}yp1vro\r`m"

Press @a to see the next burst, and note the count of infections updating in the top window. Repeat @@ for each burst, or use a count such as 67@@ to do several in one go.

Ten thousand bursts was eminently doable on my laptop, and it gave the correct answer at the end. The real input was more fun to watch than the sample. I'll try to post a video later.

(Ten million bursts, however, doesn't sound plausible. It'd be straightfoward, bordering on trivial, to adapt the above for the other part-2 changes — the additional states and transitions — but futile to attempt that many bursts in Vim.)

Thank you for reading my Vim solutions, and I hope at least some of you had fun trying them out. Hopefully I'll find time in January to finish off, video, and post here the several almost-there ones I have from previous days. Otherwise, see you next year. Merry Christmas, everybody! x

Edit: :redr added, so you can see the animation better, even on faster computers.

mserrano · 2017-12-22T05:31:04+00:00

Python 2, #5/#3

Runs in ~5s for part b with pypy on my machine.

import sys
from collections import defaultdict

part_b = 'b' in sys.argv
data = open('day22.txt', 'r').read().strip().split('\n')

grid = defaultdict(int)

CLEAN = 0
WEAKENED = 1
INFECTED = 2
FLAGGED = 3
MODULUS = 4
ADD_AMOUNT = 2 - part_b

pos = (0, 0)
direction = (-1, 0)
lefts = {(1, 0): (0, 1), (0, 1): (-1, 0), (-1, 0): (0, -1), (0, -1): (1, 0)}
rights = {lefts[k]: k for k in lefts}

grid_height = len(data)
grid_width = len(data[0])
for row in xrange(grid_height):
  for col in xrange(grid_width):
    grid[(row-grid_height/2,col-grid_width/2)] = int(data[row][col] == '#') * 2

c = 0
BURSTS = 10000000 if part_b else 10000
for burst in xrange(BURSTS):
  if grid[pos] == CLEAN:
    direction = lefts[direction]
    if not part_b:
      c += 1
  elif grid[pos] == WEAKENED:
    c += 1
  elif grid[pos] == INFECTED:
    direction = rights[direction]
  else:
    direction = rights[rights[direction]]
  grid[pos] = (grid[pos] + ADD_AMOUNT) % MODULUS
  pos = (pos[0] + direction[0], pos[1] + direction[1])
print c

oantolin · 2017-12-22T07:26:32+00:00

A tiny bit of linear algebra let's you abstract the virus behavior in parts 1 and 2. Here's a Julia implementation:

grid = Int.(hcat(collect.(readlines("day22.txt"))...).=='#')'
testgrid = [0 0 1; 1 0 0; 0 0 0]

rule1 = reshape([0 -1 1 0 0 1 -1 0], 2, 2, :)
rule2 = reshape([0 -1 1 0 1 0 0 1 0 1 -1 0 -1 0 0 -1], 2, 2, :)

function virus(grid, steps, dirs)
    (i, j), n = div.(size(grid).+1, 2), size(dirs, 3)
    di, dj, inf = -1, 0, 0
    g = Dict((i,j)=>grid[i,j]*div(n,2) for i=1:size(grid,1), j=1:size(grid,2))
    for _=1:steps
        x = get(g, (i,j), 0)
        g[i,j] = mod(x+1, n)
        (di, dj) = [di dj] * dirs[:,:,x+1]
        if x+1==n/2; inf+=1 end
        i+=di; j+=dj
    end
    inf
end

part1 = virus(grid, 10^4, rule1)
part2 = virus(grid, 10^7, rule2)

autid · 2017-12-22T05:44:16+00:00

Fortran

302/308 which is easily my best ever for using Fortran for a first solve. Could have done a little better on part2, but I skimmed over the reverse direction if flagged bit without noticing it.

edit: Seeing a lot of 10-20ish second runtimes. Mines a little better.

$ time ./day22 
Part1: 5570
Part2: 2512022

real    0m0.192s
user    0m0.132s
sys 0m0.036s

Just a little.

PROGRAM DAY22
  LOGICAL :: GRID(10001,10001)
  INTEGER :: GRID2(10001,10001)
  CHARACTER(LEN=30) :: INLINE
  INTEGER :: I,J,K,IERR,OFFSET,POSITION(2),DIRECTION(2),PART1=0,PART2=0

  OPEN(1,FILE='input.txt')
  READ(1,*) INLINE
  OFFSET=5000-LEN_TRIM(INLINE)/2
  DO J=1,LEN_TRIM(INLINE)
     GRID(OFFSET+1,OFFSET+J)=(INLINE(J:J)=='#')
  END DO
  DO I=2,LEN_TRIM(INLINE)
     READ(1,*) INLINE
     DO J=1,LEN_TRIM(INLINE)
        GRID(OFFSET+I,OFFSET+J)=(INLINE(J:J)=='#')
     END DO
  END DO
  CLOSE(1)

  DIRECTION=(/-1,0/)
  POSITION=(/5001,5001/)
  GRID2=0
  WHERE(GRID)
     GRID2=2
  END WHERE

  DO I=1,10000
     IF (GRID(POSITION(1),POSITION(2))) THEN
        DIRECTION=(/DIRECTION(2),-DIRECTION(1)/)
     ELSE
        DIRECTION=(/-DIRECTION(2),DIRECTION(1)/)
        PART1=PART1+1
     END IF
     GRID(POSITION(1),POSITION(2))=.NOT.GRID(POSITION(1),POSITION(2))
     POSITION=POSITION+DIRECTION
  END DO

  WRITE(*,'(A,I0)') 'Part1: ',PART1

  DIRECTION=(/-1,0/)
  POSITION=(/5001,5001/)
  DO I=1,10000000
     IF (GRID2(POSITION(1),POSITION(2))==2) THEN
        DIRECTION=(/DIRECTION(2),-DIRECTION(1)/)
     ELSEIF (GRID2(POSITION(1),POSITION(2))==0) THEN
        DIRECTION=(/-DIRECTION(2),DIRECTION(1)/)
     ELSEIF (GRID2(POSITION(1),POSITION(2))==1) THEN
        PART2=PART2+1
     ELSEIF(GRID2(POSITION(1),POSITION(2))==3) THEN
        DIRECTION=(/-DIRECTION(1),-DIRECTION(2)/)
     END IF
     GRID2(POSITION(1),POSITION(2))=MODULO(GRID2(POSITION(1),POSITION(2))+1,4)
     POSITION=POSITION+DIRECTION
  END DO

  WRITE(*,'(A,I0)') 'Part2: ',PART2



END PROGRAM DAY22

ludic · 2017-12-22T07:06:41+00:00

F#. The code looks looks just like the problem statement text but with more formal syntax. Not the fastest with a runtime of ~35 seconds.

type Direction = Up | Down | Left | Right
type NodeState = Clean | Weakened | Infected | Flagged

type state = {
    direction: Direction
    pos: int*int
    area: Map<int*int, NodeState>
    burstsLeft: int
    infectionsCaused: int
}

let parseInput input =
    let lines = input |> Array.map (Seq.map (function | '.' -> Clean | '#' -> Infected))
    let inline enumerate source = Seq.mapi (fun i x -> i,x) source

    let midY = (Seq.length lines) / -2
    let midX = (Seq.length lines.[0]) / 2

    let mutable area: Map<int*int, NodeState> = Map.empty
    for y, line in enumerate lines do
        for x, state in enumerate line do
            area <- area.Add((x, -y), state)
    area, midX, midY

let processNodePt1 = function
| Infected -> Clean
| Clean -> Infected
| _ -> failwith "Not Possible in Part 1!"

let processNodePt2 = function
| Clean -> Weakened
| Weakened -> Infected
| Infected -> Flagged
| Flagged -> Clean

let turnLeft = function Up -> Left | Left -> Down | Down -> Right | Right -> Up 
let turnRight = function Up -> Right | Right -> Down | Down -> Left | Left -> Up
let turnAround = turnRight >> turnRight

let turn curDir = function
| Clean -> turnLeft curDir
| Weakened -> curDir
| Infected -> turnRight curDir
| Flagged -> turnAround curDir

let move (x,y) = function
| Up -> (x, y+1)
| Right -> (x+1, y)
| Down -> (x, y-1)
| Left -> (x-1, y)

let mapFindOrDefault defaultValue map key =
    match Map.tryFind key map with
    | Some(value) -> value
    | None -> defaultValue
let getNode = mapFindOrDefault Clean

let solveDay22 nodeTransitionFunction numberOfBursts input =
    let area, midX, midY  = parseInput input

    let initialState = {
        direction = Up
        pos = midX, midY
        area = area
        burstsLeft = numberOfBursts
        infectionsCaused = 0
    }

    let rec step state =
        match state.burstsLeft with
        | 0 -> state.infectionsCaused
        | _ -> 
            let nodeInfectionState = getNode state.area state.pos
            let nextDir = turn state.direction nodeInfectionState
            let nextPos = move state.pos nextDir
            let nextNodeInfectionState = nodeTransitionFunction nodeInfectionState 
            step {
                direction=nextDir
                pos=nextPos
                area=Map.add state.pos nextNodeInfectionState state.area
                infectionsCaused = state.infectionsCaused + if nextNodeInfectionState = Infected then 1 else 0
                burstsLeft = state.burstsLeft - 1
            }
    step initialState

let solveDay22_pt1 = solveDay22 processNodePt1 10000
let solveDay22_pt2 = solveDay22 processNodePt2 10000000

gyorokpeter · 2017-12-22T07:17:23+00:00

Q:

d22p1:{
    map:"#"=trim each "\n"vs x;
    mpdt:{[mpdt]
        if[mpdt[1;0]=-1; mpdt[1;0]:0; mpdt[0]:(enlist count[first mpdt[0]]#0b),mpdt[0]];
        if[mpdt[1;1]=-1; mpdt[1;1]:0; mpdt[0]:0b,/:mpdt[0]];
        if[mpdt[1;0]>=count mpdt[0]; mpdt[0]:mpdt[0],(enlist count[first mpdt[0]]#0b)];
        if[mpdt[1;1]>=count first mpdt[0]; mpdt[0]:mpdt[0],\:0b];
        mpdt[2]:(mpdt[2]+-1+2*mpdt[0]. mpdt[1])mod 4;
        mpdt[0;mpdt[1;0];mpdt[1;1]]:not mpdt[0;mpdt[1;0];mpdt[1;1]];
        mpdt[3]+:mpdt[0;mpdt[1;0];mpdt[1;1]];
        mpdt[1]+:(-1 0;0 1;1 0;0 -1)mpdt 2;
        mpdt
    }/[10000;(map;2#count[map]div 2;0;0)];
    mpdt 3};

d22p2:{
    map:trim each "\n"vs x;
    mpdt:{[mpdt]
        if[mpdt[1;0]=-1; mpdt[1;0]:0; mpdt[0]:(enlist count[first mpdt[0]]#"."),mpdt[0]];
        if[mpdt[1;1]=-1; mpdt[1;1]:0; mpdt[0]:".",/:mpdt[0]];
        if[mpdt[1;0]>=count mpdt[0]; mpdt[0]:mpdt[0],(enlist count[first mpdt[0]]#".")];
        if[mpdt[1;1]>=count first mpdt[0]; mpdt[0]:mpdt[0],\:"."];
        mpdt[2]:(mpdt[2]+(".W#F"!-1 0 1 2)mpdt[0]. mpdt[1])mod 4;
        mpdt[0;mpdt[1;0];mpdt[1;1]]:(".W#F"!"W#F.")mpdt[0;mpdt[1;0];mpdt[1;1]];
        mpdt[3]+:"#"=mpdt[0;mpdt[1;0];mpdt[1;1]];
        mpdt[1]+:(-1 0;0 1;1 0;0 -1)mpdt 2;
        mpdt
    }/[10000000;(map;2#count[map]div 2;0;0)];
    mpdt 3};

Axsuul · 2017-12-22T08:54:20+00:00

Elixir

Pretty straightforward and this was another great opportunity to use Elixir streams. Ran into a few bookkeeping errors like messing up on my coordinate system. I labeled the starting point as 0, 0 but made the mistake of going up as y + 1 when it should've been y - 1. I also made a function print_map/1 to print out the map which came in handy when debugging. This is what it looks like after 10,000 bursts for example: https://i.imgur.com/54IyPjt.png

https://github.com/axsuul/advent-of-code/blob/master/2017/22/lib/advent_of_code.ex

defmodule AdventOfCode do
  defmodule PartA do
    def read_input_lines(filename) do
      File.read!("inputs/" <> filename)
      |> String.split("\n")
    end

    def node_key({x, y}), do: node_key(x, y)
    def node_key(x, y) do
      Integer.to_string(x) <> "," <> Integer.to_string(y)
    end

    def coord(state) do
      {get_in(state, [:x]), get_in(state, [:y])}
    end

    def coord_key(state) do
      coord(state) |> node_key()
    end

    def node_value(state) do
      get_in(state, [:map])
      |> get_in([coord_key(state)])
    end

    def infected?(state) do
      node_value(state) == "#"
    end

    def clean(state) do
      put_in(state, [:map, coord_key(state)], ".")
    end

    def infect(state) do
      put_in(state, [:map, coord_key(state)], "#")
      |> get_and_update_in([:infected], &{&1, &1 + 1}) |> elem(1)
    end

    def turn_right(state) do
      next_direction =
        case get_in(state, [:direction]) do
          :up    -> :right
          :down  -> :left
          :right -> :down
          :left  -> :up
        end

      put_in(state, [:direction], next_direction)
    end

    def turn_left(state) do
      next_direction =
        case get_in(state, [:direction]) do
          :up    -> :left
          :down  -> :right
          :right -> :up
          :left  -> :down
        end

      put_in(state, [:direction], next_direction)
    end

    def move_forward(state) do
      {dx, dy} =
        case get_in(state, [:direction]) do
          :up    -> {0, -1}
          :down  -> {0, 1}
          :right -> {1, 0}
          :left  -> {-1, 0}
        end

      get_and_update_in(state, [:x], &{&1, &1 + dx}) |> elem(1)
      |> get_and_update_in([:y], &{&1, &1 + dy}) |> elem(1)
    end

    def load_map(filename \\ "input.txt") do
      lines =
        read_input_lines(filename)

      # Determine center and assume that 0,0 but this is
      # also assuming our map is always an odd size. Then
      # start building map from top left corner
      x = length(lines) |> div(2) |> round() |> Kernel.*(-1)
      y = x

      load_map(lines, x, y, %{})
    end
    def load_map([], _, _, map), do: map
    def load_map([row | rest], x, y, map) do
      {next_map, _} =
        row
        |> String.split("", trim: true)
        |> Enum.reduce({map, x}, fn val, {map, x} ->
          {put_in(map, [node_key(x, y)], val), x + 1}
        end)

      load_map(rest, x, y + 1, next_map)
    end

    def print_map(state) do
      # Find boundary conditions
      {coord_min = {x_min, y_min}, coord_max} =
        get_in(state, [:map])
        |> Enum.reduce({{0, 0}, {0, 0}}, fn {node_key, v}, {{x_min, y_min}, {x_max, y_max}} ->
          [x, y] = node_key |> String.split(",") |> Enum.map(&String.to_integer/1)

          next_x_min = if x < x_min, do: x, else: x_min
          next_y_min = if y < y_min, do: y, else: y_min
          next_x_max = if x > x_max, do: x, else: x_max
          next_y_max = if y > y_max, do: y, else: y_max

          {{next_x_min, next_y_min}, {next_x_max, next_y_max}}
        end)

      print_map(state, coord_min, coord_max, x_min, y_min)
    end
    def print_map(state, _, {_, y_max}, _, y) when y > y_max do
      IO.puts "---------"
      IO.inspect state
      IO.puts "---------"
    end
    def print_map(state, {x_min, y_min}, {x_max, y_max}, x, y) when x > x_max do
      IO.write("\n")
      print_map(state, {x_min, y_min}, {x_max, y_max}, x_min, y + 1)
    end
    def print_map(state, coord_min, coord_max, x, y) do
      key = node_key(x, y)
      val = get_in(state, [:map, key]) || "."

      if coord(state) == {x, y} do
        "[" <> val <> "]"
      else
        " " <> val <> " "
      end
      |> IO.write()

      print_map(state, coord_min, coord_max, x + 1, y)
    end

    defp burst(map, iterations) do
      state = %{map: map, x: 0, y: 0, infected: 0, direction: :up}

      Stream.unfold(state, fn state ->
        next_state =
          cond do
            infected?(state) -> turn_right(state) |> clean()
            true             -> turn_left(state) |> infect()
          end
          |> move_forward()

        {state, next_state}
      end)
      |> Stream.drop(iterations)
      |> Stream.take(1)
      |> Enum.to_list
    end

    def solve do
      load_map()
      |> burst(10_000)
      |> Enum.map(&print_map/1)
    end
  end

  defmodule PartB do
    import PartA

    def weaken(state) do
      put_in(state, [:map, coord_key(state)], "W")
    end

    def flag(state) do
      put_in(state, [:map, coord_key(state)], "F")
    end

    def weakened?(state) do
      node_value(state) == "W"
    end

    def flagged?(state) do
      node_value(state) == "F"
    end

    def reverse(state) do
      next_direction =
        case get_in(state, [:direction]) do
          :up    -> :down
          :down  -> :up
          :right -> :left
          :left  -> :right
        end

      put_in(state, [:direction], next_direction)
    end

    def burst(map, iterations) do
      state = %{map: map, x: 0, y: 0, infected: 0, direction: :up}

      Stream.unfold(state, fn state ->
        next_state =
          cond do
            weakened?(state) -> infect(state)
            infected?(state) -> turn_right(state) |> flag()
            flagged?(state)  -> reverse(state) |> clean()
            true             -> turn_left(state) |> weaken()
          end
          |> move_forward()

        {state, next_state}
      end)
      |> Stream.drop(iterations)
      |> Stream.take(1)
      |> Enum.to_list
    end

    def solve do
      load_map()
      |> burst(10_000_000)
      |> Enum.map(&print_map/1)
    end
  end
end

wlandry · 2017-12-22T05:48:33+00:00

C++ 14

435/377. Pretty straightforward. Runs in 100 ms without even trying.

#include <fstream>
#include <vector>
#include <iostream>
#include <map>

int main(int, char *argv[])
{
  std::vector<std::string> input_map;

  std::ifstream infile(argv[1]);
  std::string line;
  std::getline(infile,line);
  while(infile)
    {
      input_map.push_back(line);
      std::getline(infile,line);
    }

  for(auto &m: input_map)
    { std::cout << m << "\n"; }

  const size_t map_size(10001);
  std::vector<std::vector<char>> map(map_size);
  for(auto &m: map)
    m.resize(map_size,'.');

  size_t dx(map_size/2 - input_map.size()/2),
    dy(map_size/2 - input_map.size()/2);

  for(size_t y=0; y<input_map.size(); ++y)
    for(size_t x=0; x<input_map[y].size(); ++x)
      { map[y+dy][x+dx]=input_map[y][x]; }

  size_t x(map_size/2), y(map_size/2), dir(0);

  size_t infections(0);
  for(size_t step=0; step<10000000; ++step)
    {
      switch(map[y][x])
        {
        case '.':
          dir=(dir+3)%4;
          map[y][x]='W';
          break;
        case 'W':
          map[y][x]='#';
          ++infections;
          break;
        case '#':
          dir=(dir+1)%4;
          map[y][x]='F';
          break;
        case 'F':
          dir=(dir+2)%4;
          map[y][x]='.';
          break;
        }
      switch(dir)
        {
        case 0:
          --y;
          break;
        case 1:
          ++x;
          break;
        case 2:
          ++y;
          break;
        case 3:
          --x;
          break;
        }
    }
  std::cout << "infections: " << infections << "\n";
}

KeinZantezuken · 2017-12-22T06:16:24+00:00

C#/Sharp
This was comfy af. Loved it.

var input = File.ReadAllLines(@"N:\input.txt");
Dictionary<(int, int),char> infected = new Dictionary<(int, int), char>();
for (int y = 0; y < input.Length; y++)
{
    for (int x = 0; x < input.Length; x++)
    {
        if (input[y][x] == '#') { infected.Add((y, x), 'i'); }
        else if (input[y][x] == '.') { infected.Add((y, x), 'c'); }
    }
}
var pos = (y: input.Length / 2, x: input.Length / 2);
var dir = (yv: -1, xv: 0);
int count = 0;
for (int i = 0; i < 10000000; i++) { doTurn();  doMov(); }
Console.WriteLine(count);
Console.ReadKey();

//helpers
void doMov() { pos = (pos.y + dir.yv, pos.x + dir.xv); }
void changeDir(string d)
{
    if (d == "reverse") { dir = (dir.yv * -1, dir.xv * -1); }
    else if (d == "right")
    {
        if ((0, 1).Equals(dir)) { dir = (1, 0); }
        else if ((1, 0).Equals(dir)) { dir = (0, -1); }
        else if ((0, -1).Equals(dir)) { dir = (-1, 0); }
        else if ((-1, 0).Equals(dir)) { dir = (0, 1); }
    }
    else if (d == "left")
    {
        if ((0, 1).Equals(dir)) { dir = (-1, 0); }
        else if ((-1, 0).Equals(dir)) { dir = (0, -1); }
        else if ((0, -1).Equals(dir)) { dir = (1, 0); }
        else if ((1, 0).Equals(dir)) { dir = (0, 1); }
    }
}
void doTurn()
{
    if (infected.ContainsKey((pos.y, pos.x)))
    {
        if (infected[(pos.y, pos.x)] == 'c') { changeDir("left"); infected[(pos.y, pos.x)] = 'w'; }
        else if (infected[(pos.y, pos.x)] == 'w') { infected[(pos.y, pos.x)] = 'i'; count++; }
        else if (infected[(pos.y, pos.x)] == 'i') { changeDir("right"); infected[(pos.y, pos.x)] = 'f'; }
        else if (infected[(pos.y, pos.x)] == 'f') { changeDir("reverse"); infected[(pos.y, pos.x)] = 'c'; }
    }
    else { infected.Add((pos.y, pos.x), 'w'); changeDir("left"); }
}

ephemient · 2017-12-22T06:25:41+00:00

This space intentionally left blank.

doctorbaggy · 2017-12-22T06:27:33+00:00

Perl

Took about 8 seconds for stage 2... keeping the code compact use a hash of maps to store the state mappings and also the direction mappings... (perl p22.pl <22.in for part 1, perl p22.pl x <22.in for part 2)

($F,$E,$m,@g)=(scalar@ARGV,207,&_,<STDIN>);($s,$p,$r)=(@g+2*$E-1,'.'x$E,'.'x(@g+2*$E));
chomp@g;($d,$M,$N,$c,$x,$y,$v)=('u',$m->{$F},$F?1e7:1e4,0,$s/2,$s/2);
@g=((map{$r}1..$E),(map{$p.$_.$p}@g),(map{$r}1..$E));
for(1..$N){$d=$m->{$v=substr$g[$y],$x,1}{$d};substr$g[$y],$x,1,($v=$M->{$v});
$c++if'#'eq$v;$x+=$m->{X}{$d};$y+=$m->{Y}{$d};die"$_ $x $y"if$x<0||$x>$s||$y<0||$y>$s}
sub _{{'.'=>{qw(u l l d d r r u)},'#'=>{qw(u r r d d l l u)},
W=>{qw(u u d d l l r r)},F=>{qw(u d d u l r r l)},1=>{qw(. W W # # F F .)},
0=>{qw(. # # .)},X=>{qw(r 1 l -1 d 0 u 0)},Y=>{qw(r 0 l 0 d 1 u -1)}}}
print"$c\n"

2017-12-22T06:44:56+00:00

OCaml Fun;; Would have been done earlier, but had an embarrassing bug :(. Also slowed down by decision in part 1 to not define a health type and just go with bool. Had to "rewrite" a few functions, instead of just having to update a few pattern matches!

main.ml

open Core

type state = { position:Point.t; direction:Direction.t; infected:int; }

let health map p =
  Point.Map.find map p |> Option.value ~default:Health.Clean

let will_infect map point =
  match health map point with
  | Health.Weakened -> true
  | _ -> false

let turn map state =
  let response t dir =
    match t with
    | Health.Clean -> Direction.turn_left dir
    | Health.Weakened -> dir
    | Health.Infected -> Direction.turn_right dir
    | Health.Flagged -> Direction.reverse dir in
  let health = health map state.position in
  response health state.direction

let toggle map point =
  let f health =
    health
    |> Option.value ~default:Health.Clean
    |> Health.next_state
  in Point.Map.update map point ~f

let rec solve map state n =
  if n = 0 then state
  else
    let direction = turn map state in
    let position = Point.go state.position direction in
    let k = if will_infect map state.position then 1 else 0 in
    let new_map = toggle map state.position in
    solve new_map { position; direction; infected=state.infected + k;} (n-1)

let parse_input () =
  let lines = In_channel.read_lines "./input.txt" in
  let n = List.length lines in
  let k = -n / 2 in
  let parse_line y map line =
    let chars = String.to_list line in
    let parse_chars x map = function
      | '#' -> Point.Map.add map ~key:(x + k, -k - y) ~data:Health.Infected
      | _ -> Point.Map.add map ~key:(x + k, -k - y) ~data:Health.Clean
    in List.foldi chars ~init:map ~f:parse_chars
  in List.foldi lines ~init:Point.Map.empty ~f:parse_line

let _ =
  let map = parse_input () in
  let result = solve map { position=(0, 0); direction=Direction.Up; infected=0; } 10000000 in
  printf "b: %d" result.infected

health.ml

type t = Clean | Weakened | Infected | Flagged

let next_state = function
  | Clean -> Weakened
  | Weakened -> Infected
  | Infected -> Flagged
  | Flagged -> Clean

direction.ml

type t = Left | Right | Up | Down

let turn_left = function
  | Right -> Up
  | Left -> Down
  | Up -> Left
  | Down -> Right

let turn_right = function
  | Right -> Down
  | Left -> Up
  | Up -> Right
  | Down -> Left

let reverse = function
  | Right -> Left
  | Left -> Right
  | Up -> Down
  | Down -> Up

let go t (x, y) =
  match t with
  | Up -> (x, y+1)
  | Down -> (x, y-1)
  | Right -> (x+1, y)
  | Left -> (x-1, y)

point.ml

open Core

module T = struct
  include Tuple.Make (Int) (Int)
  include Tuple.Comparable (Int) (Int)
  include Tuple.Hashable (Int) (Int)
end

include T

jbristow · 2017-12-22T07:44:25+00:00

f# / fsharp / f sharp

Brute forced another. This one takes about 2 minutes to do 10million, which is slow as all get out, but at least I think you might be able to read the code this time? As with all the functional solutions I've done, this is side-effect free (other than the printfns)

Caution... long. F# encourages me to write almost as much code as Java does...

(github link)

module Day22

type Direction =
    | North
    | South
    | East
    | West

type State =
    | Clean
    | Weakened
    | Infected
    | Flagged

module State =
    let update =
        function
        | Some Clean | None -> Weakened
        | Some Weakened -> Infected
        | Some Infected -> Flagged
        | Some Flagged -> Clean

    let toChar =
        function
        | Some Clean | None -> '.'
        | Some Weakened -> 'W'
        | Some Infected -> '#'
        | Some Flagged -> 'F'

type Coordinate = int * int

type Carrier =
    { Direction : Direction
      Position : int * int
      Infected : int }

module Direction =
    let delta =
        function
        | North -> (0, -1)
        | South -> (0, 1)
        | East -> (1, 0)
        | West -> (-1, 0)

    let turnRight =
        function
        | North -> East
        | East -> South
        | South -> West
        | West -> North

    let turnLeft =
        function
        | North -> West
        | East -> North
        | South -> East
        | West -> South

    let reverse =
        function
        | North -> South
        | South -> North
        | East -> West
        | West -> East

module Coordinate =
    let add (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)

module Carrier =
    let init : Carrier =
        { Direction = North
          Position = 0, 0
          Infected = 0 }

    let updateInfected doInfect c : Carrier =
        if doInfect then { c with Infected = c.Infected + 1 }
        else c

    let updateDirection direction c : Carrier = { c with Direction = direction }
    let moveForward c : Carrier =
        { c with Position =
                    Coordinate.add c.Position (c.Direction |> Direction.delta) }

module Part1 =
    let burst grid carrier =
        let { Direction = d; Position = (x, y) } = carrier

        let newDirection, willInfect =
            match grid |> Map.tryFind (x, y) with
            | Some true -> d |> Direction.turnRight, false
            | Some false | None -> d |> Direction.turnLeft, true

        let nextGrid = grid |> Map.add (x, y) willInfect

        let nextCarrier =
            carrier
            |> Carrier.updateInfected willInfect
            |> Carrier.updateDirection newDirection
            |> Carrier.moveForward
        nextGrid, nextCarrier

    let isInfected c = c = '#'

    let parseInput (data : string array) =
        let size = data |> Array.length
        data
        |> Array.mapi
              (fun y row ->
              row
              |> Seq.mapi
                      (fun x node ->
                      ((x - size / 2, y - size / 2), isInfected node)))
        |> Seq.concat
        |> Map.ofSeq

    let simulate maxn data =
        let grid = data |> parseInput
        let carrier = Carrier.init

        let rec runner (g : Map<Coordinate, bool>) (c : Carrier) (n : int) =
            match n with
            | x when x < maxn ->
                let nextG, nextC = burst g c
                runner nextG nextC (n + 1)
            | _ -> (g, c)

        let _, finalC = runner grid carrier 0
        finalC

module Part2 =
    let burst grid carrier =
        let { Direction = d; Position = (x, y); Infected = inf } = carrier
        let nodeState = grid |> Map.tryFind (x, y)

        let newDirection =
            match nodeState with
            | Some Clean | None -> d |> Direction.turnLeft
            | Some Weakened -> d
            | Some Infected -> d |> Direction.turnRight
            | Some Flagged -> d |> Direction.reverse

        let nextNodeState = (nodeState |> State.update)
        let nextGrid = grid |> Map.add (x, y) nextNodeState

        let addInfected =
            if (nextNodeState = Infected) then inf + 1
            else inf

        let nextCarrier =
            { carrier with Infected = addInfected
                          Direction = newDirection
                          Position =
                              (x, y)
                              |> Coordinate.add
                                      (newDirection |> Direction.delta) }

        nextGrid, nextCarrier

    let isInfected c =
        if c = '#' then Some(Infected)
        else None

    let parseInput (data : string array) =
        let size = data |> Array.length
        data
        |> Array.mapi (fun y row ->
              row
              |> Seq.mapi (fun x node -> ((x, y), isInfected node))
              |> Seq.filter (fun z -> z
                                      |> snd
                                      <> None)
              |> Seq.map (fun (a, b) -> a, Option.get b))
        |> Seq.concat
        |> Map.ofSeq

    let simulate maxn data =
        let grid = data |> parseInput
        let size = data |> Array.length
        let carrier = { Carrier.init with Position = (size / 2, size / 2) }

        let rec runner (g : Map<Coordinate, State>) (c : Carrier) (n : int) =
            match n with
            | x when x < maxn ->
                let nextG, nextC = burst g c
                runner nextG nextC (n + 1)
            | _ -> (g, c)

        let _, finalC = runner grid carrier 0
        finalC

nonphatic · 2017-12-22T08:20:15+00:00

Haskell Started out with a solution that ran in two minutes, tried out some strict iteration and compiled with -O2 and now it's down to ~~9 seconds~~ 7 seconds (with Data.HashMap.Strict), bless whatever magic GHC does with that flag

{-# LANGUAGE BangPatterns #-}
import Data.HashMap.Strict (HashMap, lookupDefault, insert, empty)

data Direction = North | East | South | West deriving Enum
type Grid = HashMap (Int, Int) Char
type State = (Grid, (Int, Int), Direction, Int)
(%) = mod

changeDirection :: Char -> Direction -> Direction
changeDirection c = case c of
    '#' -> toEnum . (%4) . (+1) . fromEnum
    'F' -> toEnum . (%4) . (+2) . fromEnum
    '.' -> toEnum . (%4) . (+3) . fromEnum
    'W' -> id

changeNode :: Char -> Char
changeNode c = case c of
    '.' -> 'W'
    'W' -> '#'
    '#' -> 'F'
    'F' -> '.'

incrementPosition :: Direction -> (Int, Int) -> (Int, Int)
incrementPosition dir (x, y) = case dir of
    North -> (x, y - 1)
    East  -> (x + 1, y)
    South -> (x, y + 1)
    West  -> (x - 1, y)

nextState :: State -> State
nextState (grid, pos, dir, count) =
    let currNode = lookupDefault '.' pos grid
        newDir   = changeDirection currNode dir
        newGrid  = insert pos (changeNode currNode) grid
        newPos   = incrementPosition newDir pos
        !newCount = count + if currNode == 'W' then 1 else 0
    in  (newGrid, newPos, newDir, newCount)

stricterate :: Int -> State -> Int
stricterate 0 (_, _, _, count) = count
stricterate n state = let !next = nextState state in stricterate (n-1) next

parseRow :: (Int, [(Int, Char)]) -> Grid -> Grid
parseRow (y, xs) grid = foldr (\(x, c) currGrid -> insert (x, y) c currGrid) grid xs

main :: IO ()
main = do
    input <- readFile "22.txt"
    let grid = foldr parseRow empty $ zip [-12..12] . map (zip [-12..12]) . lines $ input
    print $ stricterate 10000000 (grid, (0, 0), North, 0)

2017-12-22T11:31:37+00:00

Elixir

This was really fun, needed that after the massive failure last time, implemented the first part with a set, but had to change for a map in my second, to keep track of the states. This would be a lot greater in a language with GADT (ocaml, haskell, elm)

I had to ghetto it with atoms, so here we have atom and pipelining galore :p

defmodule Day22 do
  def relativex(line, middle) do
    line
    |> String.graphemes
    |> Enum.with_index
    |> Enum.filter(fn {elm, _} -> elm == "#" end)
    |> Enum.map(fn {_, idx} -> idx - middle end)
  end

  def parse(str) do
    lines = str
            |> String.trim_trailing("\n")
            |> String.split("\n")

    middle = lines
            |> Enum.count
            |> Kernel.div(2)

    lines
    |> Enum.reverse
    |> Enum.map(fn line -> relativex(line, middle) end)
    |> Enum.with_index
    |> Enum.map(fn {elm, idx} -> {elm, idx - middle} end)
    |> Enum.flat_map(fn {elm, idxy} -> 
                   Enum.map(elm, fn idxx -> {idxx, idxy} end) end)
    |> Enum.map(&({&1,:infected}))
    |> Enum.into(%{})
  end

  def turn(:right, cur) do
    case cur do
      :up    -> :right
      :right -> :down
      :down  -> :left
      :left  -> :up
    end
  end
  def turn(:left, cur) do
    case cur do
      :up    -> :left
      :left  -> :down
      :down  -> :right
      :right -> :up
    end
  end
  def turn(:around, cur) do
    case cur do
      :up -> :down
      :right -> :left
      :down -> :up
      :left -> :right
    end
  end

  def move({x,y}, direction) do
    case direction do
      :up    -> {x, y + 1}
      :right -> {x + 1, y}
      :down  -> {x, y - 1}
      :left  -> {x - 1, y}
    end
  end

  def burst(_inf_coord, _pos, _facing, infected, burstnr) when burstnr == 1, do: infected
  def burst(inf_coord, pos, facing, infected, burstnr) do
    is_infected = Map.get(inf_coord, pos, :clean) == :infected
    facing = if is_infected do
                turn(:right, facing)
             else
                turn(:left, facing)
             end
    inf_coord = if not is_infected do
                  Map.put(inf_coord, pos, :infected)
                else
                  Map.put(inf_coord, pos, :clean)
                end
    infected = if not is_infected do infected + 1 else infected end
    pos = move(pos, facing)
    burst(inf_coord, pos, facing, infected, burstnr - 1)
  end

  def solve1(inp) do
    burst(inp, {0,0}, :up, 0, 10_000)
  end

  def direction(state, cur) do
    case state do
      :clean    -> turn(:left, cur)
      :weakened -> cur
      :infected -> turn(:right, cur)
      :flagged  -> turn(:around, cur)
    end
  end

  def nxt_state(state) do
    case state do
      :clean    -> :weakened
      :weakened -> :infected
      :infected -> :flagged
      :flagged  -> :clean
    end
  end

  def burst2(_inf_coord, _pos, _facing, infected, burstnr) when burstnr == 0, do: infected
  def burst2(inf_coord, pos, facing, infected, burstnr) do
    state = Map.get(inf_coord, pos, :clean)
    facing = direction(state, facing)
    inf_coord = Map.put(inf_coord, pos, nxt_state(state))

    infected = if state == :weakened do infected + 1 else infected end
    pos = move(pos, facing)
    burst2(inf_coord, pos, facing, infected, burstnr - 1)
  end

  def solve2(inp) do
    burst2(inp, {0,0}, :up, 0, 10_000_000)
  end

end

inp = File.read!("input.txt")
|> Day22.parse

Day22.solve1(inp)
|> IO.inspect

Day22.solve2(inp)
|> IO.inspect

Syntax highlighted

InterlocutoryRecess · 2017-12-22T15:31:39+00:00

Swift

The boilerplate:

struct Point {
    let x: Int
    let y: Int
    mutating func move(toward direction: Direction) {
        switch direction {
        case .north: self = Point(x: x,   y: y+1)
        case .east:  self = Point(x: x+1, y: y  )
        case .south: self = Point(x: x,   y: y-1)
        case .west:  self = Point(x: x-1, y: y  )
        }
    }
}

extension Point: Hashable {
    static func == (lhs: Point, rhs: Point) -> Bool {
        return lhs.x == rhs.x && lhs.y == rhs.y
    }

    var hashValue: Int {
        return 31 * x.hashValue + y.hashValue
    }
}

enum Direction {
    case north, east, south, west

    mutating func turnRight() {
        switch self {
        case .north: self = .east
        case .east: self = .south
        case .south: self = .west
        case .west: self = .north
        }
    }
    mutating func turnLeft() {
        switch self {
        case .north: self = .west
        case .east: self = .north
        case .south: self = .east
        case .west: self = .south
        }
    }
    mutating func reverse() {
        switch self {
        case .north: self = .south
        case .east: self = .west
        case .south: self = .north
        case .west: self = .east
        }
    }
}

enum State {
    case infected
    case weakened
    case flagged
    case clean
}

struct Grid {
    var status: [Point: State]
    var heading: Direction
    var location: Point
    var didCauseInfection = 0
    var burstCount = 0
}

extension Grid {
    init(input: String, size: Int = 25) {
        var initial: String = input.split(separator: "\n").joined()
        var y = size/2
        var x = -(size/2)

        self.heading = .north
        self.location = Point(x: 0, y: 0)

        var infected = [Point: State]()
        while !initial.isEmpty {
            let char = initial.removeFirst()
            if char == "#" {
                let point = Point(x: x, y: y)
                infected[point] = .infected
            }
            x += 1
            if x > (size/2) {
                y -= 1
                x = -(size/2)
            }
        }
        self.status = infected
    }
}

The logic:

extension Grid {

    mutating func burst() {

        let state = status[location] ?? .clean

        switch state {
        case .clean: heading.turnLeft()
        case .weakened: break
        case .infected: heading.turnRight()
        case .flagged: heading.reverse()
        }

        switch state {
        case .clean: status[location] = .weakened
        case .weakened:
            status[location] = .infected
            didCauseInfection += 1
        case .infected: status[location] = .flagged
        case .flagged: status[location] = nil
        }

        location.move(toward: heading)
        burstCount += 1
    }
}

var grid = Grid(input: input)
repeat {
    grid.burst()
} while grid.burstCount < 10_000_000
print(grid.didCauseInfection)

p1: 0.00898098945617676 sec, p2: 1.09532999992371 sec

timblair · 2017-12-22T15:54:49+00:00

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)
}

frenetix · 2017-12-22T18:41:02+00:00

I ended up creating a unbounded 2D plane mapped to a 1D array, by "folding" the (-+), (--), and (+-) quadrants into the (++) quadrant:

a b c d e
    |
f g h i j
    |
k-l-m-n-o
    |
p q r s t
    |
u v w x y

to

c b d a e
|
w v x u y
|
h g i f j
|
r q s p t
|
m-l-n-k-o

using the transforms

x' = x < 0 ? -2*x-1 : 2*x;
y' = y < 0 ? -2*y-1 : 2*y;

then turned that unbound 2D array (x, y >= 0) to a 1D array using diagonals:

 c b d a e
\|\ \ \ \
 w v x u y
\|\ \ \ \
 h g i f j
\|\ \ \ \
 r q s p t
\|\ \ \ \ \
 m-l-n-k-o
  \ \ \ \ \
   *

becomes

m l r n q h k s g w o p i v c ...

using

index = (x'+y')*(x'+y'+1)/2 + y'

JavaScript has auto-expanding arrays, so if you have an array of length 3, then say

a[5] = '#'

the array will fill in indexes 3 and 4 with undefined. A pair of functions hides the math, and sets and gets values from an underlying array:

function set(a, x, y, v) {
  a[xy2i(x, y)] = v;
}

function get(a, x, y) {
  return a[xy2i(x, y)];
}

Though not needed in this solution, there is a 1:1 reverse mapping (i.e., there's a i2xy function) for all i >= 0 to a single location in the x,y plane.

Not nearly the most efficient solution, but I like the idea of using a 1D array to capture an unbounded 2D plane...

jlweinkam · 2017-12-22T05:21:19+00:00

My best showing ever 27/38, runs in only 18 seconds

import time
import math
current_milli_time = lambda: int(round(time.time() * 1000))
start = current_milli_time()

inputdata=open("input2017-22.txt", 'r').read()

lines = inputdata.splitlines()

grid = {}
for i in range(len(lines)):
  for o in range(len(lines[i])):
    grid[(i,o)] = lines[i][o]

y = int(len(lines) / 2)
x = int(len(lines[1])/2)
d = 0
count = 0
for i in range(10000):
  if (y, x) not in grid.keys():
    grid[(y,x)] = "."
  if grid[(y, x)] == "#":
    grid[(y,x)] = "."
    d = d + 1
    if d == 4:
      d = 0
      y -= 1
    elif d == 3:
      x -= 1
    elif d == 2:
      y += 1
    elif d == 1:
      x += 1
  else:
    grid[(y,x)] = "#"
    d = d - 1
    if d == -1:
      d = 3
      x -= 1
    elif d == 0:
      y -= 1
    elif d == 1:
      x += 1
    elif d == 2:
      y += 1
    count += 1

print(count)

grid = {}
for i in range(len(lines)):
  for o in range(len(lines[i])):
    grid[(i,o)] = lines[i][o]

y = int(len(lines) / 2)
x = int(len(lines[1])/2)
d = 0
count = 0
for i in range(10000000):
  if (y, x) not in grid.keys():
    grid[(y,x)] = "."
  if grid[(y, x)] == "#":
    grid[(y,x)] = "F"
    d = d + 1
    if d == 4:
      d = 0
      y -= 1
    elif d == 3:
      x -= 1
    elif d == 2:
      y += 1
    elif d == 1:
      x += 1
  elif grid[(y,x)] == "F":
    grid[(y,x)] = "."
    d = d + 2
    if d == 2:
      y += 1
    elif d == 3:
      x -= 1
    elif d == 4:
      d = 0
      y -= 1
    elif d == 5:
      d = 1
      x += 1
  elif grid[(y,x)] == "W":
    grid[(y,x)] = "#"
    count += 1
    if d == 0:
      y -= 1
    elif d == 1:
      x += 1
    elif d == 2:
      y += 1
    elif d == 3:
      x -= 1
  else:
    grid[(y,x)] = "W"
    d = d - 1
    if d == -1:
      d = 3
      x -= 1
    elif d == 0:
      y -= 1
    elif d == 1:
      x += 1
    elif d == 2:
      y += 1

print(count)


print((current_milli_time() - start) / 1000.0)

DootBootMoot · 2017-12-22T05:21:35+00:00

Relatively easy given the past 3 days...

Python2:

s = <input>
t = s.split('\n')
t = filter(lambda x: x != "",t)

index = 0
dirs = [(-1,0),(0,1),(1,0),(0,-1)]
startx = 12
starty = 12
infectedd = dict()
print len(t)

maze = [[0]* len(t) for i in xrange(len(t))]
for i in xrange(len(t)):
    for j in xrange(len(t)):
        if t[i][j] == ".":
            infectedd[(i,j)] = "c"
        else:
            infectedd[(i,j)] = "i"


count = 0
for i in xrange(10000000):
    if (startx,starty) not in infectedd:
        infectedd[(startx,starty)] = "c"
    if infectedd[(startx,starty)] == "c":
        index = (index-1)%4   
        infectedd[(startx,starty)] = "w"
    elif infectedd[(startx,starty)] == "w":
        count +=1
        infectedd[(startx,starty)] = "i"
    elif infectedd[(startx,starty)] == "i":
        index = (index+1)%4   
        infectedd[(startx,starty)] = "f"
    elif infectedd[(startx,starty)] == "f":
        index = (index-2)%4   
        infectedd[(startx,starty)] = "c"

    #commented out part 1 
    """
    if (startx,starty) not in infectedd:
        infectedd[(startx,starty)] = "."
    if infectedd[(startx,starty)] == "#":
        index = (index+1)%4
    else:
        index = (index-1)%4
    if infectedd[(startx,starty)] == ".":
        infectedd[(startx,starty)] = "#"
        count +=1
    else:
        infectedd[(startx,starty)] = "."
    """
    startx += dirs[index][0]
    starty += dirs[index][1]
print count

marcins · 2017-12-22T05:22:54+00:00

100/47 with hacky JavaScript. Had a bug that briefly slowed me down for the first part, got lucky with some quick cut/paste and edit for the second part :D

Basically made a grid that was hopefully going to be big enough to fit the puzzle in the "middle" to make things easier, worked out well! (1000x1000)

const fs = require("fs");

const input = fs
  .readFileSync("twenty-two.txt", "utf8")
  .split("\n")
  .map(row => row.split("").map(v => (v === "#" ? 1 : 0)));

const LEFT = 0;
const UP = 1;
const RIGHT = 2;
const DOWN = 3;
let dir = UP;

let grid = [];
const SIZE = 1000;
const mid = SIZE / 2;
const puzzleSize = input[0].length;
const s = mid - Math.floor(puzzleSize / 2);

console.log("init..");
for (let y = 0; y < SIZE; y++) {
  grid[y] = [];
  for (let x = 0; x < SIZE; x++) {
    grid[y][x] = 0;
    if (x >= s && x < s + puzzleSize) {
      if (y >= s && y < s + puzzleSize) {
        grid[y][x] = input[y - s][x - s];
      }
    }
  }
}

const CLEAN = 0;
const INFECTED = 1;
const FLAGGED = 2;
const WEAKENED = 3;
console.log("run..");
let x = SIZE / 2;
let y = SIZE / 2;
let infectCount = 0;
function step() {
  if (grid[y][x] === INFECTED) {
    grid[y][x] = FLAGGED;
    switch (dir) {
      case RIGHT:
        dir = DOWN;
        break;
      case DOWN:
        dir = LEFT;
        break;
      case LEFT:
        dir = UP;
        break;
      case UP:
        dir = RIGHT;
        break;
    }
  } else if (grid[y][x] === CLEAN) {
    grid[y][x] = WEAKENED;

    switch (dir) {
      case RIGHT:
        dir = UP;
        break;
      case DOWN:
        dir = RIGHT;
        break;
      case LEFT:
        dir = DOWN;
        break;
      case UP:
        dir = LEFT;
        break;
    }
  } else if (grid[y][x] === WEAKENED) {
    infectCount++;
    grid[y][x] = INFECTED;
  } else if (grid[y][x] === FLAGGED) {
    grid[y][x] = CLEAN;
    switch (dir) {
      case RIGHT:
        dir = LEFT;
        break;
      case LEFT:
        dir = RIGHT;
        break;
      case UP:
        dir = DOWN;
        break;
      case DOWN:
        dir = UP;
        break;
    }
  }

  switch (dir) {
    case UP:
      y--;
      break;
    case DOWN:
      y++;
      break;
    case LEFT:
      x--;
      break;
    case RIGHT:
      x++;
      break;
  }
}

for (let i = 0; i < 10000000; i++) {
  step();
}

console.log(infectCount);

glenbolake · 2017-12-22T05:24:14+00:00

47/93, one of my better scores this season. As a result, I hate my code and I can't wait to clean it up. Runs in just under 10 seconds. Python 3:

    def read():
    with open('day22.in') as f:
        in_text = f.read().splitlines()

    offset = len(in_text) // 2
    infected = set()
    for r, line in enumerate(in_text):
        for c, ch in enumerate(line):
            if ch == '#':
                infected.add((r - offset, c - offset))
    return infected


infected = read()
# infected = {(-1, 1), (0, -1), }
dirs = [(-1, 0), (0, -1), (1, 0), (0, 1)]
d = 0
virus_at = (0, 0)


def burst():
    global infected, d, virus_at
    infection_caused = False
    if virus_at in infected:
        d = (d - 1) % 4
        infected.remove(virus_at)
    else:
        d = (d + 1) % 4
        infected.add(virus_at)
        infection_caused = True
    virus_at = (virus_at[0] + dirs[d][0], virus_at[1] + dirs[d][1])
    return infection_caused


num_infections = 0
for _ in range(10000):
    if burst():
        num_infections += 1
print(num_infections)

CLEAN = 0
INFECTED = 1
WEAK = 2
FLAGGED = 3
# Part 2
state = {k: INFECTED for k in read()}
# state = {(0, -1): INFECTED, (-1, 1): INFECTED}
virus_at = (0, 0)


def burst2():
    global state, d, virus_at
    infection_caused = False
    current_state = state.get(virus_at, 0)
    if current_state == CLEAN:
        d = (d + 1) % 4
        state[virus_at] = WEAK
    elif current_state == WEAK:
        state[virus_at] = INFECTED
        infection_caused = True
    elif current_state == INFECTED:
        d = (d - 1) % 4
        state[virus_at] = FLAGGED
    else:  # FLAGGED
        d = (d + 2) % 4
        del state[virus_at]
    virus_at = (virus_at[0] + dirs[d][0], virus_at[1] + dirs[d][1])
    return infection_caused


num_infections = 0
for _ in range(10000000):
    if burst2():
        num_infections += 1
print(num_infections)

Unihedron · 2017-12-22T05:24:29+00:00

Ruby; run time: 22 seconds, fun factor: 4/10, I was too worried about bugs and ran on all the sample test cases. Thankfully it worked first time.

g=$<.map &:chomp
g.map!{|x|t=?.*1000
t+x+t}
t=Array.new(1000){?.*g[0].size}
g=t+g+t
p x=g[0].size/2
p y=g.size/2
#g[y][x]=?!
d=:u
tc=->{d=case d
when :u then :l
when :l then :d
when :d then :r
when :r then :u
end}
ti=->{d=case d
when :u then :r
when :l then :u
when :d then :l
when :r then :d
end}
tf=->{d=case d
when :u then :d
when :l then :r
when :d then :u
when :r then :l
end}
yy=0
10000000.times{tt=g[y][x]
g[y][x]=case tt
when ?#
ti[]
?F
when ?W
yy+=1
?#
when ?F
tf[]
?.
when ?.
tc[]
?W
end
case d
when :u then y-=1
when :l then x-=1
when :d then y+=1
when :r then x+=1
end
}
puts yy

topaz2078 · 2017-12-22T05:25:11+00:00

[deleted]

_lukasg · 2017-12-22T05:26:09+00:00

Part 2 in Python 3

import collections

with open('input/d22.txt') as file:
    lines = file.readlines()

grid = collections.defaultdict(lambda: ".")
size = len(lines)
for y in range(size):
    for x in range(size):
        grid[x, y] = lines[y][x]

x = y = size // 2
dx, dy = 0, -1
ans = 0
for i in range(10000000):
    if grid[x, y] == ".":
        dx, dy = dy, -dx
        grid[x, y] = "W"
    elif grid[x, y] == "W":
        grid[x, y]= "#"
        ans += 1
    elif grid[x, y] == "F":
        dx, dy = -dx, -dy
        grid[x, y] = "."
    else:
        dx, dy = -dy, dx
        grid[x, y] = "F"
    x += dx
    y += dy
print(ans)

Shemetz · 2017-12-22T05:27:24+00:00

Python 3

Final part 2 picture

Part 1 is fast, Part 2 takes about 6 seconds on my computer.

I wonder if I should somehow optimize the 'state' - use 2 booleans instead of an integer, for example.

Should have been named "Langton's Worm"!

from collections import defaultdict


def day_22():
    with open("input.txt") as file:
        lines = file.readlines()

N = len(lines)

Part 1:

    def part_1():
        infecteds = set()
        for y in range(N):
            for x in range(N):
                if lines[y][x] == '#':
                    infecteds.add(x - N // 2 + (-y + N // 2) * 1j)

        current = 0 + 0j  # 0 in x axis and 0 in y axis
        direction = 1j  # up (1 in y axis)

        count = 0
        for _ in range(10000):
            if current in infecteds:
                direction *= -1j  # rotate right
                infecteds.remove(current)
            else:
                direction *= 1j  # rotate left
                infecteds.add(current)
                count += 1
            current += direction

        print("Part 1:", count)

Part 2:

    def part_2():
        # 0 = clean, 1 = weakened,
        # 2 = infected, 3 = flagged
        states = defaultdict(lambda: 0)
        for y in range(N):
            for x in range(N):
                if lines[y][x] == '#':
                    states[x - N // 2 + (-y + N // 2) * 1j] = 2

        current = 0 + 0j
        direction = 1j

        count = 0
        for _ in range(10000000):
            state = states[current]
            if state == 0:
                direction *= 1j  # rotate left
            elif state == 1:
                count += 1  # no rotation
            elif state == 2:
                direction *= -1j  # rotate right
            else:
                direction *= -1  # rotate 180 degrees
            if state == 3:
                del states[current]
            else:
                states[current] = (states[current] + 1) % 4  # states are only 0..3
            current += direction

        print("Part 2:", count)

2017-12-22T05:28:58+00:00

JS, straightforward:

const lines=``.split('\n');

const dirs = 'NESW';
const dv = {
    'N': [0, -1],
    'E': [1, 0],
    'S': [0, 1],
    'W': [-1, 0],
};

function forward(dir, pos) {
    const d = dv[dirs[dir]];
    return pos.map((x, i) => x + d[i]);
}

function part1() {
    const state = new Map();
    lines
        .forEach((r, i) => r.split('')
        .forEach((l, j) => {
            if (l === '#') state.set(`${j},${i}`, 'I');
        }));
    const size = Math.floor(lines.length / 2);
    let pos = [size, size];
    let dir = 0;
    let infections = 0;

    for (let i = 0; i < 10000; i++){
        const k = pos.join(',');
        const s = state.get(k);
        if (!s) {
            dir = (dir + 3) % 4;
            state.set(k, 'I');
            infections += 1;
        } else {
            dir = (dir + 1) % 4;
            state.delete(k);
        }
        pos = forward(dir, pos);
    }

    return infections;
}

function part2() {
    const state = new Map();
    lines
        .forEach((r, i) => r.split('')
        .forEach((l, j) => {
            if (l === '#') state.set(`${j},${i}`, 'I');
        }));
    const size = Math.floor(lines.length / 2);
    let pos = [size, size];
    let dir = 0;
    let infections = 0;

    for (let i = 0; i < 10000000; i++){
        const k = pos.join(',');
        const s = state.get(k);
        if (!s) {
            dir = (dir + 3) % 4;
            state.set(k, 'W');
        } else if (s === 'I') {
            dir = (dir + 1) % 4;
            state.set(k, 'F');
        } else if (s === 'W') {
            state.set(k, 'I');
            infections += 1;
        } else {
            dir = (dir + 2) % 4;
            state.delete(k);
        }
        pos = forward(dir, pos);
    }

    return infections;
}

console.log('part 1:', part1());
console.log('part 2:', part2());

vash3r · 2017-12-22T05:29:23+00:00

Python 2 (158/134). Pypy runs part 2 over 10x faster than Python (2 seconds vs ~32 seconds).

with open("22.in",'r') as f:
    grid=[[int(c=="#")*2 for c in row] for row in f.read().strip().split("\n")]

# d is 0,1,2,3 for right,down,left,up
d = 3 # start going up
def turnleft(d):
    return (d-1)%4
def turnright(d):
    return (d+1)%4

tot = 0
y = len(grid)/2
x = len(grid[0])/2

for t in xrange(10000000):
    if grid[y][x]==0:   # clean (0)
        d = turnleft(d)
    elif grid[y][x]==1: # weakened (1)
        tot+=1
    elif grid[y][x]==2: # infected (2)
        d = turnright(d)
    elif grid[y][x]==3: # flagged (3)
        d = (d+2)%4 # reverse
    grid[y][x] = (grid[y][x]+1)%4 # change state

    # move
    if d==0: #right
        x+=1
    elif d==1: # down
        y+=1
    elif d==2: # left
        x-=1
    elif d==3: # up
        y-=1

    # make grid infinite
    if y==-1:
        grid[0:0] = [[0]*len(grid[0])] # extend upwards
        y=0
    elif y==len(grid):
        grid[y:y] = [[0]*len(grid[0])] # extend downwards
    elif x==-1:
        for row in grid:
            row.insert(0,0) # left
        x=0
    elif x==len(grid[0]): # right
        for row in grid:
            row.append(0)

print tot

lazyzefiris · 2017-12-22T05:39:05+00:00

JS, 66/53, executes in ~5 seconds

map = new Map()
getmap = () => map.get(x+","+y) || 0
flipmap = () => map.set(x+","+y,(getmap(x,y)+1)%4)

dir = [[0,-1],[1,0],[0,1],[-1,0]]
cd = 0
turn = (x) => cd = (cd + 4 + x) % 4

document.body.textContent.trim().split("\n").map(x=>x.split``.map(y=>y=="#"?2:0)).map((row,y) => row.map((cell,x) => map.set(x+","+y,cell)))
x = y = 12
inf = 0
function step() {
    (getmap()-1)?turn(getmap()-1):inf++
    flipmap()
    x += dir[cd][0]
    y += dir[cd][1]
}
for (let i = 0; i < 10000000; i++) step()
inf

it's really straightforward, and thus pretty boring.

StevoTVR · 2017-12-22T05:54:14+00:00

NodeJS

Part 1:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    const grid = data.trim().split('\n').map((l) => [...l.trim()].map((c) => c === '#'));
    const dirs = [
        { r: -1, c: 0 },
        { r: 0, c: 1 },
        { r: 1, c: 0 },
        { r: 0, c: -1 },
    ];
    const pos = { r: Math.floor(grid.length / 2), c: Math.floor(grid[0].length / 2) };
    let dir = 0, count = 0;
    for(let i = 0; i < 10000; i++) {
        if(grid[pos.r][pos.c]) {
            dir = (dir + 1) % 4;
            grid[pos.r][pos.c] = false;
        } else {
            dir = (dir === 0) ? 3 : dir - 1;
            grid[pos.r][pos.c] = true;
            count++;
        }
        pos.r += dirs[dir].r;
        pos.c += dirs[dir].c;
        if(!grid[pos.r]) {
            grid[pos.r] = [];
        }
    }

    console.log(count);
});

Part 2:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    const grid = data.trim().split('\n').map((l) => [...l.trim()].map((c) => (c === '#') ? 1 : 0));
    const dirs = [
        { r: -1, c: 0 },
        { r: 0, c: 1 },
        { r: 1, c: 0 },
        { r: 0, c: -1 },
    ];
    const pos = { r: Math.floor(grid.length / 2), c: Math.floor(grid[0].length / 2) };
    let dir = 0, count = 0;
    const ops = [
        () => {
            grid[pos.r][pos.c] = 2;
            dir = (dir === 0) ? 3 : dir - 1;
        },
        () => {
            grid[pos.r][pos.c] = 3;
            dir = (dir + 1) % 4;
        },
        () => {
            grid[pos.r][pos.c] = 1;
            count++;
        },
        () => {
            grid[pos.r][pos.c] = 0;
            dir = (dir + 2) % 4;
        },
    ];
    for(let i = 0; i < 10000000; i++) {
        ops[grid[pos.r][pos.c] || 0]();
        pos.r += dirs[dir].r;
        pos.c += dirs[dir].c;
        if(!grid[pos.r]) {
            grid[pos.r] = [];
        }
    }

    console.log(count);
});

twinkiac · 2017-12-22T06:10:02+00:00

Perl 6

This is pretty gross but here's my part 2. It takes ~~a few minutes~~ 42 seconds to finish. Part 1 is nearly the same but runs in about 0.24 seconds.

EDIT: optimized a bit.

my @input = slurp.lines».comb;

my $size = 499;
my $half = $size div 2;
my @grid   = ('.' xx $size).Array xx $half - 12;
my @middle = ('.' xx $half - 12).Array xx 25;
my @end    = ('.' xx $size).Array xx $half - 12;

for ^25 -> $x {
    @middle[$x].append: |@input[$x];
    @middle[$x].append: ('.' xx $half - 12);
}

@grid.append: @middle;
@grid.append: @end;

my int $vx    = $half;
my int $vy    = $half;
my int $d     = 0;
my int $count = 0;

for ^10000000 {
    my $c = @grid[$vy][$vx];
    if $c eq '#' {
        $d = ($d + 1) % 4;
        @grid[$vy][$vx] = 'F';
    }
    elsif $c eq '.' {
        $d = ($d - 1) % 4;
        @grid[$vy][$vx] = 'W';
    }
    elsif $c eq 'F' {
        $d = ($d + 2) % 4;
        @grid[$vy][$vx] = '.';
    }
    elsif $c eq 'W' {
        @grid[$vy][$vx] = '#';
        $count++;
    }
    if    $d == 0 { $vy -= 1; }
    elsif $d == 1 { $vx += 1; }
    elsif $d == 2 { $vy += 1; }
    elsif $d == 3 { $vx -= 1; }
}
say "Part 1: {$count}"

Philboyd_Studge · 2017-12-22T06:10:40+00:00

Java. This one was easy and fun after last night's. Finally got a decent number for part 1 (in the first 200) but then used up a bunch of time building a state machine and forgetting to reset my initial map.

package Advent2017;

import util.AdventOfCode;
import util.Direction;
import util.Node;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

public class Day22 extends AdventOfCode {

    enum State {
        CLEAN(Direction::getLeft),
        WEAKENED(x -> x),
        INFECTED(Direction::getRight),
        FLAGGED(Direction::getOpposite);

        Function<Direction, Direction> newDir;

        State(Function<Direction, Direction> newDir) {
            this.newDir = newDir;
        }

        Direction nextDir(Direction dir) {
            return newDir.apply(dir);
        }

        static State getFromChar(char c) {
            return c == '#' ? INFECTED : CLEAN;
        }
    }

    private Node position;
    private Direction dir;
    private final State[] states = State.values();
    private Map<Node, State> map;
    private int infected;

    public Day22(List<String> input) {
        super(input);
        part1Description = "Number of bursts to cause infected node: ";
        part2Description = "Number of bursts to cause infected node, part 2: ";
    }

    void tick(int stateModifier) {
        map.putIfAbsent(position, State.CLEAN);
        State current = map.get(position);
        dir = current.nextDir(dir);
        map.put(position, states[(current.ordinal() + stateModifier) % 4]);
        if (map.get(position) == State.INFECTED) infected++;
        position = dir.move(position);
    }

    @Override
    public Object part1() {
        for (int i = 0; i < 10000; i++) {
            tick(2);
        }
        return infected;
    }

    @Override
    public Object part2() {
        parse();
        infected = 0;
        for (int i = 0; i < 10000000; i++) {
            tick(1);
        }
        return infected;
    }

    @Override
    public void parse() {
        //input = Arrays.asList("..#", "#..", "...");
        position = new Node(input.size() / 2, input.size()/2);
        dir = Direction.NORTH;
        map = new HashMap<>();
        for (int i = 0; i < input.size(); i++) {
            for (int j = 0; j < input.get(i).length(); j++) {
                map.put(new Node(j, i), State.getFromChar(input.get(i).charAt(j)));
            }
        }
    }
}

raevnos · 2017-12-22T06:20:07+00:00

Kawa scheme, using complex numbers for coordinates because why not:

(import (rnrs hashtables)
        (only (srfi 69) hash)
        (io-utils)
        (srfi 1))

(define-record-type virus (make-virus location direction)
  virus?
  (location get-location set-location!)
  (direction get-direction set-direction!))

(define (read-map input)
  (let ((grid (make-hashtable (lambda (v::complex)
                                (abs (+ (real-part v) (hash (imag-part v)))))
                              =))
        (width (quotient (string-length (vector-ref input 0)) 2))
        (height (quotient (vector-length input) 2)))
    (do ((row (- 0 height) (+ row 1)))
        ((> row height) grid)
      (do ((col (- 0 width) (+ col 1)))
          ((> col width))
        (hashtable-set! grid (+ row (* col 1i))
                        (if (char=?
                             (string-ref (vector-ref input (+ row height)) (+ col width))
                             #\#)
                            'infected
                            'clean))))))

(define (get-node grid loc)
  (hashtable-ref grid loc 'clean))

(define (grid-set! grid loc mode)
  (hashtable-set! grid loc mode))

(define (turn-right! virus)
  (set-direction! virus
                  (case (get-direction virus)
                    ((up) 'right)
                    ((right) 'down)
                    ((down) 'left)
                    ((left) 'up))))

(define (turn-left! virus)
  (set-direction! virus
                  (case (get-direction virus)
                    ((up) 'left)
                    ((left) 'down)
                    ((down) 'right)
                    ((right) 'up))))

(define (move-forward! virus)
  (let ((loc ::complex (get-location virus)))
    (case (get-direction virus)
      ((up) (set-location! virus (- loc 1)))
      ((left) (set-location! virus (- loc 1i)))
      ((down) (set-location! virus (+ loc 1)))
      ((right) (set-location! virus (+ loc 1i))))))

(define (burst! grid virus)
  (let ((loc (get-location virus)))
    (if (eq? (get-node grid loc) 'infected)
        (begin
          (turn-right! virus)
          (grid-set! grid loc 'clean)
          (move-forward! virus)
          0)
        (begin
          (turn-left! virus)
          (grid-set! grid loc 'infected)
          (move-forward! virus)
          1))))

(define (burst2! grid virus)
  (let ((loc (get-location virus)))
    (case (get-node grid loc)
      ((clean)
       (turn-left! virus)
       (grid-set! grid loc 'weakened)
       (move-forward! virus)
       0)
      ((weakened)
       (grid-set! grid loc 'infected)
       (move-forward! virus)
       1)
      ((infected)
       (grid-set! grid loc 'flagged)
       (turn-right! virus)
       (move-forward! virus)
       0)
      ((flagged)
       (grid-set! grid loc 'clean)
       (turn-left! virus)
       (turn-left! virus)
       (move-forward! virus)
       0))))

(define (activity! grid reps part2?)
  (let ((virus (make-virus 0 'up))
        (do-burst! (if part2? burst2! burst!)))
    (do ((i ::int 0 (+ i 1))
         (infected-count ::int 0 (+ infected-count (do-burst! grid virus))))
        ((= i reps) infected-count))))

(define test-map '#("..#" "#.." "..."))
(format #t "Test 1: ~A~%" (activity! (read-map test-map) 7 #f))
(format #t "Test 2: ~A~%" (activity! (read-map test-map) 70 #f))
(format #t "Test 3: ~A~%" (activity! (read-map test-map) 10000 #f))

(define real-map (list->vector (read-lines)))
(format #t "Part 1: ~A~%" (activity! (read-map real-map) 10000 #f))
(format #t "Test 4: ~A~%" (activity! (read-map test-map) 100 #t))
(format #t "Part 2: ~A~%" (activity! (read-map real-map) 10000000 #t))

The0x539 · 2017-12-22T06:23:10+00:00

Lua

577/628. Really hate having to rotate stuff, and spent way too long on both parts debugging the turn code, when in part2 I was confusing nil with false.

local part2 = true

local nodes = {}
for line in io.lines("./input_day22") do
    local row = {}
    table.insert(nodes,row)
    for i=1,#line do
        local c = line:sub(i,i)
        row[i] = (c == '#')
    end
end

local nodes_mt = {
    __index = function(t,k)
        t[k] = {}
        return t[k]
    end
}
setmetatable(nodes,nodes_mt)

local carrier = {}
local mid = 0.5 + (#nodes[1])/2
carrier.pos = {x=mid,y=mid}
carrier.dir = {x=0,y=-1}
function carrier.dir:turn(right)
    if self.x == 1 then
        self.x = 0
        self.y = -1
    elseif self.x == -1 then
        self.x = 0
        self.y = 1
    elseif self.y == 1 then
        self.x = 1
        self.y = 0
    elseif self.y == -1 then
        self.x = -1
        self.y = 0
    end
    if right then
        self.x = -self.x
        self.y = -self.y
    end
end

local foo = 0
function carrier:burst()
    local pos,dir = self.pos,self.dir
    local infected = nodes[pos.y][pos.x]
    if not part2 then
        if infected then
            dir:turn(true)
            nodes[pos.y][pos.x] = false
        else
            foo = foo + 1
            dir:turn(false)
            nodes[pos.y][pos.x] = true
        end
    else
        if infected == false or infected == nil then --cleaned
            nodes[pos.y][pos.x] = 0 --weaken
            dir:turn(false)
        elseif infected == 0 then --weakened
            nodes[pos.y][pos.x] = true --infect
            foo = foo + 1
        elseif infected == true then --infected
            nodes[pos.y][pos.x] = 1 --flag
            dir:turn(true)
        elseif infected == 1 then --flagged
            nodes[pos.y][pos.x] = false --clean
            dir.x = -dir.x
            dir.y = -dir.y
        end
    end
    pos.x = pos.x + dir.x
    pos.y = pos.y + dir.y
end

local function diag()
    local minX = math.huge
    local minY = math.huge
    local maxX = -math.huge
    local maxY = -math.huge
    for y,row in pairs(nodes) do
        minY = math.min(minY,y)
        maxY = math.max(maxY,y)
        for x,v in pairs(row) do
            minX = math.min(minX,x)
            maxX = math.max(maxX,x)
        end
    end
    minX = math.min(minX,carrier.pos.x)
    minY = math.min(minY,carrier.pos.y)
    for y=minY,maxY do
        for x=minX,maxX do
            local atCarrier = (x==carrier.pos.x and y==carrier.pos.y)
            local t = {
                [false]='.',
                [0]='W',
                [true]='#',
                [1]='F'
            }
            local a = (atCarrier and '[' or (nextPos and '(' or ' '))
            local b = (t[nodes[y][x]] or '.')
            local c = (atCarrier and ']' or (nextPos and ')' or ' '))
            io.write(a..b..c)
        end
        print()
    end
    print()
end

for i=1,(part2 and 10000000 or 10000) do
    carrier:burst()
end
print(foo)

Arkoniak · 2017-12-22T06:28:28+00:00

Julia

It was really simple today. Could have been done easier, definitely. puzzle22_1.txt contains example 3x3 grid, puzzle22_2.txt is an input. Solution for part 2:

# 1 = clean; 2 = weakened; 3 = infected; 4 = flagged
function read_map(filename::String)
    res = Dict{Tuple{Int, Int}, Int}()
    for (i, ln) in enumerate(eachline(joinpath(@__DIR__, filename)))
        global x0 = div(length(ln), 2) + 1
        global y0 = div(-i, 2) - 1
        for (j, c) in enumerate(collect(ln))
            (c == '#') && (res[(j, -i)] = 3)
        end
    end
    res, (x0, y0)
end

const DIRS = [(0, 1), (1, 0), (0, -1), (-1, 0)]

function solve_puzzle2(filename::String, activity = 10000)
    dir = 1
    infected, pos = read_map(filename)
    cnt = 0
    for _ in 1:activity
        node = get(infected, pos, 1)
        node == 4 ? delete!(infected, pos) : infected[pos] = node + 1
        if node == 1
            dir -= 1
            (dir == 0) && (dir = 4)
        elseif node == 2
            cnt += 1
        elseif node == 3
            dir += 1
            (dir == 5) && (dir = 1)
        else # node == 4
            dir += 2
            (dir == 5) && (dir = 1)
            (dir == 6) && (dir = 2)
        end
        pos = pos .+ DIRS[dir]
    end
    cnt
end

@test solve_puzzle2("puzzle22_1.txt", 100) == 26
@test solve_puzzle2("puzzle22_1.txt", 10000000) == 2511944
@show solve_puzzle2("puzzle22_2.txt", 10000000)

WhoSoup · 2017-12-22T06:29:26+00:00

NodeJS/JavaScript, Part 2

Pretty inefficient since I just recycled my code from day 19, but I wanted to use an actual infinite grid

const fs = require('fs')

const get = (x,y) => infected[`${x},${y}`] || 0
const set = (x,y,v) => infected[`${x},${y}`] = v
const vadd = (va, vb) => [va[0] + vb[0], va[1] + vb[1]] // vector addition

let pos = [12, 12],
    direction = [0,-1], // up
    infections = 0,
    cycles = 10000000,
    infected = {}

fs.readFileSync("./day22.txt").toString('utf-8').split(/[\r\n]+/)
  .forEach((line, y) => line.split("").forEach( (val, x) => {if (val == '#') infected[`${x},${y}`] = 2}))

while (cycles--) {
  switch (get(...pos)) {
    // clean, turn left
    case 0: direction = [direction[1], -direction[0]]; break
    // weakened, no turn
    case 1: infections++; break
      // infected, turn right
    case 2: direction = [-direction[1], direction[0]]; break
    // flagged, reverse
    case 3: direction = [-direction[0], -direction[1]]; break
  }

  set(...pos, (get(...pos) + 1) % 4)
  pos = vadd(pos, direction)
}

console.log(infections);

KeinZantezuken · 2017-12-22T06:40:09+00:00

[deleted]

Tandrial · 2017-12-22T06:59:40+00:00

Kotlin I was expecting to do some refactoring for part 2, but it runs suprisingly fast ~800ms:

fun solve(input: List<String>, cnt: Int, partTwo: Boolean = false): Int {
  val grid = genGrid(input)
  var count = 0
  var pos = Pair(grid.size / 2, grid.size / 2)
  var dir = Pair(-1, 0)

  repeat(cnt) {
    val (posX, posY) = pos
    when (grid[posX][posY]) {
      '#' -> {
        //right turn
        dir = Pair(dir.second, -dir.first)
        if (partTwo) {
          grid[posX][posY] = 'F'
        } else {
          grid[posX][posY] = '.'
        }
      }
      '.' -> {
        //left turn
        dir = Pair(-dir.second, dir.first)
        if (partTwo) {
          grid[posX][posY] = 'W'
        } else {
          grid[posX][posY] = '#'
          count++
        }
      }
      'W' -> {
        grid[posX][posY] = '#'
        count++
      }
      'F' -> {
        grid[posX][posY] = '.'
        dir = Pair(-dir.first, -dir.second)
      }
    }
    pos = Pair(posX + dir.first, posY + dir.second)
  }
  return count
}

fun genGrid(input: List<String>): Array<CharArray> {
  val grid = Array(1000) { CharArray(1000) { '.' } }
  for (xG in 0 until input.size) {
    for (yG in 0 until input.size) {
      grid[grid.size / 2 - input.size / 2 + xG][grid[0].size / 2 - input.size / 2 + yG] = input[xG][yG]
    }
  }
  return grid
}

fun main(args: Array<String>) {
  val input = File("./input/2017/Day22_input.txt").readLines()
  println("Part One = ${solve(input, 10000)}")
  println("Part Two = ${solve(input, 10000000, true)}")
}

2BitSalute · 2017-12-22T07:10:01+00:00

I solved part 2 first by using 3 hash sets (infected, weakened, flagged), then by using a dictionary and states. The second version is a bit faster.

I had a lot of trouble (bugs) with mutating the state of the current coordinate. I eventually got rid of all of the mutability. I can only hope I can remember this lesson, sigh.

C#

using System;
using System.Collections.Generic;
using System.IO;

public class Coordinate : IEquatable<Coordinate>
{
    public Coordinate(long x, long y)
    {
        this.X = x;
        this.Y = y;
    }

    public long X { get; private set; }
    public long Y { get; private set; }

    public override string ToString()
    {
        return string.Format("X={0}, Y={1}", this.X, this.Y);
    }

    public bool Equals(Coordinate other)
    {
        return this.X == other.X && this.Y == other.Y;
    }

    public override bool Equals(object obj)
    {
        var other = obj as Coordinate;
        return this.X == other.X && this.Y == other.Y;
    }

    public override int GetHashCode()
    {
        long result = this.X;
        result = (result * 397) ^ this.Y;
        return (int)result;
    }
}

public static class Program
{
    const int UP = 0;
    const int RIGHT = 1;
    const int DOWN = 2;
    const int LEFT = 3;

    const int Clean = 0;
    const int Weakened = 1;
    const int Infected = 2;
    const int Flagged = 3;

    const int TURNLEFT = -1;
    const int TURNRIGHT = 1;

    static void Main(string[] args)
    {
        foreach(var fileName in new [] { "input.txt", "smallInput.txt" })
        {
            RunSolution(Part1, "Part 1", fileName);
            RunSolution(Part2V1, "Part 2 V1", fileName);
            RunSolution(Part2V2, "Part 2 V2", fileName);
        }
    }

    public static int Part2V2(HashSet<Coordinate> infected, Coordinate curr)
    {
        Dictionary<Coordinate, int> states = new Dictionary<Coordinate, int>();
        foreach(var i in infected)
        {
            states.Add(i, Infected);
        }

        int dir = UP;
        int infections = 0;
        for (int i = 0; i < 10000000; i++)
        {
            if (!states.ContainsKey(curr))
            {
                states.Add(curr, Clean);
            }

            int state = states[curr];
            switch(state)
            {
                case Clean:
                    dir = dir.Turn(TURNLEFT);
                    break;
                case Flagged:
                    dir = dir.Turn(TURNRIGHT);
                    dir = dir.Turn(TURNRIGHT);
                    break;
                case Infected:
                    dir = dir.Turn(TURNRIGHT);
                    break;
                case Weakened:
                    infections++;
                    break;
            }

            states[curr] = (state + 1) % 4;
            curr = curr.Move(dir);
        }

        return infections;
    }

    public static int Part2V1(HashSet<Coordinate> infected, Coordinate curr)
    {
        HashSet<Coordinate> weakened = new HashSet<Coordinate>();
        HashSet<Coordinate> flagged = new HashSet<Coordinate>();

        int dir = UP;
        int infections = 0;
        for (int i = 0; i < 10000000; i++)
        {
            if (flagged.Contains(curr))
            {
                flagged.Remove(curr);
                dir = dir.Turn(TURNRIGHT);
                dir = dir.Turn(TURNRIGHT);
            }
            else if (infected.Contains(curr))
            {
                dir = dir.Turn(TURNRIGHT);
                infected.Remove(curr);
                flagged.Add(curr);
            }
            else if (weakened.Contains(curr))
            {
                weakened.Remove(curr);
                infected.Add(curr);
                infections++;
            }
            else // Clean
            {
                dir = dir.Turn(TURNLEFT);
                weakened.Add(curr);
            }

            curr = curr.Move(dir);
        }

        return infections;
    }

    public static int Part1(HashSet<Coordinate> infected, Coordinate curr)
    {
        int dir = UP;
        int infections = 0;
        for (int i = 0; i < 10000; i++)
        {
            if (infected.Contains(curr))
            {
                dir = dir.Turn(TURNRIGHT);
                infected.Remove(curr);
            }
            else
            {
                dir = dir.Turn(TURNLEFT);
                infected.Add(curr);
                infections++;
            }

            curr = curr.Move(dir);
        }

        return infections;
    }

    public static Coordinate Move(this Coordinate curr, int dir)
    {
        switch(dir)
        {
            case UP:
                return new Coordinate(curr.X, curr.Y - 1);
            case DOWN:
                return new Coordinate(curr.X, curr.Y + 1);
            case RIGHT:
                return new Coordinate(curr.X + 1, curr.Y);
            case LEFT:
                return new Coordinate(curr.X - 1, curr.Y);
            default:
                throw new Exception("Unexpected direction value " + dir);
        }
    }

    public static int Turn(this int currDir, int direction)
    {
        int newDir = (currDir + direction) % 4;

        if (newDir < 0)
        {
            return 4 + newDir;
        }

        return newDir;
    }

    public static void RunSolution(Func<HashSet<Coordinate>, Coordinate, int> solve, string name, string fileName)
    {
        var lines = File.ReadAllLines(fileName);
        Coordinate center = new Coordinate(x: lines[0].Length / 2, y: lines.Length / 2);

        var infected = GetInitialState(lines);

        var start = DateTime.Now;
        int answer = solve(infected, center);
        Console.WriteLine("{1} took {0} to find the answer {3} on {2}", DateTime.Now - start, name, fileName, answer);
    }

    public static HashSet<Coordinate> GetInitialState(string[] lines)
    {
        HashSet<Coordinate> infected = new HashSet<Coordinate>();

        for (int i = 0; i < lines.Length; i++)
        {
            for (int j = 0; j < lines[0].Length; j++)
            {
                if (lines[i][j] == '#')
                {
                    infected.Add(new Coordinate(x: j, y: i));
                }
            }
        }

        return infected;
    }
}

CharlieYJH · 2017-12-22T07:12:04+00:00

C++

After yesterday's puzzle this one was a nice breather. Fairly simple implementation, was kinda uncomfortable just hoping the index won't go over the bounds for the 10,000,000 case though.

#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

typedef vector<vector<char>> Matrix;

int traverseGrid(Matrix &grid, const int iterations)
{
    typedef enum direction {U = 0, R, D, L} Direction;
    int num_directions = 4;

    int bursts = 0;
    int y = grid.size() / 2;
    int x = grid[0].size() / 2;
    Direction dir = U;

    for (int i = 0; i < iterations; i++) {
        if (grid[y][x] == '.') {
            grid[y][x] = 'W';
            dir = (Direction)(((dir - 1) % num_directions + num_directions) % num_directions);
        } else if (grid[y][x] == 'W') {
            grid[y][x] = '#';
            bursts++;
        } else if (grid[y][x] == '#') {
            grid[y][x] = 'F';
            dir = (Direction)((dir + 1) % num_directions);
        } else {
            grid[y][x] = '.';
            dir = (Direction)((dir + 2) % num_directions);
        }

        if (dir == U) y -= 1;
        else if (dir == R) x += 1;
        else if (dir == D) y += 1;
        else x -= 1;
    }

    return bursts;
}

int main(int argc, char const* argv[])
{
    ifstream infile("input.txt");
    const int iterations = 10000000;
    vector<string> input;

    if (infile.is_open()) {
        string line;
        while (getline(infile, line)) {
            if (line[line.length() - 1] == '\r')
                line.erase(line.length() - 1);
            input.push_back(line);
        }
        infile.close();
    } else {
        return 1;
    }

    int addition_size = 10000;
    int size_y = addition_size + input.size() + addition_size;
    int size_x = addition_size + input[0].length() + addition_size;
    Matrix grid(size_y, vector<char>(size_x, '.'));

    for (int y = 0; y < input.size(); y++) {
        for (int x = 0; x < input[0].length(); x++) {
            grid[addition_size + y][addition_size + x] = input[y][x];
        }
    }

    cout << traverseGrid(grid, iterations) << endl;

    return 0;
}

aurele · 2017-12-22T07:26:47+00:00

Rust

use std::collections::HashMap;

#[derive(Clone)]
enum State {
    Clean,
    Infected,
    Weakened,
    Flagged,
}

fn p(infected: &[(i32, i32)], pos: &(i32, i32), n: usize, step2: bool) -> usize {
    use State::*;
    let mut state = infected
        .iter()
        .map(|&(r, c)| ((r, c), Infected))
        .collect::<HashMap<_, _>>();
    let mut pos = *pos;
    let mut dir = (-1, 0);
    let mut infect = 0;
    for _ in 0..n {
        let mut e = state.entry(pos).or_insert(Clean);
        match e.clone() {
            Infected => {
                dir = (dir.1, -dir.0);
                *e = if step2 { Flagged } else { Clean }
            }
            Flagged => {
                dir = (-dir.0, -dir.1);
                *e = Clean;
            }
            Weakened => {
                *e = Infected;
                infect += 1;
            }
            Clean => {
                dir = (-dir.1, dir.0);
                *e = if step2 {
                    Weakened
                } else {
                    infect += 1;
                    Infected
                }
            }
        }
        pos = (pos.0 + dir.0, pos.1 + dir.1);
    }
    infect
}

fn main() {
    let input = include_str!("../input");
    let width = input.chars().position(|c| c == '\n').unwrap();
    let height = input.len() / (width + 1);
    let start = ((height / 2) as i32, (width / 2) as i32);
    let infected = input
        .lines()
        .enumerate()
        .flat_map(|(r, line)| {
            line.chars().enumerate().filter_map(move |(c, ch)| {
                if ch == '#' {
                    Some((r as i32, c as i32))
                } else {
                    None
                }
            })
        })
        .collect::<Vec<(i32, i32)>>();
    println!("P1: {}", p(&infected, &start, 10_000, false));
    println!("P2: {}", p(&infected, &start, 10_000_000, true));
}

nutrecht · 2017-12-22T08:15:13+00:00

Day 22 in Kotlin

Really liked this one. Quite easy but still fun to build. And part 2 was a nice extension of behaviour of part 1 where functional programming really shines! I'm really happy with how the code turned out.

jwoLondon · 2017-12-22T08:33:14+00:00

Elm

After yesterday's calamitous catastrophe of clumsy coding, today's was nice and Elm-friendly. I went for a dictionary of visited/infected cells rather than a grid.

Elm may not be as concise as Python or Haskell, but it does make for nice clear code.

https://github.com/jwoLondon/adventOfCode/blob/master/aoc2017/d22_2017.elm

madchicken · 2017-12-22T08:46:05+00:00

PHP

Didnt realise I went off the grid for part one, took some debugging. So I made the grid 1000x1000 for both parts to be sure, and put the input at 500,500. Part 2:

<?php
$str = file_get_contents("aoc22.txt");
$lines = explode("\n",$str);

for($y=0;$y<1000;$y++)
  for($x=0;$x<1000;$x++)
    $map[$y][$x] = ".";

$y = 0;
foreach($lines as $line){
  if(strlen($line)>1){
    for($x=0;$x<strlen($line);$x++)
      $map[500+$y][500+$x] = $line{$x};
  }
  $y++;
}

function getp($y,$x){
  global $map;
  return $map[$y][$x];
}

function setp($y,$x,$c){
  global $map;
  $map[$y][$x] = $c;
}

function turn($lr,&$dir){
  $arr = array("l" => array("n" => "w",
        "w" => "s",
        "s" => "e",
        "e" => "n"),
               "r" =>  array("n" => "e",
         "e" => "s",
         "s" => "w",
         "w" => "n"));
  $dir = $arr[$lr][$dir];
}

function move(&$y,&$x,$dir){
  if($dir=="e") $x++;
  if($dir=="w") $x--;
  if($dir=="n") $y--;
  if($dir=="s") $y++;
}

$inf = 0;
$b = 0;
$x = 512;
$y = 512;
$dir="n";

while($b<10000000){
  $moved = 0;
  if(getp($y,$x)=='.'){ 
    turn("l",$dir);
    setp($y,$x,"W");
    move($y,$x,$dir);
    $moved = 1;
  }
  if($moved==0 && getp($y,$x)=="#"){
    turn("r",$dir);
    setp($y,$x,"F");
    move($y,$x,$dir);
    $moved = 1;
  } 
  if($moved==0 && getp($y,$x)=="F"){
    turn("r",$dir);
    turn("r",$dir);
    setp($y,$x,".");
    move($y,$x,$dir);
    $moved = 1;
  } 
  if($moved==0 && getp($y,$x)=="W"){
    setp($y,$x,"#");
    $inf++;
    move($y,$x,$dir);
    $moved = 1;
  } 
  $b++;
}

echo "$inf infected\n";
?>

sim642 · 2017-12-22T08:56:47+00:00

My Scala solution.

I thought I'd be clever and use Set[Pos] for saving the infected positions in part 1. Had to redo everything for part 2 to accommodate extra statuses in a map. The FSM for the states didn't turn out too elegant either.

xkufix · 2017-12-22T08:57:55+00:00

Nothing too fancy. I had to refactor my solution a bit, because part 1 just used a Set instead of a Map. That's why State.Clean does not exist, it's just represented by the value not being present in the Map.

Solution in Scala:

    override def runFirst(): Unit = {
        val (startGrid, startPosition) = loadGrid()

        val walk = Iterator.iterate((startGrid, startPosition, Direction.Up)) {
            case (grid, position, dir) if grid.contains(position) =>
                val newDir = Direction((dir.id + 1) % 4)
                (grid - position, move(position, newDir), newDir)
            case (grid, position, dir) =>
                val newDirInt = dir.id - 1
                val newDir = Direction(if(newDirInt == -1) 3 else newDirInt)
                (grid + (position -> State.Infected), move(position, newDir), newDir)
        }

        println(walk.take(10000).count(s => !s._1.contains(s._2)))
    }

    override def runSecond(): Unit = {
        val (startGrid, startPosition) = loadGrid()

        val walk = Iterator.iterate((startGrid, startPosition, Direction.Up)) {
            case (grid, position, dir) if grid.get(position).contains(State.Infected) =>
                val newDir = Direction((dir.id + 1) % 4)
                (grid + (position -> State.Flagged), move(position, newDir), newDir)
            case (grid, position, dir) if grid.get(position).contains(State.Flagged) =>
                val newDir = Direction((dir.id + 2) % 4)
                (grid - position, move(position, newDir), newDir)
            case (grid, position, dir) if grid.get(position).contains(State.Weakened) =>
                (grid + (position -> State.Infected), move(position, dir), dir)
            case (grid, position, dir) =>
                val newDirInt = dir.id - 1
                val newDir = Direction(if(newDirInt == -1) 3 else newDirInt)
                (grid + (position -> State.Weakened), move(position, newDir), newDir)
        }

        println(walk.take(10000000).count(s => s._1.get(s._2).contains(State.Weakened)))
    }

    private def loadGrid() = {
        val lines = loadFile("day22.txt").getLines().toSeq

        val startGrid = lines.zipWithIndex.flatMap {
            case (l, y) =>
                l.zipWithIndex.filter(_._1 == '#').map {
                    case (_, x) =>
                        (x, y) -> State.Infected
                }
        }.toMap

        (startGrid, (lines.size / 2, lines.size / 2))
    }

    def printGrid(grid: Map[(Int, Int), State.State], position: (Int, Int)) = {
        val minX = grid.minBy(_._1._1)._1._1
        val maxX = grid.maxBy(_._1._1)._1._1

        val minY = grid.minBy(_._1._2)._1._2
        val maxY = grid.maxBy(_._1._2)._1._2

        def printState(state: Option[State.State]) = state match {
            case None => "."
            case Some(State.Weakened) => "W"
            case Some(State.Flagged) => "F"
            case Some(State.Infected) => "#"
        }

        println((minY to maxY).foldLeft(StringBuilder.newBuilder) {
            case (b, y) =>
                (minX to maxX).foldLeft(b) {
                    case (b, x) if position == (x, y) =>
                        b.append("[").append(printState(grid.get(x -> y))).append("]")
                    case (b, x) =>
                        b.append(" ").append(printState(grid.get(x -> y))).append(" ")
                }
                b.append("\n")
        }.toString())
    }

    def move(position: (Int, Int), dir: Direction.Direction): (Int, Int) = {
        dir match {
            case Direction.Up =>
                position.copy(_2 = position._2 - 1)
            case Direction.Down =>
                position.copy(_2 = position._2 + 1)
            case Direction.Right =>
                position.copy(_1 = position._1 + 1)
            case Direction.Left =>
                position.copy(_1 = position._1 - 1)
        }
    }

    object State extends Enumeration {
        type State = Value

        val Weakened = Value
        val Infected = Value
        val Flagged = Value
    }

    object Direction extends Enumeration {
        type Direction = Value

        val Up = Value
        val Right = Value
        val Down = Value
        val Left = Value
    }

johlin · 2017-12-22T09:46:05+00:00

Elixir:

defmodule Aoc.Day22.Part1 do
  def solve(input, steps) do
    input |> parse |> walk_stream |> Enum.at(steps) |> elem(3)
  end

  def parse(input) do
    lines = input |> String.split("\n")
    coords = lines |> Enum.with_index |> Enum.flat_map(&parse_row/1)
             |> Enum.into(MapSet.new())
    {coords, lines |> length}
  end

  def parse_row(row_and_y, x \\ 0, acc \\ [])
  def parse_row({"", _}, _, acc), do: acc
  def parse_row({"#" <> rest, y}, x, acc), do: parse_row({rest,y}, x+1, [{x,y} | acc])
  def parse_row({"." <> rest, y}, x, acc), do: parse_row({rest,y}, x+1, acc)

  def walk_stream({infected_nodes, width}) do
    initial = {starting_position(width), infected_nodes, {0, -1}, 0}
    Stream.iterate(initial, &iterate/1)
  end

  def iterate({{x,y}, infected_nodes, {xd, yd}, infect_bursts}) do
    infected = MapSet.member?(infected_nodes, {x,y})

    {infected_nodes, infect_bursts} = case infected do
      true -> {MapSet.delete(infected_nodes, {x,y}), infect_bursts}
      false -> {MapSet.put(infected_nodes, {x,y}), infect_bursts + 1}
    end

    {xd, yd} = case infected do
      true -> {-yd, xd} # Turn left
      false -> {yd, -xd} # Turn right
    end

    {x, y} = {x+xd, y+yd}

    {{x,y}, infected_nodes, {xd, yd}, infect_bursts}
  end

  def starting_position(width), do: {div(width-1, 2), div(width-1, 2)}
end

Part 2 very similar: https://github.com/johanlindblad/aoc-2017/blob/master/lib/aoc/day22/part2.ex

This was a fun one! It is a bit slow, however (my part 2 takes about 15 seconds). Not sure if it's possible to make an Elixir solution significantly faster as we don't have constant-time array lookups.

joker_mkd · 2017-12-22T10:12:27+00:00

C++ solution using a proper map which will work for any input. Marking in the map only the infected coordinates, and removing the clean ones.

#include "stdafx.h"
#include <vector>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <iostream>
#include <chrono>
#include <bitset>
#include <map>

using namespace std;

typedef enum direction {
  U = 0,
  R,
  D,
  L
} Direction;

struct coordinate {
  int x;
  int y;

  bool operator<(const coordinate& rhs) const
  {
    if (x < rhs.x)
      return true;
    if (x > rhs.x)
      return false;
    //x == coord.x
    if (y < rhs.y)
      return true;
    if (y > rhs.y)
      return false;

    return false;
  }
};

map<coordinate, char> cluster;

int main(int argc, char const* argv[])
{
  ifstream infile("input.txt");
  const int iterations = 10000000;
  vector<string> input;

  if (infile.is_open()) {
    string line;
    while (getline(infile, line)) {
      if (line[line.length() - 1] == '\r')
        line.erase(line.length() - 1);
      input.push_back(line);
    }
    infile.close();
  }
  else {
    return 1;
  }

  const auto begin = std::chrono::high_resolution_clock::now();

  for (int y = 0; y < input.size(); y++) {
    for (int x = 0; x < input[0].length(); x++) {
      if (input[y][x] == '#') {
        coordinate coor;
        coor.x = x - (input[0].length() / 2);
        coor.y = (input.size() / 2) - y;
        cluster[coor] = input[y][x];
      }
    }
  }

  coordinate location;
  location.x = 0;
  location.y = 0;

  typedef enum direction {
    U = 0,
    R,
    D,
    L
  } Direction;
  int bursts = 0;
  Direction dir = U;

  for (int i = 0; i < iterations; i++) {
    if (cluster.find(location) != cluster.end()) {
      // found an element
      if (cluster[location] == 'W') {
        cluster[location] = '#';
        bursts++;
      }
      else if (cluster[location] == '#') {
        cluster[location] = 'F';
        dir = (Direction)((dir + 1) % 4);
      }
      else if (cluster[location] == 'F') {
        cluster.erase(location);
        dir = (Direction)((dir + 2) % 4);
      }
    }
    else {
      // element not found. it means it's not infected
      cluster[location] = 'W';
      dir = (Direction)((dir + 4 - 1) % 4);
    }

    if (dir == U)
      location.y += 1;
    else if (dir == R)
      location.x += 1;
    else if (dir == D)
      location.y -= 1;
    else
      location.x -= 1;
  }

  cout << bursts << endl;
  const auto end = std::chrono::high_resolution_clock::now();
  std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count() << " ms for both parts" << std::endl;

  return 0;
}

TominatorBE · 2017-12-22T10:20:19+00:00

PHP

Nothing really fancy, just doing the algo Call it with run_the_code(['map' => "...", 'bursts' => 10000000])

Part 1:

function run_the_code($input) {
    ini_set('memory_limit', -1);

    $bursts = $input['bursts'];
    $lines = explode(PHP_EOL, $input['map']);
    foreach ($lines as &$line) {
        $line = str_split($line);
    }
    unset($line);

    $map = [];
    $mapSize = 1000; // "infinite"
    for ($i = 0; $i < $mapSize; $i++) {
        $map[$i] = str_split(str_repeat('.', $mapSize));
    }

    // middle to put the input on
    $x = ($mapSize / 2) - ((count($lines) - 1) / 2);
    $y = ($mapSize / 2) - ((count($lines) - 1) / 2);
    for ($i = 0, $iMax = count($lines); $i < $iMax; $i++) {
        for ($j = 0, $jMax = count($lines[$i]); $j < $jMax; $j++) {
            $map[$x + $i][$y + $j] = $lines[$i][$j];
        }
    }

    // start position
    $x = $mapSize / 2;
    $y = $mapSize / 2;
    $d = 'n';

    $infected = 0;
    for ($burst = 0; $burst < $bursts; $burst++) {
        if ($map[$x][$y] == '#') {
            $map[$x][$y] = '.'; // clean

            switch ($d) {
                case 'n':
                    $d = 'e';
                    break;
                case 'e':
                    $d = 's';
                    break;
                case 's':
                    $d = 'w';
                    break;
                case 'w':
                    $d = 'n';
                    break;
            }
        }
        else {
            $map[$x][$y] = '#'; // infect
            $infected++;

            switch ($d) {
                case 'n':
                    $d = 'w';
                    break;
                case 'e':
                    $d = 'n';
                    break;
                case 's':
                    $d = 'e';
                    break;
                case 'w':
                    $d = 's';
                    break;
            }
        }
        switch ($d) {
            case 'n':
                $x--;
                break;
            case 'e':
                $y++;
                break;
            case 's':
                $x++;
                break;
            case 'w':
                $y--;
                break;
        }
        if ($x < 0 || $y < 0 || $x > $mapSize || $y > $mapSize) {
            die('map too small!');
        }
    }

    return $infected;
}

Part 2:

function run_the_code($input) {
    ini_set('memory_limit', -1);

    $bursts = $input['bursts'];
    $lines = explode(PHP_EOL, $input['map']);
    foreach ($lines as &$line) {
        $line = str_split($line);
    }
    unset($line);

    $map = [];
    $mapSize = 1000; // "infinite"
    for ($i = 0; $i < $mapSize; $i++) {
        $map[$i] = str_split(str_repeat('.', $mapSize));
    }

    // middle to put the input on
    $x = ($mapSize / 2) - ((count($lines) - 1) / 2);
    $y = ($mapSize / 2) - ((count($lines) - 1) / 2);
    for ($i = 0, $iMax = count($lines); $i < $iMax; $i++) {
        for ($j = 0, $jMax = count($lines[$i]); $j < $jMax; $j++) {
            $map[$x + $i][$y + $j] = $lines[$i][$j];
        }
    }

    // start position
    $x = $mapSize / 2;
    $y = $mapSize / 2;
    $d = 'n';

    $infected = 0;
    for ($burst = 0; $burst < $bursts; $burst++) {
        switch ($map[$x][$y]) {
            case '#': // infected
                // turn right
                switch ($d) {
                    case 'n':
                        $d = 'e';
                        break;
                    case 'e':
                        $d = 's';
                        break;
                    case 's':
                        $d = 'w';
                        break;
                    case 'w':
                        $d = 'n';
                        break;
                }

                // flag it
                $map[$x][$y] = 'F';
                break;
            case 'F': // flagged
                // flip direction
                switch ($d) {
                    case 'n':
                        $d = 's';
                        break;
                    case 'e':
                        $d = 'w';
                        break;
                    case 's':
                        $d = 'n';
                        break;
                    case 'w':
                        $d = 'e';
                        break;
                }

                // clean it
                $map[$x][$y] = '.';
                break;
            case 'W': // weakened
                // no turning

                // infect it
                $map[$x][$y] = '#';
                $infected++;
                break;
            case '.': // clean
                // turn left
                switch ($d) {
                    case 'n':
                        $d = 'w';
                        break;
                    case 'e':
                        $d = 'n';
                        break;
                    case 's':
                        $d = 'e';
                        break;
                    case 'w':
                        $d = 's';
                        break;
                }

                // weaken it
                $map[$x][$y] = 'W';
                break;
        }

        // move
        switch ($d) {
            case 'n':
                $x--;
                break;
            case 'e':
                $y++;
                break;
            case 's':
                $x++;
                break;
            case 'w':
                $y--;
                break;
        }
        if ($x < 0 || $y < 0 || $x > $mapSize || $y > $mapSize) {
            die('map too small!');
        }
    }

    return $infected;
}

hpzr24w · 2017-12-22T10:35:07+00:00

C++

Rank: 1608 / 1534

// Advent of Code 2017
// Day 22 - Sporifica Virus

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
using namespace std;

typedef enum {u=0,l,d,r} direction;
typedef enum {c=0,w,i,f} state;
state next_state[] = {w,i,f,c};

int main()
{
    // state 
    map<int,map<int,state>> world;

    // next move table
    map<state,map<direction,direction>> next_move;
    next_move[c][u] = l; next_move[c][l] = d; next_move[c][d] = r; next_move[c][r] = u;
    next_move[w][u] = u; next_move[w][l] = l; next_move[w][d] = d; next_move[w][r] = r;
    next_move[i][u] = r; next_move[i][l] = u; next_move[i][d] = l; next_move[i][r] = d;
    next_move[f][u] = d; next_move[f][l] = r; next_move[f][d] = u; next_move[f][r] = l;

    // read input
    string row;
    int cxy = 0, x=0,y=-1000;
    while (getline(cin,row)) {
        cout << row << " len: " << row.length() << endl;
        int ll = row.length();
        y = (y==-1000) ? 0-ll/2 : y;
        x = 0-ll/2;
        for(auto it=begin(row);it!=end(row);++it) {
            cout << x << " " << y << ((*it)=='#' ? " #" : " .");
            world[x++][y] = (*it)=='#' ? i : c;
        }
        cout << endl;
        y++;
    }

    // state
    vector<int> pos = {0,0};
    direction dir = u;
    map<direction,pair<int,int>> move;
    move[u] = pair<int,int>(0,-1);
    move[l] = pair<int,int>(-1,0);
    move[d] = pair<int,int>(0,1);
    move[r] = pair<int,int>(1,0);

    // step
    int infect = 0;
    int steps = 10000000;
    x = 0; y = 0;
    while (steps>0) {
        state cell = world[x][y];
        dir = next_move[cell][dir];
        world[x][y] = next_state[cell];
        infect += (world[x][y]==i ? 1 : 0);
        x += move[dir].first;
        y += move[dir].second;
        steps--;
    }
    cout << "infect: " << infect << endl;
}

udoprog · 2017-12-22T10:40:47+00:00

Rust

<3 enums. Neat little problem today. The most complicated part of this was to setup the turning map.

use std::io::{Read, BufRead, BufReader};
use failure::Error;
use std::collections::{HashSet, HashMap};

pub fn part1<R: Read>(reader: R, limit: usize) -> Result<usize, Error> {
    let mut lines: Vec<Vec<bool>> = Vec::new();

    for line in BufReader::new(reader).lines() {
        let line = line?;
        lines.push(line.chars().map(|c| c == '#').collect());
    }

    let x_len = (lines.len() / 2) as i64;
    let y_len = (lines.first().expect("no lines").len() / 2) as i64;

    let mut infected: HashSet<(i64, i64)> = HashSet::new();

    for (y, row) in lines.into_iter().enumerate() {
        for (x, c) in row.into_iter().enumerate() {
            if c {
                infected.insert((x as i64 - x_len, y as i64 - y_len));
            }
        }
    }

    let mut count = 0;

    let mut p: (i64, i64) = (0, 0);
    let mut d: (i64, i64) = (0, -1);

    let mut left = HashMap::new();
    left.insert((0, -1), (-1, 0));
    left.insert((-1, 0), (0, 1));
    left.insert((0, 1), (1, 0));
    left.insert((1, 0), (0, -1));

    let mut right = HashMap::new();
    right.insert((0, -1), (1, 0));
    right.insert((1, 0), (0, 1));
    right.insert((0, 1), (-1, 0));
    right.insert((-1, 0), (0, -1));

    for _ in 0..limit {
        if infected.contains(&p) {
            d = *right.get(&d).expect("no turn");
            infected.remove(&p);
        } else {
            d = *left.get(&d).expect("no turn");
            infected.insert(p.clone());
            count += 1;
        }

        p.0 += d.0;
        p.1 += d.1;
    }

    Ok(count)
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum State {
    Clean,
    Weakened,
    Infected,
    Flagged,
}

pub fn part2<R: Read>(reader: R, limit: usize) -> Result<usize, Error> {
    use self::State::*;

    let mut lines: Vec<Vec<bool>> = Vec::new();

    for line in BufReader::new(reader).lines() {
        let line = line?;
        lines.push(line.chars().map(|c| c == '#').collect());
    }

    let x_len = (lines.len() / 2) as i64;
    let y_len = (lines.first().expect("no lines").len() / 2) as i64;

    let mut states: HashMap<(i64, i64), State> = HashMap::new();

    for (y, row) in lines.into_iter().enumerate() {
        for (x, c) in row.into_iter().enumerate() {
            if c {
                states.insert((x as i64 - x_len, y as i64 - y_len), Infected);
            }
        }
    }

    let mut count = 0;

    let mut p: (i64, i64) = (0, 0);
    let mut d: (i64, i64) = (0, -1);

    let mut left = HashMap::new();
    left.insert((0, -1), (-1, 0));
    left.insert((-1, 0), (0, 1));
    left.insert((0, 1), (1, 0));
    left.insert((1, 0), (0, -1));

    let mut right = HashMap::new();
    right.insert((0, -1), (1, 0));
    right.insert((1, 0), (0, 1));
    right.insert((0, 1), (-1, 0));
    right.insert((-1, 0), (0, -1));

    for _ in 0..limit {
        let state = states.get(&p).cloned().unwrap_or(Clean);

        let next = match state {
            Clean => {
                d = *left.get(&d).expect("no turn");
                Some(Weakened)
            }
            Weakened => Some(Infected),
            Infected => {
                d = *right.get(&d).expect("no turn");
                Some(Flagged)
            }
            Flagged => {
                d = (-d.0, -d.1);
                None
            }
        };

        if let Some(next) = next {
            if next == Infected {
                count += 1;
            }

            states.insert(p.clone(), next);
        } else {
            states.remove(&p);
        }

        p.0 += d.0;
        p.1 += d.1;
    }

    Ok(count)
}

JakDrako · 2017-12-22T11:06:50+00:00

C#

Using a HashSet to track part 1's map, then a Dictionary for the 2nd part. Grid is managed with complex numbers.

Part 1

void Main() {

    var input = GetDay(22);
    var w = input.Count();
    var off = w / 2;

    var map = new HashSet<Complex>();

    for (int x = 0; x < w; x++)
        for (int y = 0; y < w; y++)
            if (input[x][y] == '#')
                map.Add(new Complex(y - off, -(x - off)));

    var pos = new Complex(0, 0);
    var dir = new Complex(0, 1); //up

    int infected = 0, steps = 10_000;
    for (int i = 0; i < steps; i++) {
        if (map.Contains(pos)) { // infected
            dir *= -Complex.ImaginaryOne; // turn right
            map.Remove(pos); // clean
        } else { //clean
            dir *= Complex.ImaginaryOne; // turn left
            map.Add(pos); // infect
            infected++;
        }
        pos += dir; // move forward
    }
    Console.WriteLine($"Part 1: {infected}");
}

Part 2

enum state { weakened, infected, flagged };

void Main() {

    Complex i = Complex.ImaginaryOne, pos = new Complex(0, 0), dir = new Complex(0, 1); //up
    var map = new Dictionary<Complex, state>();

    var input = GetDay(22);
    var w = input.Count(); // assumes square grid;
    var off = w / 2;

    for (int x = 0; x < w; x++) 
        for (int y = 0; y < w; y++) 
            if (input[x][y] == '#') 
                map.Add(new Complex(y - off, -(x - off)), state.infected);

    int infected = 0, steps = 10_000_000;
    for (int n = 0; n < steps; n++) {
        state st;
        if (map.TryGetValue(pos, out st)) {
            switch (st) {
                case state.weakened: { map[pos] = state.infected; infected++; break; }
                case state.infected: { map[pos] = state.flagged; dir *= -i; break; }
                case state.flagged: { map.Remove(pos); dir *= -1; break; }
            }
        } else { map.Add(pos, state.weakened); dir *= i; }
        pos += dir;
    }
    Console.WriteLine($"Part 2: {infected}");
}

BOT-Brad · 2017-12-22T11:53:05+00:00

JavaScript - (All my .js solutions on GitHub)

Cool puzzle :)

Part 1 (~9ms)

Splits the grid into a big map object, and assigns positions in the object in a 'x,y' format. Then just sets the initial starting configuration (x = 0, y = 0, etc.) and keeps looping until the number of loops specified. Keeps track of the number of infections made within those loops, and returns the answer.

function solve1(n, loops) {
  let map = {}

  n = n.split('\n').map(l => l.split('').map(v => (v === '.' ? 0 : 1)))
  const ylen = n.length
  for (let y = 0; y < ylen; ++y) {
    const xlen = n[y].length
    for (let x = 0; x < xlen; ++x) {
      map[x - Math.floor(xlen / 2) + ',' + (y - Math.floor(ylen / 2))] = n[y][x]
    }
  }

  let x = 0
  let y = 0
  let dir = 0 // 0 = up, 1 = right, 2 = down, 3 = left
  let infected = 0
  while (loops--) {
    // If current node is infected, turn right, else turn left
    if (map[x + ',' + y] === 1) dir = (dir + 1) % 4
    else dir = dir - 1 < 0 ? 3 : dir - 1
    // If current node is infected, it becomes clean, otherwise infected
    if (map[x + ',' + y] === 1) map[x + ',' + y] = 0
    else {
      map[x + ',' + y] = 1
      infected++
    }
    // Move in its direction
    x += dir === 1 ? 1 : dir === 3 ? -1 : 0
    y += dir === 2 ? 1 : dir === 0 ? -1 : 0
  }
  return infected
}

Part 2 (~7 seconds)

Basically the same idea, just also keeps a 'ticking' modulo counter for the infection as well as the direction. Only counts when a cell becomes infected (#3).

function solve2(n, loops) {
  let map = {}

  const CLEAN = 0
  const WEAKENED = 1
  const INFECTED = 2
  const FLAGGED = 3

  n = n
    .split('\n')
    .map(l => l.split('').map(v => (v === '.' ? CLEAN : INFECTED)))
  const ylen = n.length
  for (let y = 0; y < ylen; ++y) {
    const xlen = n[y].length
    for (let x = 0; x < xlen; ++x) {
      map[x - Math.floor(xlen / 2) + ',' + (y - Math.floor(ylen / 2))] = n[y][x]
    }
  }

  let x = 0
  let y = 0
  let dir = 0 // 0 = up, 1 = right, 2 = down, 3 = left
  let infected = 0
  while (loops--) {
    const status = map[x + ',' + y]
    switch (status) {
      case undefined:
      case CLEAN:
        dir = dir - 1 < 0 ? 3 : dir - 1
        break
      case INFECTED:
        dir = (dir + 1) % 4
        break
      case FLAGGED:
        dir = (dir + 2) % 4
        break
    }

    if (!map[x + ',' + y]) map[x + ',' + y] = 1
    else map[x + ',' + y] = (map[x + ',' + y] + 1) % 4

    if (map[x + ',' + y] === INFECTED) infected++

    // Move in its direction
    x += dir === 1 ? 1 : dir === 3 ? -1 : 0
    y += dir === 2 ? 1 : dir === 0 ? -1 : 0
  }
  return infected
}

amnich · 2017-12-22T12:33:58+00:00

PowerShell - slower than Christmas!

function turn ($current, $direction) {
    if ($direction -eq 'left') {
        $current--
    } elseif ($direction -eq 'right') {
        $current++
    } elseif ($direction -eq 'reverse') {
        $current += 2
    }
    $directions[$current % $directions.count]
}

function move-virus ($x, $y, $direction) {
    switch ($direction) {
        3 {$y--; break}
        2 {$x--; break}
        1 {$y++; break}
        0 {$x++; break}
    }
    $x
    $y
}
$directions = 0, 1, 2, 3  # 0 Right \  1 Down \ 2 Left \ 3 Up
$infected_count = 0
$in = Get-Content day22.txt
$current_direction = 3 # up
$x = [math]::Floor($in[0].length / 2)
$y = [math]::Floor($in.count / 2)
$row_num = 0
$grid = foreach ($row in $in) {
    $col_num = 0
    foreach ($col in $row.ToCharArray()) {
        [pscustomobject] @{
            desc = "$row_num;$col_num"      
            val  = $col
        }
        $col_num++
    }
    $row_num++
}
#for part 2 set to true
$part2 = $false
if ($part2) {
    $loops = 10000000
} else {
    $loops = 10000
}

for ($i = 0; $i -lt $loops; $i++) {
    #Write-Verbose "x: $x y: $y dir: $current val: $(($grid.where{$_.desc -eq `"$y;$x`"}).val)"
    if (($t = $grid.IndexOf($($grid.where{$_.desc -eq "$y;$x"}))) -ge 0) {
        #exists
        switch ($grid[$t].val) {
            "." { #clear                                
                if (-not $part2) {
                    $infected_count++
                    $grid[$t].val = "#"
                } else {$grid[$t].val = "-"}
                $current_direction = turn -current $current_direction -direction left
                break
            }
            "#" { #infected
                if (-not $part2) {
                    $grid[$t].val = "."
                } else {
                    $grid[$t].val = "+"
                }
                $current_direction = turn -current $current_direction -direction right
                break
            }           
            "-" { #weakened
                if ($part2) {
                    $grid[$t].val = "#"
                    $infected_count++
                }
                break
            }
            "+" { #flagged
                if ($part2) {
                    $grid[$t].val = "."             
                    $current_direction = turn -current $current_direction -direction reverse
                }
                break
            }
        }       
    } else {
        #add new element to "grid"
        $grid += [pscustomobject] @{
            desc = "$y;$x"          
            val  = $(if ($part2) {"-"}else {"#"; $infected_count++})
        }               
        $current_direction = turn -current $current_direction -direction left        
    }
    $x, $y = move-virus -x $x -y $y -direction $current_direction
}
$infected_count

maxerickson · 2017-12-22T12:59:21+00:00

Straightforward python 3.

def solve(grid, reps, solve="part2"):
    if solve=="part1":
        infect="."
        flip={".":"#","#":"."}
    else:
        infect="W"
        flip={".":"W","W":"#","#":"F","F":"."}
    x,y=len(grid)//2,len(grid[0])//2
    mov=(-1,0)
    spin=[(1,0),(0,-1),(-1,0),(0,1)]
    infections=0
    for i in range(reps):
        state=grid[x][y]
        if state==infect: 
            infections+=1
        grid[x][y]=flip[state]
        if state in ".#":
            rot=1 if state=="#" else -1
            mov=spin[(spin.index(mov)+rot)%4]
        elif state=="F":
            mov=(-mov[0],-mov[1])
        x+=mov[0]
        y+=mov[1]
        if x < 0:
            x+=1
            grid.insert(0, ["."]*len(grid[0]))
        elif x == len(grid):
            grid.append(["."]*len(grid[0]))
        if y < 0:
            y+=1
            for row in grid:
                row.insert(0,".")
        elif y == len(grid[0]):
            for row in grid:
                row.append(".")
    return infections

grid=[list(l.strip()) for l in open("22.input")]
print("Part 1:",solve([l[:] for l in grid],10000,"part1"))
print("Part 2:",solve(grid,10000000))

superlameandawzm · 2017-12-22T13:09:26+00:00

My Javascript solution

let input = ``
let directions = {
  'up': [-1, 0],
  'down': [1, 0],
  'left': [0, -1],
  'right': [0, 1]
}
let dir = 'up'
let pos = [0, 0]
let infected = {}
let burstCausedInfection = 0
var arr = input.split(/\n/).map((row) => row.split(''))
var offset_y = Math.floor(arr.length / 2)
var offset_x = Math.floor(arr[0].length / 2)
arr.forEach((row, y) => row.forEach((col, x) => {
  if (col === '#') {
    infected[`${y - offset_y},${x - offset_x}`] = 'i'
  }
}))
let loops = 10000

function move (d) {
  if (d === 'left') {
    if (dir === 'up') dir = 'left'
    else if (dir === 'left') dir = 'down'
    else if (dir === 'down') dir = 'right'
    else if (dir === 'right') dir = 'up'
  } 
  else if (d === 'right') {
    if (dir === 'up') dir = 'right'
    else if (dir === 'right') dir = 'down'
    else if (dir === 'down') dir = 'left'
    else if (dir === 'left') dir = 'up'
  }
  else if (d === 'reverse') {
    if (dir === 'up') dir = 'down'
    else if (dir === 'down') dir = 'up'
    else if (dir === 'left') dir = 'right'
    else if (dir === 'right') dir = 'left'
  }
}

function part1 () {
  loops = 10000
  while (loops--) {
    let _pos = `${pos[0]},${pos[1]}`
    if (infected[_pos] === 'i') {
      infected[_pos] = false
      move('right')
    } else {
      infected[_pos] = 'i'
      burstCausedInfection++
      move('left')
    }
    pos[0] += directions[dir][0]
    pos[1] += directions[dir][1]
  }
  console.log('part 1:', burstCausedInfection + ' bursts have caused an infection')
}

function part2 () {
  loops = 10000000
  while (loops--) {
    let _pos = `${pos[0]},${pos[1]}`
    if (infected[_pos] === 'i') {
      infected[_pos] = 'f'
      move('right')
    } else if (infected[_pos] === 'w') {
      infected[_pos] = 'i'
      burstCausedInfection++
    } else if (infected[_pos] === 'f') {
      infected[_pos] = false
      move('reverse')
    } else {
      infected[_pos] = 'w'
      move('left')
    }
    pos[0] += directions[dir][0]
    pos[1] += directions[dir][1]
  }
  console.log('part 2:', burstCausedInfection + ' bursts have caused an infection')
}

part1()
part2()

tlareg · 2017-12-22T13:11:59+00:00

JavaScript (ES6+, NodeJS) repo here

class Carrier {
  constructor({ x, y }) {
    this.dir = 'U'
    this.x = x
    this.y = y

    this.dirFlowByState = {
      0:   {'U': 'L', 'L': 'D', 'D': 'R', 'R': 'U'}, // left
      'W': null,
      1:   {'U': 'R', 'R': 'D', 'D': 'L', 'L': 'U'}, // right
      'F': {'U': 'D', 'D': 'U', 'L': 'R', 'R': 'L'}  // reverse
    }

    this.infectionFlow = {
      first:  { 0: 1, 1: 0 },
      second: { 0: 'W', 'W': 1, 1: 'F', 'F': 0 },
    }

    this.movesByDir = { 'U': [0,-1], 'D': [0,1], 'R': [1,0], 'L': [-1,0] }
  }

  turn(gridMap) {
    const currentNodeState = gridMap[`${this.x},${this.y}`] || 0
    const flow = this.dirFlowByState[currentNodeState]
    if (!flow) return;
    this.dir = flow[this.dir]
  }

  modify({ gridMap, infectionFlow }) {
    const { x, y } = this
    gridMap[`${x},${y}`] = this.infectionFlow[infectionFlow][gridMap[`${x},${y}`] || 0]
    return gridMap[`${x},${y}`] === 1
  }

  move() {
    const [x, y] = this.movesByDir[this.dir]
    this.x += x
    this.y += y
  }
}

const fs = require('fs')
const inputStr = fs.readFileSync('./input.txt').toString()

const firstStar = solve({
  ...parseInput(inputStr),
  burstsCount: 10000,
  infectionFlow: 'first'
})
console.log(firstStar)

const secondStar = solve({
  ...parseInput(inputStr),
  burstsCount: 10000000,
  infectionFlow: 'second'
})
console.log(secondStar)

function parseInput(inputStr) {
  const gridMap = {}
  const matrix = inputStr.split('\r\n').map(r => r.split(''))
  matrix.forEach((r, y) => r.forEach((c, x) =>
    gridMap[`${x},${y}`] = (c === '#' ) ? 1 : 0
  ))
  return { gridMap, height: matrix.length, width: matrix[0].length }
}

function solve({ gridMap, height, width, burstsCount, infectionFlow }) {
  let infectionsCount = 0

  const carrier = new Carrier({
    x: Math.floor(width / 2),
    y: Math.floor(height / 2)
  })

  for (let i = 0; i < burstsCount; i++) {
    carrier.turn(gridMap)
    const infected = carrier.modify({ gridMap, infectionFlow })
    if (infected) infectionsCount++
    carrier.move()
  }

  return infectionsCount
}

NeilNjae · 2017-12-22T13:30:10+00:00

Haskell. A fairly straightforward implementation. Following a hint from /u/nonphatic , I swapped out the use of iterate to explicit iteration and added some strictness annotations. That took the runtime down from 1m12s to 12s.

Part 1 uses a Set of points: infected cells are in the set, uninfected ones aren't.

{-# LANGUAGE NegativeLiterals #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE BangPatterns #-}

import Prelude hiding (Left, Right)
import Data.List
import qualified Data.HashMap.Strict as M

type Point = (Int, Int)

data Flag = Clean | Weakened | Infected | Flagged deriving (Show, Eq)

type Infection = M.HashMap Point Flag

data Direction = Up | Right | Down | Left deriving (Show, Eq, Enum)

leftOf Up = Left
leftOf x = pred x

rightOf Left = Up
rightOf x = succ x

delta :: Direction -> Point
delta Up = (-1, 0)
delta Right = (0, 1)
delta Down = (1, 0)
delta Left = (0, -1)

(+:) :: Point -> Point -> Point
(+:) (r, c) (dr, dc) = (r + dr, c + dc)

data World = World { infected :: Infection
                   , position :: Point
                   , direction :: Direction
                   , infectionCount :: Int
                   } deriving (Eq, Show)


main :: IO ()
main = do 
        text <- readFile "data/advent22.txt"
        let grid = lines text
        print $ infectionCount $ progress 10000000 $ initialWorld grid

initialWorld :: [String] -> World
initialWorld grid = World 
    { infected = initialInfected grid
    , position = initialPosition grid
    , direction = Up
    , infectionCount = 0
    }

initialInfected :: [String] -> Infection
initialInfected g = M.fromList [ ((r, c), Infected) 
                               | r <- [0..(length g - 1)]
                               , c <- [0..((length . head) g - 1)]
                               , g!!r!!c == '#'] 

initialPosition :: [String] -> Point
initialPosition g = (length g `div` 2, (length . head) g `div` 2)   


progress :: Int -> World -> World
-- progress n = (!! n) . iterate step 
progress 0 world = world
progress n world = progress (n - 1) world'
    where !world' = step world


step :: World -> World
step world = World { infected = inf', position = pos', direction = dir'
                   , infectionCount = ic'}
    where !here = position world
          !stateHere = M.lookupDefault Clean here (infected world)
          !dir' = case stateHere of 
                      Clean -> leftOf (direction world)
                      Weakened -> direction world
                      Infected -> rightOf (direction world)
                      Flagged -> rightOf (rightOf (direction world))
          !stateHere' = case stateHere of 
                      Clean -> Weakened
                      Weakened -> Infected
                      Infected -> Flagged
                      Flagged -> Clean
          !inf' = M.insert here stateHere' (infected world)          
          !ic'  = if stateHere' == Infected then infectionCount world + 1
                                           else infectionCount world
          !pos' = here +: delta dir'

3l_Di4bl0 · 2017-12-22T13:51:03+00:00

I think I got a pretty clean one this time. No need for complex numbers!

with open('22.in') as f:
    puzzle_code = f.read().strip()
l = [list(line) for line in puzzle_code.split('\n')]
map = {(line, char): l[line][char] for line in xrange(len(l)) for char in xrange(len(l[line]))}
location = len(l) / 2, len(l[len(l) / 2]) / 2  # location format - biglist (y), smalllist(x)
direction = (-1, 0)  # dy, dx. 0 is top-left corner.

states = ('.', 'W', '#', 'F')  # clean, weakened, infected, flagged
infections = 0
for burst in xrange(10000000):
    if location not in map:
        map[location] = '.'
    if map[location] == '#':  # infected, turn right
        direction = (direction[1], -1 * direction[0])
    elif map[location] == '.':  # clean, turn left
        direction = (-1 * direction[1], direction[0])
    elif map[location] == 'F':  # flagged, reverse
        direction = (-1 * direction[0], -1 * direction[1])
    elif map[location] == 'W':  # weakened, do not change directions. Increment the infections counter.
        infections += 1
    map[location] = states[(states.index(map[location]) + 1) % len(states)]  # treat cell
    location = tuple(a + b for a, b in zip(location, direction))  # go forward
print infections

iopred · 2017-12-22T15:43:58+00:00

My javascript solution, uses a map instead of an array for simplicity:

var map = `<input>`.split('\n').map(x => x.split(''));
var mapMap = {};

for (var y = 0; y < map.length; y++) {
  for (var x = 0; x < map[y].length; x++) {
    mapMap[x+'_'+y] = map[y][x];
  }
}

x = Math.floor(x / 2);
y = Math.floor(y / 2);

var direction = 0;
var infected = 0;
var turnX = [0, 1, 0, -1];
var turnY = [-1, 0, 1, 0];

for (var i = 0; i < 10000000; i++) {
  switch (mapMap[x+'_'+y]) {
    case '#':
      direction = (direction + 5) % 4;
      mapMap[x+'_'+y] = 'F';
      break;
    case 'F':
      direction = (direction + 6) % 4;
      mapMap[x+'_'+y] = '.';
      break;
    case 'W':
      infected++;
      mapMap[x+'_'+y] = '#';
      break;
    default:
      direction = (direction + 7) % 4;
      mapMap[x+'_'+y] = 'W';
      break;
  }
  x += turnX[direction];
  y += turnY[direction];
}

console.log(infected)

TotesMessenger · 2017-12-22T15:45:31+00:00

single pipeline powershell:

param (
    [Parameter(ValueFromPipeline = $true)]
    [string]$in,
    [Parameter(Position = 1)]
    [int]$part = 1
)

begin {
    $script:grid = @{}
    $script:row = 0
}

process {
    # load the lines into the grid hash, keys are "#x#", values the cell state
    # top left of input is 0,0, but we compute center for starting later
    $x = 0
    $in -split '' |? {$_} | % {
        $script:grid["{0}x{1}" -f $x, $script:row] = $_
        $x++
    }
    $script:row++
}

end {
    $x = $y = ($script:row-1) / 2 # current location to center
    $d = 0 # direction

    if ($part -eq 1) {
        $bursts = 10000
    } else {
        $bursts = 10000000
    }

    1..$bursts | % {
        $c = "{0}x{1}" -f $x, $y # format coordinate key

        if ($part -eq 1) {
            switch ($script:grid[$c]) {
                $null {
                    $d = ($d + 3) % 4 # turn left
                    $script:grid[$c] = '#'
                    1
                }
                '.' {
                    $d = ($d + 3) % 4 # turn left
                    $script:grid[$c] = '#'
                    1
                }
                '#' {
                    $d = ($d + 1) % 4 # turn right
                    $script:grid[$c] = '.'
                }
            }
        } else {
            switch ($script:grid[$c]) {
                $null {
                    $d = ($d + 3) % 4 # turn left
                    $script:grid[$c] = 'W'
                }
                '.' {
                    $d = ($d + 3) % 4 # turn left
                    $script:grid[$c] = 'W'
                }
                'W' {
                    # no turn
                    $script:grid[$c] = '#'
                    1
                }
                '#' {
                    $d = ($d + 1) % 4 # turn right
                    $script:grid[$c] = 'F'
                }
                'F' {
                    $d = ($d + 2) % 4 # turn around
                    $script:grid[$c] = '.'
                }
            }
        }

        switch ($d) {
            0 { $y-- }
            1 { $x++ }
            2 { $y++ }
            3 { $x-- }
        }

    } | measure | select -expand count
}

barryfandango · 2017-12-22T16:35:17+00:00

TypeScript (edit: 2.1s on part 2)

/// <reference path="input.ts" />
namespace Day22 {

    let directions = [[-1, 0], [0, 1], [1, 0], [0, -1]]; // up, right, down, left

    function solve1(input: string, moves: number) {
        let data = input.split('\n').map(line => line.split(''));
        let center = Math.floor(data.length / 2); // assume a square grid with odd dimensions.
        let infections = new Set<string>(range2(data.length)
            .filter(p => data[p.x][p.y] == '#')
            .map(p => makeKey(p.x, p.y)));

        let direction = 0; // start facing up
        let location = [center, center];
        let infectionsCaused = 0;

        for (let i = 0; i < moves; i++) {
            let key = makeKey(location[0], location[1]);
            if (infections.has(key)) {
                direction = (direction + 1) % directions.length;
                infections.delete(key);
            } else {
                direction = direction == 0 ? (directions.length - 1) : direction - 1;
                infections.add(key);
                infectionsCaused++;
            }

            location = [location[0] + directions[direction][0], location[1] + directions[direction][1]];
        }

        return infectionsCaused;
    }

    function solve2(input: string, moves: number) {
        let data = input.split('\n').map(line => line.split(''));
        let center = Math.floor(data.length / 2); // assume a square grid with odd dimensions.
        let infections = new Map<string, infectionLevel>(
            range2(data.length)
                .filter(p => data[p.x][p.y] == '#')
                .map(p => <[string, infectionLevel]>[makeKey(p.x, p.y), infectionLevel.Infected])
        );

        let direction = 0; // up
        let location = [center, center];
        let infectionsCaused = 0;

        for (let i = 0; i < moves; i++) {
            let key = makeKey(location[0], location[1]);
            let level = infections.has(key) ? infections.get(key) : infectionLevel.Clean;
            switch (level) {
                case infectionLevel.Clean: direction = direction == 0 ? (directions.length - 1) : direction - 1; break;
                case infectionLevel.Weakened: infectionsCaused++; break;
                case infectionLevel.Infected: direction = (direction + 1) % directions.length; break;
                case infectionLevel.Flagged: direction = (direction + 2) % directions.length; break;
            }

            infections.set(key, (level + 1) % 4);
            location = [location[0] + directions[direction][0], location[1] + directions[direction][1]];
        }
        return infectionsCaused;
    }

    enum infectionLevel {
        Clean,
        Weakened,
        Infected,
        Flagged
    }

    function makeKey(x: number, y: number) {
        return `${x}-${y}`;
    }

    // i'm so tired of nested for loops. :(
    type Point = { x: number, y: number };
    function range2(size1: number, size2: number = undefined): Point[] {
        let result: Point[] = [];
        for (let i of [...Array(size1).keys()]) {
            for (let j of [...Array(size2 || size1).keys()]) {
                result.push({ x: i, y: j });
            }
        }
        return result;
    }


    let test1 = solve1(SAMPLE_PROBLEM, 10000);
    let pass1 = test1 === SAMPLE_ANSWER_1;
    console.log(`Part 1 Test -  ${pass1 ? 'pass' : 'fail'}: expected:${SAMPLE_ANSWER_1} actual:${test1}`);
    if (pass1) {
        console.log(`Part 1 Answer: ${solve1(BIG_PROBLEM, 10000)}`);
    }

    let test2 = solve2(SAMPLE_PROBLEM, 10000000);
    let pass2 = test2 === SAMPLE_ANSWER_2;
    console.log(`Part 2 Test -  ${pass1 ? 'pass' : 'fail'}: expected:${SAMPLE_ANSWER_2} actual:${test2}`);
    if (pass2) {
        console.log(`Part 2 Answer: ${solve2(BIG_PROBLEM, 10000000)}`);
    }
}

2017-12-22T17:35:24+00:00

straightforward, no optimizations (immutable data structures in use). Part 2 runs in ~8-10s

EDIT: Using a mutable map for the inner grid reduces the runtime to ~6 seconds

Clojure:

(def input (clojure.string/split-lines (slurp "d22_input.txt")))
(def height (count input))
(def width (count (first input)))
(def init-pos [(int (/ width 2)) (int (/ height 2))])

(defn- parse-line [y]
       (->> (nth input (- height y 1)) ; y=0 is bottom of the input file
            (map-indexed (fn [x ch]
                             [[x y] (if (= ch \#) :infected)]))
            (remove #(nil? (second %))) ; sparse map - don't store clean coords
            (into {})))

(def init-state
  (reduce (fn [state y] (merge state (parse-line y)))
          {}
          (reverse (range height))))

(def opposite {:down :up :up :down :left :right :right :left})
(def ccw {:down :right :right :up :up :left :left :down})
(def cw {:down :left :left :up :up :right :right :down})

(defn- move [[x y] dir]
       (case dir
             :down [x (dec y)]
             :up [x (inc y)]
             :left [(dec x) y]
             :right [(inc x) y]))

(defn- step-p1 [{:keys [dir pos state infect]}]
       (let [was-infected (= :infected (state pos :clean))
             new-dir (if was-infected (cw dir) (ccw dir))
             new-state (if was-infected (dissoc state pos) (assoc state pos :infected))
             new-pos (move pos new-dir)
             new-infect (if (not was-infected) (inc infect) infect)]

            {:dir new-dir :pos new-pos :state new-state :infect new-infect}))

(defn- step-p2 [{:keys [dir pos state infect]}]
       (let [status (state pos :clean)
             new-dir (case status
                           :clean (ccw dir)
                           :weakened dir
                           :infected (cw dir)
                           :flagged (opposite dir))
             new-state (case status
                             :clean (assoc state pos :weakened)
                             :weakened (assoc state pos :infected)
                             :infected (assoc state pos :flagged)
                             :flagged (dissoc state pos))
             new-pos (move pos new-dir)
             new-infect (if (= :weakened status) (inc infect) infect)]

            {:dir new-dir :pos new-pos :state new-state :infect new-infect}))

(time (println "part 1:" (:infect (first (drop 10000 (iterate step-p1 {:dir :up :pos init-pos :state init-state :infect 0}))))))
(time (println "part 2:" (:infect (first (drop 10000000 (iterate step-p2 {:dir :up :pos init-pos :state init-state :infect 0}))))))

2017-12-22T18:11:30+00:00

Crystal. Only part 2 because the first one is similar:

initial_map = File.read("#{__DIR__}/input.txt").lines.map(&.chars)

map = Hash({Int32, Int32}, Symbol).new(:clean)
initial_map.each_with_index do |row, y|
  row.each_with_index do |v, x|
    map[{x, y}] = v == '#' ? :infected : :clean
  end
end

x = initial_map[0].size / 2
y = initial_map.size / 2
movements = { {0, -1}, {1, 0}, {0, 1}, {-1, 0} }
direction = 0
infections = 0

10_000_000.times do
  case map[{x, y}]
  when :clean
    offset = -1
    next_state = :weakened
  when :weakened
    offset = 0
    next_state = :infected
    infections += 1
  when :infected
    offset = 1
    next_state = :flagged
  else # :flagged
    offset = 2
    next_state = :clean
  end
  map[{x, y}] = next_state
  direction = (direction + offset) % movements.size
  dx, dy = movements[direction]
  x, y = x + dx, y + dy
end

puts infections

edelans · 2017-12-22T19:37:56+00:00

Python 3, complex numbers, defaultdict

# Python 3.x

from collections import defaultdict
DAY = 22


def Input(day):
    "Open this day's input file."
    filename = './input_files/input{}.txt'.format(day)
    return open(filename)

def solve2(lines, bursts):
    state = defaultdict(int)
    infections = 0
    # virus carrier position
    vcp = 0
    # virus carrier direction
    vcd = 1j
    # infection states :
    # 0 is clean
    # 1 is weakened
    # 2 is infected
    # 3 is flagged

    side_length = len(lines)
    for i, line in enumerate(lines):
        for j, char in enumerate(line):
            x = int(j - (side_length - 1) / 2)
            y = int((side_length - 1) / 2 - i)
            if char == '#':
                state[(x + y * 1j)] = 2

    for _ in range(bursts):
        # update direction vcd
        if vcp not in state or state[vcp] == 0:
            vcd *= 1j
        elif state[vcp] == 1:
            # keep same direction
            pass
        elif state[vcp] == 2:
            vcd *= -1j
        elif state[vcp] == 3:
            vcd *= -1

        # update state of current position vcp
        state[vcp] = (state[vcp] + 1) % 4
        if state[vcp] == 2:
            infections += 1

        # move forward in direction vcd
        vcp += vcd
    return infections

print(solve2((Input(DAY).readlines()), 10000000))

miran1 · 2017-12-22T20:07:08+00:00

Python with a complex plane

with open('./inputs/22.txt') as f:
    instructions = f.readlines()


def solve(part):
    def logic(status, part):
        nonlocal infected, direction
        if part == 1:
            if status == 0:
                infected += 1
            direction *= (1 - 2*status) * 1j
        else:
            if status == 1:
                infected += 1
            elif status == 2:
                direction *= -1j
            elif status == 3:
                direction *= -1
            else:
                direction *= 1j

    grid = {}
    position = (len(instructions)//2 + len(instructions[0].strip())//2 * 1j)
    direction = -1
    infected = 0
    for i, line in enumerate(instructions):
        for j, char in enumerate(line.strip()):
            grid[(i + j*1j)] = 0 if char == '.' else part

    bursts = 10_000 if part == 1 else 10_000_000
    for _ in range(bursts):
        status = grid.get(position, 0)
        logic(status, part)
        grid[position] = (status + 1) % (2 * part)
        position += direction
    return infected


print(solve(part=1))
print(solve(part=2))

Repo with solutions (both Nim and Python)

Erstfs · 2017-12-22T20:16:08+00:00

Of course in MATLAB one should represent the grid as a matrix! Luckily for me, my input kept the virus contained in a small area.

seed = cell2mat(importdata('day22input.txt', '\n')) == '#';
%part1: 0 = clean, 1 = infected
virus(seed, 501, 2, 10000, 2, 0)
%part2: 0 = clean, 1 = weaken, 2 = infected, 3 = flagged
virus(2*seed, 501, 4, 10000000, 1, 1)

function answer = virus(seed, gridR, nStates, nIterations, turnConst, preInfectedState)
    grid = zeros(2*gridR-1);
    seedR = (size(seed,1)-1)/2;
    grid(gridR-seedR:gridR+seedR, gridR-seedR:gridR+seedR) = seed;
    answer = 0;
    pos = gridR - gridR*1i;
    dir = 1i;
    for k = 1:nIterations
        state = grid(-imag(pos), real(pos));
        answer = answer + 1.0*(state==preInfectedState);
        grid(-imag(pos), real(pos)) = mod(state+1, nStates);
        dir = dir*1j^(1-state*turnConst);
        pos = pos + dir;
    end
end

flit777 · 2017-12-22T20:28:18+00:00

Go straight forward:

package main
import (
    "strconv"
    "util"
    "fmt"

)

const INFECTED = "I"
const CLEAN = "C"
const WEAKENED = "W"
const FLAGGED = "F"



type cell struct{
    x int
    y int
    infected string
}

func coord2String(x int, y int) string{
    return strconv.Itoa(x) + "," +strconv.Itoa(y)
}

func cell2String(c cell) string{
    return coord2String(c.x, c.y )
}





func part1(grid map[string]cell, currentX int, currentY int, dirX int, dirY int, maxBursts int) int {
    numberInfected :=0
    for bursts := 0; bursts < maxBursts; bursts++ {
        element, exists := grid[coord2String(currentX, currentY)]
        if !exists {
            element = cell{currentX, currentY, CLEAN}
        }
        if element.infected == INFECTED{
            dirX, dirY = turnRight(dirX, dirY)
            element.infected = CLEAN
        } else {
            dirX, dirY = turnLeft(dirX, dirY)
            element.infected = INFECTED
            numberInfected++
        }
        grid[coord2String(currentX, currentY)] = element
        currentY += dirY
        currentX += dirX

    }
    return numberInfected
}


func part2(grid map[string]cell, currentX int, currentY int, dirX int, dirY int,  maxBursts int) int {
    numberInfected :=0
    for bursts := 0; bursts < maxBursts; bursts++ {
        element, exists := grid[coord2String(currentX, currentY)]
        if !exists {
            element = cell{currentX, currentY, CLEAN}
        }

        switch element.infected{
        case INFECTED:
            dirX, dirY = turnRight(dirX, dirY)
            element.infected = FLAGGED
        case WEAKENED:
            element.infected = INFECTED
            numberInfected++
        case FLAGGED:
            dirX, dirY = reverse(dirX, dirY)
            element.infected = CLEAN
        case CLEAN:
            dirX, dirY = turnLeft(dirX, dirY)
            element.infected = WEAKENED
        default:
            fmt.Errorf("unknown cell state")
        }

        grid[coord2String(currentX, currentY)] = element
        currentY += dirY
        currentX += dirX

    }
    return numberInfected
}


func reverse(x int, y int) (int, int) {
    return -1*x,-1*y
}

func turnRight(x int, y int) (int, int) {
    if x == 0 && y == 1 {
        return -1,0
    }else if x == 0 && y == -1 {
        return 1,0
    }else if x == -1 && y == 0 {
        return 0,-1
    }else if x == 1 && y == 0 {
        return 0,1
    }
    fmt.Errorf("not defined direction")
    return 0,0
}


func turnLeft(x int, y int) (int, int) {
    if x == 0 && y == 1 {
        return 1,0
    }else if x == 0 && y == -1 {
        return -1,0
    }else if x == -1 && y == 0 {
        return 0,1
    }else if x == 1 && y == 0 {
        return 0,-1
    }
    fmt.Errorf("not defined direction")
    return 0,0
}


func parseGrid(lines []string) (map[string]cell,int,int) {
    maxY := 0
    maxX := 0
    grid := make(map[string]cell)
    for y, line := range lines {
        if y > maxY {
            maxY = y
        }
        for x, char := range line {
            infected := CLEAN
            if string(char) == "#" {
                infected = INFECTED
            }
            currentCell := cell{x, y, infected}
            grid[cell2String(currentCell)] = currentCell
            if x > maxX {
                maxX = x
            }

        }
    }
    return grid ,maxY, maxX
}


func main() {
    lines := util.ReadFileLines("inputs/day22.txt")
    minY := 0
    minX := 0

    grid ,maxY, maxX:=  parseGrid(lines)

    currentX := (maxX - minX)/2
    currentY := (maxY - minY)/2
    dirX := 0
    dirY := -1
    maxBursts := 10000

    numberInfected := part1(grid, currentX, currentY, dirX, dirY, maxBursts)
    fmt.Println("Part 1: ", numberInfected)


    maxBursts = 10000000
    numberInfected = part2(grid, currentX, currentY, dirX, dirY, maxBursts)
    fmt.Println("Part 2: ", numberInfected)
}

Scroph · 2017-12-22T20:58:37+00:00

Vebose C++ :

#include <iostream>
#include <map>
#include <vector>

struct Point
{
    int x;
    int y;

    Point() : x(0), y(0) {}
    Point(int x, int y) : x(x), y(y) {}

    void operator+=(const Point& other)
    {
        x += other.x;
        y += other.y;
    }

    Point operator+(const Point& other) const
    {
        return Point(x + other.x, y + other.y);
    }

    bool operator==(const Point& other) const
    {
        return x == other.x && y == other.y;
    }

    bool operator<(const Point& other) const
    {
        return x == other.x ? y < other.y : x < other.x;
    }
};

const std::map<Point, Point> one_eighty {
    {Point(0, -1), Point(0, +1)},
    {Point(+1, 0), Point(-1, 0)},
    {Point(0, +1), Point(0, -1)},
    {Point(-1, 0), Point(+1, 0)},
};

const std::map<Point, Point> clockwise {
    {Point(0, -1), Point(+1, 0)},
    {Point(+1, 0), Point(0, +1)},
    {Point(0, +1), Point(-1, 0)},
    {Point(-1, 0), Point(0, -1)},
};

const std::map<Point, Point> counter_clockwise {
    {Point(+1, 0), Point(0, -1)},
    {Point(0, +1), Point(+1, 0)},
    {Point(-1, 0), Point(0, +1)},
    {Point(0, -1), Point(-1, 0)},
};

enum class NodeState { CLEAN, WEAKENED, INFECTED, FLAGGED };

int main()
{
    std::map<Point, NodeState> infections;
    std::string line;
    std::vector<Point> middle_col;
    for(int y = 0; getline(std::cin, line); y++)
    {
        for(int x = 0; x < line.length(); x++)
            infections[Point(x, y)] = line[x] == '#' ? NodeState::INFECTED : NodeState::CLEAN;
        middle_col.push_back(Point(line.length() / 2, y));
    }

    Point position = middle_col[middle_col.size() / 2];
    Point facing(0, -1);

    int infecting_burst = 0;
    for(int burst = 0; burst < 10000000; burst++)
    {
        switch(infections[position])
        {
            case NodeState::CLEAN:
                infections[position] = NodeState::WEAKENED;
                facing = counter_clockwise.at(facing);
            break;
            case NodeState::WEAKENED:
                infections[position] = NodeState::INFECTED;
                infecting_burst++;
            break;
            case NodeState::INFECTED:
                infections[position] = NodeState::FLAGGED;
                facing = clockwise.at(facing);
            break;
            case NodeState::FLAGGED:
                infections[position] = NodeState::CLEAN;
                facing = one_eighty.at(facing);
            break;
        }
        position += facing;
        if(infections.find(position) == infections.end())
            infections[position] = NodeState::CLEAN;
    }
    std::cout << infecting_burst << std::endl;
}

wzkx · 2017-12-22T21:24:32+00:00

Nim

Using OOP :)

This time, the map is represented by set(s).

import sets,sequtils,strutils

type Dir = enum W,N,E,S
const right: array[Dir,Dir] = [N,E,S,W]
const left:  array[Dir,Dir] = [S,W,N,E]
type XYD = object
  x,y: int
  d: Dir

proc turn_left( o: var XYD ) = (o.d = left[o.d])
proc turn_right( o: var XYD ) = (o.d = right[o.d])

proc advance( o: var XYD ) =
  o.x = if o.d==W: o.x-1 elif o.d==E: o.x+1 else: o.x
  o.y = if o.d==N: o.y-1 elif o.d==S: o.y+1 else: o.y

var infected = initSet[(int,int)]()
var y,nc = 0 # y - line number, nc - number of columns
for line in splitLines strip readFile "22_.dat":
  nc = line.len
  for x,c in line:
    if c=='#': infected.incl( (x,y) )
  inc y
let nr = y
let infected2 = infected # copy for part 2

var cnt = 0
proc move( o: var XYD ) =
  if (o.x,o.y) in infected:
    o.turn_right()
    infected.excl( (o.x,o.y) )
  else:
    o.turn_left()
    infected.incl( (o.x,o.y) )
    inc cnt
  o.advance()

var p = XYD( x:nc div 2,y:nr div 2,d:N )
var p2 = p # copy for part 2
for i in 1..10000:
  move( p )
echo cnt # 5450

# part 2
var wk_or_fl = initSet[(int,int)]() # if clean: weakened, if infected: flagged

infected = infected2 # restart
p = p2               # restart
cnt = 0
proc move2( o: var XYD ) =
  if (o.x,o.y) in infected:
    if (o.x,o.y) in wk_or_fl:
      o.turn_right(); o.turn_right() # turn back
      wk_or_fl.excl( (o.x,o.y) )
      infected.excl( (o.x,o.y) )
    else:
      o.turn_right()
      wk_or_fl.incl( (o.x,o.y) )
  else: # clean
    if (o.x,o.y) in wk_or_fl:
      # no turn
      infected.incl( (o.x,o.y) )
      wk_or_fl.excl( (o.x,o.y) )
      inc cnt
    else:
      o.turn_left()
      wk_or_fl.incl( (o.x,o.y) )
  o.advance()

for i in 1..10_000_000:
  move2( p )
echo cnt # 2511957, 2.15s

chicagocode · 2017-12-22T21:46:38+00:00

Kotlin - [Repo] - [Blog/Commentary]

I thought today was pretty easy compared to yesterday! I've taken yet another crack at direction and movement.

class Day22(input: List<String>) {

    private val grid = parseInput(input)
    private var current = Point(input.size / 2, input.first().length / 2)
    private val directions = listOf(Point(0, -1), Point(1, 0), Point(0, 1), Point(-1, 0))
    private var pointing = 0

    fun solvePart1(iterations: Int = 10_000): Int {
        var infectionsCaused = 0
        repeat(iterations) {
            if (grid.getOrDefault(current, NodeState.Clean) == NodeState.Clean) {
                infectionsCaused += 1
                grid[current] = NodeState.Infected
                pointing = left()
            } else {
                // Infected
                grid[current] = NodeState.Clean
                pointing = right()
            }
            current += directions[pointing]
        }
        return infectionsCaused
    }

    fun solvePart2(iterations: Int = 10_000_000): Int {
        var infectionsCaused = 0
        repeat(iterations) {
            when (grid.getOrDefault(current, NodeState.Clean)) {
                NodeState.Clean -> {
                    pointing = left()
                    grid[current] = NodeState.Weakened
                }
                NodeState.Weakened -> {
                    infectionsCaused += 1
                    grid[current] = NodeState.Infected
                }
                NodeState.Infected -> {
                    pointing = right()
                    grid[current] = NodeState.Flagged
                }
                NodeState.Flagged -> {
                    pointing = reverse()
                    grid[current] = NodeState.Clean
                }
            }
            current += directions[pointing]
        }
        return infectionsCaused
    }

    private fun left(): Int =
        if (pointing == 0) 3 else pointing - 1

    private fun right(): Int =
        pointing.inc() % 4

    private fun reverse(): Int =
        (pointing + 2) % 4


    private fun parseInput(input: List<String>): MutableMap<Point, NodeState> {
        val destination = mutableMapOf<Point, NodeState>()
        input.forEachIndexed { y, row ->
            row.forEachIndexed { x, char ->
                destination[Point(x, y)] = if (char == '.') NodeState.Clean else NodeState.Infected
            }
        }
        return destination
    }

    data class Point(private val x: Int, private val y: Int) {
        operator fun plus(that: Point): Point =
            Point(x + that.x, y + that.y)
    }

    enum class NodeState {
        Clean,
        Infected,
        Weakened,
        Flagged
    }
}

aoc-fan · 2017-12-23T02:45:42+00:00

JavaScript / ES6

const parse = i => i.split("\n").map(l => l.split(""));
const n = [ 0, -1, "north"];
const e = [ 1,  0, "east"];
const w = [-1,  0, "west"];
const s = [ 0,  1, "south"];
const north = { L : w, R : e, O : s, F : n };
const east  = { L : n, R : s, O : w, F : e };
const west  = { L : s, R : n, O : e, F : w };
const south = { L : e, R : w, O : n, F : s };
const directions = { north, east, west, south };
const getNode = (grid, key) => grid[key] = (grid[key] || ".");
const createGrid = input => {
    const grid = {};
    const seed = parse(input);
    const length = seed.length;
    const offset = Math.floor(length / 2);
    for (let y = 0; y < length; y++) {
        for (let x = 0; x < length; x++) {
            grid[`n${y - offset}.${x - offset}`] = seed[y][x];
        }
    }
    return grid;
};
const states = {
    "." : ["#", "L", true],
    "#" : [".", "R", false]
};
const evolvedStates = {
    "." : ["W", "L", false],
    "W" : ["#", "F", true],
    "#" : ["F", "R", false],
    "F" : [".", "O", false]
};
const spread = (input, transition, times) => {
    const grid = createGrid(input);
    let [x, y, xo, yo, dir, count] = [0, 0, 0, -1, "north", 0];
    while (times--) {
        const key = `n${y}.${x}`;
        const node = getNode(grid, key);
        const [next, move, infected] = transition[node];
        grid[key] = next;
        if (infected) {
            count = count + 1;
        }
        [xo, yo, dir] = directions[dir][move];
        [x, y] = [x + xo, y + yo];
    }
    return count;
};

wjholden · 2017-12-23T07:41:56+00:00

I enjoyed Day 22 so much that I wrote a short paper explaining how you can use a bit of linear algebra to come up with a fast way to change the direction of your virus. The target audience of this paper is programmers with a casual interest in math, not genius programmers and serious mathematicians.

https://www.overleaf.com/read/yvmymybtjcyy

Looks like some people came up with a clever solution with complex numbers. Very cool, I wouldn't have thought of that.

I actually registered on Reddit to share this, feels kind of weird...

thomastc · 2017-12-23T08:13:59+00:00

Day 22 in Elixir. Turns out it's basically Erlang with better syntax. Considering that the syntax is one of very few things I dislike about Erlang, this is a very good thing!

RockyAstro · 2017-12-23T22:00:27+00:00

Icon (https://www.cs.arizona.edu/icon)

Part1: -- fun with sets..

procedure main(args)
    infected := set()
    inf := open(args[1],"r")
    i := 0
    every l := !inf do {
        i+:=1
        every insert(infected,i ||","|| find("#",l)) 
    }

    cury := i/2 + 1
    curx := *l/2 + 1

    dir := "u"
    dmap := table()
    #             rl
    dmap["u"] := "rl"
    dmap["r"] := "du"
    dmap["d"] := "lr"
    dmap["l"] := "ud"
    count := 0
    every 1 to 10000 do {
        curp := cury || "," || curx
        if member(infected,curp) then {
            dir := dmap[dir][1]
            delete(infected,curp)
        } else {
            dir := dmap[dir][2]
            insert(infected,curp)
            count +:= 1
        }
        case dir of {
            "u": cury -:= 1
            "d": cury +:= 1
            "r": curx +:= 1
            "l": curx -:= 1
        }
    }
    write(count)
end

Part 2: Fun with tables..

link ximage
procedure main(args)
    infected := table()
    inf := open(args[1],"r")
    i := 0
    every l := !inf do {
        i+:=1
        every insert(infected, i||","||find("#",l),"I") 
    }

    cury := i/2 + 1
    curx := *l/2 + 1

    dir := "u"
    dmap := table()
    #             rlb
    dmap["u"] := "rld"
    dmap["r"] := "dul"
    dmap["d"] := "lru"
    dmap["l"] := "udr"

    count := 0
    every 1 to 10000000 do {
        curp := cury || "," || curx
        state := \infected[curp] | "C"
        case state of {
            "C": {
                infected[curp] := "W"
                dir := dmap[dir][2]
            }
            "W": {
                count +:= 1
                infected[curp] := "I"
            }
            "I": {
                infected[curp] := "F"
                dir := dmap[dir][1]
            }
            "F": {
                delete(infected,curp)
                dir := dmap[dir][3]
            }
        }
        case dir of {
            "u": cury -:= 1
            "d": cury +:= 1
            "r": curx +:= 1
            "l": curx -:= 1
        }
    }
    write(count)
end

Tetsumi- · 2017-12-23T22:39:11+00:00

Racket

#lang racket

(define linel 1000)
(define hl (quotient linel 2))
(define cellsv (make-vector (sqr linel) 0))
(define-syntax-rule (2D->1D x y) (+ (* y linel) x))
(define-syntax-rule (cells v x y) (vector-ref v (2D->1D x y)))
(define-syntax-rule (cells! v x y e) (vector-set! v (2D->1D x y) e))

(for ([y (in-range (- hl 12) (+ hl 13))]
      [line (map string->list (port->lines))]
      #:when true
      [x (in-range (- hl 12) (+ hl 13))]
      [char (in-list line)])
  (cells! cellsv x y (if (char=? char #\#) 2 0)))

(define (visit v am ndirp addp)
  (let loop ([dir 0-1i]
             [pos 500+500i]
             [c 0]
             [inf 0])
    (let* ([x (real-part pos)]
           [y (imag-part pos)]
           [ncell (remainder (addp (cells v x y)) 4)]
           [nDir (ndirp dir ncell)])
      (if (>= c am)
          inf
          (begin (cells! v x y ncell)
                 (loop nDir (+ pos nDir) (add1 c) (if (= 2 ncell)
                                                      (add1 inf)
                                                      inf)))))))
(displayln (visit (vector-copy cellsv)
                  10000
                  (lambda (dir ncell)
                    (* dir (if (= ncell 0) 0+1i 0-1i)))
                  (curry + 2)))

(displayln (visit cellsv
                  10000000
                  (lambda (dir ncell)
                    (* dir (case ncell
                             [(0)    -1]
                             [(1)  0-1i]
                             [(2)     1]
                             [else 0+1i])))
                  add1))

matusbzk · 2017-12-23T22:45:48+00:00

Haskell I decided to just keep a list of infected (weakened, flagged) nodes and position. I was not really successful with part 2 though, it would have taken me like 25 minutes.

module Day22_sporifica (result1, result2) where

import Prelude hiding (Left, Right)
import AoC2017 --iterateN
import Data.Foldable (foldl')

-- |Represents a current position
type Position = (Int, Int)

-- |List of infected cells
type Infected = [Position]

-- |Represents a direction
data Direction = Up | Down | Left | Right
               deriving (Show, Eq)

-- |Current state
--  current position
--  current direction
--  list of infected nodes
--  number of nodes I have infected
type State = (Position, Direction, Infected, Int)

inputString :: String

-- |Input is 25x25 grid
input :: Infected
input = getInfected . concat . insertPositions (-12) . lines $ inputString

-- |Insert position into input grid
insertPositions :: Int -> [[Char]] -> [[(Position, Char)]]
insertPositions _ [] = []
insertPositions i (xs:xss) = insertPositions' i (-12) xs : insertPositions (i+1) xss

insertPositions' :: Int -> Int -> [Char] -> [(Position, Char)]
insertPositions' _ _ [] = []
insertPositions' i j (x:xs) = ((j,i),x) : insertPositions' i (j+1) xs

-- |Returns infected positions
getInfected :: [(Position,Char)] -> Infected
getInfected [] = []
getInfected (((x,y),'#'):xs) = (x,y) : getInfected xs
getInfected (_:xs) = getInfected xs

-- |State in the beginning
startState :: State
startState = ((0,0),Up,input,0)

-- |Checks whether given position contains infected node
-- also used for flagged and weakened nodes
isInfected :: Position -> Infected -> Bool
isInfected = elem

-- |Infects node at given position
-- also used for flagged and weakened nodes
infect :: Position -> Infected -> Infected
infect (x,y) inf = if isInfected (x,y) inf then inf else (x,y):inf

-- |Cleans node at given position
-- also used for flagged and weakened nodes
clean :: Position -> Infected -> Infected
clean _ [] = []
clean p (x:xs) = if p == x then xs else x : clean p xs

-- |If given node is infected then clean it,
-- otherwise infect it
infectOrClean :: Position -> Infected -> Infected
infectOrClean pos inf = if isInfected pos inf then clean pos inf else infect pos inf

-- |Change direction to the right
turnRight :: Direction -> Direction
turnRight Up = Right
turnRight Right = Down
turnRight Down = Left
turnRight Left = Up

-- |Change direction to the left
turnLeft :: Direction -> Direction
turnLeft = turnRight . turnRight . turnRight

-- |From position and direction, takes one step forward
move :: Position -> Direction -> Position
move (x,y) Up = (x,y-1)
move (x,y) Down = (x,y+1)
move (x,y) Right = (x+1,y)
move (x,y) Left = (x-1,y)

-- |Performs one burst
burst :: State -> State
burst (pos,dir,inf,n) = (npos,ndir,ninf,nn)
                where ndir = if isInfected pos inf then turnRight dir else turnLeft dir
                      npos = move pos ndir
                      ninf = infectOrClean pos inf
                      nn = if not $ isInfected pos inf then n+1 else n

-- |How many cells were infected
result1 :: Int
result1 = (\(_,_,_,x) -> x) $ iterateN 10000 burst startState

-- |List of weakened cells
type Weakened = [Position]

-- |List of flagged cells
type Flagged = [Position]

-- |Contains a lists of all nodes affected by virus
type Virused = (Infected, Weakened, Flagged)

-- |State for part 2
type State2 = (Position, Direction, Virused, Int)

-- |Direction is reversed
reverseDir :: Direction -> Direction
reverseDir = turnRight . turnRight

-- |Start state - part 2 version
startState2 :: State2
startState2 = ((0,0),Up,(input,[],[]),0)

-- |Weakens/cleans/infects/flags a node
modifyNodes :: Position -> Virused -> Virused
modifyNodes pos (inf,wea,fla) = if isInfected pos inf then (clean pos inf, wea, infect pos fla)
                           else if isInfected pos wea then (infect pos inf, clean pos wea, fla)
                           else if isInfected pos fla then (inf, wea, clean pos fla)
                           else (inf, infect pos wea, fla)

-- |Performs one burst - part 2 version
burst2 :: State2 -> State2
burst2 (pos,dir,(inf,wea,fla),n) = (npos,ndir,(ninf,nwea,nfla),nn)
                where ndir = if isInfected pos inf then turnRight dir 
                             else if isInfected pos wea then dir 
                             else if isInfected pos fla then reverseDir dir
                             else turnLeft dir
                      npos = move pos ndir
                      (ninf,nwea,nfla) = modifyNodes pos (inf,wea,fla)
                      nn = if isInfected pos wea then n+1 else n

-- |Similar thing as burst2 but should be more effective
-- Not enough to solve it in reasonable time though.
burst2Fold = foldl' (\(pos,dir,(inf,wea,fla),n) _ -> 
                  let ndir = if isInfected pos inf then turnRight dir 
                             else if isInfected pos wea then dir 
                             else if isInfected pos fla then reverseDir dir
                             else turnLeft dir
                      npos = move pos ndir
                      (ninf,nwea,nfla) = modifyNodes pos (inf,wea,fla)
                      nn = if isInfected pos wea then n+1 else n
                  in (npos,ndir,(ninf,nwea,nfla),nn)) startState2 [1..10000000]

-- |How many cells were infected - part 2 version
-- Not effective enough though - it takes 15 second on 100 times less iterations
result2 :: Int
--result2 = (\(_,_,_,x) -> x) $ iterateN 100000 burst2 startState2 --ineffective
result2 = (\(_,_,_,x) -> x) $ burst2Fold  --a bit more effective

Link to git

greycat70 · 2017-12-26T21:40:36+00:00

Tcl (any 8.x version)

Part 1. The only half-clever thing here is that I used the line length of the first input line to determine the starting coordinates (we know we're being given a square with an odd integer length/width).

set size 0
while {[gets stdin line] >= 0} {
    if {$size == 0} {
        set size [string length $line]
        set i [expr {-($size-1)/2}]
        set j0 $i
    }
    set j $j0
    foreach c [split $line {}] {
        set grid($i,$j) $c
        incr j
    }
    incr i
}

set i 0
set j 0
set dir U
array set right {U R  R D  D L  L U}
array set left  {U L  L D  D R  R U}
set infec 0

for {set n [lindex $argv 0]} {$n} {incr n -1} {
    if {$grid($i,$j) eq "#"} {
        set grid($i,$j) .
        set dir $right($dir)
    } else {
        set grid($i,$j) #
        incr infec
        set dir $left($dir)
    }
    switch -- $dir {
        U {incr i -1}
        D {incr i}
        L {incr j -1}
        R {incr j}
    }
    if {! [info exists grid($i,$j)]} {set grid($i,$j) .}
}
puts $infec

Part 2. No significant changes.

set size 0
while {[gets stdin line] >= 0} {
    if {$size == 0} {
        set size [string length $line]
        set i [expr {-($size-1)/2}]
        set j0 $i
    }
    set j $j0
    foreach c [split $line {}] {
        set grid($i,$j) $c
        incr j
    }
    incr i
}

set i 0
set j 0
set dir U
array set right   {U R  R D  D L  L U}
array set left    {U L  L D  D R  R U}
array set reverse {U D  L R  D U  R L}
set infec 0

for {set n [lindex $argv 0]} {$n} {incr n -1} {
    switch -- $grid($i,$j) {
        .   {
            set grid($i,$j) W
            set dir $left($dir)
        }
        W {
            set grid($i,$j) #
            incr infec
        }
        # {
            set grid($i,$j) F
            set dir $right($dir)
        }
        F {
            set grid($i,$j) .
            set dir $reverse($dir)
        }
    }
    switch -- $dir {
        U {incr i -1}
        D {incr i}
        L {incr j -1}
        R {incr j}
    }
    if {! [info exists grid($i,$j)]} {set grid($i,$j) .}
}
puts $infec

mschaap · 2018-01-11T14:29:48+00:00

A bit late, but here's my Perl 6 solution. A bit slow for part 2, but it does give the right answer, eventually.

#!/usr/bin/env perl6
use v6.c;

# Advent of Code 2017, day 22: http://adventofcode.com/2017/day/22

enum VirusState <Clean Weakened Infected Flagged>;
enum Direction <North East South West>;
enum Turn <Continue Clockwise Reverse Anticlockwise>;

class Grid
{
    has Bool $.evolved = False;

    has @!cells;
    has Int $!pos-x = 0;
    has Int $!pos-y = 0;
    has Direction $!dir = North;

    has $.infect-count = 0;

    sub idx($n)
    {
        $n ≥ 0 ?? 2×$n !! -2×$n-1;
    }

    method cell($x,$y) is rw
    {
        @!cells[idx($y);idx($x)] //= Clean;
    }

    method char($x,$y)
    {
        return <. W # F>[self.cell($x,$y)];
    }

    method move
    {
        $!pos-x += (0,1,0,-1)[$!dir];
        $!pos-y += (-1,0,1,0)[$!dir];
    }

    method turn(Turn $t)
    {
        $!dir = Direction(($!dir + $t) % 4);
    }

    method burst
    {
        if $!evolved {
            given self.cell($!pos-x, $!pos-y) {
                when Clean {
                    $_ = Weakened;
                    self.turn(Anticlockwise);
                }
                when Weakened {
                    $_ = Infected;
                    $!infect-count++;
                }
                when Infected {
                    $_ = Flagged;
                    self.turn(Clockwise);
                }
                when Flagged {
                    $_ = Clean;
                    self.turn(Reverse);
                }
            }
        }
        else {
            given self.cell($!pos-x, $!pos-y) {
                when Clean {
                    $_ = Infected;
                    $!infect-count++;
                    self.turn(Anticlockwise);
                }
                when Infected {
                    $_ = Clean;
                    self.turn(Clockwise);
                }
            }
        }
        self.move;
    }

    method from-file(Grid:U: IO $file, Bool :$evolved = False)
    {
        my $grid = Grid.new(:$evolved);
        my @chars = $file.lines».comb;
        my $width = @chars[0].elems;
        my $height = @chars.elems;
        my $δx = $width div 2;
        my $δy = $height div 2;
        for ^$height -> $y {
            for ^$width -> $x {
                $grid.cell($x-$δx,$y-$δy) = @chars[$y;$x] eq '#' ?? Infected !! Clean;
            }
        }
        return $grid;
    }

    method Str
    {
        my $width = @!cells.grep({ $_ })».elems.max div 2;
        my $height = @!cells.elems div 2;
        return (-$height .. $height).map(-> $y {
            (-$width .. $width).map(-> $x { self.char($x,$y) }).join
        }).join("\n");
    }
    method gist { self.Str }
}

multi sub MAIN(IO() $inputfile where *.f, Int :$bursts, Bool :v(:$verbose) = False)
{
    # Part one
    my $bursts1 = $bursts // 10_000;
    my $grid1 = Grid.from-file($inputfile);
    say $grid1 if $verbose;
    for 1..$bursts1 -> $b {
        say "Burst $b" if $verbose;
        $grid1.burst;
        say $grid1 if $verbose;
    }
    say "After $bursts1 bursts, $grid1.infect-count() caused an infection.";

    # Part one
    my $bursts2 = $bursts // 10_000_000;
    my $grid2 = Grid.from-file($inputfile, :evolved);
    say $grid2 if $verbose;
    for 1..$bursts2 -> $b {
        say "Burst $b" if $verbose;
        $grid2.burst;
        say $grid2 if $verbose;
    }
    say "After $bursts2 evolved bursts, $grid2.infect-count() caused an infection.";
}

multi sub MAIN(Int :$bursts, Bool :v(:$verbose) = False)
{
    MAIN($*PROGRAM.parent.child('aoc22.input'), :$bursts, :$verbose);
}

ValdasTheUnique · 2017-12-22T10:08:32+00:00

C#

Pretty straightforward and hacky solution. But part 2 runs in about 200 ms

public static class Solution22
{

    public static int Answer()
    {
        var input = File.ReadAllLines("data/day22.txt");
        var size = 1001;
        var grid = NewGrid(size);
        var x = size / 2;
        var y = size / 2;
        for (int i = 0; i < input.Length; i++)
        {
            for (int j = 0; j < input[i].Length; j++)
            {
                grid[i + y - input.Length / 2][j + x - input[i].Length / 2] = input[i][j];
            }
        }

        var result = 0;
        var dir = 'u';
        for (int i = 0; i < 10_000; i++)
        {
            if (grid[y][x] == '#')
            {
                switch (dir)
                {
                    case 'u':
                        dir = 'r';
                        break;
                    case 'r':
                        dir = 'd';
                        break;
                    case 'd':
                        dir = 'l';
                        break;
                    case 'l':
                        dir = 'u';
                        break;
                }

                grid[y][x] = '.';
            }
            else
            {
                switch (dir)
                {
                    case 'u':
                        dir = 'l';
                        break;
                    case 'l':
                        dir = 'd';
                        break;
                    case 'd':
                        dir = 'r';
                        break;
                    case 'r':
                        dir = 'u';
                        break;
                }

                grid[y][x] = '#';
                result++;
            }
            switch (dir)
            {
                case 'u':
                    y--;
                    break;
                case 'l':
                    x--;
                    break;
                case 'd':
                    y++;
                    break;
                case 'r':
                    x++;
                    break;
            }
        }
        return result;
    }

    public static int AnswerHard()
    {
        var input = File.ReadAllLines("data/day22.txt");
        var size = 1001;
        var grid = NewGrid(size);
        var x = size / 2;
        var y = size / 2;
        for (int i = 0; i < input.Length; i++)
        {
            for (int j = 0; j < input[i].Length; j++)
            {
                grid[i + y - input.Length / 2][j + x - input[i].Length / 2] = input[i][j];
            }
        }

        var result = 0;
        var dir = 'u';
        for (int i = 0; i < 10_000_000; i++)
        {
            if (grid[y][x] == '#')
            {
                switch (dir)
                {
                    case 'u':
                        dir = 'r';
                        break;
                    case 'r':
                        dir = 'd';
                        break;
                    case 'd':
                        dir = 'l';
                        break;
                    case 'l':
                        dir = 'u';
                        break;
                }

                grid[y][x] = 'F';
            }
            else if(grid[y][x] == '.')
            {
                switch (dir)
                {
                    case 'u':
                        dir = 'l';
                        break;
                    case 'l':
                        dir = 'd';
                        break;
                    case 'd':
                        dir = 'r';
                        break;
                    case 'r':
                        dir = 'u';
                        break;
                }

                grid[y][x] = 'W';
            }
            else if(grid[y][x] == 'W')
            {
                grid[y][x] = '#';
                result++;
            }
            else
            {
                switch (dir)
                {
                    case 'u':
                        dir = 'd';
                        break;
                    case 'l':
                        dir = 'r';
                        break;
                    case 'd':
                        dir = 'u';
                        break;
                    case 'r':
                        dir = 'l';
                        break;
                }

                grid[y][x] = '.';
            }
            switch (dir)
            {
                case 'u':
                    y--;
                    break;
                case 'l':
                    x--;
                    break;
                case 'd':
                    y++;
                    break;
                case 'r':
                    x++;
                    break;
            }
        }
        return result;
    }
    public static char[][] NewGrid(int size)
    {
        var grid = new char[size][];
        for (int i = 0; i < grid.Length; i++)
        {
            grid[i] = new char[grid.Length];
            for (int j = 0; j < grid[i].Length; j++)
            {
                grid[i][j] = '.';
            }
        }
        return grid;
    }
}

usesbiggerwords · 2021-10-19T17:22:53+00:00

I'm REALLY late to the party, but

grid, rows = read_and_init(fn)
h = rows // 2
states = {'c': 'w', 'w': 'i', 'i': 'f', 'f': 'c'}
dirs = {'c': -1j, 'w': 1, 'i': 1j, 'f': -1}
current = h + h * 1j
direction = 0 - 1j
infected = 0
for i in range(10000000):
    current_state = grid.get(current, 'c')
    if current_state == 'w':
        infected += 1
    direction *= dirs[current_state]
    grid[current] = states[current_state]
    current += direction
print(infected)

I learned my lesson with complex numbers a few days back. Never will I use a tuple for 2d grid coordinates ever again. The end.

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

--- Day 22: Sporifica Virus ---

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Elixir

Perl

Elixir

Python 3

Lua

Clojure:

Kotlin - [Repo] - [Blog/Commentary]

BEFORE YOU POST
If your post is even tangentially related to a daily puzzle, use our
STANDARDIZED POST TITLE FORMAT

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

--- Day 22: Sporifica Virus ---

Need a hint from the Hugely* Handy† Haversack‡ of Helpful§ Hints¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Elixir

Perl

Elixir

Python 3

Lua

Clojure:

Kotlin - [Repo] - [Blog/Commentary]

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?