This is a solution to Advent of Code 2023 day 14, written in Raku.

https://adventofcode.com/2023/day/14

### Part One

Tilt the platform so that the rounded rocks all roll north. Afterward, what is the total load on the north support beams?

Strategy:

- Read the input data into a 2 dimensional array
- Walk the array, moving
`O`

chars up into empty space - Keep iterating until nothing moves

There are lots of opportunities to optimize this if necessary, but this brute-force method should be good enough.

```
my @grid[100;100] = '14-input.txt'.IO.lines>>.comb;
my $moved;
repeat {
$moved = 0;
for 1..^100 -> $y {
for ^100 -> $x {
if @grid[$y;$x] eq 'O' && @grid[$y-1;$x] eq '.' {
@grid[$y-1;$x] = 'O';
@grid[$y;$x] = '.';
$moved += 1;
}
}
}
} while $moved > 0;
my $total = [+] (^100).map(
-> $y {
[+] (^100).map(
-> $x {
(100 - $y) if @grid[$y;$x] eq 'O'
})
});
say "Total load is {$total}";
say "Took " ~ (now - ENTER now).base(10,2) ~ " seconds";
```

Total load is 108792 Took 0.30 seconds

### Part Two

The parabolic reflector dish deforms, but not in a way that focuses the beam. To do that, you'll need to move the rocks to the edges of the platform. Fortunately, a button on the side of the control panel labeled "spin cycle" attempts to do just that!

Each cycle tilts the platform four times so that the rounded rocks roll north, then west, then south, then east. After each tilt, the rounded rocks roll as far as they can before the platform tilts in the next direction. After one cycle, the platform will have finished rolling the rounded rocks in those four directions in that order…

Run the spin cycle for 1000000000 cycles. Afterward, what is the total load on the north support beams?

One billion cycles is a hint that we shouldn't even try to run to completion and that the cycle state will start repeating itself.

Strategy:

- Run each cycle of moving
`O`

chars to the North, West, South and East - Add the resulting weight to a map and a list for later lookup
- Detect when there is a repeating cycle state and extrapolate the result

Resuing the approach from part 1 but if it completes in a few minutes, then that's still good enough.

```
constant \size = 100;
my @grid[size;size] = '14-input.txt'.IO.lines>>.comb;
my %totals-to-cycle;
my @totals-by-cycle;
my $moved;
for ^500 -> $cycle {
# North
for ^size -> \x {
repeat {
$moved = 0;
for 1..^size -> \y {
if @grid[y; x] eq 'O' && @grid[y - 1; x] eq '.' {
@grid[y - 1; x] = 'O';
@grid[y; x] = '.';
$moved += 1;
}
}
} while $moved > 0;
}
# West
for ^size -> \y {
repeat {
$moved = 0;
for 1..^size -> \x {
if @grid[y; x] eq 'O' && @grid[y; x - 1] eq '.' {
@grid[y; x - 1] = 'O';
@grid[y; x] = '.';
$moved += 1;
}
}
} while $moved > 0;
}
# South
for ^size -> \x {
repeat {
$moved = 0;
for 1..^size -> \y {
if @grid[y - 1; x] eq 'O' && @grid[y; x] eq '.' {
@grid[y; x] = 'O';
@grid[y - 1; x] = '.';
$moved += 1;
}
}
} while $moved > 0;
}
# East
for ^size -> \y {
repeat {
$moved = 0;
for 1..^size -> \x {
if @grid[y; x-1] eq 'O' && @grid[y; x] eq '.' {
@grid[y; x] = 'O';
@grid[y; x-1] = '.';
$moved += 1;
}
}
} while $moved > 0;
}
my $total = [+] (^size).map(
-> \y {
[+] (^size).map(
-> \x {
(size - y) if @grid[y; x] eq 'O'
})
});
# print '.';
if %totals-to-cycle{$total}:exists {
my $prev-cycle = %totals-to-cycle{$total};
if $prev-cycle > 5 && (@totals-by-cycle[$prev-cycle-5 .. $prev-cycle]
~~ @totals-by-cycle[$cycle-5 .. $cycle]) {
my $cycle-length = $cycle - $prev-cycle;
my $pos-in-cycle = (1_000_000_000 - $cycle) % $cycle-length;
my $abs-pos = $cycle - $cycle-length + $pos-in-cycle - 1;
my $load = @totals-by-cycle[$abs-pos];
# say "\nprev={$prev-cycle}, len={$cycle-length}, abs={$abs-pos}";
say "\nTotal load is {$load}";
last;
}
}
%totals-to-cycle{$total} = $cycle;
@totals-by-cycle[$cycle] = $total;
}
say "Took " ~ (now - ENTER now).base(10,2) ~ " seconds";
```

Total load is 99118 Took 58.03 seconds