11.pl

#!/usr/bin/perl -w
use strict;
use Data::Dumper;
use feature 'say';
use Clipboard;
use List::Util qw/sum min max/;
use Math::Cartesian::Product;
use Math::Complex;

sub out {
  my $out = shift;
  Clipboard->copy_to_all_selections($out);
  print "$out\n";
}

# Utility function to make sure 2d array has equal rows
# input arr,fill. no output
sub equalize {
  my $arr = shift;
  my $fill = shift;
  my $rows = @$arr;
  my $cols = max(map {scalar(@$_)} @$arr);
  print "$rows $cols\n";
  for my $row (@$arr) {
    while (@$row < $cols) {
      push @$row, $fill;
    }
  }
}

# Find neighbors
# input arr, row, col, neigh_arr
# returns array of [row, col, value]
sub neigh {
  my $arr = shift;
  my $row = shift;
  my $col = shift;
  my $neigh = shift;
  my $rows = @$arr;
  my $cols = @{$arr->[$row]};
  my @out;
  for my $pair (@$neigh) {
    my ($rd, $cd) = @$pair;
    my ($nr, $nc) = ($row + $rd, $col + $cd);
    next if $nr < 0;
    next if $nc < 0;
    next if $nr >= $rows;
    next if $nc >= $cols;
    push @out, [$nr, $nc, $arr->[$nr][$nc]];
  }
  return @out;
}

# Orthogonal
sub oneigh {
  return neigh(@_, [[-1,0], [1, 0], [0, -1], [0, 1]]);
}

# All neighbors
sub aneigh {
  return neigh(@_, [
    [-1, -1], [-1, 0], [-1, 1],
    [ 0, -1],          [ 0, 1],
    [ 1, -1], [ 1, 0], [ 1, 1]]);
}

# Numeric sort because sort defaults to lex
# returns new array
sub nsort {
  my $in = \@_;
  if (@$in == 1) {
    $in = $in->[0];
  }
  return sort {$a <=> $b} @$in;
}

# Binary conversions
sub bin2dec {
  my $in = shift;
  return oct("0b$in");
}
sub dec2bin {
  my $in = shift;
  return sprintf ("%b", $in);
}

my $sum=0;

my @A;

ROW: while(<>) {
  chomp;
  my @l = split('');
  push @A, \@l;
}

for (my $i=1; ; $i++) {
  my @flash;
  my $fc=0;
  for my $r (0..$#A) {
    for my $c (0..$#{$A[0]}) {
      $A[$r][$c]++;
    }
  }
  my $f=1;
  while ($f) {
    $f=0;
    for my $r (0..$#A) {
      for my $c (0..$#{$A[0]}) {
        if ($A[$r][$c] > 9) {
          next if ($flash[$r][$c]);
          $sum++;
          for my $n (aneigh(\@A, $r, $c)) {
            my ($nr, $nc) = @$n;
            $A[$nr][$nc]++;
          }
          $flash[$r][$c]++;
          $fc++;
          $f=1;
        }
      }
    }
  }
  for my $r (0..$#A) {
    for my $c (0..$#{$A[0]}) {
      $A[$r][$c] = 0 if $flash[$r][$c];
    }
  }
  if ($i == 100) {
    out($sum);
  }
  if ($fc == @{$A[0]} * @A) {
    out $i;
    last;
  }
}