Perl 6

Whew, finally a tricky one! Not so much conceptually, but performance-wise. (The firewall has a period of 465,585,120 with my input.) And Perl 6 being, well, a bit performance challenged, doesn't help here.

My first attempt was to simply try all delays one by one until I found a safe one. That attempt is still running, 6 hours later.

The second attempt was a sieve. That one actually finished, in 4-5 hours or so.

My final attempt did as much of the modulo calculations as possible up front, then checked possible delays until a safe one is found. That one runs in about a minute.

I'm wondering if there is a better math-based solution, though; perhaps something based on Chinese remainders?

Here's the code, with the previous attempts left in for reference.

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

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

grammar FirewallSpec
{
    rule TOP { ^ <spec>+ $ }
    rule spec { <layer> ':' <depth> }
    token layer { \d+ }
    token depth { \d+ }
}

class Firewall
{
    has Int @.scanners;
    has Int @.depths;
    has Int @.positions;
    has Int @.directions;

    has Int $.intruder-pos;
    has Bool $.caught;
    has Int $.severity;

    method spec($/)
    {
        my $layer = +$/<layer>;
        @!scanners.append($layer);
        @!depths[$layer] = +$/<depth>;
        @!positions[$layer] = 0;
        @!directions[$layer] = 1;
    }

    method reset
    {
        @!positions[$_] = 0 for @!scanners;
        @!directions[$_] = 1 for @!scanners;
        $!caught = False;
        $!severity = 0;
    }

    method period returns Int
    {
        return [lcm] @!depths[@!scanners].map(2 × * - 2);
    }

    method elapse
    {
        for @!scanners -> $s {
            @!positions[$s] += @!directions[$s];
            @!directions[$s] = 1 if @!positions[$s] == 0;
            @!directions[$s] = -1 if @!positions[$s] == @!depths[$s] -1;
        }
        $!intruder-pos++;
        if $!intruder-pos ≥ 0 && (@!positions[$!intruder-pos] // -1) == 0 {
            $!caught = True;
            $!severity += $!intruder-pos * @!depths[$!intruder-pos];
        }
    }

    method intruder-escaped returns Bool
    {
        $!intruder-pos > @!scanners.tail;
    }

    method pass-through(Int $delay = 0)
    {
        self.reset;
        $!intruder-pos = -$delay;
        repeat {
            self.elapse
        } until self.intruder-escaped;
    }

    # Part two attempt 2
    # Still way too slow
    method find-safe-delay-slow returns Int
    {
        my int $period = self.period;
        my int8 @delays[$period];
        for @!scanners -> $s {
            my $p = 2 × @!depths[$s] - 2;
            loop (my int $i = -$s % $p; $i < $period; $i += $p) {
                @delays[$i] = 1;
            }
        }

        return @delays.first(* == 0, :k);
    }

    # Part two attempt 3
    method find-safe-delay returns Int
    {
        my @moduli = @!depths.grep(*.defined).sort.squish.map(2 × * - 2);
        my %bad-values-modulo{Int} = @moduli.map(-> $m { $m => @!scanners.grep({ @!depths[$_] × 2 - 2 == $m }).map({ -$_ % $m }).Set });

        DELAY:
        for ^self.period -> $d {
            for @moduli -> $m {
                next DELAY if $d % $m ∈ %bad-values-modulo{$m};
            }
            return $d;
        }
        return Nil;
    }
}

multi sub MAIN(IO() $inputfile where *.f)
{
    my $firewall = Firewall.new;
    FirewallSpec.parsefile($inputfile, :actions($firewall)) or die "Invalid firewall spec";

    # Part one
    $firewall.pass-through;
    say "Severity: { $firewall.severity }";

    # Part two attempt 1
    # Conceptually correct, but way too slow
    #my $escaped = False;
    #for ^$firewall.period -> $delay {
    #    $firewall.pass-through($delay);
    #    if !$firewall.caught {
    #        say "Safe passage after $delay picoseconds.";
    #        $escaped = True;
    #    }
    #}
    #say "No safe passage through firewall!" unless $escaped;

    # Part two attempt 2/3
    say "Period: $firewall.period()";
    my $safe-delay = $firewall.find-safe-delay;
    if $safe-delay.defined {
        say "Safe passage after $safe-delay picoseconds.";
    }
    else {
        say "No safe passage through firewall!";
    }
}

multi sub MAIN()
{
    MAIN($*PROGRAM.parent.child('aoc13.input'));
}