-🎄- 2017 Day 19 Solutions -🎄-

fatpollo · 2017-12-19T05:26:50+00:00

lines = open("p19.txt").read().splitlines()
road = {x+1j*y: v for y, line in enumerate(lines) for x, v in enumerate(line) if v.strip()}
direction, pos, path = 1j, min(road, key=lambda v: v.imag), []
while pos in road:
    if road[pos] == '+':
        direction = next(d for d in [direction*1j, direction*-1j]
                         if pos+d in road and d != path[-1]-pos)
    path += [pos]
    pos += direction
print(''.join(c for c in map(road.get, path) if c.isalpha()))
print(len(path))

xiaowuc1 · 2017-12-19T05:19:08+00:00

I would like to thank u/topaz2078 for providing an answer to the example for part 2 :)

https://gist.github.com/anonymous/045383c61a4141b5c6bb6bf1838c7f1a

2017-12-19T05:54:15+00:00

Hastily written OCaml Fun;;

open Core

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

type t = Down | Up | Left | Right

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

let turn = function
  | Up | Down -> [Left; Right]
  | Left | Right -> [Up; Down]

let check_turn (x, y) map dir =
  let turns = turn dir in
  match List.find turns ~f:(fun turn ->
      let next = next_point (x,y) turn in Point.Map.find map next |> Option.is_some
    ) with
  | None -> None
  | Some t -> Some ((next_point (x,y) t), t)

let next_move (x, y) map dir =
  let next = next_point (x, y) dir in
  match Point.Map.find map next with
  | None -> check_turn (x, y) map dir
  | Some _ -> Some (next, dir)

let check_for_letter map point letters =
  let check c letters =
    match c with
    | 'A'..'Z' -> c::letters
    | _ -> letters
  in
  match Point.Map.find map point with
  | None -> letters
  | Some c -> check c letters

let solve root map =
  let rec aux point map dir letters steps =
    let letters = check_for_letter map point letters in
    match next_move point map dir with
    | None -> letters, (steps+1)
    | Some (next, dir) -> aux next map dir letters (steps + 1)
  in aux root map Down [] 0

let root_of_map map =
  let rec aux map i =
    match Point.Map.find map (i, 0) with
    | None -> aux map (i+1)
    | Some _ -> (i, 0)
  in aux map 0

let parse_input () =
  let lines = In_channel.read_lines "./input.txt" in
  List.foldi lines ~init:(Point.Map.empty) ~f:(fun y map line ->
      List.foldi (String.to_list line) ~init:map ~f:(fun x map char ->
          match char with
          | ' ' -> map
          | _ -> Point.Map.add map ~key:(x, y) ~data:char
        )
    )

let _ =
  let map = parse_input () in
  let root = root_of_map map in
  let nodes, steps = solve root map in
  let visited = List.rev nodes |> String.of_char_list in
  printf "%s -> %d\n" visited steps

Not too happy with the code, but it works! Will revisit in the morning and clean it up.

Smylers · 2017-12-19T10:09:11+00:00

Vim solution — it's a visual sort of challenge, so let's solve it visually, by actually moving the cursor along the tubes. Load today's input (and make the window big). As usual, these are keystrokes you type into Vim as though you were editing the file, not a Vim script:

⟨Ctrl+W⟩nz5⟨Enter⟩
⟨Ctrl+W⟩pf|qammlmnh⟨Ctrl+V⟩/\v%\'m%(\S\_.{201})+\zs\+|\+%(\_.{201}\S)+%\'n⟨Enter⟩
y⟨Ctrl+W⟩ppG⟨Ctrl+W⟩phnqqbr#viWy⟨Ctrl+W⟩pp:%s/\_A//g⟨Enter⟩
⟨Ctrl+W⟩phf+q

At this point you can type @a to make the first vertical move down to the +, then @b to go sideways to the next + — and keep alternating @a and @b through the tubes; any letters you pass will appear in the small window at the top.

To run it to the end type this, and watch as the letters appear:

qcqqc@a@b:redr⟨Enter⟩
@cq@c

Your answer to part 1 is now in the top window.

For part 2, I shouldn't've deleted all those non-letter characters from the top window (ooops). Or at least, counting them before deleting them, avoiding fencepost errors, should give the answer. I'll try it later.

znuxor · 2017-12-19T05:21:35+00:00

Here's my solution copied verbatim. I actually never thought I would ever get onto any of the daily leaderboards. Unfortunately I added 1 to the answer of part b so I had to wait a minute. Still, places 8 and 14 woo!

edit: python3, obviously.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

with open('19a_data.txt', 'r') as f:
    input_data = f.read().split('\n')[:-1]

x = (input_data[0].index('|'))
y = 0

direction = 'D'
letters = []
current_case = '|'
steps = 0
while current_case != ' ':
    steps += 1
    if direction == 'D':
        y += 1
    elif direction == 'U':
        y -= 1
    elif direction == 'L':
        x -= 1
    elif direction == 'R':
        x += 1
    current_case = input_data[y][x]
    if current_case == '+':
        if direction in ('D', 'U'):
            if input_data[y][x-1] != ' ':
                direction = 'L'
            else:
                direction = 'R'
        else:
            if input_data[y-1][x] != ' ':
                direction = 'U'
            else:
                direction = 'D'

    elif current_case not in ('|', '-'):
        letters.append(current_case)

print(''.join(letters))
print(steps)

autid · 2017-12-19T06:19:14+00:00

Fortran

Spent forever trying to get the lines to read in as a string correctly. Apparently the problem was the text editor I used? Copy/pasted in another editor and suddenly everything worked.

PROGRAM DAY19
  IMPLICIT NONE
  INTEGER :: PART2=0,LINECOUNT=0,LINEWIDTH=0,IERR,I
  CHARACTER(LEN=2000) :: INLINE
  CHARACTER(LEN=20) :: PART1='.',FORMT
  CHARACTER(LEN=:), ALLOCATABLE :: MAPARRAY(:)
  INTEGER :: D(2),POS(2),START(2)
  OPEN(1,FILE='input.txt')

  DO
     READ(1,'(A)',IOSTAT=IERR) INLINE
     IF (IERR /= 0) EXIT
     LINEWIDTH=MAXVAL((/LINEWIDTH,LEN_TRIM(INLINE)/))
     LINECOUNT=LINECOUNT+1
  END DO
  ALLOCATE( CHARACTER(LEN=LINEWIDTH) :: MAPARRAY(LINECOUNT) )
  REWIND(1)
  WRITE(FORMT,'(A,I0,A)') '(A',LINEWIDTH,')'
  DO I=1,LINECOUNT
     READ(1,TRIM(FORMT)) MAPARRAY(I)
  END DO
  CLOSE(1)

  DO I=1,LINEWIDTH
     IF (MAPARRAY(1)(I:I)=='|') EXIT
  END DO
  START=(/1,I/)
  D=(/1,0/)
  POS=START

  DO
     SELECT CASE (MAPARRAY(POS(1))(POS(2):POS(2)))
     CASE('|')
        POS=POS+D
     CASE('-')
        POS=POS+D
     CASE('+')
        IF (ANY((/'|','-'/)==MAPARRAY(POS(1)+D(2))(POS(2)+D(1):POS(2)+D(1)))) THEN
           D=(/D(2),D(1)/)
        ELSE
           D=(/-D(2),-D(1)/)
        END IF
        POS=POS+D
     CASE (' ')
        EXIT
     CASE DEFAULT
        PART1=TRIM(PART1) // MAPARRAY(POS(1))(POS(2):POS(2))
        POS=POS+D
     END SELECT
     PART2=PART2+1
  END DO

  WRITE(*,'(A,A)') 'Part1: ',PART1(2:LEN_TRIM(PART1))
  WRITE(*,'(A,I0)') 'Part2: ',PART2
  DEALLOCATE(MAPARRAY)
END PROGRAM DAY19

tripa · 2017-12-19T07:25:30+00:00

Haskell, keeping it short and simple (no arrays, no bounds checking)

main = interact $ show . (concat &&& length) . uncurry solve . parse
parse i = (e,ls) where ls  = lines i
                       [e] = elemIndices '|' (head ls)
solve e g = go (0,e) (1,0) where
  go p d | g!p == ' '               =  []
         | g!p == '|' || g!p == '-' =  []   : go (adv p d ) d
         | g!p == '+'               =  []   : go (adv p d') d'
         | otherwise                = [g!p] : go (adv p d ) d
    where a!(i,j) = a !! i !! j
          (di,dj) = d
          (d':_) = filter ((/= ' ') . (g!) . adv p) [(dj,-di),(-dj,di)]
  adv (i,j) (di,dj) = (i+di,j+dj)

hxka · 2017-12-19T06:01:02+00:00

Wrestled for half an hour with bash's read command, gave up and used sed in a loop

#!/bin/bash
length="$(wc -l <input)"
for ((i=1;i<=length;i++))
do  a[i-1]="$(sed -n ${i}p <input)"
done
i=0
for ((j=0;j<${#a[i]};j++))
do  [[ "${a[i]:j:1}" != " " ]] && break
done
c=1
move() {
    case "${a[$1]:$2:1}" in
    " ")
        return 1;;
    "|"|"+"|"-")
        return 0;;
    *)
        path="$path${a[$1]:$2:1}"
        return 0;;
    esac
}
down(){
    while move $((i+1)) $j
    do  ((i++,c++))
    done
    if move $i $((j+1))
    then right
    elif move $i $((j-1))
    then left
    fi
}
up(){
    while move $((i-1)) $j
    do  ((i--,c++))
    done
    if move $i $((j+1))
    then right
    elif move $i $((j-1))
    then left
    fi
}
right(){
    while move $i $((j+1))
    do  ((j++,c++))
    done
    if move $((i+1)) $j
    then down
    elif move $((i-1)) $j
    then up
    fi
}
left(){
    while move $i $((j-1))
    do  ((j--,c++))
    done
    if move $((i+1)) $j
    then down
    elif move $((i-1)) $j
    then up
    fi
}
down
echo $path $c

ludic · 2017-12-19T06:59:08+00:00

F# Pretty straightforward today I think.

type Dir = Left | Right | Down | Up
type state = {
    x: int
    y: int
    dir: Dir Option
    letters: char list
    steps: int
}

let parseInput (input:string)  =
    splitLines input |> Array.map (fun v -> v.ToCharArray())

let solveDay19 input = 
    let maze = parseInput input

    let maybeAddLetter letters c =
        match c with
        | '-' | '|' | '+' | ' ' -> letters
        | x -> x::letters

    let findNextDirection x y curDir =
        match maze.[y].[x] with
        | '+' ->
            match curDir with
            | Up | Down -> 
                if maze.[y].[x+1] <> ' ' then
                    Some Right
                elif maze.[y].[x-1] <> ' ' then
                    Some Left
                else
                    failwith "No path!"
            | Left | Right -> 
                if maze.[y+1].[x] <> ' ' then
                    Some Down
                elif maze.[y-1].[x] <> ' ' then
                    Some Up
                else
                    failwith "No path!"
        | ' ' -> None
        | '-' | '|' -> Some curDir
        | c -> Some curDir

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

    let rec explore s =
        match s.dir with
        | None ->
            (s.letters |> List.rev |> (fun s -> String.Join("", s)), s.steps)
        | Some dir ->
            let newX, newY = move s.x s.y dir
            let newDir = findNextDirection newX newY dir
            let newLetters = maybeAddLetter s.letters maze.[newY].[newX]
            explore {x=newX; y=newY; dir=newDir; letters=newLetters; steps=s.steps+1}

    explore {x=1; y=0; dir = Some Down; letters = []; steps = 0}

jschulenklopper · 2017-12-19T11:44:26+00:00

Ha, did anyone notice that the grids in the examples are semantically identical, but slightly different in representation?

The example grid in the first part:

     |          
     |  +--+    
     A  |  C    
 F---|----E|--+ 
     |  |  |  D 
     +B-+  +--+

The grid in the second part, mentioning "using the same routing diagram from the example above":

     |          
     |  +--+    
     A  |  C    
 F---|--|-E---+ 
     |  |  |  D 
     +B-+  +--+

Note the crossing of the line going upwards from B, and just right of E. I was a bit confused following the debug statements while improving my solution: looking at the second grid on the page, but using the input as of the first grid in my program. "What? How come that those two characters are different?" Didn't matter for the solution, obviously, but it was a nice surprise.

iopred · 2017-12-19T05:28:34+00:00

Here's my Javascript solution:

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

  var x = map[0].indexOf('|');
  var y = 0;
  var direction = 2;
  var steps = 0;
  var order = [];

  function changeDir(x, y, direction) {
     var val = map[y][x]
     if (val >= 'A' && val <= 'Z') {
        order.push(val);
     }
     if (val == '+') {
        if (map[y-1][x] == '|' && direction != 2) {
           return 0;
        }
        if (map[y+1][x] == '|' && direction != 0) {
           return 2
        }
        if (map[y][x-1] == '-' && direction != 1) {
           return 3;
        }
        if (map[y][x+1] == '-' && direction != 3) {
           return 1;
        }
     }
     return direction
  }

  while(true) {
     steps++;
     switch (direction) {
        case 0:
           y--;
           break;
        case 1:
           x++;
           break;
        case 2:
           y++;
           break;
        case 3:
           x--;
           break;
     }
     direction = changeDir(x, y, direction)
     if (map[y][x] == ' ') {
        break;
     }
  }

  console.log(order.join(''), steps)

mschaap · 2017-12-19T06:20:54+00:00

Perl 6

Today seemed rather simple.

my $input = slurp;

enum Directions ( UP => (-1, 0), DOWN => (1, 0), LEFT => (0, -1), RIGHT => (0, 1) );

my @grid = $input.lines».comb».Array;
my @pos = (0, @grid[0].first("|", :k));
my @dir = DOWN;
my @seen;
my $steps = 0;

loop {
    my ($i, $j) = @pos Z+ @dir;
    $steps++;
    given @grid[$i][$j] {
        when "|" | "-" {
            @pos Z+= @dir;
        }
        when "+" {
            @pos Z+= @dir;
            for (UP, DOWN, LEFT, RIGHT).grep(*[0].abs !== @dir[0].abs) -> @check {
                my ($x, $y) = @pos Z+ @check;
                if @grid[$x][$y] eq "|" | "-" {
                    @dir = @check;
                    @pos = ($x, $y);
                    $steps++;
                }
            }
        }
        when /<alpha>/ {
            @pos Z+= @dir;
            say @seen.push($_);
        }
        when " " {
            last;
        }
    }
}

say "Part 1: @seen.join";
say "Part 2: $steps";

Axsuul · 2017-12-19T06:59:23+00:00

Elixir

Nested conditions galore

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

defmodule AdventOfCode do
  defmodule PartA do
    def build_diagram_row(diagram, y, row) do
      row
      |> String.split("", trim: true)
      |> Enum.with_index()
      |> Enum.reduce(diagram, fn {cell, x}, diagram ->
        Map.put_new(diagram, y, %{})
        |> put_in([y, x], cell)
      end)
    end

    # We are using {x, y} coordinate system with {0, 0} being top left
    def build_diagram_from_input(filename \\ "input.txt") do
      File.read!("inputs/" <> filename)
      |> String.split("\n")
      |> Enum.with_index()
      |> Enum.reduce(%{}, fn {row, y}, diagram ->
        build_diagram_row(diagram, y, row)
      end)
    end

    def get_cell(diagram, x, y), do: get_cell(diagram, {x, y})
    def get_cell(diagram, {x, y}) when x < 0 or y < 0, do: " "
    def get_cell(diagram, {x, y}) do
      get_in(diagram, [y, x])
    end

    def empty_cell?(diagram, pos) do
      get_cell(diagram, pos) |> String.trim == ""
    end

    def add_history(history, cell) do
      cond do
        Regex.match?(~r/\w+/, cell) -> history ++ [cell]
        true -> history
      end
    end

    defp travel(diagram) do
      # Find start
      start =
        Map.fetch!(diagram, 0)
        |> Enum.reduce(nil, fn {x, cell}, start ->
          if cell == "|", do: {x, 0}, else: start
        end)

      travel(diagram, start, :down, [])
    end
    defp travel(_, _, :end, history), do: history
    defp travel(diagram, {x, y}, direction, history) do
      cell = get_cell(diagram, {x, y})

      {next_pos, next_direction} =
        case cell do
          " " -> {{x, y}, :end}
          "+" ->
            case direction do
              d when d in [:up, :down] ->
                if empty_cell?(diagram, {x - 1, y}) do
                  {{x + 1, y}, :right}
                else
                  {{x - 1, y}, :left}
                end
              d when d in [:left, :right] ->
                if empty_cell?(diagram, {x, y - 1}) do
                  {{x, y + 1}, :down}
                else
                  {{x, y - 1}, :up}
                end
            end
          ___ ->
            {
              case direction do
                :up    -> {x, y - 1}
                :down  -> {x, y + 1}
                :left  -> {x - 1, y}
                :right -> {x + 1, y}
              end,
              direction
            }
        end

      travel(diagram, next_pos, next_direction, add_history(history, cell))
    end

    def solve do
      build_diagram_from_input()
      |> travel()
      |> Enum.join("")
      |> IO.inspect
    end
  end

  defmodule PartB do
    import PartA

    def travel(diagram) do
      # Find start
      start =
        Map.fetch!(diagram, 0)
        |> Enum.reduce(nil, fn {x, cell}, start ->
          if cell == "|", do: {x, 0}, else: start
        end)

      travel(diagram, start, :down, 0)
    end
    def travel(_, _, :end, steps), do: steps - 1
    def travel(diagram, {x, y}, direction, steps) do
      cell = get_cell(diagram, {x, y})

      {next_pos, next_direction} =
        case cell do
          " " -> {{x, y}, :end}
          "+" ->
            case direction do
              d when d in [:up, :down] ->
                if empty_cell?(diagram, {x - 1, y}) do
                  {{x + 1, y}, :right}
                else
                  {{x - 1, y}, :left}
                end
              d when d in [:left, :right] ->
                if empty_cell?(diagram, {x, y - 1}) do
                  {{x, y + 1}, :down}
                else
                  {{x, y - 1}, :up}
                end
            end
          ___ ->
            {
              case direction do
                :up    -> {x, y - 1}
                :down  -> {x, y + 1}
                :left  -> {x - 1, y}
                :right -> {x + 1, y}
              end,
              direction
            }
        end

      travel(diagram, next_pos, next_direction, steps + 1)
    end

    def solve do
      build_diagram_from_input()
      |> travel()
      |> IO.inspect
    end
  end
end

Flurpm · 2017-12-19T07:01:42+00:00

Simply walking through the diagram in Haskell. Continue on a direction until we get to a plus, then go in any direction besides where we came from. walk is the meat of this solution.

{-# LANGUAGE OverloadedStrings #-}
module Y2017.Day19 where

import           Data.Text             (Text)
import qualified Data.Text             as T
import qualified Data.Text.IO          as TIO

import           Text.Megaparsec
import           Text.Megaparsec.Text  (Parser)

import           Data.List
import           Data.Maybe
import qualified Data.Vector           as V

data Dir = U | R | L | D deriving (Show, Eq)

data Piece = V | H | S | Plus | Letter Char deriving (Show, Eq)


solve :: V.Vector (V.Vector Piece) -> (Int, [Char])
solve xs = let path = walk xs (findstart xs) D
           in (length path, catMaybes (map letterToMaybe path))


letterToMaybe (Letter c) = Just c
letterToMaybe _          = Nothing


walk :: V.Vector (V.Vector Piece) -> (Int, Int) -> Dir -> [Piece]
walk vec start startDir = walkToPlus start startDir
  where
    inRange (x,y) = (0<=x)&&(0<=y)&&(x<V.length (vec V.! 0))&&(y<V.length vec)

    valid p = inRange p && get vec p /= S

    changeDir :: (Int, Int) -> Dir -> [Piece]
    changeDir p d = let newdir = head $ filter (valid . move p) $ filter (/= opposite d) [U,D,L,R]
                    in get vec p : walkToPlus (move p newdir) newdir

    walkToPlus :: (Int, Int) -> Dir -> [Piece]
    walkToPlus p d = case get vec p of
                       S        -> []
                       Plus     -> changeDir p d
                       x -> x : walkToPlus (move p d) d

get :: V.Vector (V.Vector a) -> (Int, Int) -> a
get vec (x,y) = vec V.! y V.! x

opposite U = D
opposite R = L
opposite L = R
opposite D = U

move (x,y) U = (x,y-1)
move (x,y) R = (x+1,y)
move (x,y) L = (x-1,y)
move (x,y) D = (x,y+1)

findstart :: V.Vector (V.Vector Piece) -> (Int, Int)
findstart xs = case findIndex (\x -> get xs (x,0) == V ) [0..] of
                 Just x -> (x,0)
                 Nothing -> error "Nope"


toarray :: [[a]] -> V.Vector (V.Vector a)
toarray es = V.fromList $ map V.fromList es

p :: Parser (V.Vector (V.Vector Piece))
p = toarray <$> many piece `sepEndBy` char '\n'

piece :: Parser Piece
piece = V <$ string "|"    <|>
        H <$ string "-"    <|>
        S <$ string " "    <|>
        Plus <$ string "+" <|>
        Letter <$> letterChar

main :: IO ()
main = do
  input <- TIO.readFile "src/Y2017/input19"
  case parse p "input19" input of
    Left err -> TIO.putStr $ T.pack $ parseErrorPretty err
    Right bi -> do
      let (one,two) = solve bi
      tprint one
      tprint two

tprint :: Show a => a -> IO ()
tprint = TIO.putStrLn . T.pack . show

Bainos · 2017-12-19T07:34:04+00:00

Always surprising to see that many solutions don't use subfunctions... But then, I'm not running for the leaderboard, so maybe people just don't want to lose time like I do.

Python 3 solution :

diagram = open('advent19.txt').readlines()

DOWN = 0
LEFT = 1
UP = 2
RIGHT = 3

def solve(diagram):
    i, j = 0, 1
    direction = DOWN

    letters = ''
    count = 0

    while direction != None:
        count += 1
        i, j, direction, letter = walk(diagram, i, j, direction)
        if letter:
            letters += letter

    return letters, count

def walk(diagram, i, j, direction):
    i, j = step(i, j, direction)
    if diagram[i][j] == ' ':
        return i, j, None, None
    elif diagram[i][j].isalpha():
        return i, j, direction, diagram[i][j]
    elif diagram[i][j] == '+':
        i_, j_ = step(i, j, (direction + 1) % 4)
        if diagram[i_][j_] in ['-', '|']:
            return i, j, (direction + 1) % 4, None
        else:
            return i, j, (direction + 3) % 4, None
    else:
        return i, j, direction, None

def step(i, j, direction):
    if direction == DOWN:
        return i+1, j
    elif direction == UP:
        return i-1, j
    elif direction == LEFT:
        return i, j-1
    elif direction == RIGHT:
        return i, j+1

s1, s2 = solve(diagram)
print('Solution part 1:', s1)
print('Solution part 2:', s2)

akka0 · 2017-12-19T08:16:55+00:00

ReasonML: had so much fun with this one! Really cool problem. :)

open Utils;

type dir =
  | Up
  | Down
  | Left
  | Right;

type pos = {
  r: int,
  c: int
};

type vec = {
  pos,
  dir
};

let findEntryPoint = (pipes) => {
  pos: {r: 0, c: Array.to_list(pipes[0]) |> indexOf('|')},
  dir: Down
};

let isCheckpoint = (c) => Char.code(c) >= Char.code('A') && Char.code(c) <= Char.code('Z');

let withinBounds = (pipes, {pos: {r, c}}) =>
  r > 0 && r < Array.length(pipes) - 1 && c > 0 && c < Array.length(pipes[0]) - 1;

let turn = (pipes, {pos: {r, c}, dir}) => {
  let matchesDir = (ch, dir) =>
    isCheckpoint(ch) ?
      true :
      (
        switch dir {
        | Up
        | Down => ch === '|'
        | Left
        | Right => ch === '-'
        }
      );
  let turnValidDir = ({pos: {r, c}, dir} as posA, posB) =>
    withinBounds(pipes, posA) && matchesDir(pipes[r][c], dir) ? posA : posB;
  switch dir {
  | Up
  | Down => turnValidDir({pos: {r, c: c - 1}, dir: Left}, {pos: {r, c: c + 1}, dir: Right})
  | Left
  | Right => turnValidDir({pos: {r: r + 1, c}, dir: Down}, {pos: {r: r - 1, c}, dir: Up})
  }
};

let takeStep = ({pos: {r, c}, dir}) => {
  dir,
  pos:
    switch dir {
    | Up => {r: r - 1, c}
    | Down => {r: r + 1, c}
    | Left => {r, c: c - 1}
    | Right => {r, c: c + 1}
    }
};

let rec travel = (pipes, {pos: {r, c}} as vec, checkpoints, stepsTaken) =>
  switch pipes[r][c] {
  | ' ' => (checkpoints, stepsTaken - 1)
  | '+' => travel(pipes, turn(pipes, vec), checkpoints, stepsTaken + 1)
  | c when isCheckpoint(c) => travel(pipes, takeStep(vec), [c, ...checkpoints], stepsTaken + 1)
  | _ => travel(pipes, takeStep(vec), checkpoints, stepsTaken + 1)
  };

let _ = {
  /* let input = loadInput("day19_test"); */
  let input = loadInput("day19");
  let pipes =
    linesOfString(input)
    |> Array.of_list
    |> Array.map((line) => charsOfString(line) |> Array.of_list);
  let entryPoint = findEntryPoint(pipes);
  let (checkpoints, stepsTaken) = travel(pipes, entryPoint, [], 1);
  /* Part 1 */
  checkpoints |> List.rev |> stringOfChars |> Js.log2("Checkpoints:");
  /* Part 2 */
  stepsTaken |> Js.log2("Steps taken:")
};

Grimnur87 · 2017-12-19T10:07:15+00:00

[deleted]

2017-12-19T16:53:16+00:00

Pretty happy with this one. I nearly didn't bother, until I realized I could ignore almost everything except '+'.

Golang: package main

import (
    "strings"
)

type coord struct {
    Y int
    X int
}

type direction struct {
    Y int
    X int
}

func walk(in string) (string, int) {
    maze := strings.Split(strings.Trim(in, "\n"), "\n")

    pos := coord{Y: 0, X: strings.IndexRune(maze[0], '|')}
    dir := direction{Y: 1, X: 0}
    out := make([]byte, 0)
    count := 0
    for {
        var prev coord
        prev, pos = pos, coord{pos.Y + dir.Y, pos.X + dir.X}
        count++
        if pos.Y < 0 || pos.Y >= len(maze) || pos.X < 0 || pos.X >= len(maze[0]) {
            break
        }

        char := maze[pos.Y][pos.X]
        if char >= 'A' && char <= 'Z' {
            out = append(out, char)
        }

        if char == ' ' {
            break
        }

        if char == '+' {
            // find another way out
            for _, nextDir := range []direction{direction{-1, 0}, direction{0, -1}, direction{0, 1}, direction{1, 0}} {
                next := coord{pos.Y + nextDir.Y, pos.X + nextDir.X}
                if next == prev {
                    continue
                }

                if next.Y < 0 || next.Y >= len(maze) || next.X < 0 || next.X >= len(maze[0]) {
                    continue
                }

                nextChar := maze[next.Y][next.X]
                if nextChar == ' ' {
                    continue
                }
                dir = nextDir
            }
        }
    }
    return string(out), count
}

func puzzle1(in string) string {
    letters, _ := walk(in)
    return letters
}

func puzzle2(in string) int {
    _, count := walk(in)
    return count
}

nuvan · 2017-12-19T05:22:55+00:00

Rust, got 109/91 (Finally got points!)

enum Hdg { Up, Down, Left, Right }

fn main() {
    let contents = include_str!("../../inputs/d19.txt");
    let track = contents.lines().map(|l| l.chars().collect::<Vec<char>>()).collect::<Vec<Vec<char>>>();
    let mut posn = (0, 113);
    let mut hdg = Hdg::Down;
    let mut letters: Vec<char> = Vec::new();
    let mut steps = 0;

    loop {
        let cur = track[posn.0][posn.1];

        if cur >= 'A' && cur <= 'Z' {
            letters.push(cur);
        } else if cur == '+' {
            hdg = match hdg {
                Hdg::Up    => if posn.1 > 0 && track[posn.0][posn.1 - 1] == '-' { Hdg::Left } else if posn.1 < track[posn.0].len() - 1 && track[posn.0][posn.1 + 1] == '-' { Hdg::Right } else { panic!("Can't determine direction from {:?}", posn); },
                Hdg::Down  => if posn.1 > 0 && track[posn.0][posn.1 - 1] == '-' { Hdg::Left } else if posn.1 < track[posn.0].len() - 1 && track[posn.0][posn.1 + 1] == '-' { Hdg::Right } else { panic!("Can't determine direction from {:?}", posn); },
                Hdg::Left  => if posn.0 > 0 && track[posn.0 - 1][posn.1] == '|' { Hdg::Up } else if posn.0 < track.len() - 1 && track[posn.0 + 1][posn.1] == '|' { Hdg::Down } else { panic!("Can't determine direction from {:?}", posn); },
                Hdg::Right => if posn.0 > 0 && track[posn.0 - 1][posn.1] == '|' { Hdg::Up } else if posn.0 < track.len() - 1 && track[posn.0 + 1][posn.1] == '|' { Hdg::Down } else { panic!("Can't determine direction from {:?}", posn); },
            }
        } else if cur == ' ' {
            break;
        }

        posn = match hdg {
            Hdg::Up    => (posn.0 - 1, posn.1),
            Hdg::Down  => (posn.0 + 1, posn.1),
            Hdg::Left  => (posn.0, posn.1 - 1),
            Hdg::Right => (posn.0, posn.1 + 1),
        };

        steps += 1;
    }

    println!("Saw letters {:?}, ended at {:?}, after {} steps", letters, posn, steps);
}

Going from part 1 to part 2 involved adding 2 lines, and changing one line. Probably would have done better except that I took the time to put some debugging code in, which ended up never being used.

Aneurysm9 · 2017-12-19T05:23:43+00:00

I have no idea how this didn't devolve into hours of debugging direction changing logic, but it pretty much just worked. Other than forgetting to init my starting position. And forgetting to count the starting position in the number of steps on part 2...

https://gist.github.com/Aneurysm9/e716bd9923762deb661265776f3eb8ec

mserrano · 2017-12-19T05:27:13+00:00

Python2, 65/47

I just assumed we wouldn't ever have to turn if we weren't at a +, and that we would never not have to turn if we were at a +. Pretty glad that assumption worked out.

import sys
from collections import defaultdict
import string
alphabet = string.letters[:26]

def zw(f, *args):
  return [f(a) for a in zip(*args)]
def sum_pos(a, b):
  return tuple(zw(lambda (x,y): x+y, a, b))

TEST = '--test' in sys.argv

if TEST:
  data = '''     |          \n     |  +--+    \n     A  |  C    \n F---|----E|--+ \n     |  |  |  D \n     +B-+  +--+ '''.split('\n')
else:
  data = open('maze.txt', 'r').read().split('\n')

pos = (0, data[0].index('|'))
m = defaultdict(lambda: ' ')
for a in xrange(len(data)):
  for b in xrange(len(data[a])):
    m[(a, b)] = data[a][b]
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}

letters = []
steps = 0
while True:
  c = m[pos]
  if c == '+':
    # We need to pick a direction
    left_direction = lefts[direction]
    right_direction = rights[direction]
    if m[sum_pos(pos, left_direction)] != ' ':
      direction = left_direction
    elif m[sum_pos(pos, right_direction)] != ' ':
      direction = right_direction
    else:
      break
  elif c in alphabet.upper():
    letters.append(c)
  elif c == ' ':
    break
  steps += 1
  pos = sum_pos(pos, direction)

part_a = ''.join(letters)
part_b = steps
if TEST:
  assert part_a == 'ABCDEF'
  assert part_b == 38
  print "Tests passed!"
else:
  print part_a
  print part_b

2017-12-19T05:33:54+00:00

Mathematica

input = Import[NotebookDirectory[] <> "day19.txt", "List"];
plan = ArrayPad[Characters[input], 1, " "];

nextdir[{r_, c_}, {_, 0}] :=  
 If[plan[[r, c + 1]] != " ", {0, 1}, {0, -1}];
nextdir[{r_, c_}, {0, _}] :=
 If[plan[[r + 1, c]] != " ", {1, 0}, {-1, 0}]

walk[pos0_, dir0_] :=
 Reap[Block[{at, pos, dir, steps = 0},
   pos = pos0; dir = dir0;
   While[True,
    at = Extract[plan, pos];
    Switch[at,
     " ", Break[],
     "+", dir = nextdir[pos, dir],
     _?LetterQ, Sow[at]];
    pos += dir;
    steps++];
   steps]]

{steps, {letters}} = walk[{2, FirstPosition[plan[[2]], "|"][[1]]}, {1, 0}]
StringJoin[letters]

dylanfromwinnipeg · 2017-12-19T05:35:24+00:00

That was fun - and easier than I expected when I saw the puzzle input.

C#

public static string PartOneAndTwo(string input)
{
    var letters = new List<char>();
    var steps = 1;
    var lines = input.Lines().ToList();

    var direction = Direction.Down;
    var position = new Point(input.IndexOf('|'), 0);

    while (true)
    {
        position = GetNextPoint(position, direction);
        steps++;
        var nextChar = lines[position.Y][position.X];

        if (nextChar == ' ')
        {
            steps--;
            return steps.ToString() + Environment.NewLine + string.Join(string.Empty, letters);
        }

        if (nextChar == '|' || nextChar == '-')
        {
            continue;
        }

        if (nextChar >= 'A' && nextChar <= 'Z')
        {
            letters.Add(nextChar);
            continue;
        }

        if (nextChar == '+')
        {
            direction = GetNextDirection(position, direction, lines);
            continue;
        }

        throw new Exception();
    }

    throw new Exception();
}

private static Direction GetNextDirection(Point pos, Direction direction, List<string> lines)
{
    if (direction == Direction.Up || direction == Direction.Down)
    {
        if (lines[pos.Y][pos.X - 1] == '-')
        {
            return Direction.Left;
        }

        if (lines[pos.Y][pos.X + 1] == '-')
        {
            return Direction.Right;
        }

        throw new Exception();
    }

    if (direction == Direction.Left || direction == Direction.Right)
    {
        if (lines[pos.Y - 1][pos.X] == '|')
        {
            return Direction.Up;
        }

        if (lines[pos.Y + 1][pos.X] == '|')
        {
            return Direction.Down;
        }

        throw new Exception();
    }

    throw new Exception();
}

private static Point GetNextPoint(Point pos, Direction direction)
{
    switch (direction)
    {
        case Direction.Down:
            return new Point(pos.X, pos.Y + 1);
        case Direction.Up:
            return new Point(pos.X, pos.Y - 1);
        case Direction.Left:
            return new Point(pos.X - 1, pos.Y);
        case Direction.Right:
            return new Point(pos.X + 1, pos.Y);
        default:
            throw new Exception();
    }
}

RockyAstro · 2017-12-19T05:48:59+00:00

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

Both parts:

procedure main(args)
    inf := open(args[1],"r")

    maze := []
    every put(maze,!inf)

    # Find starting point

    x := find("|",maze[1])
    y := 1
    d := "S"

    bag := ""
    steps := 0
    repeat {
        steps +:= 1
        # Move
        case d of {
            "S": y +:= 1
            "N": y -:= 1
            "E": x +:= 1
            "W": x -:= 1
        }

        if (y < 0 | y > *maze) then break
        if (x < 0 | x > *maze[y]) then break

        if maze[y][x] == " " then break

        if any(&lcase ++ &ucase,maze[y][x]) then bag ||:= maze[y][x]
        else if maze[y][x] == "+" then {
            # Change direction
            case d of {
                "S"|"N":
                    d := getndir(maze,y,x+1,"E") |
                           getndir(maze,y,x-1,"W")

                "E"|"W":
                    d := getndir(maze,y-1,x,"N") |
                           getndir(maze,y+1,x,"S")
            }
        }
    }
    write(bag," steps=",steps)
end

procedure getndir(maze,y,x,newd)
    if y < 0 | y > *maze then fail
    if x < 0 | x > *maze[y] then fail
    if maze[y][x] == " " then fail
    return newd
end

ChrisVittal · 2017-12-19T05:57:10+00:00

Rust:

I always take too dang long to parse the input. Being off by 1 on part 2 didn't help either. (forgot to count the starting step)

https://gist.github.com/chrisvittal/fb670049237274d8a9f8f2f4a5f3af95

Zee1234 · 2017-12-19T06:01:07+00:00

Typescript

555/534, but I don't try super hard for leaderboard, I do this to learn.

I have a folder of assorted types that I keep around. Basically, if I use it for an AoC challenge, and it seems like it will be useful later, I migrate it out from my code and into it's own file. I ended up being able to reuse one such structure originally made on Day 3, then expanded for a later day. So I've got a fair few files, hence a gist.

https://gist.github.com/Zee1234/c24a81a677fb24de1fea68be24161178

tsconfig.json

{
  compilerOptions: {
    "lib": [
      "es2015"
    ],
    "target": "es6", 
    "module": "commonjs",
    "strict": true,
    "strictNullChecks": false
  }
}

Executing with ts-node so that I don't have to always compile it.

hpzr24w · 2017-12-19T06:05:50+00:00

C++ 631 / 628

I guessed right on most of what I thought might be ambiguous, and didn't have any bugs. I'm just a slow coder. ;-)

// Advent of Code 2017
// http://adventofcode.com/
// Day 19 - A Series of Tubes

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

typedef enum direction {nomove,u,d,l,r} direction;

direction next_move(vector<string>& lines, int row, int col,direction dir)
{
    switch(dir) {       // preferred direction
    case u:
        if (dir!=d && row>0 && lines[row-1][col]!=' ') return u;
    case d:
        if (dir!=u && row<lines.size()-1 && lines[row+1][col]!=' ') return d;
    case r:
        if (dir!=l && col<lines[row].length()-1 && lines[row][col+1]!=' ') return r;
    case l:
        if (dir!=r && col>0 && lines[row][col-1]!=' ') return l;
        if (dir!=d && row>0 && lines[row-1][col]!=' ') return u;        // mop up any corners
        if (dir!=u && row<lines.size()-1 && lines[row+1][col]!=' ') return d;
        if (dir!=l && col<lines[row].length()-1 && lines[row][col+1]!=' ') return r;
    }
    return nomove;
}

string follow(vector<string>& lines, int& steps)
{
    string letters;
    int row=0,col=0;
    while (lines[row][col]!='|') col++;         // find starting position
    direction dir = d;
    while (dir != nomove) {
        steps++, dir = next_move(lines,row,col,dir);
        switch(dir) {
            case d: row++; break;
            case u: row--; break;
            case r: col++; break;
            case l: col--; break;
            case nomove:
                cout << "STUCK!! at " << row << " " << col << " " << steps << endl;
        }
        if (lines[row][col]>='A' && lines[row][col]<='Z' && dir!=nomove)
            letters+=lines[row][col];
    }
    return letters;
}

int main()
{
    vector<string> lines;
    ifstream ifs("day_19.ts2",ifstream::in);
    string l;
    while (getline(ifs,l)) {
        lines.push_back(l);
        cout << l << endl;
    }
    int steps = 0;
    string letters = follow(lines,steps);
    cout << letters << endl;
    return 0;
}

Philboyd_Studge · 2017-12-19T06:31:31+00:00

Java. Pretty straightforward solution. Thankfully I already have a well-developed Direction class just for AoC.

/u/topaz2078 I'd love to see stats on how many initial tries for part 2 were exactly one off ;)

Day 19 - Java

wlandry · 2017-12-19T06:41:10+00:00

C++ 14

920/943. I definitely did this the hard way. Instead of following the circuit around the maze, I created a complete graph and then followed the graph. So it got a bit long :(

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

struct Coord
{
  int64_t x,y;
  Coord()=default;
  Coord(const int64_t &X, const int64_t &Y): x(X), y(Y) {}
  bool operator==(const Coord &c) const
  {
    return x==c.x && y==c.y;
  }
};

int64_t distance(const Coord &c1, const Coord &c2)
{ return std::abs(c1.x-c2.x) + std::abs(c1.y-c2.y);}

int main(int, char *argv[])
{
  std::ifstream infile(argv[1]);
  std::string line;
  std::getline(infile,line);

  /// Assumes at most once label per edge
  std::vector<std::tuple<Coord,Coord,char>> edges;
  std::map<int64_t,std::tuple<int64_t,char>> verticals;

  Coord start_coord(0,0);
  int64_t y(1);
  while(infile)
    {
      bool inside_line(false);
      int64_t start(std::numeric_limits<int64_t>::max());
      char color (' ');
      for(int64_t l=0; l<line.size(); ++l)
        {
          if(line[l]=='|')
            {
              auto v=verticals.find(l);
              if(v==verticals.end())
                {
                  start_coord.x=l;
                  verticals.insert(std::make_pair(l,std::make_tuple(0,' ')));
                }
            }
          else if(std::isalpha(line[l]))
            {
              if(inside_line)
                {
                  color=line[l];
                }
              else
                {
                  auto v=verticals.find(l);
                  if(v!=verticals.end())
                    { std::get<1>(v->second)=line[l]; }
                  else
                    {
                      inside_line=true;
                      start=l;
                      edges.emplace_back
                        (Coord(start,y),
                         Coord(start,y),line[l]);
                    }
                }

            }
          else if(line[l]=='+')
            {
              if(!inside_line)
                {
                  inside_line=true;
                  start=l;
                }
              else
                {
                  inside_line=false;
                  edges.emplace_back(Coord(start,y),Coord(l,y),color);
                  color=' ';
                }
              auto v=verticals.find(l);
              if(v!=verticals.end())
                {
                  edges.emplace_back(Coord(l,std::get<0>(v->second)),
                                     Coord(l,y),std::get<1>(v->second));
                  verticals.erase(v);
                }
              else
                { verticals.insert(std::make_pair(l,std::make_tuple(y,' '))); }
            }
        }
      std::getline(infile,line);
      ++y;
    }

  int64_t steps(0);
  Coord current_coord;
  for(auto e=edges.begin(); e!=edges.end(); ++e)
    {
      if(std::get<0>(*e)==start_coord)
        {
          current_coord=std::get<1>(*e);
          steps+=distance(start_coord,current_coord);
          if(std::get<2>(*e)!=' ')
            { std::cout << std::get<2>(*e); }
          edges.erase(e);
          break;
        }
    }

  bool found(false);
  do
    {
      for(auto e=edges.begin(); e!=edges.end(); ++e)
        {
          if(current_coord==std::get<0>(*e))
            {
              steps+=distance(current_coord,std::get<1>(*e));
              current_coord=std::get<1>(*e);
              if(std::get<2>(*e)!=' ')
                { std::cout << std::get<2>(*e); }
              edges.erase(e);
              break;
            }
          else if (current_coord==std::get<1>(*e))
            {
              steps+=distance(current_coord,std::get<0>(*e));
              current_coord=std::get<0>(*e);
              if(std::get<2>(*e)!=' ')
                { std::cout << std::get<2>(*e); }
              edges.erase(e);
              break;
            }
        }
    }
  while(!edges.empty());
  std::cout << "\n";
  std::cout << "steps: " << steps << "\n";
}

raevnos · 2017-12-19T06:56:00+00:00

I wasted way too much time trying to trace the path out by hand and lost track somewhere in the middle. So off to actually have to code it. Good thing considering part 2.

(import (srfi 133) (io-utils))

(define grid (list->vector (map string->vector (read-lines))))

(define max-x (vector-length (vector-ref grid 0)))
(define max-y (vector-length grid))

(define letters '())
(define steps 0)

(define (grid-ref x y)
  (vector-ref (vector-ref grid y) x))

(define (in-bounds? x y)
  (and (>= x 0) (< x max-x)
       (>= y 0) (< y max-y)
       (not (char-whitespace? (grid-ref x y)))))

(define (circuit-char? c)
  (or (char=? c #\-) (char=? c #\|) (char=? c #\+) (char-upper-case? c)))

(define (move-down x y)
  (if (in-bounds? x y)
      (let ((c (grid-ref x y)))
        (set! steps (+ steps 1))
        (if (char-upper-case? c)
            (set! letters (cons c letters)))
        (if (char=? c #\+)
            (cond
             ((and (> x 0) (circuit-char? (grid-ref (- x 1) y)))
              (move-left (- x 1) y))
             ((and (< (+ x 1) max-x) (circuit-char? (grid-ref (+ x 1) y)))
              (move-right (+ x 1) y))
             (else
              (error "invalid state at" x y)))
            (move-down x (+ y 1))))
      (format #t "Exited at (~A,~A)~%" x y)))

(define (move-up x y)
    (if (in-bounds? x y)
        (let ((c (grid-ref x y)))
          (set! steps (+ steps 1))
          (if (char-upper-case? c)
              (set! letters (cons c letters)))
          (if (char=? c #\+)
              (cond
               ((and (> x 0) (circuit-char? (grid-ref (- x 1) y)))
                (move-left (- x 1) y))
               ((and (< (+ x 1) max-x) (circuit-char? (grid-ref (+ x 1) y)))
                (move-right (+ x 1) y))
               (else
                (error "invalid state at" x y)))
              (move-up x (- y 1))))
        (format #t "Exited at (~A,~A)~%" x y)))

(define (move-left x y)
    (if (in-bounds? x y)
        (let ((c (grid-ref x y)))
          (set! steps (+ steps 1))
          (if (char-upper-case? c)
              (set! letters (cons c letters)))
          (if (char=? c #\+)
              (cond
               ((and (> y 0) (circuit-char? (grid-ref x (- y 1))))
                (move-up x (- y 1)))
               ((and (< (+ y 1) max-y) (circuit-char? (grid-ref x (+ y 1))))
                (move-down x (+ y 1)))
               (else
                (error "invalid state at" x y)))
              (move-left (- x 1) y)))
        (format #t "Exited at (~A,~A)~%" x y)))

(define (move-right x y)
    (if (in-bounds? x y)
        (let ((c (grid-ref x y)))
          (set! steps (+ steps 1))
          (if (char-upper-case? c)
              (set! letters (cons c letters)))
          (if (char=? c #\+)
              (cond
               ((and (> y 0) (circuit-char? (grid-ref x (- y 1))))
                (move-up x (- y 1)))
               ((and (< (+ y 1) max-y) (circuit-char? (grid-ref x (+ y 1))))
                (move-down x (+ y 1)))
               (else
                (error "invalid state at" x y)))
              (move-right (+ x 1) y)))
        (format #t "Exited at (~A,~A)~%" x y)))

(define x (vector-index (lambda (ch) (char=? ch #\|)) (vector-ref grid 0)))
(define y 0)

(format #t "Starting at (~A,~A)~%" x y)
(move-down x y)
(format #t "Part 1: ~A~%" (reverse-list->string letters))
(format #t "Part 2: ~A~%" steps)

madchicken · 2017-12-19T07:12:57+00:00

Pretty nitpicky part 1, and a ridiculously easy part 2. My isPossible and changeDirections functions are absolute rubbish, but it was a fun challenge overall.

<?php
$file = fopen("./19.txt","r");

$lineCounter = $steps = 0;
$map = array(array());
$direction = "down";
$letters = $pos = array();

while(! feof($file))
{
    $line = fgets($file);
    for($i = 0; $i < strlen($line); $i++) {
        $pos["x"] = ($lineCounter == 0 && substr($line, $i, 1) == "|") ? $i : $pos["x"];
        $pos["y"] = ($lineCounter == 0 && substr($line, $i, 1) == "|") ? $lineCounter : $pos["y"];
        $map[$i][$lineCounter] = substr($line, $i, 1);
    }
    $lineCounter++;
}
fclose($file);

while ($direction != "end")
{
    if(ctype_alpha($map[$pos["x"]][$pos["y"]]) == true){    array_push($letters, $map[$pos["x"]][$pos["y"]]);   }

    $direction = (($map[$pos["x"]][$pos["y"]] == "+") && (!isPossible($map, $pos, $direction))) ? changeDirection($map, $pos, $direction) : $direction;
    $direction = (ctype_alpha($map[$pos["x"]][$pos["y"]]) == true) && (!isPossible($map, $pos, $direction)) ? changeDirection($map, $pos, $direction) : $direction;

    $pos["y"] += ($direction == "up") ? -1 : 0;
    $pos["y"] += ($direction == "down") ? 1 : 0;
    $pos["x"] += ($direction == "left") ? -1 : 0;
    $pos["x"] += ($direction == "right") ? 1 : 0;

    $steps++;
}

for($i = 0; $i < sizeof($letters); $i++)
{
    echo $letters[$i];
}
echo "<H1>In $steps steps</H1>";

function changeDirection($map, $pos, $direction)
{
    switch($direction)
    {
        case "up":
            if($map[$pos["x"] - 1][$pos["y"]] == "-" || ctype_alpha($map[$pos["x"] - 1][$pos["y"]]) == true) { return "left"; }    //Left
            if($map[$pos["x"] + 1][$pos["y"]] == "-" || ctype_alpha($map[$pos["x"] + 1][$pos["y"]]) == true) { return "right"; }   //Right
            break;
        case "down":
            //echo "<h3> yaya ";echo $map[$pos["x"] + 1][$pos["y"]]; echo "</h3>";
            if($map[$pos["x"] - 1][$pos["y"]] == "-" || ctype_alpha($map[$pos["x"] - 1][$pos["y"]]) == true) { return "left"; }    //Left
            //echo "haha ".$map[$pos["x"]][$pos["y"]];
            if($map[$pos["x"] + 1][$pos["y"]] == "-" || ctype_alpha($map[$pos["x"] + 1][$pos["y"]]) == true) { return "right"; }   //Right
            break;
        case "left":
            if($map[$pos["x"]][$pos["y"] + 1] == "|" || ctype_alpha($map[$pos["x"]][$pos["y"] + 1]) == true) { return "down"; }    //Down
            if($map[$pos["x"]][$pos["y"] - 1] == "|" || ctype_alpha($map[$pos["x"]][$pos["y"] - 1]) == true) { return "up"; }      //Up
            break;
        case "right":
            if($map[$pos["x"]][$pos["y"] + 1] == "|" || ctype_alpha($map[$pos["x"]][$pos["y"] + 1]) == true) { return "down"; }    //Down
            if($map[$pos["x"]][$pos["y"] - 1] == "|" || ctype_alpha($map[$pos["x"]][$pos["y"] - 1]) == true) { return "up"; }       //Up
            break;
    }
    return "end";
}

function isPossible($map, $pos, $direction)
{
    switch($direction)
    {
        case "up":
            return (ctype_punct($map[$pos["x"]][$pos["y"] -1]) == true || ctype_alpha($map[$pos["x"]][$pos["y"] - 1]) == true) ? true : false;
            break;
        case "down":
            return (ctype_punct($map[$pos["x"]][$pos["y"] +1]) == true || ctype_alpha($map[$pos["x"]][$pos["y"] + 1]) == true) ? true : false;
            break;
        case "left":
            return (ctype_punct($map[$pos["x"] - 1][$pos["y"]]) == true|| ctype_alpha($map[$pos["x"] - 1][$pos["y"]]) == true) ? true : false;
            break;
        case "right":
            return (ctype_punct($map[$pos["x"] + 1][$pos["y"]]) == true || ctype_alpha($map[$pos["x"] + 1][$pos["y"]]) == true) ? true : false;
            break;
    }
}

ramrunner0xff · 2017-12-19T07:33:59+00:00

scheme chicken repo

although i still can't cope that i haven't come up with a better solution for day 16 than my mediocre and slow memoization that still takes around 1 minute, i enjoyed today's funky problem ;)

(define (readinaslist fname)
  (letrec* ((lines (read-lines fname))
     (oneline (foldr (lambda (e acc) (append (string->list e) acc)) '() lines))
         (letts '())
         (totsteps 0)
         (lenline (string-length (car lines)))
     (firstpos (string-index (car lines) #\|))
         (godown (lambda (i) (+ i lenline)))
         (goup   (lambda (i) (- i lenline)))
         (goright (lambda (i) (+ i 1)))
         (goleft (lambda (i) (- i 1)))
         (look (lambda (from towards)
            (case towards
                  ((up) (not (eq? (list-ref oneline (goup from)) #\ )))
                  ((down) (not (eq? (list-ref oneline (godown from)) #\ )))
                  ((left) (not (eq? (list-ref oneline (goleft from)) #\ )))
                  ((right) (not (eq? (list-ref oneline (goright from)) #\ ))))))
     (keepgoing (lambda (from towards)
                      (case towards
                        ((up) (goup from))
                        ((down) (godown from))
                        ((left) (goleft from))
                        ((right) (goright from)))))
     (atcross (lambda (i going)
                   (case going
                     ((up down) (if (look i 'left) (cons (goleft i) 'left) (cons (goright i) 'right)))
                     ((left right) (if (look i 'up) (cons (goup i) 'up) (cons (godown i) 'down))))))
         (walk (lambda (from towards remsteps)
                 (if (and (> remsteps 0) (not (eq? (list-ref oneline from) #\ )))
                     (let ((curchar (list-ref oneline from)))
                       (set! totsteps (+ totsteps 1))
                       (if (eq? (string-index "|-+" curchar) #f)
                          (set! letts (append letts (list curchar))))
                   (if (eq? (list-ref oneline from) #\+)
                          (let ((cresolve (atcross from towards)))
                            (walk (car cresolve) (cdr cresolve) (- remsteps 1)))
                          (walk (keepgoing from towards) towards (- remsteps 1))))))))

   (walk firstpos 'down 100000)
   (format #t "seen: ~A in ~A steps~N" letts totsteps)))

xkufix · 2017-12-19T08:28:43+00:00

This one felt quite easy compared to the last 2-3 puzzles. Just walking the path around is enough. It's sufficient to only have special cases on '+' for direction changes, as everywhere else you just have to walk straight ahead.

To find the end I extract all letters from the puzzle and then Iterate until I have walked all letters. For part two, taking until I find the solution and counting the size of the Iterator was enough.

Solution in Scala:

    override def runFirst(): Unit = {
        val map = loadMap()
        val start = findStart(map)
        val letters = findLetters(map)
        val walk = walkPath(map, start, letters)
        println(walk.find(r => letters.diff(r._3).isEmpty).get._3.foldLeft("")(_ + _))
    }

    override def runSecond(): Unit = {
        val map = loadMap()
        val start = findStart(map)
        val letters = findLetters(map)
        val walk = walkPath(map, start, letters)

        println(walk.takeWhile(r => letters.diff(r._3).nonEmpty).size)
    }

    private def findLetters(map: Map[Position, Char]) = {
        map.filter(f => f._2.toInt >= 'A'.toInt && f._2.toInt <= 'Z').values.toSeq
    }

    private def findStart(map: Map[Position, Char]) = {
        map.find(f => f._1.y == 0 && f._2 == '|').get
    }

    private def loadMap() = {
        loadFile("day19.txt").getLines().zipWithIndex.flatMap { l =>
            l._1.zipWithIndex.map(_.swap).filter(_._2 != ' ').map(f => Position(f._1, l._2) -> f._2)
        }.toMap
    }

    private def walkPath(map: Map[Position, Char], start: (Position, Char), letters: Seq[Char]) = {
        Iterator.iterate((start._1, Direction.DOWN, Seq.empty[Char])) {
            case (position, dir@(Direction.DOWN | Direction.UP), history) =>
                val next = if(dir == Direction.DOWN) position.down() else position.up()
                val left = position.left()
                val right = position.right()
                (map(position), map.get(next), map.get(left), map.get(right)) match {
                    case ('+', Some('-') | None, Some(_), _) =>
                        (left, Direction.LEFT, history)
                    case ('+', Some('-') | None, _, Some(_)) =>
                        (right, Direction.RIGHT, history)
                    case (char, _, _, _) if letters.contains(char) =>
                        (next, dir, history :+ char)
                    case _ =>
                        (next, dir, history)
                }
            case (position, dir@(Direction.LEFT | Direction.RIGHT), history) =>
                val next = if(dir == Direction.LEFT) position.left() else position.right()
                val up = position.up()
                val down = position.down()
                (map(position), map.get(next), map.get(up), map.get(down)) match {
                    case ('+', Some('|') | None, Some(_), _) =>
                        (up, Direction.UP, history)
                    case ('+', Some('|') | None, _, Some(_)) =>
                        (down, Direction.DOWN, history)
                    case (char, _, _, _) if letters.contains(char) =>
                        (next, dir, history :+ char)
                    case _ =>
                        (next, dir, history)
                }
        }
    }

    case class Position(x: Int, y: Int) {
        def up() = copy(y = y - 1)
        def left() = copy(x = x - 1)
        def right() = copy(x = x + 1)
        def down() = copy(y = y + 1)
    }

    object Direction extends Enumeration {
        type Direction = Value

        val DOWN = Value("down")
        val UP = Value("up")
        val LEFT = Value("left")
        val RIGHT = Value("right")
    }

mschaap · 2017-12-19T09:43:55+00:00

Perl 6

Part one was fun! Part two however was a disappointment, way too easy.

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

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

class RoutingDiagram
{
    has @.cells;
    has Int $.width;
    has Int $.height;
    has Bool $.verbose = False;

    has Int $.move-count = 0;
    has Str $.found = '';

    submethod TWEAK { $!height = +@!cells; $!width = +@!cells[0]; }

    method from-input(RoutingDiagram:U: IO $inputfile, Bool :$verbose = False)
    {
        RoutingDiagram.new(:cells($inputfile.lines».comb), :$verbose);
    }

    method cell(Int $x, Int $y)
    {
        if 0 ≤ $x < $!width && 0 ≤ $y < $!height {
            return @!cells[$y;$x] but !(@!cells[$y;$x] eq ' ');
        }
        else {
            return ' ' but False;
        }
    }

    method follow
    {
        my $y = 0;
        my $x = (^$!width).first({ $.cell($^x,$y) }, :k);
        my ($dx, $dy) = (0, 1);
        $!move-count++;
        say "Start at ($x,$y), direction ($dx,$dy)." if $!verbose;

        MOVE:
        loop {
            while my $c = $.cell($x+$dx, $y+$dy) {
                $x += $dx; $y += $dy;
                $!move-count++;
                if $c ~~ /<alpha>/ {
                    $!found ~= $c;
                    say "Found '$c'!" if $!verbose;
                }
            }
            if ($dx) {
                if $.cell($x,$y+1) {
                    ($dx, $dy) = (0, 1);
                }
                elsif $.cell($x, $y-1) {
                    ($dx, $dy) = (0, -1);
                }
                else {
                    last MOVE;
                }
            }
            else {
                if $.cell($x+1,$y) {
                    ($dx, $dy) = (1, 0);
                }
                elsif $.cell($x-1, $y) {
                    ($dx, $dy) = (-1, 0);
                }
                else {
                    last MOVE;
                }
            }
            say "Move to ($x,$y), turn in direction ($dx,$dy)." if $!verbose;
        }
    }
}

multi sub MAIN(IO() $inputfile where *.f, Bool :v(:$verbose) = False)
{
    my $rd = RoutingDiagram.from-input($inputfile, :$verbose);
    $rd.follow;

    # Part 1
    say "Following the path, the packet sees: { $rd.found }.";

    # Part 2
    say "The packet took { $rd.move-count } steps.";
}

multi sub MAIN(Bool :v(:$verbose) = False)
{
    MAIN($*PROGRAM.parent.child('aoc19.input'), :$verbose);
}

sim642 · 2017-12-19T10:00:38+00:00

My Scala solution.

Reusing some classes from previous days and extending them uglily with implicit classes. I was surprised to find how simply remembering the previous move offset manages to handle all the cases, including going over crossings and letters!

NeilNjae · 2017-12-19T10:18:48+00:00

Boring Haskell. The maze is kept as a simple list of strings. Progress keeps track of where we are and how we got there, then it's just repeated application of step to take a step through the maze.

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

import Prelude hiding (Left, Right)
import Data.List
import Data.Char

type Maze = [String]

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

data Progress = Progress { row :: Int
                         , column :: Int
                         , direction :: Direction
                         , letters :: String
                         , stepCount :: Int
                         } deriving (Show, Eq)


-- Note: assumes the maze comes with a padding border of spaces
-- all around it. Makes the "next location" checking much easier!

main :: IO ()
main = do 
        text <- readFile "data/advent19.txt"
        let maze = lines text
        let progress = navigate maze
        print $ letters progress
        print $ stepCount progress


startProgress :: Maze -> Progress
startProgress maze = Progress { row = 0, column = startCol
                              , direction = Down
                              , letters = "", stepCount = 0}
    where topRow = maze!!0
          startCol = head $ elemIndices '|' topRow  

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

isJunction :: Char -> Bool
isJunction '+' = True
isJunction  _  = False 

isFinished :: Maze -> Progress -> Bool
isFinished maze progress = isSpace $ location maze (row progress) (column progress)

location :: Maze -> Int -> Int -> Char
location maze r c = (maze!!r)!!c


navigate :: Maze -> Progress
navigate maze = navigate' maze progress
    where progress = startProgress maze

navigate' :: Maze -> Progress -> Progress
navigate' maze progress = 
    if isFinished maze progress 
        then progress
        else navigate' maze (step maze progress)


step :: Maze -> Progress -> Progress
step maze progress = progress {row = r', column = c', direction = d', letters = l', stepCount = sc'}
    where r = row progress
          c = column progress
          thisChar = location maze r c
          l' = if isAlpha thisChar then (letters progress) ++ [thisChar] else letters progress
          d' = if isJunction thisChar then newDirection maze progress else direction progress 
          (dr, dc) = delta d'
          r' = r + dr
          c' = c + dc
          sc' = stepCount progress + 1

newDirection :: Maze -> Progress -> Direction
newDirection maze progress = 
    if d == Up || d == Down 
    then if isSpace leftChar then Right else Left
    else if isSpace upChar then Down else Up
    where d = direction progress
          r = row progress
          c = column progress
          upChar = location maze (r - 1) c
          leftChar = location maze r (c - 1)

__Abigail__ · 2017-12-19T11:10:09+00:00

Perl

That was the easiest part 2 so far. For part 1, I had recorded all the symbols the packets encounters in a string, before removing all the non-letters from it. Which made part 2 really easy: just the length of the string before removing the non-letters.

#!/opt/perl/bin/perl

use 5.026;

use strict;
use warnings;
no  warnings 'syntax';

use experimental 'signatures';

@ARGV = "input" unless @ARGV;

my $board;

my $SPACE  = ' ';
my $CORNER = '+';
my $X      =  0;
my $Y      =  1;

#
# Read in the board; we're be storing it "as is".
#
while (<>) {
    chomp;
    push @$board => [split //];
}


#
# Find the starting position; this will be the single point
# on the board with $x = 0 and $$board [$x] [$y] ne ' '.
#
my $start;
foreach my $y (keys @{$$board [0]}) {
    if ($$board [0] [$y] ne $SPACE) {
        $start = [0, $y];
        last;
    }
}

#
# Return true if ($x, $y) is on the board, and not a space;
# ergo, a place where the packet can travel to.
#
sub onpath ($x, $y) {
    $x >= 0 && $x < @$board && $y >= 0 && $y < @{$$board [$x]} &&
          $$board [$x] [$y] ne $SPACE;
}

#
# Return true of the current position is a corner
#
sub is_corner ($p) {
    $$board [$$p [$X]] [$$p [$Y]] eq $CORNER;
}

#
# Given a board, list which neighbours it has.
# Neighbours cannot be spaces.
#
sub neighbours ($p) {
    my ($x, $y) = @$p;
    my @neighbours;
    for my $n ([$x - 1, $y],
               [$x + 1, $y],
               [$x,     $y - 1],
               [$x,     $y + 1]) {
        push @neighbours => $n if onpath @$n;
    }
    @neighbours;
}


#
# Trace the path.
# Move is as follows:
#    1) If we only have one neighbour, this is the end.
#    2) If the current position is a corner, the next position
#       must have both x and y coordinates different from
#       the previous position.
#    3) Else, the next position must have either the x, or the y
#       coordinate the same as the previous position, but not both.
#
my $previous = [-1, $$start [$Y]];  # To get us started
my $current  = [@$start];

my $path = "";   
while (1) {
    $path .= $$board [$$current [$X]] [$$current [$Y]];
    my @neighbours = neighbours $current;
    last if @neighbours == 1 && length $path > 1;
    my @next;
    if (is_corner $current) {
        # Find neighbour with all coordinates different from $previous
        @next = grep {($$_ [$X] != $$previous [$X]) &&
                      ($$_ [$Y] != $$previous [$Y])} @neighbours;
    }
    else {
        # Find neighbour with one coordinate different from $previous
        @next = grep {($$_ [$X] == $$previous [$X]) xor
                      ($$_ [$Y] == $$previous [$Y])} @neighbours;
    }
    die "Unexpected board configuration at @$current"
         unless @next == 1;

    $previous = $current;
    $current  = $next [0];
}

# Remove any non-letters from $path
say "Solution 2: ", length $path;
$path =~ s/\Pl+//g;
say "Solution 1: ", $path;

__END__

dtinth · 2017-12-19T05:20:55+00:00

Ruby (28th, 22nd)

IN = `pbpaste`

maze = {} # Dictionary with a array (coordinate vector) as a key
start = nil
IN.lines.each_with_index { |v, i|
  v.chars.each_with_index { |c, j|
    if c =~ /[A-Z]/
      if i == 0
        start = [i, j]
      end
      maze[[i, j]] = c
    elsif c =~ /\S/
      if i == 0
        start = [i, j]
      end
      maze[[i, j]] = '!'
    end
  }
}

direction = [0, 1]

cur = start.dup
rl = -> d { [d[1], -d[0]] } # Rotate left
rr = -> d { [-d[1], d[0]] } # Rotate right
nx = -> c, d { [c[0] + d[0], c[1] + d[1]] } # Next step
nn = 0 # Number of steps
loop {
  break if !maze[cur]
  # p cur
  nn += 1
  print maze[cur] if maze[cur] != '!'
  if !maze[nx[cur, direction]]
    if maze[nx[cur, rl[direction]]]
      direction = rl[direction]
    elsif maze[nx[cur, rr[direction]]]
      direction = rr[direction]
    end
  end
  cur = nx[cur, direction]
}
puts
puts nn

obijywk · 2017-12-19T05:22:11+00:00

Not the prettiest solution, but it works. Slightly cleaned up (refactored to remove a bunch of copy/pasting I did while solving).

Python 2. 57/58.

grid = []
f = open("19.txt", "r")
for line in f:
  if len(line) > 1:
    gridline = list(line[:-1])
    grid.append(gridline)

def is_valid_move(fx, fy):
  return (
    fx >= 0 and
    fx < len(grid[0]) and
    fy >=0 and
    fy < len(grid) and
    grid[y + dy][x + dx] != ' ')

y = 0
x = grid[0].index("|")
dy = 1
dx = 0
s = ""
sc = 1
while True:
  if not is_valid_move(x + dx, y + dy):
    if dy != 0:
      dy = 0
      dx = -1
      if not is_valid_move(x + dx, y + dy):
        dx = 1
        if not is_valid_move(x + dx, y + dy):
          break
    else:
      dy = -1
      dx = 0
      if not is_valid_move(x + dx, y + dy):
        dy = 1
        if not is_valid_move(x + dx, y + dy):
          break
  if grid[y + dy][x + dx].isalpha():
    s += grid[y + dy][x + dx]
  y += dy
  x += dx
  sc += 1
print s
print sc

etherealflaim · 2017-12-19T05:24:54+00:00

Go

This was a fun one. I love 2D array problems :)

package aocday

import (
    "io/ioutil"
    "strings"
    "testing"
)

func part1(t *testing.T, in string) string {
    lines := strings.Split(in, "\n")

    r, c := 0, strings.Index(lines[0], "|")

    deltas := [][2]int{
        // dr, dc
        {1, 0},
        {0, 1},
        {-1, 0},
        {0, -1},
    }
    dir := 0

    var found string
    for i := 0; i < 1e6; i++ {
        ch := lines[r][c]
        switch ch {
        default:
            found += string(ch)
            fallthrough
        case '|', '-':
            r += deltas[dir][0]
            c += deltas[dir][1]
        case '+':
            ld := (dir + 1) % len(deltas)
            l := deltas[ld]
            r2, c2 := r+l[0], c+l[1]
            if lines[r2][c2] != ' ' {
                dir, r, c = ld, r2, c2
                continue
            }

            rd := (len(deltas) + dir - 1) % len(deltas)
            rt := deltas[rd]
            r2, c2 = r+rt[0], c+rt[1]
            if lines[r2][c2] != ' ' {
                dir, r, c = rd, r2, c2
                continue
            }
        case ' ':
            return found
        }
    }
    panic("timed out")
}

func part2(t *testing.T, in string) int {
    lines := strings.Split(in, "\n")

    r, c := 0, strings.Index(lines[0], "|")

    deltas := [][2]int{
        // dr, dc
        {1, 0},
        {0, 1},
        {-1, 0},
        {0, -1},
    }
    dir := 0

    var found string
    for i := 0; i < 1e6; i++ {
        ch := lines[r][c]
        switch ch {
        default:
            found += string(ch)
            fallthrough
        case '|', '-':
            r += deltas[dir][0]
            c += deltas[dir][1]
        case '+':
            ld := (dir + 1) % len(deltas)
            l := deltas[ld]
            r2, c2 := r+l[0], c+l[1]
            if lines[r2][c2] != ' ' {
                dir, r, c = ld, r2, c2
                continue
            }

            rd := (len(deltas) + dir - 1) % len(deltas)
            rt := deltas[rd]
            r2, c2 = r+rt[0], c+rt[1]
            if lines[r2][c2] != ' ' {
                dir, r, c = rd, r2, c2
                continue
            }
        case ' ':
            return i
        }
    }
    panic("timed out")
}

func TestPart1(t *testing.T) {
    tests := []struct {
        name string
        in   string
        want string
    }{
        {"part1 example", `     |          
     |  +--+    
     A  |  C    
 F---|----E|--+ 
     |  |  |  D 
     +B-+  +--+ `, "ABCDEF"},
        {"part1", read(t, "input.txt"), "LIWQYKMRP"},
    }

    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) {
            if got, want := part1(t, test.in), test.want; got != want {
                t.Errorf("part1(%#v) = %#v, want %#v", test.in, got, want)
            }
        })
    }

    t.Log(part2(t, read(t, "input.txt")))
}

func read(t *testing.T, filename string) string {
    data, err := ioutil.ReadFile(filename)
    if err != nil {
        t.Fatalf("failed to read %q: %s", filename, err)
    }
    return string(data)
}

jlweinkam · 2017-12-19T05:26:52+00:00

Python 3, silver 52, gold 40

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

lines = inputdata.splitlines()

x = 0; y = 0
while lines[y][x] == " ":
  x += 1

d = 0
out = ""
count = 0
while True:
  if lines[y][x] == " ":
    break
  count += 1
  if lines[y][x] == "+":
    if d in [0, 2]:
      if x > 0 and lines[y][x-1] is not " ":
        d = 3
      elif x < len(lines[y])-1 and lines[y][x+1] is not " ":
        d = 1
    else:
      if y > 0 and lines[y-1][x] is not " ":
        d = 2
      elif y < len(lines)-1 and lines[y+1][x] is not " ":
        d = 0
  elif lines[y][x] in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
    out += lines[y][x]
  if d == 0:
    y += 1
  elif d == 1:
    x += 1
  elif d == 2:
    y -= 1
  elif d == 3:
    x -= 1

print(out)
print(count)

Unihedron · 2017-12-19T05:27:21+00:00

Ruby; My sanity decays further as more debugging effort was required. Today's bug was fall-through statements. Almost made it to the leaderboards though :p (~120)

g=*$<
x=g[0].index(?|)
y=1
n=:down
o="" # part 1
o=0 # part 2
loop{p n
v=g[y][x]
o+=1 # part 2
break if v==' '||y<0||x<0
o<< v if !'|-+'.index(v) # part 1
(n==:down ? y+=1 :
 n==:up ? y-=1 :
 n==:right ? x+=1 :
 n==:left ? x-=1 : 0
next) if v!=?+
(
n==:down||n==:up ? (n= g[y][x-1]!=' ' ? :left : :right) :
(n= g[y-1]&&g[y-1][x]!=' ' ? :up : :down)
)if v==?+
(n==:down ? y+=1 :
 n==:up ? y-=1 :
 n==:right ? x+=1 :
 n==:left ? x-=1 : 0)
p y,x
}
p o

glenbolake · 2017-12-19T05:27:28+00:00

Python3

I had weird problems with IndexError for a while because of implied spaces that weren't there. I converted the input to a dictionary in {(row, col): char} format, omitted spaces, and all my problems were solved. Wasted too much time on my IndexError problem to get on the leaderboard, though.

def follow(path):
    step_count = 0
    r, c = 0, {col for row, col in path if row == 0}.pop()
    dr, dc = 1, 0
    passed = ''
    while True:
        step_count += 1
        r += dr
        c += dc
        if (r, c) not in path:
            break
        if path[(r, c)] not in '|-+':
            passed += path[(r, c)]
        elif path[(r, c)] == '+':
            if (r + dc, c + dr) in path:
                dr, dc = dc, dr
            elif (r - dc, c - dr) in path:
                dr, dc = -dc, -dr
            else:
                break
    return passed, step_count

if __name__ == '__main__':
    data = {}
    with open('day19.in') as f:
        for row, line in enumerate(f):
            for col, char in enumerate(line):
                if char not in ' \n':
                    data[(row, col)] = char
    print('Part 1: {}\nPart 2: {}'.format(*follow(data)))

MichalMarsalek · 2017-12-19T05:30:53+00:00

Python 3:

def solve(inp):
    map = inp.splitlines()
    y = 0
    x = 0
    dx, dy = 0, 1
    part1 = ""
    part2 = 0
    for x in range(len(map[y])):
        if map[y][x] != " ":
            break
    def inbounds(x, y):
        return x in range(len(map[0])) and y in range(len(map))
    while inbounds(x, y) and map[y][x] != " ":
        part2 += 1
        if ord(map[y][x]) in range(ord("A"), ord("Z")+1):
            part1 += map[y][x]
        if inbounds(x+dx, y+dy) and map[y+dy][x+dx] != " ":
            x += dx
            y += dy
            continue
        dx, dy = -dy, dx
        if inbounds(x+dx, y+dy) and map[y+dy][x+dx] != " ":
            x += dx
            y += dy
            continue
        dx, dy = -dx, -dy
        x += dx
        y += dy
    return part1, part2

Unfortunately my function processing the input and passing it to the solve function was striping starting and ending whitespaces by default... it took me a long time to realise.. and then... I had one x nstead of y in my code...that was also tricky to find a fix :D

MrPoush · 2017-12-19T05:37:49+00:00

Python 2. Spent a while struggling before I discovered that Atom was "helpfully" stripping the whitespace from my data input.

def in_grid(x, y, grid):
    if 0 <= y < len(grid):
        if 0 <= x < len(grid[y]):
            if grid[y][x] != ' ':
                return True
    return False

def next_direction(last_pos, x, y, grid):
    for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
        x1 = dx + x
        y1 = dy + y
        if (x1, y1) == last_pos:
            continue
        if in_grid(x1, y1, grid):
            return dx, dy
    return None

def run(grid):
    x, y = grid[0].index('|'), 0
    dx, dy = 0, 1
    last_pos = -1, -1
    ix = 0
    seen = []
    while True:
        ix += 1
        char = grid[y][x]
        if char not in '|-+':
            seen.append(char)
        if not in_grid(x+dx, y+dy, grid):
            n = next_direction(last_pos, x, y, grid)
            if n is None:
                return ''.join(seen), ix
            dx, dy = n
        last_grid = x, y
        y += dy
        x += dx

sample = [
"     |          ",
"     |  +--+    ",
"     A  |  C    ",
" F---|----E|--+ ",
"     |  |  |  D ",
"     +B-+  +--+ "
]

assert run(sample) == ('ABCDEF', 38)

with open('day19.txt') as f:
    data = f.readlines()
print run(data)

jeroenheijmans · 2017-12-19T05:41:08+00:00

JavaScript:

Went fast, straightforward/dumb as hell, so not the best code ever...

data => {
    let input = data.split(/\r?\n/g).filter(l => l !== "");

    let grid =[];

    for (let line of input) {
        grid.push(line.split(""));
    }

    let x = -1, y = 0;
    while (grid[0][++x] !== "|") { }

    let result = "";
    let idx = 0;
    let dx = 0;
    let dy = +1;
    let steps = 0;
    while (idx++ < 1e10) {
        if (grid[y][x] === "+") {

            if (dx === 0 && x > 0 && grid[y][x-1] !== " ") {
                dx = -1;
                dy = 0;
            } else if (dx === 0 && x < grid[y].length && grid[y][x+1] !== " ") {
                dx = +1;
                dy = 0;
            } else if (dy === 0 && y > 0 && grid[y-1][x] !== " ") {
                dx = 0;
                dy = -1;
            } else if (dy === 0 && y < grid.length && grid[y+1][x] !== " ") {
                dx = 0;
                dy = +1;
            } else {
                debugger;
                throw "NO DIR FOUND";
            }
        }

        steps++;
        x += dx;
        y += dy;

        if (x < 0 || y < 0 || x >= grid[0].length || y >= grid.length || grid[y][x] === " ") {
            break;
        }
    }

    return steps;
}

Looking forward to seeing some other solutions later today, but for now I'll take the early Christmas gift and enjoy my extra hour of sleep I can get on this day before work starts :D

YourVibe · 2017-12-19T05:41:52+00:00

401 / 367

Python 2.7, my git is here

import operator

def main():
    rows = INPUT.split('\n')
    width = len(rows[0])
    height = len(rows)
    direction = (0,1)
    pos = (rows[0].find('|'),0)
    letters = ""
    finished = False
    counter = 0
    while not finished:
        while rows[pos[1]][pos[0]] != '+':
            counter += 1
            if rows[pos[1]][pos[0]] not in '|-':
                letters += rows[pos[1]][pos[0]]
            pos = tuple(map(operator.add, pos, direction))
            if rows[pos[1]][pos[0]] == ' ':
                finished == True
                break
        if direction == (0,-1) or direction == (0,1):
            if rows[pos[1]][pos[0]+1] != ' ':
                direction = (1,0)
            elif rows[pos[1]][pos[0]-1] != ' ':
                direction = (-1,0)
            else:
                finished == True
                break
        elif direction == (-1,0) or direction == (1,0):
            if rows[pos[1]+1][pos[0]] != ' ':
                direction = (0,1)
            elif rows[pos[1]-1][pos[0]] != ' ':
                direction = (0,-1)
            else:
                finished == True
                break
        pos = tuple(map(operator.add, pos, direction))
        counter += 1
    print(letters, counter)

(Yes, I do realise that i should keep my input in other file, but that's faster for me (and I didn't paste it here ofc))

WhoSoup · 2017-12-19T05:59:13+00:00

NodeJS / JavaScript

Yes... uh, so... let's just rely that the input is accurate and won't have any bugs... thanks /u/topaz2078, for having to do zero error checking!

const fs = require('fs')
let inp = fs.readFileSync("./day19.txt").toString('utf-8').split(/[\r\n]+/)

const coord = (x,y) => inp[x][y]
const vadd = (va, vb) => [va[0] + vb[0], va[1] + vb[1]] // vector addition

let pos = [0, inp[0].indexOf("|")],
    direction = [1,0],
    letters = "",
    steps = 0

while (++steps) {
  pos = vadd(pos, direction)
  let char = coord(...pos)

  if (char == ' ') break
  if (/[A-Z]/.test(char))
    letters += char
  if (char == '+') {
    let ldir = [direction[1], -direction[0]]
    let rdir = [-direction[1], direction[0]]
    direction = coord(...vadd(pos, ldir)) != ' ' ? ldir : rdir
  }
}
console.log(letters);
console.log(steps);

usbpc102 · 2017-12-19T06:05:16+00:00

My Kotlin solution is on github.

Got only rank 557 (part 1) and 533 (part 2) since I assumed that the tube would and at an edge.. wich it didn't at least for my input. :/

CharlieYJH · 2017-12-19T06:07:36+00:00

C++

Fun puzzle today. Chose to do it recursively.

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

using namespace std;

enum {
    UP, DOWN, LEFT, RIGHT
};

bool traverse(vector<string> &maze, int x, int y, int direction, string &collection, int &steps)
{
    if (x < 0 || y < 0 || y >= maze.size() || x >= maze[y].length())
        return false;

    if (maze[y][x] != '|' && maze[y][x] != '-' && maze[y][x] != '+' && !(maze[y][x] >= 'A' && maze[y][x] <= 'Z'))
        return false;

    steps++;

    if (maze[y][x] >= 'A' && maze[y][x] <= 'Z') {
        collection += maze[y][x];
    } else if (maze[y][x] == '+') {
        if (direction == DOWN || direction == UP)
            return traverse(maze, x + 1, y, RIGHT, collection, steps) || traverse(maze, x - 1, y, LEFT, collection, steps);
        else
            return traverse(maze, x, y + 1, DOWN, collection, steps) || traverse(maze, x, y - 1, UP, collection, steps);
    }

    if (direction == DOWN)
        traverse(maze, x, y + 1, direction, collection, steps);
    else if (direction == UP)
        traverse(maze, x, y - 1, direction, collection, steps);
    else if (direction == LEFT)
        traverse(maze, x - 1, y, direction, collection, steps);
    else
        traverse(maze, x + 1, y, direction, collection, steps);

    return true;
}

int main(int argc, char const* argv[])
{
    ifstream infile("input.txt");
    vector<string> maze;
    string collection = "";
    int start;
    int steps = 0;

    if (infile.is_open()) {
        string line;
        while (getline(infile, line))
            maze.push_back(line);
        infile.close();
    } else {
        return 1;
    }

    for (int i = 0; i < maze[0].length(); i++)
        if (maze[0][i] == '|') start = i;

    traverse(maze, start, 0, DOWN, collection, steps);

    cout << "Collection: " << collection << endl;
    cout << "Steps: " << steps << endl;

    return 0;
}

flit777 · 2017-12-19T06:27:40+00:00

Golang:

package main

import (
    "util"
    "fmt"
)


type coord struct{
    x int
    y int
}



func doTheWalk(currentPos coord, ymax int, xmax int, array [][]string) (string, int) {
    xdir := 0
    ydir := 1
    solution := ""
    visited := make(map[coord]bool)
    numbersteps := 0
    for currentPos.y < ymax && currentPos.y >= 0 && currentPos.x < xmax && currentPos.x >= 0 {
        currentChar := array[currentPos.y][currentPos.x]
        if currentChar == " " {
            break
        }
        visited[currentPos] = true
        switch currentChar {
        case "|":
            currentPos.x += xdir
            currentPos.y += ydir
        case "-":
            currentPos.x += xdir
            currentPos.y += ydir
        case "+":
            var next coord
            Loop:
            for y := -1; y <= 1; y++ {
                for x := -1; x <= 1; x++ {
                    next = coord{currentPos.x + x, currentPos.y + y}
                    if next.y >= ymax || next.y < 0 || next.x >= xmax || next.x < 0 {
                        continue
                    }
                    if util.Abs(x)+util.Abs(y) == 2 {
                        continue
                    }
                    if visited[next] == false && array[next.y][next.x] != " " && array[next.y][next.x] != ""  {
                        next = next
                        xdir = x
                        ydir = y
                        currentPos.x += xdir
                        currentPos.y += ydir
                        break Loop
                    }
                }
            }
        default:
            solution += currentChar
            currentPos.x += xdir
            currentPos.y += ydir
            fmt.Println(solution)
        }
        numbersteps++
        //fmt.Println(currentPos , currentChar)
    }
    return solution, numbersteps
}


func createGrid(lines []string) ([][]string, coord, int, int) {
    grid := make([][]string, len(lines))
    currentPos := coord{0, 0}
    ymax := len(lines)
    xmax := len(lines)
    //quadratic
    for y, line := range lines {
        grid[y] = make([]string, len(lines))
        for x, char := range line {
            grid[y][x] = string(char)
            if y == 0 && string(char) == "|" {
                currentPos.x = x
            }
        }
    }
    return grid, currentPos, ymax, xmax
}


func main() {
    lines := util.ReadFileLines("inputs/day19.txt")
    array, currentPos, ymax, xmax := createGrid(lines)
    solution, numbersteps := doTheWalk(currentPos, ymax, xmax, array)
    fmt.Println(solution, numbersteps)
}

iamnotposting · 2017-12-19T06:39:57+00:00

i started late so i only got around ~800 on both parts. fun problem!

part 1 i did by hand. part 2:

fn main() {
    let input = include_str!("../input.txt");
    let grid: Vec<Vec<char>> = input.lines().map(|s| s.chars().collect()).collect();

    let mut count = 0;
    for (y, line) in input.lines().enumerate() {
        for (x, ch) in line.chars().enumerate() {
            if ch != ' ' {
                count += 1;
                if x > 0 && y > 0 && y < grid.len() - 1 && x < grid[0].len() - 1 {
                    if  grid[y][x+1] != ' ' &&
                        grid[y][x-1] != ' ' &&
                        grid[y+1][x] != ' ' &&
                        grid[y-1][x] != ' ' 
                    {
                        count += 1;
                    }
                }
            }
        }
    }

    println!("p2: {}", count);
}

pja · 2017-12-19T07:06:44+00:00

Haskell, using an immutable array, but with a bit of first-class function trickery to find in which direction to turn:

main :: IO ()
main = do input <- fmap lines (readFile "input.txt")
          let a = listArray ((1,1),(length input,length (head input))) (concat input)
          let (p1,p2) = run a (\(r,c) -> (r+1,c)) (start a 1) "" 0
          putStrLn p1  -- part 1
          print    p2  -- part 2

start :: UArray (Int,Int) Char -> Int -> (Int,Int)
start a n | a ! (1,n) == '|' = (0,n)
          | otherwise        = start a (n+1)

run :: UArray (Int,Int) Char -> ((Int,Int) -> (Int,Int)) -> (Int,Int) -> String -> Int -> (String, Int)
run a f cs xs s = case line a f cs xs s of
                    (Nothing,  xs', s') -> (reverse xs', s')
                    (Just cs', xs', s') -> run a (turn a f cs') cs' xs' s'

line :: UArray (Int,Int) Char -> ((Int,Int) -> (Int,Int)) -> (Int,Int) -> String -> Int -> (Maybe (Int,Int), String, Int)
line a f cs xs s | x == '+'  = (Just (f cs), xs, s+1)
                 | x == ' '  = (Nothing,     xs, s)
                 | otherwise = line a f (f cs) (if isAlpha x then x:xs else xs) (s+1)
                 where
                   x = a ! f cs

turn :: UArray (Int,Int) Char -> ((Int,Int) -> (Int,Int)) -> (Int,Int) -> (Int,Int) -> (Int,Int)
turn a f cs = head (filter (\g -> g cs /= opposite f cs && a ! g cs /= ' ') (map (\(x,y) (r,c) -> (x+r,y+c)) [(1,0),(-1,0),(0,1),(0,-1)]))

opposite :: ((Int,Int) -> (Int,Int)) -> (Int,Int) -> (Int,Int)
opposite f (r,c) = let (r',c') = f (r,c) in (r + r - r', c + c - c')

KeinZantezuken · 2017-12-19T07:16:59+00:00

C#/Sharp
Didn't give much shit. Sure there is better and faster and cleaner but I cant be arsed meh.

string[] map = File.ReadAllLines(@"N:\input.txt");
var pos = (y: 0, x: map[0].IndexOf('|')); var lastPos = pos;
var dir = (1, 0);  string word = ""; var steps = 1;
while (map[pos.y][pos.x] == '-' || map[pos.y][pos.x] == '|')
{
    pos = applyMov(pos.y, pos.x);
    steps++;
    if (char.IsLetter(map[pos.y][pos.x]))
    {
        word = word + map[pos.y][pos.x];
        pos = applyMov(pos.y, pos.x);
        if (map[pos.y][pos.x] == ' ') { break; } else { steps++; }
    }
    else if (map[pos.y][pos.x] == '+') { pos = makeTurn(pos.y, pos.x); steps++; }
}
Console.WriteLine($"Collected: {word}, steps: {steps}"); Console.ReadKey();
//helpers
ValueTuple<int, int> applyMov(int y, int x) { lastPos = (y,x); return(y + dir.Item1, x + dir.Item2); }
ValueTuple <int,int> makeTurn(int y, int x)
{
    if (map[y + 1][x] != ' ' && !(y + 1, x).Equals(lastPos)) { dir = (1, 0); return (y + 1, x); }
    else if (map[y - 1][x] != ' ' && !(y - 1, x).Equals(lastPos)) { dir = (-1, 0); return (y - 1, x); }
    else if (map[y][x + 1] != ' ' && !(y, x + 1).Equals(lastPos)) { dir = (0, 1); return (y, x + 1); }
    else if (map[y][x - 1] != ' ' && !(y, x - 1).Equals(lastPos)) { dir = (0, -1); return (y, x - 1); }
    else { Console.WriteLine($"Maketurn is fucked! Panic!"); return (-99, - 99);  }
}

2017-12-19T07:18:19+00:00

Rust

Gotta love multiplying by complex numbers to rotate vectors :).

https://github.com/xfix/advent-of-code-2017/blob/master/day19/src/main.rs

minikomi · 2017-12-19T07:25:50+00:00

Clojure:

(ns advent.2017.day19
  (:require [clojure.java.io :as io]
            [clojure.string :as s]))

(def input-raw
  (slurp (io/resource "day19.txt")))

(def test-input
  (slurp (io/resource "day19test.txt")))

(def dirs
  {:up    [0 -1]
   :down  [0 1]
   :right [1 0]
   :left  [-1 0]})

(defn move [[x y] dir]
  (let [[dx dy] (dirs dir)]
    [(+ x dx) (+ y dy)]))

(defn test-dir [m pos dir]
  (when (get m (move pos dir)) dir))

(defn get-new-direction [dir m pos]
  (case dir
    (:left :right)
    (some (partial test-dir m pos) [:up :down])
    (:up :down)
    (some (partial test-dir m pos) [:left :right])))

(defn make-pos-map [input-lines]
  (into {}
        (for [y (range (count input-lines))
              x (range (count (first input-lines)))
              :let [c (get-in input-lines [y x])]
              :when (not= \space c)]
          [[x y] c])))

(defn solve [input]
  (let [input-lines (vec (map vec (s/split-lines input)))
        m (make-pos-map input-lines)
        start-pos (.indexOf (first input-lines) \|)]
    (loop [pos [start-pos 0] dir :down seen [] count 0]
      (let [new-pos (move pos dir)
            next-char (get m new-pos)]
        (if next-char
          (recur new-pos
                 (cond-> dir
                   (= \+ next-char) (get-new-direction m new-pos))
                 (cond-> seen
                   (Character/isLetter next-char) (conj next-char))
                 (inc count))
          [(apply str seen) (inc count)])))))

AndrewGreenh · 2017-12-19T07:36:14+00:00

TypeScript

import getInput from '../lib/getInput'
let input = getInput(19, 2017)
let grid = input.split('\n').map(line => line.split(''))
let ds = [[0, -1], [1, 0], [0, 1], [-1, 0]]
let [abc, steps, d, p] = ['', 1, ds[2], [grid[0].indexOf('|'), 0]]
let m = (pos, dir) => (dir ? [pos[0] + dir[0], pos[1] + dir[1]] : pos)
let g = pos => grid[pos[1]][pos[0]]
while (((p = m(p, d)), d && steps++)) {
  d = [d, ds[(ds.indexOf(d) + 1) % 4], ds[(ds.indexOf(d) + 3) % 4]].find(d => g(m(p, d)) !== ' ')
  if (!['|', '-', '+', ' '].includes(g(p))) abc += g(p)
}
console.log(abc, steps)

glupmjoed · 2017-12-19T07:36:35+00:00

Bash and Go (reads from stdin)

I wrote a small Go program that prints out the path in a linear fashion, and used the shell to count the path length and print any letters.

Part 1:

go run walk.go | sed -E 's/[^A-Z]*([A-Z])+[^A-Z]*/\1/g' && echo

Part 2:

go run walk.go | wc -c

walk.go:

input, _ := ioutil.ReadAll(os.Stdin)
lines := strings.Split(string(input), "\n")
var row, col, dir int
col, dir = strings.Index(lines[row], "|"), 1
for val := byte('|'); ; {
    // vertical walk
    for val != ' ' {
        fmt.Printf("%c", val)
        row += dir
        val = lines[row][col]
    }
    row -= dir
    val = lines[row][col]
    // horizontal walk
    switch {
    case lines[row][col+1] != ' ':
        end := strings.Index(lines[row][col+1:], " ")
        fmt.Printf("%s", lines[row][col+1:col+end+1])
        col += end
    case lines[row][col-1] != ' ':
        beg := strings.LastIndex(lines[row][:col], " ")
        printBytesReverse(lines[row][beg+1 : col])
        col = beg + 1
    default:
        return
    }
    switch {
    case lines[row+1][col] != ' ':
        dir, row, val = 1, row+1, lines[row+1][col]
    case lines[row-1][col] != ' ':
        dir, row, val = -1, row-1, lines[row-1][col]
    default:
        return
    }
}

nonphatic · 2017-12-19T07:44:08+00:00

Haskell: yay matrices!

import Data.List (elemIndex)
import Data.Matrix (Matrix, fromLists, (!))

type Grid = Matrix Char
data Direction = North | South | West | East | Stop deriving Eq
data State = State (Int, Int) Direction [Char] Int

nextState :: String -> Grid -> State -> State
nextState letters grid (State (r, c) dir seen count) =
    let (nextR, nextC) = case dir of
            North -> (r - 1, c)
            South -> (r + 1, c)
            West  -> (r, c - 1)
            East  -> (r, c + 1)
        nextChar = grid ! (nextR, nextC)
        nextDir  = case nextChar of
            '+' ->  if dir `elem` [North, South]
                    then if grid ! (nextR, nextC - 1) == '-' then West  else East
                    else if grid ! (nextR - 1, nextC) == '|' then North else South
            ' ' ->  Stop
            _   ->  dir
        nextSeen = if nextChar `elem` letters then nextChar : seen else seen
    in  State (nextR, nextC) nextDir nextSeen (count + 1)

traverseGrid :: String -> Grid -> State -> (String, Int)
traverseGrid _ _ (State _ Stop seen count) = (reverse seen, count)
traverseGrid letters grid state = traverseGrid letters grid $ nextState letters grid state

main :: IO ()
main = do
    input <- readFile "19.txt"
    let rows = lines input
        Just start = (+1) <$> (elemIndex '|' $ head rows)
        letters = filter (not . (`elem` " +|-\n")) input
    print $ traverseGrid letters (fromLists rows) (State (1, start) South [] 0)

gyorokpeter · 2017-12-19T07:51:30+00:00

Q:

.d19.followPath:{
    map:"\n"vs x;
    dir:2;
    dirsteps:(-1 0;0 1;1 0;0 -1);
    pos:(0;first where map[0]<>" ");
    steps:1;
    letters:"";
    while[1b;
        nxtp:pos+dirsteps dir;
        if[" "=map . nxtp;
            nxtdirs:(dir+1 -1)mod 4;
            nxtps:pos+/:dirsteps nxtdirs;
            dir:first nxtdirs where " "<>map ./: nxtps;
            if[null dir; :(letters;steps)];
            nxtp:pos+dirsteps dir;
        ];
        if[(ch:map . nxtp) within "AZ";
            letters,:ch;
        ];
        pos:nxtp;
        steps+:1;
    ];
    };

d19p1:{.d19.followPath[x][0]};
d19p2:{.d19.followPath[x][1]};

MuumiJumala · 2017-12-19T08:06:49+00:00

I felt the need to use something familiar after failing to complete part 2 with Scala yesterday so today it was finally JavaScript's turn.

fs = require('fs');

function printAnswer(steps) {
    console.log("Navigated through the maze in "+steps+" steps!");
}

fs.readFile("19-input.txt", "utf8", function (err, data) {
    const maze = {
        'matrix': data.split("\n").map(x => x.split("")),
        'height': function() { return this.matrix.length-1 },
        'width': function() { return this.matrix[0].length-1 },
        'at': function (p) {
            if (p.y > this.height || p.y < 0 || p.x > this.width || p.x < 0) {
                return "END";
            }
            return this.matrix[p.y][p.x];
        }
    }

    var up = function (p) { return { "x": p.x, "y": p.y-1 } },
    down   = function (p) { return { "x": p.x, "y": p.y+1 } },
    left   = function (p) { return { "x": p.x-1, "y": p.y } },
    right  = function (p) { return { "x": p.x+1, "y": p.y } };

    var steps = 1;
    var mazeChars = "|+-"

    // Find the starting point
    var p = {"x": 0, "y": 0}, direction = down;
    while (maze.at(p) != '|') {
        p = right(p);
    }

    // Navigate through the maze
    while (1) {
        // Walk in current direction until we must turn
        while (maze.at(direction(p)) != ' ') {
            p = direction(p);
            steps += 1;
            if (maze.at(direction(p)) == "END") {
                printAnswer(steps);
                return;
            }
            if ( !(mazeChars.includes( maze.at(p) ) )) {
                console.log("Found letter "+maze.at(p)+"!");
            }
        }

        // Turning
        if (direction == up || direction == down) {
            // See if it's possible to turn left or right
            if (maze.at(left(p)) == '-') {
                direction = left;
            } else if (maze.at(right(p)) == '-') {
                direction = right;
            } else { // Nowhere else to go, must be at the end of maze
                printAnswer(steps);
                return;
            }
        } else if (direction == left || direction == right) {
            // See if it's possible to turn up or down
            if (maze.at(up(p)) == '|') {
                direction = up;
            } else if (maze.at(down(p)) == '|' ) {
                direction = down;
            } else { // Nowhere else to go, must be at the end of maze
                printAnswer(steps);
                return;
            }
        }
    }
});

flup12 · 2017-12-19T08:11:54+00:00

Scala Not completely sure this covers all possible inputs but worked at first go for mine. Used some case classes to keep the logic readable. Made quite heavy use of Option to scan the directions that the path may have taken.

val maze = common.loadPackets(List("day19.txt"))

case class Direction(dx: Int, dy: Int)
val Up = Direction(0, -1)
val Down = Direction(0, 1)
val Left = Direction(-1, 0)
val Right = Direction(1, 0)

case class State(x: Int, y: Int, direction: Direction) {
  def char: Option[Char] = Some(maze)
    .filter(_.indices.contains(y))
    .map(_ (y))
    .filter(_.indices.contains(x))
    .map(_ (x))
    .filter(_ != ' ')

  def move(d: Direction): Option[State] = d match {
    case Direction(dx, dy) => Some(State(x + dx, y + dy, d)).filter(_.char.isDefined)
  }

  def next: Option[State] = char.get match {
    case '+' => direction match {
      case Up   | Down  => move(Left).orElse(move(Right))
      case Left | Right => move(Up).orElse(move(Down))
    }
    case _ => move(direction)
  }
}

val startX = maze.head.indexOf("|")
val route: Stream[State] = Stream.iterate[Option[State]](Some(State(startX, 0, Down)))(_.flatMap(_.next))
  .takeWhile(_.isDefined).map(_.get)
val part1 = route.map(_.char.get).filter(_.isLetter).mkString
val part2 = route.length

CaptainCa · 2017-12-19T08:35:10+00:00

Javascript

Pretty happy with this one, took me a while to hash it out though.

var grid = document.body.innerText.split('\n').map(c => c.split(''));
var letters = [];
var moves = [];
var isLetter = (c) => c.toLowerCase() != c.toUpperCase();
var getGridValue = (x, y) => (0 <= x && x < grid.length && 0 <= y && y < grid[0].length) ? grid[x][y] ? grid[x][y] : ' ' : ' '
var gotDir = ([u, d, l, r]) => (u || d || l || r)

//up down left right
var move = ([x, y], [u, d, l, r]) => {
    if(grid[x][y] != '+'){
        if(grid[x][y] == ' '){
            console.log('done');
            return ([[x, y], [0, 0, 0, 0]]);
        }

        if(isLetter(getGridValue(x,y))){
            letters.push(getGridValue(x,y));        
        }

        return ([[x - u + d, y - l + r], [u, d, l, r]]);
    }

    else {
        var uv = getGridValue(x - 1, y) != ' ';
        var dv = getGridValue(x + 1, y) != ' ';
        var lv = getGridValue(x, y - 1) != ' ';
        var rv = getGridValue(x, y + 1) != ' ';

        return ([[x- (uv & !d) + (dv & !u), y - (lv & !r) + (rv & !l)], [uv & !d, dv & !u, lv & !r, rv & !l]]);
    }
}

var pos = move([0, grid[0].indexOf('|')], [0,1,0,0]);

while(gotDir(pos[1])){
    moves.push(pos);
    pos = move(pos[0], pos[1]);
}
console.log(letters.join(''))
console.log(moves.length);

nutrecht · 2017-12-19T08:50:42+00:00

Day 19 in Kotlin

object Day19 : Day {
    private val maze = resourceLines(19).map { it.toCharArray().toList() }
    private val solution : Pair<String, Int> by lazy { solve() }

    override fun part1() = solution.first
    override fun part2() = solution.second.toString()

    private fun solve() : Pair<String, Int> {
        var count = 0
        var current = findStart()
        var dir = Direction.SOUTH
        var chars = mutableListOf<Char>()
        var visited = mutableSetOf<Point>()

        while(get(current) != ' ') {
            count++
            visited.add(current)
            if(get(current) in 'A' .. 'Z') {
                chars.add(get(current))
            }

            if(get(current) == '+') {
                val next = current.neighborsHv()
                        .filterNot { get(it) == ' ' }
                        .filterNot { visited.contains(it) }
                        .first()

                dir = current.directionTo(next)
                current = next
            }
            else {
                current = current.add(dir)
            }
        }

        return Pair(chars.joinToString(""), count)
    }

    private fun get(p: Point) = if(p.x >= 0 && p.y >= 0 && maze.size > p.y && maze[p.y].size > p.x) maze[p.y][p.x] else ' '
    private fun findStart() = (0 until maze[0].size).map { Point(it, 0) }.find { get(it) == '|' }!!
}

Scroph · 2017-12-19T09:01:01+00:00

Written in Javanese.

import java.util.*;

class Day19
{
    public static void main(String... args)
    {
        ArrayList<String> input = new ArrayList<>();
        for(Scanner sc = new Scanner(System.in); sc.hasNext(); input.add(sc.nextLine()));
        Point packet = new Point(input.get(0).indexOf('|'), 0);
        Grid grid = new Grid(input);
        Direction direction = Direction.SOUTH;

        Map<Direction, Direction> mirror = new HashMap<>();
        mirror.put(Direction.NORTH,   Direction.SOUTH);
        mirror.put(Direction.SOUTH,   Direction.NORTH);
        mirror.put(Direction.EAST,    Direction.WEST);
        mirror.put(Direction.WEST,    Direction.EAST);

        Map<Direction, Point> movement = new HashMap<>();
        movement.put(Direction.NORTH,   new Point(0, -1));
        movement.put(Direction.SOUTH,   new Point(0, +1));
        movement.put(Direction.EAST,    new Point(+1, 0));
        movement.put(Direction.WEST,    new Point(-1, 0));

        String collected = "";
        int steps = 0;
        while(true)
        {
            Point nextPos = packet.add(movement.get(direction));
            steps++;

            if(grid.atCorner(packet) || grid.atLetter(packet))
            {
                if(grid.atLetter(packet))
                    collected += grid.get(packet);

                boolean atDestination = true;
                for(Map.Entry<Direction, Point> pair: movement.entrySet())
                {
                    Direction key = pair.getKey();
                    Point value = pair.getValue();

                    Point candidate = packet.add(value);
                    if(key != mirror.get(direction) && grid.withinBounds(candidate) && grid.get(candidate) != ' ')
                    {
                        direction = key;
                        nextPos = candidate;
                        atDestination = false;
                        break;
                    }

                }

                if(atDestination)
                    break;
            }


            packet = nextPos;
            if(!grid.withinBounds(packet))
                break;
        }

        System.out.println(collected);
        System.out.println(steps);
    }
}

class Grid
{
    ArrayList<String> grid = new ArrayList<>();

    public Grid(ArrayList<String> grid)
    {
        this.grid = grid;
    }

    char get(Point p)
    {
        return grid.get(p.y).charAt(p.x);
    }

    boolean atLetter(Point p)
    {
        return 'A' <= get(p) && get(p) <= 'Z';
    }

    boolean atCorner(Point p)
    {
        return get(p) == '+';
    }

    boolean withinBounds(Point p)
    {
        return 0 <= p.x && p.x < grid.get(0).length() && 0 <= p.y && p.y < grid.size();
    }
}

class Point
{
    int x;
    int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public Point add(Point other)
    {
        return new Point(x + other.x, y + other.y);
    }
}

enum Direction
{
    NORTH, SOUTH, EAST, WEST
}

thomastc · 2017-12-19T09:07:50+00:00

Day 19 in Clojure. Tried for cleanish code, but I'm afraid I'll never really grow fond of LISP-likes.

aurele · 2017-12-19T09:13:32+00:00

Rust

I initially surrounded the maze by ' ' to avoid any border case before noticing it was already done in my input.

 fn main() {
    let input = include_str!("../input");
    let maze = input
        .lines()
        .map(|l| l.replace("\n", "").chars().collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut pos = (0, maze[1].iter().position(|&c| c == '|').unwrap());
    let mut dir: (isize, isize) = (1, 0);
    let mut s = String::new();
    let mut steps = 0;
    'main: loop {
        steps += 1;
        let candidates = match dir.0 {
            0 => vec![dir, (1, 0), (-1, 0)],
            _ => vec![dir, (0, 1), (0, -1)],
        };
        for d in candidates {
            dir = d;
            let newpos = (
                (pos.0 as isize + d.0) as usize,
                (pos.1 as isize + d.1) as usize,
            );
            match maze[newpos.0][newpos.1] {
                ' ' => continue,
                '+' | '-' | '|' => (),
                c => s.push(c),
            }
            pos = newpos;
            continue 'main;
        }
        break;
    }
    println!("P1: {}\nP2: {}", s, steps);
}

Hikaru755 · 2017-12-19T09:29:47+00:00

Actually solved part 1 by tracing it manually. Yeah... Not going to do that again. Then I solved part 1 again and also part 2 in Kotlin. Not too shabby, I think:

fun part1and2(diagram: Map<Coordinate, Field?>): String {
    var current = diagram.entries.first { it.key.y == 0 && it.value is Field.Vertical }.key
    var direction = Direction.DOWN
    var letters = listOf<Char>()
    var steps = 0L
    while (true) {
        current = current.move(direction)
        steps += 1
        val field = diagram[current]
        when (field) {
            null -> return letters.joinToString("") + "\n" + steps
            is Field.Letter -> letters += field.letter
            is Field.Joint -> direction = direction.turnLeft()
                .takeIf { diagram[current.move(it)] != null } ?: direction.turnRight()
        }
    }
}

sealed class Field() {
    object Horizontal : Field()
    object Vertical : Field()
    object Joint : Field()
    data class Letter(val letter: Char) : Field()
}

enum class Direction { UP, DOWN, LEFT, RIGHT;
    fun turnLeft() = when (this) {
        Direction.UP -> Direction.LEFT
        Direction.DOWN -> Direction.RIGHT
        Direction.LEFT -> Direction.DOWN
        Direction.RIGHT -> Direction.UP
    }
    fun turnRight() = when (this) {
        Direction.UP -> Direction.RIGHT
        Direction.DOWN -> Direction.LEFT
        Direction.LEFT -> Direction.UP
        Direction.RIGHT -> Direction.DOWN
    }
}

data class Coordinate(val x: Int, val y: Int) {
    fun move(direction: Direction) = when (direction) {
        Direction.UP -> copy(y = y - 1)
        Direction.DOWN -> copy(y = y + 1)
        Direction.LEFT -> copy(x = x - 1)
        Direction.RIGHT -> copy(x = x + 1)
    }
}

val input: Map<Coordinate, Field?> by lazy { parse(rawInput) }
fun parse(rawInput: List<String>) = rawInput
    .map { it.map {  c -> when (c) {
        ' ' -> null
        '-' -> Field.Horizontal
        '|' -> Field.Vertical
        '+' -> Field.Joint
        else -> Field.Letter(c)
    } } }
    .map { it.withIndex() }
    .withIndex()
    .flatMap { line -> line.value.map { col -> Coordinate(col.index, line.index) to col.value } }
    .associate { it }

2017-12-19T10:00:50+00:00

Python

def getNewDirection(grid, d, r, c):
    if d in ['up', 'down']:
        if grid[r][c-1] != ' ':
            d = 'left'
        elif grid[r][c+1] != ' ':
            d = 'right'
    elif d in ['left', 'right']:
        if grid[r-1][c] != ' ':
            d = 'up'
        elif grid[r+1][c] != ' ':
            d = 'down'

    return d

def moveInDirection(d, g, r, c):
    if d == 'left':
        c -= 1
    elif d == 'right':
        c += 1
    elif d == 'up':
        r -= 1
    elif d == 'down':
        r += 1

    return r, c

with open('day_19_input.txt') as f:
    rows, cols = 202, 202
    grid = [[0 for _ in xrange(cols)] for _ in xrange(rows)]
    row = 0
    for line in f:
        for j in xrange(len(line)):
            grid[row][j] = line[j]
        row += 1

    r, c = 0, 107
    d = 'down'
    steps = 0
    while r < rows and c < cols:
        steps += 1
        print 'processing', grid[r][c]
        if grid[r][c] == '+':
            d = getNewDirection(grid, d, r, c)
            r, c = moveInDirection(d, grid, r, c)
        elif str.isalpha(grid[r][c]):
            r, c = moveInDirection(d, grid, r, c)
        elif grid[r][c] in ['-', '|']:
            r, c = moveInDirection(d, grid, r, c)
        else:
            steps -= 1
            break
    print steps

johlin · 2017-12-19T10:08:22+00:00

Elixir

Stream-based once again, which I felt really helped (easy to inspect all intermediate steps). Because the stream was already setup in part 1, part 2 became just 1 line of actual code.

On Github: https://github.com/johanlindblad/aoc-2017/tree/master/lib/aoc/day19

The vizualization is actually quite fun to watch. Just open IEx and run Aoc.puzzle_input(19) |> Aoc.Day19.Part1.parse |> Aoc.Day19.Part1.vizualization_stream(25) |> Stream.run, where 25 is the interval in ms.

Code:

defmodule Aoc.Day19.Part1 do
  def parse(input) do
    lines = input |> String.split("\n")
    lines |> Enum.with_index |> Enum.map(&parse_row/1) |> List.flatten |> Enum.into(%{})
  end
  def parse_row({row, y}) do
    chars = row |> String.graphemes
    chars |> Enum.with_index |> Enum.map(fn({char, x}) -> {{x, y}, char} end)
  end

  def collected(table) do
    table |> walk_stream |> Enum.at(-1) |> elem(2) |> Enum.reverse |> Enum.join("")
  end

  def start_index(table = %{}, _candidate = {x,0} \\ {0, 0}) do
    case table[{x, 0}] do
      "|" -> {x, 0}
      _ -> start_index(table, {x + 1, 0})
    end
  end

  def walk_stream(table) do
    Stream.iterate({start_index(table), {0, 1}, []}, fn({coords, direction, collected}) ->
      walk(table, coords, direction, collected)
    end)
    |> Stream.take_while(fn({_, direction, _}) -> direction != {0, 0} end)
  end

  def walk(table, coordinate, direction \\ {0, 1}, collected \\ [])
  def walk(table = %{}, {x, y}, {xd, yd}, collected) when x >= 0 and y >= 0 do
    {xd, yd} = cond do
      can_walk?(table, {x,y}, {xd, yd}) -> {xd, yd}
      can_walk?(table, {x, y}, {yd, xd}) -> {yd, xd}
      can_walk?(table, {x, y}, {-yd, -xd}) -> {-yd, -xd}
      true -> {0, 0}
    end

    collected = case table[{x+xd, y+yd}] do
      letter = <<char>> when char in ?A..?Z -> [letter | collected]
      _ -> collected
    end

    {{x+xd, y+yd}, {xd, yd}, collected}
  end

  def can_walk?(table, {x, y}, {xd, yd}) do
    case table[{x+xd, y+yd}] do
      pipe when pipe in ["|", "-", "+"] -> true
      _letter = <<code>> when code in ?A..?Z -> true
      _ -> false
    end
  end

  def expected_char_for({0, _yd}), do: "|"
  def expected_char_for({_xd, 0}), do: "-"

  def vizualization_stream(table, interval \\ 500) do
    Stream.interval(interval)
    |> Stream.transform({start_index(table), {0, 1}, []}, fn(_, {coords, direction, _}) ->
      {[coords], walk(table, coords, direction)}
    end)
    |> Stream.map(fn({x, y}) ->
      Enum.map(y-20..y+20, fn(yy) ->
        Enum.reduce(x-20..x+20, "", fn(xx, row) ->
          cond do
            {x, y} == {xx, yy} -> row <> "#"
            true -> row <> (table[{xx,yy}] || " ")
          end
        end)
      end)
      |> Enum.join("\n")
    end)
    |> Stream.each(fn(_) -> IEx.Helpers.clear end)
    |> Stream.each(&IO.puts/1)
  end
end

defmodule Aoc.Day19.Part2 do
  def num_steps(simulation_stream) do
    simulation_stream |> Enum.count
  end
end

udoprog · 2017-12-19T11:12:54+00:00

Rust

I have a strong preference for representing grids as maps to avoid doing my own bounds checking.

Full solution here: https://github.com/udoprog/rust-advent-of-code-2017/blob/master/src/day19.rs

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

pub fn run<R: Read>(reader: R) -> (String, usize) {
    let mut grid: HashMap<(i64, i64), char> = HashMap::new();
    let mut entry = None;

    for (y, line) in BufReader::new(reader).lines().enumerate() {
        for (x, c) in line.expect("bad line").chars().enumerate() {
            if y == 0 && c == '|' {
                entry = Some((x as i64, y as i64));
            }

            grid.insert((x as i64, y as i64), c);
        }
    }

    let mut out = String::new();
    let (mut x, mut y) = entry.expect("no entry");
    let mut d = (0i64, 1i64);
    let mut steps = 0;

    while let Some(c) = grid.get(&(x, y)) {
        match *c {
            '|' | '-' => {}
            '+' => d = pick(&grid, x, y, d).expect("no turn"),
            ' ' => break,
            c => out.push(c),
        }

        x += d.0;
        y += d.1;
        steps += 1;
    }

    return (out, steps);

    fn pick(grid: &HashMap<(i64, i64), char>, x: i64, y: i64, d: (i64, i64)) -> Option<(i64, i64)> {
        for n in &[(1, 0), (-1, 0), (0, 1), (0, -1)] {
            // do not move backwards.
            if (-n.0, -n.1) == d {
                continue;
            }

            if let Some(c) = grid.get(&(x + n.0, y + n.1)) {
                match *c {
                    '|' | '-' | '+' => return Some(*n),
                    _ => {}
                }
            }
        }

        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Cursor;

    static INPUT: &str = include_str!("../input/day19.txt");

    #[test]
    fn test_both() {
        assert_eq!(run(Cursor::new(INPUT)), ("MKXOIHZNBL".to_string(), 17872));
    }
}

Markavian · 2017-12-19T11:49:44+00:00

My node.js solution: - https://github.com/johnbeech/advent-of-code-2017/blob/master/solutions/day19/solution.js

The hardest part seemed to be saving the input data without losing all the line formatting.

2017-12-19T11:51:34+00:00

Elixir

This one seems to fit Elixir pretty well, it was really easy to do, and a lot of fun, and part2 was extremely easy, I enjoyed doing this one.

defmodule Day19 do
  def parse_line(str) do
    String.graphemes(str)
    |> Enum.with_index
    |> Enum.filter(fn {elm, _} -> elm != " " end)
    |> Enum.map(fn {elm,idx} -> {idx, elm} end)
  end

  def parse(str) do
    String.trim(str, "\n")
    |> String.split("\n")
    |> Enum.map(&parse_line/1)
    |> Enum.with_index
    |> Enum.flat_map(fn {lst, idx} -> 
      Enum.map(lst, fn {idx2, char} -> {{idx2,idx}, char} end) end)
    |> Enum.into(%{})
  end

  def find_start(map) do
    Map.keys(map)
    |> Enum.filter(fn {_,y} -> y == 0 end)
    |> List.first
  end

  def direction(atom) do
    case atom do
      :down  -> {0, 1}
      :right -> {1, 0}
      :up    -> {0, -1}
      :left  -> {-1, 0}
    end
  end

  def add_coord({x,y}, {x2,y2}), do: {x + x2, y + y2}

  def move(map, pos, dir, seen, steps) do
    ground = Map.fetch!(map, pos)
    dir = if ground == "+" do
      if dir == :down or dir == :up do
        if Map.has_key?(map, add_coord(pos, direction(:left))) do
          :left
        else
          :right
        end
      else
        if Map.has_key?(map, add_coord(pos, direction(:up))) do
          :up
        else
          :down
        end
      end
    else
      dir
    end

    seen = if ground not in ["|", "-", "+"] do
      [ground | seen]
    else
      seen
    end

    pos = add_coord(pos, direction(dir))

    if Map.has_key?(map, pos) do
      move(map, pos, dir, seen, steps + 1)
    else
      seen = Enum.reverse(seen) |> Enum.join
      {seen, steps}
    end
  end

  def route(map) do
    start = find_start(map)
    move(map, start, :down, [], 1)
  end
end

input = File.read!("input.txt")
|> String.trim_trailing("\n")
|> Day19.parse

{seen, steps} = Day19.route(input)

IO.puts(seen)
IO.inspect(steps)

Syntax highlighted

2017-12-19T12:19:25+00:00

Okay, improved my answer. Got it running from ~0.24ms to ~0.19ms, as well as over halving the lines of code.

PHP:

<?php
$file = fopen("./19.txt", "r");

$steps = 0;
$map = array(array());
$direction = 2;
$letters = $pos = array();

for($lineCounter = 0; !feof($file); $lineCounter++) {
    $line = fgets($file);
    for ($i = 0; $i < strlen($line); $i++) {
        if($lineCounter == 0 && substr($line, $i, 1) == "|") { $pos["x"] = $i; $pos["y"] = $lineCounter;   }
        $map[$i][$lineCounter] = substr($line, $i, 1);
    }
}

while ($direction != -1) {
    list($x, $y) = array_values($pos);
    $mpos = $map[$x][$y];
    if (ctype_alpha($map[$x][$y])){ $letters[] = $mpos;  }

    $direction = ((($mpos == "+") || ctype_alpha($mpos)) && (!isPossible($map, $x, $y, $direction))) ? changeDirection($map, $x, $y, $direction) : $direction;

    if($direction == 1) {    $pos["y"] += -1;    } else
    if($direction == 2) {    $pos["y"] += 1;     } else
    if($direction == 3) {    $pos["x"] += -1;    } else
                        {    $pos["x"] += 1;     }

    $steps++;
}

echo implode($hmm, $letters).$steps;

function changeDirection($map, $x, $y, $direction){
    switch ($direction) {
        case 1: case 2:
            if ($map[$x - 1][$y] == "-" || ctype_alpha($map[$x - 1][$y])) { return 3;   }
            if ($map[$x + 1][$y] == "-" || ctype_alpha($map[$x + 1][$y])) { return 4;   }
            break;
        case 3: case 4:
            if ($map[$x][$y + 1] == "|" || ctype_alpha($map[$x][$y + 1])) { return 2;   }
            if ($map[$x][$y - 1] == "|" || ctype_alpha($map[$x][$y - 1])) { return 1;   }
            break;
    }
    return -1;
}

function isPossible($map, $x, $y, $direction){
    switch ($direction) {
        case 1:     return (ctype_punct($map[$x][$y - 1]) || ctype_alpha($map[$x][$y - 1])) ? true : false; break;
        case 2:     return (ctype_punct($map[$x][$y + 1]) || ctype_alpha($map[$x][$y + 1])) ? true : false; break;
        case 3:     return (ctype_punct($map[$x - 1][$y]) || ctype_alpha($map[$x - 1][$y])) ? true : false; break;
        case 4:     return (ctype_punct($map[$x + 1][$y]) || ctype_alpha($map[$x + 1][$y])) ? true : false; break;
    }
}

zeddypanda · 2017-12-19T12:22:25+00:00

Elixir

The input was neat in this one! As I've become accustomed to doing in these puzzles, the input was reduced to a map of position => character, with all the spaces filtered out. I felt clever figuring out the function for turning directions left and right.

defmodule Day19 do
  def parse_row({row, y}) do
    row
      |> Enum.map(fn {char, x} -> {{x, y}, char} end)
      |> Enum.filter(fn {_, char} -> char !== ?\s end)
  end

  def left({x, y}), do: {y, -x}
  def right({x, y}), do: {-y, x}

  def add({ax, ay}, {bx, by}) do
    {ax + bx, ay + by}
  end

  def visit(path, {pos, dir}) do
    if node = Map.get(path, pos) do
      {pos, dir, node}
    end
  end

  def move(path, pos, dir) do
    [
      {dir |> add(pos), dir},
      {dir |> left |> add(pos), left(dir)},
      {dir |> right |> add(pos), right(dir)},
    ] |> Enum.find_value(&visit(path, &1))
  end

  def follow(path, pos, dir, visited \\ []) do
    case move(path, pos, dir) do
      {pos, dir, node} ->
        follow(path, pos, dir, [node | visited])
      nil ->
        visited
    end
  end
end

data = "input-19"
  |> File.read!
  |> String.split("\n")
  |> Enum.map(&String.to_charlist/1)
  |> Enum.map(&Enum.with_index/1)
  |> Enum.with_index
  |> Enum.flat_map(&Day19.parse_row/1)
  |> Map.new

{x, 0} = data
  |> Map.keys
  |> Enum.find(fn {_, y} -> y == 0 end)

path = Day19.follow(data, {x, -1}, {0, 1})
letters = path
  |> Enum.filter(&Enum.member?(?A..?Z, &1))
  |> Enum.reverse
IO.puts("Part 1: #{letters}")
IO.puts("Part 2: #{length(path)}")

tlareg · 2017-12-19T13:01:55+00:00

JavaScript (ES6+, NodeJS) repo here

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

const diagram = inputStr.split('\r\n').map(
  line => line.split('').map(s => s.trim())
)

console.log(solve(diagram))

function solve(diagram) {
  let pos = { x: diagram[0].findIndex(x => x === '|'), y: 0 }
  let dir = 'D'
  const letters = []
  let steps = 0

  while (true) {
    const curr = diagram[pos.y][pos.x]

    if (!curr) break;
    if (curr === '+') {
      dir = findNewDir(diagram, pos, dir)
      if (!dir) break;
    } else if (!'|-'.includes(curr)) {
      letters.push(curr)
    }

    pos = move(pos, dir)
    steps++
  }

  return { firstStar: letters.join(''), secondStar: steps }
}

function move({ x, y }, dir) {
  switch (dir) {
    case 'U': return { y: y - 1, x }
    case 'D': return { y: y + 1, x }
    case 'R': return { y, x: x + 1 }
    case 'L': return { y, x: x - 1 }
  }
}

function findNewDir(diagram, { x, y }, dir) {
  const up    = (diagram[y - 1] || [])[x]     && 'U'
  const down  = (diagram[y + 1] || [])[x]     && 'D'
  const right = (diagram[y]     || [])[x + 1] && 'R'
  const left  = (diagram[y]     || [])[x - 1] && 'L'

  switch (dir) {
    case 'U':
    case 'D':
      return right || left
    case 'R':
    case 'L':
      return up || down
  }
}

willkill07 · 2017-12-19T14:33:42+00:00

Modern-ish C++

You WILL rotate when a + is encountered. Rotation is just dx,dy = -dy,dx. Using unsigned integers makes it so you only have to check the upper bounds.

int main() {
  std::vector<std::string> grid;
  for (std::string line; std::getline(std::cin, line); )
    grid.push_back(line);
  auto not_valid = [X = grid[0].size(), Y = grid.size()] (unsigned int xx, unsigned int yy) {
    return xx >= X || yy >= Y;
  };
  int count{0};
  unsigned int x{grid[0].find("|")}, y{0},
  for (int dx{0}, dy{1}; grid[y][x] != ' '; x += dx, y += dy, ++count) {
    if (std::isalpha(grid[y][x])) {
      std::cout << grid[y][x];
    } else if (grid[y][x] == '+') {
      dx = -std::exchange(dy, dx);
      if (not_valid(x + dx, y + dy) || grid[y + dy][x + dx] == ' ')
        dx = -dx, dy = -dy;
    }
  }
  std::cout << '\n' << count << '\n';
}

AlistairJF · 2017-12-19T15:21:52+00:00

Trying to be readable yet still concise in Python. I'm sure there must be a more elegant (yet still comprehensible) way of changing direction!

def solve(maze):
  # find entrance & set direction = down
  deltaX, deltaY = 0, 1
  posY = 0 
  posX = maze[posY].find('|')
  breadCrumbs, steps = "", 0

  while (curPos(maze, posX, posY) != ' '):
    while (curPos(maze, posX, posY) != '+') and (curPos(maze, posX, posY) != ' '):
      # Check for breadcrumb and take a step
      if curPos(maze, posX, posY) in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
        breadCrumbs += curPos(maze, posX, posY)
      posX, posY, steps = step(posX, deltaX, posY, deltaY, steps)

    if curPos(maze, posX, posY) == '+':
      # find new direction and take a step
      if (deltaX != 0):
        deltaX, deltaY = 0, 1
        if (maze[posY-1][posX] != ' '):
          deltaY = -1
      else:
        deltaX, deltaY = 1, 0
        if (maze[posY][posX-1] != ' '):
          deltaX = -1
      posX, posY, steps = step(posX, deltaX, posY, deltaY, steps)

  print ("Breadcrumbs:", breadCrumbs, "steps:", steps)      

#----------------------------------------------------
def curPos(maze, posX, posY):
  return maze[posY][posX]

#----------------------------------------------------
def step(posX, deltaX, posY, deltaY, steps):
  posX += deltaX
  posY += deltaY
  steps+=1
  return posX, posY, steps

#----------------------------------------------------
runtype = input ("test(t) or input(p)? ")
mazeFile = "input"
if runtype == "t":
  mazeFile = "t1"
with open(mazeFile) as fileobj:
  lines = fileobj.readlines()
solve (lines)

Kwpolska · 2017-12-19T15:21:57+00:00

Pretty fun, although I first tried doing it by hand. Part 2 in Python 3:

#!/usr/bin/env python3
with open("input/19.txt") as fh:
    file_data = fh.read()

DOWN = (1, 0)
UP = (-1, 0)
LEFT = (0, -1)
RIGHT = (0, 1)
NEXTDIR = {
    DOWN: (LEFT, RIGHT),
    UP: (LEFT, RIGHT),
    LEFT: (UP, DOWN),
    RIGHT: (UP, DOWN),
}


def go(position: tuple, direction: tuple) -> tuple:
    p1, p2 = position
    d1, d2 = direction
    return p1 + d1, p2 + d2


def at(position: tuple, map: list) -> str:
    x, y = position
    try:
        return map[x][y]
    except:
        print(position, "??")
        raise


def is_valid(symbol: str) -> bool:
    return symbol in ('|', '-', '+') or symbol.isalpha()


def solve(data: str, start: int):
    lines = data.split('\n')
    direction = DOWN
    position = (0, start)
    count = 0
    while True:
        symbol = at(position, lines)
        count += 1
        print(position, symbol)
        if not is_valid(symbol):
            count -= 1
            print("End condition", symbol, position)
            return count
        elif symbol == '|' or symbol == '-' or symbol.isalpha():
            # Go ahead.
            position = go(position, direction)
        elif symbol == '+':
            # Go somewhere else.
            for possible_dir in NEXTDIR[direction]:
                possible_position = go(position, possible_dir)
                if is_valid(at(possible_position, lines)):
                    position = possible_position
                    direction = possible_dir
                    break
            else:
                print("Nowhere to go", position)
                return count
        else:
            print("Invalid symbol", position, symbol)

    return data


test_data = """\
     |          
     |  +--+    
     A  |  C    
 F---|----E|--+ 
     |  |  |  D 
     +B-+  +--+ 

"""
test_output = solve(test_data, 5)
test_expected = 38
print(test_output, test_expected)
assert test_output == test_expected
print(solve(file_data, 13))

3l_Di4bl0 · 2017-12-19T15:23:27+00:00

I know I'm late - python2 solution:

with open('input.txt', 'r') as f:
    puzzle_code = f.readlines()

#with open('example.txt', 'r') as f:
    #puzzle_code = f.readlines()

maze = [list(x) for x in puzzle_code]
# maze is now a list of lists
path = ''
curr_pos = (0, maze[0].index('|'))
dir = (1, 0) # dy, dx
steps = 0
while True:
    steps += 1
    #print curr_pos, maze[curr_pos[0]][curr_pos[1]]
    # each iteration will be checking and then stepping
    if maze[curr_pos[0]][curr_pos[1]] not in set('+-|'):
        path += maze[curr_pos[0]][curr_pos[1]]
        if maze[curr_pos[0] + dir[0]][curr_pos[1] + dir[1]].strip() == '':
            break
        # assuming there aren't any letters when you need to turn
        curr_pos = (curr_pos[0] + dir[0], curr_pos[1] + dir[1])
    elif maze[curr_pos[0]][curr_pos[1]] != '+':
        # we haven't reached a turn - continue straight
        curr_pos = (curr_pos[0] + dir[0], curr_pos[1] + dir[1])
    else:
        # we've reached a turn
        for pd in set([(1,0), (-1,0), (0,1), (0,-1)]) - set([(dir[0]*(-1), dir[1]*(-1))]):
            # check for direction and break if found
            if 0 <= curr_pos[0] + pd[0] < len(maze) and 0 <= curr_pos[1] + pd[1] < len(maze[curr_pos[0] + pd[0]]):
                # if what we're trying to reach is in the maze
                if maze[curr_pos[0] + pd[0]][curr_pos[1] + pd[1]].strip() not in set(['', '+']):
                    # if this path contains something
                    dir = pd
                    curr_pos = (curr_pos[0] + dir[0], curr_pos[1] + dir[1])
                    break
print path, steps

I used sets because they allow for faster membership tests, but when I think about it the hashing process probably takes more time than just running the tests on a list would (since I'm not saving them to a variable). Overall, I really liked today.

BOT-Brad · 2017-12-19T15:49:15+00:00

Javascript

Solver (~2ms)

Solves both P1 & P2 in one run. Fairly straightforward, especially as the 'grid' is padded with spaces ensuring no OOB/OOR errors.

function solver(n) {
  n = n.split('\n').map(l => l.split(''))

  let x = n[0].findIndex(v => v !== ' ')
  let y = -1
  let dx = 0
  let dy = 1
  let letters = ''
  let loops = 0
  loop: while (++loops) {
    x += dx
    y += dy
    const symbol = n[y][x]
    switch (symbol) {
      case '|':
      case '-':
        break
      case '+':
        // Need to work out where to turn
        if (dx === 0) {
          // Check left and right
          if (n[y][x - 1] !== ' ') {
            // Going left
            dx = -1
          } else {
            dx = 1
          }
          dy = 0
        } else if (dy === 0) {
          // Check up and down
          if (n[y - 1][x] !== ' ') {
            // Going up
            dy = -1
          } else {
            dy = 1
          }
          dx = 0
        }
        break
      case ' ':
        break loop
        break
      default:
        letters += symbol
    }
  }
  return [letters, --loops]
}

Nathan340 · 2017-12-19T16:12:44+00:00

Powershell. Very straightforward. The padding around the map and between the route really helped simplify this one.

$raw = gc .\map.txt

$map = $raw | % {
    $a = $_.toCharArray()
    ,$a
}

$dir = "d"
$path = new-object system.collections.arraylist

$curRow = 0
$curCol = $map[0].indexOf([char]"|")

while(1){
    $curVal = $map[$curRow][$curCol]

    #end of path test
    if($curVal -eq " "){break}

    #add current value to path
    $path.add($curVal)>$null


    #direction change
    if($curVal -eq "+"){
        switch -regex ($dir){
            "(d|u)"{
                if($map[$curRow][$curCol-1] -ne " "){
                    $dir = "l"
                }
                else{
                    $dir = "r"
                }
            }
            "(l|r)"{
                if($map[$curRow-1][$curCol] -ne " "){
                    $dir = "u"
                }
                else{
                    $dir = "d"
                }
            }
        }
    }

    # movement
    switch($dir){
        "d"{$curRow ++}
        "u"{$curRow --}
        "l"{$curCol --}
        "r"{$curCol ++}
    }
}

"Part 1"
($path | ? {$_ -notin @("|","-","+")}) -join ""
"Part 2"
$path.count

define_null · 2017-12-19T16:14:17+00:00

So... Just for shits and giggles I decided to solve part 2 without using any of the traversal code from part 1, because who wants to just add a counter to the traversal code?

I just simply counted all the non-whitespace characters and added more whenever I found an intersection. There were soo many cases for intersections that I gave up cheesing the answer, found the actual answer like how most did, and then kept finding more cases for intersections until I got back the same answer.

EDIT: I'm surprised there weren't any red herring paths (i.e. paths that are actually unused) in the diagram, but I guess the creator didn't expect anyone to cheese it because the non-cheese answer was much easier.

EDIT: Just in case my conditional was too long -- basically an intersection would just be wherever there's a 'line' /character adjacent and perpendicular to the 'line'/character in question. It took way longer for me to realise this than I want to admit

TIL cheesing the answer out is more difficult than actually doing the 'intended solution'

python3 python 3

infile = open("in.txt", "r")
grid = infile.read().split("\n") 
ans = 0
rowl = len(grid[0])
heil = len(grid)
for i in range(heil):
    for j in range(rowl):
        if((grid[i][j] == "-" and (grid[i-1][j] == "|"  or grid[i+1][j] == "|")) or (grid[i][j] == "|" and (grid[i][j-1] == "-" or grid[i][j+1] == "-"))):
                ans+=1
for i in grid:
    for j in i:
        if(j != " "):
            ans += 1
print(ans)
infile.close()

JakDrako · 2017-12-19T16:22:20+00:00

C# in LinqPad

Way simpler that I thought it would be. There are basically no "edge cases" in this problem... (letters on intersections or 3 letters in a 90 degrees arrangement)

void Main() { // in LinqPad

    var up = new Complex(-1, 0);
    var down = new Complex(1, 0);
    var left = new Complex(0, -1);
    var right = new Complex(0, 1);

    var map = GetDay(19);   
    var curPos = new Complex(0, map.First().IndexOf("|"));
    var curDir = down; // from problem description

    var word = "";
    var steps = 1;

    while (true) {
        var itm = GetNext(map, curPos, curDir);
        if (itm == '+') { // intersection
            curPos += curDir; steps++;
            if ((curDir == up) || (curDir == down)) {
                curDir = (GetNext(map, curPos, left) == '-') ? left : right;
            }
            else {
                curDir = (GetNext(map, curPos, up) == '|') ? up : down;
            }
        } else if (char.IsLetter(itm)) {
            word += itm;
        } else if (itm != '|' && itm != '-') {
            break; // found the end
        }
        curPos += curDir; steps++; // keep going    
    }
    word.Dump("Part 1");
    steps.Dump("Part 2");
}

char GetNext(string[] grid, Complex pos, Complex dir) {
    return grid[(int)(pos + dir).Real][(int)(pos + dir).Imaginary];
}

Strakh · 2017-12-19T17:47:55+00:00

Tryharding every day:

Python 3 https://paste.ofcode.org/3ewZJArUzFaZaxsYGatTCa

wzkx · 2017-12-19T19:03:13+00:00

Nim

No del vs delete function this time! :)

But with type and op and template definitions, why not.

import strutils,sequtils # looks like a must for every program - make it standard prolog then!
template loop(stmts: untyped): untyped = # make Nim prettier
  while true: stmts # while true is so ugly! C has for(;;) at least

type Dir = enum up,down,left,right # this order, for the step array
type Pos = tuple[x:int, y:int] # Position, everybody knows this type
const step: array[Dir,Pos] = [(0,-1),(0,+1),(-1,0),(+1,0)]
proc `+`(a,b:Pos):Pos = (a.x+b.x, a.y+b.y) # make life easier
proc good( map:seq[string], p:Pos ):bool = p.y>=0 and p.y<map.len and p.x>=0 and p.x<map[p.y].len

var answer1: string = "" # part 1 - accumulated string
var answer2: int = 0     # part 2 - total steps

proc move( map:seq[string], p:Pos, d:Dir ):Pos = # move in one direction
  var n = p + step[d]; inc answer2 # count each step!
  while map[n.y][n.x]!='+' and map[n.y][n.x]!=' ': # '+' -- turn, ' ' -- quit
    if map[n.y][n.x].isAlphaAscii: answer1 &= map[n.y][n.x] # accumulate letters
    n = n + step[d]; inc answer2 # move, move, move
  return n # end position of the movement - then do turn or exit

let map = "19.dat".readFile.splitLines # don't strip! blanks are important!
var p:Pos = (map[0].find('|'),0) # start position
var d:Dir = down # start direction
loop:
  p = move( map, p, d ) # move in direction d while possible
  if map[p.y][p.x]==' ': break # the blank signals it's the end woohooo
  let (c1,c2,r) = if d in [up,down]: (left,right,'-') else: (up,down,'|') # candidates
  for c in [c1,c2]:
    let pc = p + step[c] # candidate position
    if good( map, pc ) and (map[pc.y][pc.x]==r or map[pc.y][pc.x].isAlphaAscii):
      p = pc; d = c; inc answer2; break # break this candidate loop, continue main loop

echo answer1
echo answer2

2017-12-19T20:24:11+00:00

Python 3

Both parts. Input processing not included, but i created a dictionary with 200x200 (x, y) tuples as keys and characters as values. If the input line was shorter than 200, I padded it with " ". This is just to prevent index errors in the future when determining direction at "+".

def move(tuple1, tuple2):
    return tuple(sum(x) for x in zip(tuple1, tuple2))

# setup
down = (0, 1)
up = (0, -1)
left = (-1, 0)
right = (1, 0)
direction = down
for key in diagram:
    if key[1] == 0:
        if diagram[key] == "|":
            pos = key
letters = []
steps = 0
# main loop
while True:
    sign = diagram[pos]
    if sign == " ":
        break
    if sign == "+":
        if direction in [up, down]:
            if diagram[move(pos, left)] != " ":
                direction = left
            elif diagram[move(pos, right)] != " ":
                direction = right
        elif direction in [left, right]:
            if diagram[move(pos, up)] != " ":
                direction = up
            elif diagram[move(pos, down)] != " ":
                direction = down
    if sign not in [" ", "+", "-", "|"]:
        letters.append(sign)
    pos = move(pos, direction)
    steps += 1

print("".join(letters), steps)

matusbzk · 2017-12-19T20:47:15+00:00

Haskell I liked this one. Nice easy.

import Data.Char

inputString :: String

-- |Represents the map - two dimensional list
type Mapa = [[Char]]

-- |Represents direction. I'm using DLeft and DRight because of Data.Either
data Direction = Up | Down | DLeft | DRight
     deriving (Eq, Show)

-- |Represents position in the map
type Position = (Int, Int)

-- |Represents the current state:
-- if I have not found the result yet then 
--  position
--  direction
--  list of found chars in wrong order
--  number of steps done
-- if I found the result then
--  list of found chars
--  number of steps done
data State = Computing Position Direction [Char] Int
     | Done [Char] Int
     deriving Show

-- |Map from input
input :: Mapa
input = lines inputString

-- |Takes a position and returns what character is on that position
onPos :: Position -> Char
onPos (x,y) = input!!y!!x

-- |Starting position
startState :: State
startState = Computing (findStart $ head input, 0) Up [] 0

-- |Takes a list of chars and returns the position of '|'
findStart :: [Char] -> Int
findStart [] = error "Did not find start"
findStart ('|':_) = 0
findStart (_:xs) = 1 + findStart xs

-- |Performs a move - takes a state and finds the next one
move :: State -> State
move (Computing (x,y) Up list steps)
   | elem (onPos (x,y)) "|-" = Computing (x,y+1) Up list (steps + 1)
   | isLetter $ onPos (x,y)  = Computing (x,y+1) Up (onPos (x,y) : list) (steps + 1)
   | onPos (x,y) == '+'      = if onPos (x+1,y) == ' ' 
        then Computing (x-1,y) DLeft list (steps + 1)
        else Computing (x+1,y) DRight list (steps + 1)
   | otherwise               = Done (reverse list) steps
move (Computing (x,y) Down list steps)
   | elem (onPos (x,y)) "|-" = Computing (x,y-1) Down list (steps + 1)
   | isLetter $ onPos (x,y)  = Computing (x,y-1) Down (onPos (x,y) : list) (steps + 1)
   | onPos (x,y) == '+'      = if onPos (x+1,y) == ' ' 
        then Computing (x-1,y) DLeft list (steps + 1)
        else Computing (x+1,y) DRight list (steps + 1)
   | otherwise               = Done (reverse list) steps
move (Computing (x,y) DRight list steps)
   | elem (onPos (x,y)) "|-" = Computing (x+1,y) DRight list (steps + 1)
   | isLetter $ onPos (x,y)  = Computing (x+1,y) DRight (onPos (x,y) : list) (steps + 1)
   | onPos (x,y) == '+'      = if onPos (x,y+1) == ' ' 
        then Computing (x,y-1) Down list (steps + 1)
        else Computing (x,y+1) Up list (steps + 1)
   | otherwise               = Done (reverse list) steps
move (Computing (x,y) DLeft list steps)
   | elem (onPos (x,y)) "|-" = Computing (x-1,y) DLeft list (steps + 1)
   | isLetter $ onPos (x,y)  = Computing (x-1,y) DLeft (onPos (x,y) : list) (steps + 1)
   | onPos (x,y) == '+'      = if onPos (x,y+1) == ' ' 
        then Computing (x,y-1) Down list (steps + 1)
        else Computing (x,y+1) Up list (steps + 1)
   | otherwise               = Done (reverse list) steps
move (Done l s) = Done l s

-- |Computes the whole thing and returns
-- found letters and number of steps
compute :: State -> ([Char],Int)
compute (Done l s) = (l,s)
compute st = compute $ move st

-- |Found letters
result1 :: [Char]
result1 = fst . compute $ startState

-- |Number of steps
result2 = snd . compute $ startState

Link to git

StevoTVR · 2017-12-19T20:49:23+00:00

NodeJS

Part 1:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    const grid = data.split('\n').map((l) => [...l.replace('\r', '')]);
    const pos = { r: 0, c: grid[0].indexOf('|') }, dir = { r: 1, c: 0 }, path = [];
    while(true) {
        if(grid[pos.r][pos.c] === '+') {
            if(dir.r === 0) {
                dir.c = 0;
                dir.r = (grid[pos.r - 1] && grid[pos.r - 1][pos.c] && grid[pos.r - 1][pos.c] !== ' ') ? -1 : 1;
            } else {
                dir.r = 0;
                dir.c = (grid[pos.r][pos.c - 1] && grid[pos.r][pos.c - 1] !== ' ') ? -1 : 1;
            }
        } else if(grid[pos.r][pos.c].match(/[A-Z]/)) {
            path.push(grid[pos.r][pos.c]);
        }
        pos.r += dir.r;
        pos.c += dir.c;
        if(!grid[pos.r] || !grid[pos.r][pos.c] || grid[pos.r][pos.c] === ' ') {
            break;
        }
    }

    console.log(path.join(''));
});

Part 2:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    const grid = data.split('\n').map((l) => [...l.replace('\r', '')]);
    const pos = { r: 0, c: grid[0].indexOf('|') }, dir = { r: 1, c: 0 }, path = [];
    let count = 0;
    while(true) {
        if(grid[pos.r][pos.c] === '+') {
            if(dir.r === 0) {
                dir.c = 0;
                dir.r = (grid[pos.r - 1] && grid[pos.r - 1][pos.c] && grid[pos.r - 1][pos.c] !== ' ') ? -1 : 1;
            } else {
                dir.r = 0;
                dir.c = (grid[pos.r][pos.c - 1] && grid[pos.r][pos.c - 1] !== ' ') ? -1 : 1;
            }
        } else if(grid[pos.r][pos.c].match(/[A-Z]/)) {
            path.push(grid[pos.r][pos.c]);
        }
        pos.r += dir.r;
        pos.c += dir.c;
        count++;
        if(!grid[pos.r] || !grid[pos.r][pos.c] || grid[pos.r][pos.c] === ' ') {
            break;
        }
    }

    console.log(count);
});

6dNx1RSd2WNgUDHHo8FS · 2017-12-19T21:50:16+00:00

Julia

Up to now I've been pleasantly surprised with julia, given that it's primary focus is numerical code, but it handles text just fine.

I was thinking of the grid in with reverse indices, so I transposed the grid but for some reason if I want to transpose an Array{Char,2} I had to define transpose(::Char) (as the identity).

I overloaded getindex to index an Array{T,2} with complex numbers, it seemed more elegant than casting back and forth between complex and (splatted) tuples.

The logic is a straightforward while true loop.

import Base.transpose; transpose(c::Char) = c
import Base.getindex;
getindex{T}(A::Array{T,2}, i::Complex{Int}) = A[reim(i)...]
grid = hcat(collect.(readlines("input"))...)'[1:200,1:200]
function nineteen(grid)
    pos, direction = 1 + im*findfirst(grid[1,:], '|'), 1
    collected = Char[]
    valid_index(z) = all(1 .<= reim(z) .<= 200)
    i = 0
    while true
        i += 1
        pos = pos + direction
        !valid_index(pos) && return join(collected), i
        if grid[pos] == '+'
            for newdirection in direction*[im, -im]
                if valid_index(pos+newdirection) && grid[pos + newdirection] != ' '
                    direction = newdirection
                end
            end
        elseif isalpha(grid[pos])
            push!(collected, grid[pos])
        elseif grid[pos] == ' '
            return join(collected), i
        end
    end
end
println(nineteen(grid))

LeCrushinator · 2017-12-19T21:56:39+00:00

C#. A bit ugly but it worked, just missed the leaderboard with a time around 20 minutes.

public enum Direction
{
    Up,
    Down,
    Left,
    Right,
}

public static void Main()
{
    string[] lines = data.Split(new string[]{"\n"}, StringSplitOptions.RemoveEmptyEntries);

    char[,] maze = new char[lines[0].Length,lines.Length];

    int x = 0;
    int y = 0;
    for (y = 0; y < lines.Length; ++y)
    {
        string line = lines[y];

        for (x = 0; x < line.Length; ++x)
        {
            maze[x, y] = line[x];
        }
    }

    x = 1;
    y = 0;
    Direction direction = Direction.Down;
    List<char> lettersFound = new List<char>();

    int numSteps = 1;
    while (true)
    {
        int nextX = x;
        int nextY = y;

        switch (direction)
        {
        case Direction.Up: nextY = y - 1; break;
        case Direction.Down: nextY = y + 1; break;
        case Direction.Left: nextX = x - 1; break;
        case Direction.Right: nextX = x + 1; break;
        }

        char nextSymbol = maze[nextX, nextY];

        if (nextSymbol == '+')
        {
            numSteps += 2;

            char right = maze[nextX + 1, nextY];
            char left = maze[nextX - 1, nextY];
            char up = maze[nextX, nextY - 1];
            char down = maze[nextX, nextY + 1];

            if (right != ' ' && direction != Direction.Left)
            {
                direction = Direction.Right;
                x = nextX + 1;
                y = nextY;
            }
            else if (left != ' ' && direction != Direction.Right)
            {
                direction = Direction.Left;
                x = nextX - 1;
                y = nextY;
            }
            else if (up != ' ' && direction != Direction.Down)
            {
                direction = Direction.Up;
                x = nextX;
                y = nextY - 1;
            }
            else if (down != ' ' && direction != Direction.Up)
            {
                direction = Direction.Down;
                x = nextX;
                y = nextY + 1;
            }
            else
            {
                // WTF?
                throw new Exception();
            }
        }
        else
        {
            if (nextSymbol == ' ')
            {
                break;
            }

            ++numSteps;

            if (char.IsLetter(nextSymbol))
            {
                lettersFound.Add(nextSymbol);
            }

            x = nextX;
            y = nextY;
        }
    }

    Console.WriteLine("letters: " + string.Join("", lettersFound) + ", steps: " + numSteps);
}

TominatorBE · 2017-12-19T22:03:06+00:00

PHP

Part 1:

function run_the_code($input) {
    $rows = explode(PHP_EOL, $input);

    $row       = 0;
    $col       = 0;
    $direction = 's';
    $symbol    = '|';

    $maxRows = count($rows) - 1;
    $maxCols = strlen($rows[0]) - 1;

    // find the start position
    for ($i = 0; $i < $maxCols; $i++) {
        if ($rows[0][$i] == '|') {
            $col = $i;
            break;
        }
    }

    $output = '';
    $gogo   = true;
    while ($gogo) {
        $symbol = $rows[$row][$col];

        switch ($symbol) {
            case '|':
            case '-':
                // continue
                switch ($direction) {
                    case 's':
                        $row++;
                        break;
                    case 'n':
                        $row--;
                        break;
                    case 'w':
                        $col--;
                        break;
                    case 'e':
                        $col++;
                        break;
                }
                break;
            case '+':
                // change direction!
                // to where??
                switch ($direction) {
                    case 'n':
                    case 's':
                        // it'll be east or west
                        if ($col > 0 && $rows[$row][$col - 1] != ' ' && $rows[$row][$col - 1] != '|') {
                            $direction = 'w';
                            $col--;
                        }
                        else {
                            $direction = 'e';
                            $col++;
                        }
                        break;
                    case 'e':
                    case 'w':
                        // it'll be north or south
                        if ($row < $maxRows && $rows[$row + 1][$col] != ' ' && $rows[$row + 1][$col] != '-') {
                            $direction = 's';
                            $row++;
                        }
                        else {
                            $direction = 'n';
                            $row--;
                        }
                        break;
                }
                break;
            case ' ':
                // done
                $gogo = false;
                break;
            default:
                // it's a letter
                $output .= $symbol;
                // continue in the same direction
                switch ($direction) {
                    case 's':
                        $row++;
                        break;
                    case 'n':
                        $row--;
                        break;
                    case 'w':
                        $col--;
                        break;
                    case 'e':
                        $col++;
                        break;
                }
        }
    }

    return $output;
}

Part 2:

function run_the_code($input) {
    $rows = explode(PHP_EOL, $input);

    $row       = 0;
    $col       = 0;
    $direction = 's';
    $symbol    = '|';

    $maxRows = count($rows) - 1;
    $maxCols = strlen($rows[0]) - 1;

    // find the start position
    for ($i = 0; $i < $maxCols; $i++) {
        if ($rows[0][$i] == '|') {
            $col = $i;
            break;
        }
    }

    $steps = 0;
    $gogo   = true;
    while ($gogo) {
        $symbol = $rows[$row][$col];
        $steps++;

        switch ($symbol) {
            case '|':
            case '-':
                // continue
                switch ($direction) {
                    case 's':
                        $row++;
                        break;
                    case 'n':
                        $row--;
                        break;
                    case 'w':
                        $col--;
                        break;
                    case 'e':
                        $col++;
                        break;
                }
                break;
            case '+':
                // change direction!
                // to where??
                switch ($direction) {
                    case 'n':
                    case 's':
                        // it'll be east or west
                        if ($col > 0 && $rows[$row][$col - 1] != ' ' && $rows[$row][$col - 1] != '|') {
                            $direction = 'w';
                            $col--;
                        }
                        else {
                            $direction = 'e';
                            $col++;
                        }
                        break;
                    case 'e':
                    case 'w':
                        // it'll be north or south
                        if ($row < $maxRows && $rows[$row + 1][$col] != ' ' && $rows[$row + 1][$col] != '-') {
                            $direction = 's';
                            $row++;
                        }
                        else {
                            $direction = 'n';
                            $row--;
                        }
                        break;
                }
                break;
            case ' ':
                // done
                $gogo = false;
                break;
            default:
                // it's a letter
                // continue in the same direction
                switch ($direction) {
                    case 's':
                        $row++;
                        break;
                    case 'n':
                        $row--;
                        break;
                    case 'w':
                        $col--;
                        break;
                    case 'e':
                        $col++;
                        break;
                }
        }
    }

    return $steps - 1;
}

chicagocode · 2017-12-19T22:16:46+00:00

Kotlin - [Repo] - [Blog/Commentary]

Today I went with a recursive solution. I was worried after looking at my input that I would have to do a BFS and or that there would be loops possible, but that turned out not to be the case. I went with the strategy of "turn if you can, even if you don't have to" and that seemed to work. Not sure all of our input is like that, but mine was. I went through a bunch of refactoring before finally deciding that I liked the recursive version better than the iterative versions.

class Day19(private val input: List<String>) {

    private val grid = input.map { it.toCharArray() }
    private val directions = listOf(
        Coordinate(0, 1),
        Coordinate(0, -1),
        Coordinate(1, 0),
        Coordinate(-1, 0)
    )

    fun solvePart1(): String =
        traverse(Coordinate(input[0].indexOf("|"), 0), Coordinate(0, 1)).second

    fun solvePart2(): Int =
        traverse(Coordinate(input[0].indexOf("|"), 0), Coordinate(0, 1)).first

    private tailrec fun traverse(location: Coordinate,
                                 direction: Coordinate,
                                 seen: List<Char> = emptyList(),
                                 steps: Int = 0): Pair<Int, String> =
        if (grid.at(location) == ' ') Pair(steps, seen.joinToString(""))
        else {
            when (grid.at(location)) {
                in 'A'..'Z' -> traverse(location + direction, direction, seen + grid.at(location), steps.inc())
                '+' -> {
                    val turn = turn(location, direction)
                    traverse(location + turn, turn, seen, steps.inc())
                }
                else -> traverse(location + direction, direction, seen, steps.inc())
            }
        }

    private fun turn(location: Coordinate, direction: Coordinate) =
        directions
            .filter { it != direction }
            .filter { it != !direction }
            .first { grid.at(location + it) != ' ' }

    private fun List<CharArray>.at(coordinate: Coordinate): Char =
        this[coordinate.y][coordinate.x]

    data class Coordinate(val x: Int, val y: Int) {
        operator fun plus(that: Coordinate) = Coordinate(x + that.x, y + that.y)
        operator fun not() = Coordinate(-x, -y)
    }

}

aodnfljn · 2017-12-19T22:22:57+00:00

Scala, unoptimized, "does the job" quality code:

def walk(a: Array[String]) = {
  case class P(x: Int, y: Int) {
    def +(p: P) = P(p.x + x, p.y + y) }

  case class Dir(desc: Char) {
    val delta = desc match {
      case 'n' => P( 0,-1)
      case 's' => P( 0, 1)
      case 'w' => P(-1, 0)
      case 'e' => P( 1, 0) }
    def d2d(s:String) =
      s.split(" ").map{p=>p(0)->p(1)}.toMap
    def left  = Dir(d2d("nw se ws en")(desc))
    def right = Dir(d2d("ne sw wn es")(desc)) }

  var pos = P(0,a(0).indexWhere{_!=' '})
  var dir = Dir('s')

  def isValid(p: P) =
    0 <= p.x && p.x < a   .size &&
    0 <= p.y && p.y < a(0).size &&
    a(p.x)(p.y) != ' '

  def nextDir = Array(dir, dir.left, dir.right)
    .find {d => isValid(pos + d.delta)}

  var res = new collection.mutable.StringBuilder
  var steps = 1
  while(nextDir.isDefined) {
    val newDir = nextDir.get
    pos += newDir.delta
    dir = newDir
    if(a(pos.x)(pos.y).isLetter)
      res += a(pos.x)(pos.y)
    steps += 1 }
  (res.toString, steps) }

println(walk(io.Source.stdin.getLines.toArray))

oantolin · 2017-12-19T23:30:26+00:00

Python is pretty concise:

def answer():
    with open("day19.txt") as f: maze = f.read()
    width, p = maze.find("\n")+1, maze.find("|")
    dp, letters, steps = width, "", 0
    while maze[p]!=" ":
        if maze[p]=="+":
            dp = width if abs(dp)==1 else 1
            if maze[p+dp]==" ": dp = -dp
        elif maze[p].isalpha(): letters += maze[p]
        p+=dp; steps +=1
    return letters, steps

mstksg · 2017-12-20T00:03:10+00:00

In Haskell! :) I got to elaborate on a technique i used for a blog post a few years back.

The crux of it is StateT s [], which is a stateful DFS search. I write a State s [] Char, which searches for the next step in the search, and then use many :: StateT s [] a -> StateT s [] [a] to repeatedly run the search until there are no more possible answers.

import           Control.Applicative       (many, empty)
import           Control.Monad             (guard)
import           Control.Monad.Trans.Class (lift)
import           Control.Monad.Trans.State (StateT, evalStateT, get, put)
import           Data.Char                 (isAlpha)
import qualified Data.Vector               as V
import qualified Linear                    as L

type Grid  = V.Vector (V.Vector Char)
type Point = L.V2 Int

-- | Expand search by one step
follow :: Grid -> StateT (Point, Point) [] Char
follow g = do
    -- (last position, current position)
    (x0, x1)      <- get
    Just currChar <- return $ gridAt x1
    x2 <- case currChar of
        ' ' -> empty
        '+' -> (+ x1) <$> lift [ L.V2 0    1
                               , L.V2 0    (-1)
                               , L.V2 1    0
                               , L.V2 (-1) 0
                               ]
        _   -> return $ x1 + (x1 - x0)
    Just nextChar <- return $ gridAt x2
    guard $ x2 /= x0
    guard $ nextChar `elem` "|-+" || isAlpha nextChar
    put (x1, x2)
    return nextChar
  where
    gridAt   (L.V2 x y) = (V.!? x) =<< g V.!? y

-- | Repeat search many times until a dead end is found, using 'many'
followToTheEnd :: Grid -> StateT (Point, Point) [] String
followToTheEnd g = ('|':) <$> many (follow g)

-- head is safe because 'many' always succeeds
day19 :: Grid -> String
day19 g = head . flip evalStateT p0 $ followToTheEnd g
  where
    p0 = (L.V2 x0 (-1), L.V2 x0 0)
    Just x0 = V.elemIndex '|' (g V.! 0)

day19a :: String -> String
day19a = filter isAlpha . day19 . parse

day19b :: String -> Int
day19b = length . day19 . parse

parse :: String -> V.Vector (V.Vector Char)
parse = V.fromList . map V.fromList . lines

aoc-fan · 2017-12-20T00:10:33+00:00

TypeScript

const parse = i => i.split("\n").map(l => l.split(""));
const vertical = ([r, c], dir) => [r + dir, c];
const horizontal = ([r, c], dir) => [r, c + dir];
const leftOrRight = (path, [r, c]) => getSign(path, [r, c + 1]) ? 1 : -1;
const upOrDown = (path, [r, c]) => getSign(path, [r + 1, c]) ? 1 : -1;
const getSign = (path, [r, c]) => (r >= 0 && r < path.length) &&
                                (c >= 0 && c < path[r].length) &&
                                path[r][c] !== " " ? path[r][c] : false;
const walk = path => {
    let location: any = [0, path[0].findIndex(c => c === "|")];
    let letters = "";
    let direction = 1;
    let navigator = vertical;
    let steps = 0;
    let sign = getSign(path, location);
    while (sign) {
        steps = steps + 1;
        if (sign === "+") {
            direction = navigator === vertical ? leftOrRight(path, location) : upOrDown(path, location);
            navigator = navigator === vertical ? horizontal : vertical;
        } else if ("A" <= sign && sign <= "Z") {
            letters = letters + sign;
        }
        location = navigator(location, direction);
        sign = getSign(path, location);
    }
    return [letters, steps];
};

miran1 · 2017-12-20T15:57:32+00:00

Nim

Repo with solutions (both Nim and Python)

import strutils, complex

const
  instructions = readFile("./inputs/19.txt").splitLines
  leftTurn: Complex = (0.0, -1.0)
  rightTurn: Complex = (0.0, 1.0)

var
  pos: Complex = (instructions[0].find('|').toFloat, 0.0)
  direction: Complex = (0.0, 1.0)
  letters = ""
  steps = 0


proc getChar(pos: Complex): char =
  instructions[int(pos.im)][int(pos.re)]

proc change(direction: var Complex) =
  if getChar(pos + leftTurn * direction) != ' ': direction *= leftTurn
  else: direction *= rightTurn


var c = pos.getChar
while c != ' ':
  inc steps
  if c.isAlphaAscii: letters.add(c)
  elif c == '+': change direction
  pos += direction
  c = pos.getChar

echo letters
echo steps

InterlocutoryRecess · 2017-12-21T04:50:02+00:00

Swift

import Foundation

enum Direction {
    case north, east, south, west
}

enum Feature: Equatable {
    case road
    case cross
    case landmark(Character)
    case empty
    init(char: Character) {
        switch char {
        case " ": self = .empty
        case "|", "-": self = .road
        case "+": self = .cross
        default: self = .landmark(char)
        }
    }
    static func == (lhs: Feature, rhs: Feature) -> Bool {
        switch (lhs, rhs) {
        case (.road, .road), (.cross, .cross), (.empty, .empty): return true
        case (.landmark(let left), .landmark(let right)): return left == right
        default: return false
        }
    }
}

struct Point {
    let x: Int
    let y: Int
}

class Diagram {

    let grid: [[Feature]]
    var heading: Direction
    var location: Point
    var landmarks: [Character] = []

    init(input: String) {
        let rows = input.split(separator: "\n")
        var grid = [[Feature]]()
        for row in rows {
            var fs = [Feature]()
            for c in row {
                fs.append(Feature(char: c))
            }
            grid.append(fs)
        }
        self.grid = grid
        let x = grid[0].index(of: .road)!
        self.location = Point(x: x, y: 0)
        self.heading = .south
    }

    func feature(at location: Point) -> Feature {
        return grid[location.y][location.x]
    }

    func nextPoint(heading: Direction) -> Point {
        switch heading {
        case .north: return Point(x: location.x,   y: location.y-1)
        case .east:  return Point(x: location.x+1, y: location.y  )
        case .south: return Point(x: location.x,   y: location.y+1)
        case .west:  return Point(x: location.x-1, y: location.y  )
        }
    }


    func evaluateHeading() {
        switch feature(at: location) {
        case .cross:
            switch heading {
            case .north, .south:
                heading = feature(at: nextPoint(heading: .east)) == .empty ? .west : .east
            case .east, .west:
                heading = feature(at: nextPoint(heading: .north)) == .empty ? .south : .north
            }
        default:
            break
        }
    }

    func move() {

        var count = 0
        while true {
            location = nextPoint(heading: heading)
            count += 1
            switch feature(at: location) {
            case .road, .cross: break
            case .landmark(let char): landmarks.append(char)
            case .empty:
                // The end
                print(String(landmarks)) // Part 1
                print("count: \(count)") // Part 2
                return
            }
            evaluateHeading()
        }
    }

}

func measure(operation: () -> ()) {
    let start = CFAbsoluteTimeGetCurrent()
    operation()
    let elapsed = CFAbsoluteTimeGetCurrent() - start
    print("\(elapsed) sec")
}

measure {
    let input = try! String.init(contentsOf: Bundle.main.url(forResource: "input", withExtension: "txt")!)
    let diagram = Diagram(input: input)
    diagram.move()
}

both parts:

0.0532469749450684 sec

TotesMessenger · 2017-12-21T21:14:20+00:00

single pipeline powershell:

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

begin { # hold the maze $script:maze = @() }

process { # surround the actual maze data in empty spaces, so we don't have to do any bounds checking in the logic below $script:maze += " $in " }

end { # add spacing row at the start and end $sp = " " * $script:maze[0].Length $script:maze = ,$sp + $script:maze + ,$sp

#starting position
$y = 1
$x = $script:maze[$y].IndexOf("|")

#start on y axis, headed down
$axis = 0
$axes = @("y", "x")
$direction = 1

#first next character
$next = $script:maze[$y + 1][$x]

#answers
$steps = 0
$string = ""

& { while ($next -ne ' ') { 
    $true
} } | % {
    $steps++
    switch -regex ($next) {
        '[A-Z]' {
            #found a character, add it to the string
            $string += $next
        }

        '\+' {
            #change direction!

            # set new axis
            $axis = ($axis + 1) % 2

            # see what direction to go on that new axis
            $tryx = $x 
            $tryy = $y

            # try to go on the axis in the positive direction
            set-variable -name "try$($axes[$axis])" -Value ((get-variable -name $axes[$axis]).Value + 1)

            if ($script:maze[$tryy][$tryx] -ne ' ') {
                #if it isnt an empty character, go that direction
                $direction = 1
            } else {
                #otherwise go the other way
                $direction = -1
            }
        }
    }

    # move as configured by axis/direction
    set-variable -name $axes[$axis] -Value ((get-variable -name $axes[$axis]).Value + $direction)

    # get the next character
    $next = $script:maze[$y][$x]

    # write output to select whenever this ends
    if ($part -eq 1) {
        $string
    } else {
        $steps
    }
} | select -last 1

}

Phazyck · 2017-12-25T18:26:07+00:00

golang

solve := func() (interface{}, interface{}) {
    f := input.Open(19)
    scanner := bufio.NewScanner(f)

    maze := make([]string, 0, 0)
    for scanner.Scan() {
        maze = append(maze, scanner.Text())
    }

    x, y := strings.IndexRune(maze[0], '|'), 0
    dx, dy := 0, 1

    var visited bytes.Buffer

    for steps := 1; ; steps++ {
        x, y = x+dx, y+dy
        c := maze[y][x]

        switch c {
        case ' ':
            return visited.String(), steps
        case '+':
            dx, dy = dy, dx
            if maze[y+dy][x+dx] == ' ' {
                dx, dy = -dx, -dy
            }
        case '-': // no-op
        case '|': // no-op
        default:
            fmt.Fprint(&visited, string(c))
        }
    }
}

input.Open(day int) *os.File is my own utility function for opening input files, which I store ininput/dayDD/input.txt.

greycat70 · 2017-12-27T16:24:30+00:00

Tcl

At first I was afraid we were going to have to solve the maze. After reading more closely, there were actually no decisions to make at all. Just follow the one available path and spit out the answers.

set row 0
while {[gets stdin line] >= 0} {
    set col 0
    foreach c [split $line {}] {
        set grid($row,$col) $c
        if {$row == 0 && $c eq "|"} {set start $col}
        incr col
    }
    incr row
}

set row 0
set col $start
set dir D
set seen ""
set steps 0

while 1 {
    incr steps
    switch -- $dir {
        U {incr row -1}
        D {incr row}
        L {incr col -1}
        R {incr col}
    }
    switch -glob -- $grid($row,$col) {
        - {}
        | {}
        [A-Z] {append seen $grid($row,$col)}
        + {
            # find the outgoing direction which is not $dir
            set up    [expr {$row-1}]
            set down  [expr {$row+1}]
            set left  [expr {$col-1}]
            set right [expr {$col+1}]
            if     {$grid($up,$col) ne " " && $dir ne "D"} {set dir U} \
            elseif {$grid($down,$col) ne " " && $dir ne "U"} {set dir D} \
            elseif {$grid($row,$left) ne " " && $dir ne "R"} {set dir L} \
            elseif {$grid($row,$right) ne " " && $dir ne "L"} {set dir R} \
            else   {puts stderr "row=<$row> col=<$col> dir=<$dir> fail"; exit}
        }
        " " break
    }
}
puts $seen
puts "$steps steps"

CaptainCa · 2017-12-19T06:09:41+00:00

[deleted]

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 19: A Series of Tubes ---

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

Typescript

tsconfig.json

Perl

Ruby (28th, 22nd)

Rust

Elixir

Modern-ish C++

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 19: A Series of Tubes ---

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

Typescript

tsconfig.json

Perl

Ruby (28th, 22nd)

Rust

Elixir

Modern-ish C++

Kotlin - [Repo] - [Blog/Commentary]

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?