🌟 Advent of Code (AoC) 2021 🌟

fn main() {
    let index: Vec<usize> = std::fs::read_to_string("input.txt")
        .unwrap()
        .split(',')
        .filter_map(|s| s.parse().ok())
        .collect();

    count_fish(&index, 80); // 352872
    count_fish(&index, 256); // 1604361182149
}

fn count_fish(data: &[usize], days: usize) {
    let mut window = [0usize; 9];
    for i in data.iter() {
        window[*i] += 1;
    }

    for _ in 0..days {
        window.rotate_left(1);
        window[6] += window[8];
    }
    println!("{:?}", window.iter().sum::<usize>());
}

internal class Puzzle6 : Puzzle<long>
{
    protected override void Solve(string[] lines)
    {
        var initialFishes = Enumerable.Range(0, 9).Select(_ => 0L).ToArray();

        foreach (var fish in lines[0].Split(",").Select(int.Parse))
        {
            initialFishes[fish] += 1;
        }

        One = CountFishes(initialFishes, 80);
        Two = CountFishes(initialFishes, 256);
    }

    private static long CountFishes(long[] fishes, int days)
    {
        fishes = fishes.ToArray();

        foreach (var _ in Enumerable.Range(0, days))
        {
            SimulateDay(fishes);
        }

        return fishes.Sum();
    }

    private static void SimulateDay(long[] fishes)
    {
        var newSpawns = fishes[0];

        foreach (var age in Enumerable.Range(1, 8))
        {
            fishes[age - 1] = fishes[age];
        }

        fishes[6] += newSpawns;
        fishes[8] = newSpawns;
    }
}

main = interact solve

solve input = "Problem 1: " ++ (show.sum.cycle) 80 ++ "\n"
           ++ "Problem 2: " ++ (show.sum.cycle) 256 ++ "\n"
    where
        -- cycle n returns a list where the element at index i
        -- is the number of fish at age i after n generations.
        cycle 0 = map (\age->length (filter (\c->c==age) input)) ['0'..'8']
        cycle n = zipWith (+) (prevTail++[0]) ([0,0,0,0,0,0,prevHead,0,prevHead])
            where (prevHead:prevTail) = cycle (n-1)

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>


int main(int argc, char **argv) {
	uint64_t fish[9] = { 0 }, total;
	int i, n;

	while (fscanf(stdin, "%i,", &i) == 1)
		fish[i]++;
	for (n = atoi(argv[1]), i = 0; i < n; i++) {
		uint64_t today;

		today = fish[0];
		memmove(fish, fish + 1, sizeof(*fish) * 8);
		fish[6] += today;
		fish[8] = today;
	}

	for (i = 0, total = 0; i < 9; i++)
		total += fish[i];
	printf("Total fishes after %i days: %lu\n", n, total);
	return 0;
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func getPartOne(numbers []int) int {
	return getLanternfish(numbers, 80)
}

func getPartTwo(numbers []int) int {
	return getLanternfish(numbers, 256)
}

func getLanternfish(numbers []int, end int) int {
	fishes := [11]int{}
	for _, number := range numbers {
		fishes[number]++
	}
	for day := 1; day <= end; day++ {
		for i := 0; i < len(fishes)-1; i++ {
			if i == 0 {
				fishes[9] = fishes[i]
				fishes[7] += fishes[i]
			}
			fishes[i] = fishes[i+1]
		}
	}
	sum := 0
	for _, val := range fishes {
		sum += val
	}
	return sum
}

func getRows(filename string) []int {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	var numbers []int
	for scanner.Scan() {
		row := scanner.Text()
		// Test data input..
		if strings.Contains(row, "Initial") {
			values := strings.Fields(row)
			fields := strings.Split(values[2], ",")
			for _, field := range fields {
				val, err := strconv.Atoi(field)
				if err != nil {
					panic(err)
				}
				numbers = append(numbers, val)
			}
			break
		} else {
			fields := strings.Split(row, ",")
			for _, field := range fields {
				val, err := strconv.Atoi(field)
				if err != nil {
					panic(err)
				}
				numbers = append(numbers, val)
			}
		}
	}
	return numbers
}

func main() {
	fmt.Println("Part one:", getPartOne(getRows("../input.txt")))
	fmt.Println("Part two:", getPartTwo(getRows("../input.txt")))
}

]dinput
to←{⎕IO←0                                   ⍝ Sequence ⍺ .. ⍵
     from step←1 ¯1×-\2↑⍺,⍺+×⍵-⍺             ⍝ step default is +/- 1.
     from+step×⍳0⌈1+⌊(⍵-from)÷step+step=0    ⍝ ⍺ thru ⍵ inclusive.
}

vents←⍎¨'[^\d]+'⎕R' '⊢⊃⎕NGET 'data/2021_dag5.txt'1
⍝ Read and shape coordinates in groups of four (x1 y1 x2 y2)
coords←↑{2 2⍴⍵}¨vents
⍝ Select the lines that are either vertical or horizontal
lines←(∨/(=⌿⍤2)coords)⌿coords
⍝ fill all lines and get the points marked
marked←↑↑,/,¨/↑(⊂to⌿)⍤2⊢lines
⍝ Count points with more than one mark
'Part one:', +/2≤≢⍤⊢⌸marked
⍝ For part 2, do not filter out only vertical or horizontal lines
allmarked←↑↑,/,¨/↑(⊂to⌿)⍤2⊢coords
⍝ As before, count points with more than one mark
'Part two:' , +/2≤≢⍤⊢⌸allmarked

⎕IO←0
⎕PP←13
fishes←+/(⍳9)∘.=⍎⊃⊃⎕NGET'6.txt'1 
f←{(⊃⍵)(+@6)1⌽⍵}
+/f⍣80⊢fishes
+/f⍣256⊢fishes

val input  = Using.resource(Source.fromFile("6.txt"))(_.mkString.trim.split(',').map(_.toInt).toVector)
val fishes = Vector.tabulate(9)(input.groupMapReduce(identity)(_ => 1L)(_ + _).withDefaultValue(0L))

LazyList.iterate(fishes)((_: @unchecked) match { case h +: t => t.updated(6, t(6) + h) :+ h })(80).sum
LazyList.iterate(fishes)((_: @unchecked) match { case h +: t => t.updated(6, t(6) + h) :+ h })(256).sum

fishes = list(map(int, open("6.in").readline().split(",")))
for num_days in (80, 256):
    days = [0] * 7
    for fish in fishes:
        days[fish] += 1

    tot = len(fishes)
    prev_spawned = 0
    prev_prev_spawned = 0
    for day in range(num_days):
        spawned = days[day % 7]
        tot += spawned
        days[day % 7] += prev_prev_spawned
        prev_prev_spawned = prev_spawned
        prev_spawned = spawned

    print(tot)

object Day7 {
	val data = readLines("7/data.txt")

	def main(args: Array[String]): Unit = {
		val crabs = data.head.split(",").map(_.toInt)
		println(crabs.length + " crabs")

		def calc(cost: (Int, Int) => Int) = {
			(0 until crabs.max).map { pos =>
				crabs.map(crab => cost(crab, pos)).sum
			}.min
		}

		// part 1
		println(calc((v, c) => abs(v - c)))

		// part 2
		println(calc((c, p) => {
			val diff = abs(c - p)
			diff * (diff + 1) / 2
		}))
	}

}

data = list(map(int, open("7.in").read().split(",")))
dist_costs = [sum(range(x)) + x for x in range(max(data) + 1)]
print(min(sum(dist_costs[abs(x - i)] for x in data) for i in range(max(data))))

#![feature(int_abs_diff)]
fn main() {
    let input: Vec<u32> = std::fs::read_to_string("input.txt")
        .unwrap()
        .split(',')
        .filter_map(|s| s.parse().ok())
        .collect();

    fuel(&input, |a, b| a.abs_diff(b)); // 355592
    fuel(&input, |a, b| (0..=a.abs_diff(b)).sum::<u32>()); // 101618069
}

fn fuel(data: &[u32], func: fn(u32, u32) -> u32) {
    let mut fuel = u32::MAX;
    for v in 1.. {
        let curr_fuel = data.iter().map(|&a| func(a, v)).sum::<u32>();
        fuel = curr_fuel.min(fuel);
        if fuel < curr_fuel {
            break;
        }
    }
    println!("{}", fuel);
}

internal class Puzzle7 : Puzzle<int>
{
    protected override void Solve(string[] lines)
    {
        var positions = lines[0].Split(',').Select(int.Parse).ToArray();
        One = GetCheapestPosition(positions, true);
        Two = GetCheapestPosition(positions, false);
    }

    private static int GetCheapestPosition(IReadOnlyCollection<int> positions, bool burnAtConstantRate) => 
        Enumerable.Range(0, positions.Max() + 1)
            .Aggregate(int.MaxValue, (lowestFuel, pos) => Math
                .Min(lowestFuel, positions
                    .Where(x => x != pos)
                    .Aggregate(0, (a, b) =>
                    {
                        var distance = Math.Abs(pos - b);
                        return a + (burnAtConstantRate
                            ? distance
                            : (distance * (distance + 1)) / 2);
                    }))
            );
}

(import std)

(define main
  (do io/bind
      (<- input (io/map unwrap! (read-file "inputs/day7.txt")))
      (let1 crabs (apps |> input
                        trim
                        (string/splits-on ",")
                        (map (<o unwrap! parse-int))
                        array/collect
                        (merge-sort int/cmp)))
      (display (apps str-append "Part 1: " (show-int (total-fuel id (median crabs) crabs))))
      (display (apps str-append "Part 2: " (show-int (total-fuel sum-nats-to-n (mean crabs) crabs))))))

(define (median sorted) (array/lookup! (/ (array/length sorted) (to-nat 2)) sorted))
(define (mean xs) (/ (+ (sum (array/iter xs)) 1) (to-int (array/length xs))))
(define (total-fuel f align crabs) (sum (map (apps <o f abs (- align)) (array/iter crabs))))
(define (sum-nats-to-n n) (/ (* n (+ 1 n)) 2)) ; Formula for sum of range [1,n]