a6.tt

composer coord
  { x: <INT> -> ($)"x", (<', '>) y: <INT> -> ($)"y"}
end coord

def coordinates: [ $IN::lines -> coord ] -> \[i]({ $..., id: $i } !\);

templates min
  <?($(1)<..$(2)>)> $(1) !
  <> $(2) !
end min

templates max
  <?($(1)<$(2)..>)> $(1) !
  <> $(2) !
end max

templates boundingbox
  @: { left: $(1).x, top: $(1).y, bottom: $(1).y, right: $(1).x };
  $(2..last)... -> @boundingbox: { left: [$.x, $@boundingbox.left] -> min,
                    top: [$.y, $@boundingbox.top] -> min,
                    bottom: [$.y, $@boundingbox.bottom] -> max,
                    right: [$.x, $@boundingbox.right] -> max };
  $@ !
end boundingbox

def bb: $coordinates -> boundingbox;

templates abs
  <0..> $ !
  <> -$ !
end abs

templates quicksort&{comparator:}
  @: [];
  $ -> #
  when <[](2..)> do
    def pivot: $(1);
    [ [ $(2..last)... -> \(
      when <?([$, $pivot] -> comparator <..0>)> do
        $ !
      otherwise
        ..|@quicksort: $;
     \)] -> quicksort&{comparator:comparator}..., $pivot, $@ -> quicksort&{comparator:comparator}... ] !
   otherwise
     $ !
end quicksort

templates byDist
  def second: $(2).dist;
  $(1).dist -> #
  <=$second> 0 !
  <..$second> -1 !
  <> 1 !
end byDist

templates sum
  @: 0;
  $... -> @sum: $@sum + $;
  $@ !
end sum

def field: [$bb.left..$bb.right -> \(def x: $;
  [ $bb.top..$bb.bottom -> \(def y: $;
       [ $coordinates... -> { id: $.id, dist: (($.x - $x -> $::raw -> abs) + ($.y - $y -> $::raw -> abs))"md" } ]
       -> quicksort&{comparator: byDist}
       -> { closest: $ -> \(<?($(1).dist <=$(2).dist>)> (id:0) -> $::value ! <> $(1).id !\),
            sum: [ $... -> $.dist ] -> sum } !
     \)
  ] !\) ];

// part 1
templates natural
  def second: $(2);
  $(1) -> #
  <=$second> 0 !
  <..$second> -1 !
  <> 1 !
end natural

templates unique
  @: $(1);
  [ $(2..last)... -> #, $@ ] !
  <~=$@>
    $@ !
    @: $;
end unique

def infinites: [ $field(1;1..last)..., $field(1..last;1)..., $field(last;1..last)..., $field(1..last;last)...]
  -> [ $... -> $.closest ] -> quicksort&{comparator: natural} -> unique;

templates flatten
  when <[]> do
    $... -> #
  otherwise
    $!
end flatten

templates reduce&{operator:}
  @: $(1);
  $(2..last)... -> @reduce: [$@reduce, $] -> operator;
  $@ !
end reduce

templates count&{low:,high:}
  @: [ $low..$high -> 0 ];
  $... -> @count($-$low+1): $@count($-$low+1) + 1;
  $@ !
end count

[ $field -> flatten -> $.closest -> \(<1.. ?($infinites <~[<=$>]>)> $ !\) ]
  -> count&{low: 1, high: $coordinates::length} -> reduce&{operator: max} -> !OUT::write

'
' -> !OUT::write

// part 2
[ $field -> flatten -> $.sum -> \(<..~10000"md"> $ !\) ] -> $::length -> !OUT::write