# Advent of Code - 2021

This is a solution to Day 7 of Advent of Code 2021.

## Day 7 - The Treachery of Whales

A giant squid, trillions of lanternfish and now there's a whale and swarm of crabs in tiny submarines too!

A giant whale has decided your submarine is its next meal, and it's much faster than you are. There's nowhere to run!

Suddenly, a swarm of crabs (each in its own tiny submarine - it's too deep for them otherwise) zooms in to rescue you! They seem to be preparing to blast a hole in the ocean floor; sensors indicate a massive underground cave system just beyond where they're aiming!

The crab submarines all need to be aligned before they'll have enough power to blast a large enough hole for your submarine to get through. However, it doesn't look like they'll be aligned before the whale catches you! Maybe you can help?

There's one major catch - crab submarines can only move horizontally.

You quickly make a list of the horizontal position of each crab (your puzzle input). Crab submarines have limited fuel, so you need to find a way to make all of their horizontal positions match while requiring them to spend as little fuel as possible.

For example, consider the following horizontal positions:

`16,1,2,0,4,2,7,1,2,14`

This means there's a crab with horizontal position 16, a crab with horizontal position 1, and so on.

Each change of 1 step in horizontal position of a single crab costs 1 fuel. You could choose any horizontal position to align them all on, but the one that costs the least fuel is horizontal position 2:

- Move from 16 to 2: 14 fuel
- Move from 1 to 2: 1 fuel
- Move from 2 to 2: 0 fuel
- Move from 0 to 2: 2 fuel
- Move from 4 to 2: 2 fuel
- Move from 2 to 2: 0 fuel
- Move from 7 to 2: 5 fuel
- Move from 1 to 2: 1 fuel
- Move from 2 to 2: 0 fuel
- Move from 14 to 2: 12 fuel
This costs a total of 37 fuel. This is the cheapest possible outcome; more expensive outcomes include aligning at position 1 (41 fuel), position 3 (39 fuel), or position 10 (71 fuel).

Determine the horizontal position that the crabs can align to using the least fuel possible. How much fuel must they spend to align to that position?

### Read input

If there's one more one-line input, I'm gonna write a new function for reading those.

In general, I'd like `read_input`

to return the desired result so that the code that solves the puzzle (these notebooks) don't have to do any manipulation (in this case, the `[0]`

is what bothers me).

It's a small thing and completely irrelevant in terms of single-run scripts like Advent of Code puzzles but I try to make this year's solutions bit better than just the minimum required to get the result.

```
from utils import read_input
def transformer(input_line):
return [int(value) for value in input_line.split(',')]
positions = read_input(7, transformer)[0]
```

### Part 1

I have a feeling that there's a more straight-forward mathematical formula for calculating this.

However, I don't know of such thing (which is often why I end up dropping out of Advent of Code eventually) so I'll keep looping over and calculating all the possible solutions.

Here I know that there's not gonna be a solution that would be smaller than the smallest position or higher than the highest position (by common sense mostly) so I'll find the cumulative fuel cost of every crabmarine (see what I did there!) to move to that position and then return the smallest.

```
def naive_align(positions):
all_positions = range(min(positions), max(positions)+1)
fuel_costs = []
for desired_position in all_positions:
cumulative_fuel_cost = 0
for crab in positions:
cumulative_fuel_cost += abs(crab - desired_position)
fuel_costs.append(cumulative_fuel_cost)
return min(fuel_costs)
```

```
result = naive_align(positions)
print(f'Solution: {result}')
assert result == 356992 # For refactoring
```

Solution: 356992

### Part 2

The crabs don't seem interested in your proposed solution. Perhaps you misunderstand crab engineering?

As it turns out, crab submarine engines don't burn fuel at a constant rate. Instead, each change of 1 step in horizontal position costs 1 more unit of fuel than the last: the first step costs 1, the second step costs 2, the third step costs 3, and so on.

As each crab moves, moving further becomes more expensive. This changes the best horizontal position to align them all on; in the example above, this becomes 5:

- Move from 16 to 5: 66 fuel
- Move from 1 to 5: 10 fuel
- Move from 2 to 5: 6 fuel
- Move from 0 to 5: 15 fuel
- Move from 4 to 5: 1 fuel
- Move from 2 to 5: 6 fuel
- Move from 7 to 5: 3 fuel
- Move from 1 to 5: 10 fuel
- Move from 2 to 5: 6 fuel
- Move from 14 to 5: 45 fuel
This costs a total of 168 fuel. This is the new cheapest possible outcome; the old alignment position (2) now costs 206 fuel instead.

Determine the horizontal position that the crabs can align to using the least fuel possible so they can make you an escape route! How much fuel must they spend to align to that position?

Now here I already know that we need more math than just looping everything over. By knowing that, I googled for a "sum of integers smaller than n" and found the solution `1/2(n)(n+1)`

which I remember having seen somewhere in high school or university math classes and everything else stays the same.

```
def step_cost(n):
return int(1/2*n*(n+1))
def accelerative_align(positions):
all_positions = range(min(positions), max(positions)+1)
fuel_costs = []
for desired_position in all_positions:
cumulative_fuel_cost = 0
for crab in positions:
cumulative_fuel_cost += step_cost(abs(crab - desired_position))
fuel_costs.append(cumulative_fuel_cost)
return min(fuel_costs)
```

```
result = accelerative_align(positions)
print(f'Solution: {result}')
assert result == 101268110 # For refactoring
```

Solution: 101268110