Haskell

This was quite fun! I got a bit distracted trying to rewrite safe in point-free style, but I think this version is the most readable. There's probably a more monadic way of writing lessOne as well, but I can't immediately see it.

safe xs = any gradual [diffs, negate <$> diffs]
  where
    diffs = zipWith (-) (drop 1 xs) xs
    gradual = all (`elem` [1 .. 3])

lessOne [] = []
lessOne (x : xs) = xs : map (x :) (lessOne xs)

main = do
  input :: [[Int]] <- map (map read . words) . lines <$> readFile "input02"
  print . length $ filter safe input
  print . length $ filter (any safe . lessOne) input

Rust

The function is_sorted_by on Iterators turned out helpful for compactly finding if a report is safe. In part 2 I simply tried the same with each element removed, since all reports are very short.

fn parse(input: String) -> Vec<Vec<i32>> {
    input.lines()
        .map(|l| l.split_whitespace().map(|w| w.parse().unwrap()).collect())
        .collect()
}

fn is_safe(report: impl DoubleEndedIterator<Item=i32> + Clone) -> bool {
    let safety = |a: &i32, b: &i32| (1..=3).contains(&(b - a));
    report.clone().is_sorted_by(safety) || report.rev().is_sorted_by(safety)
}

fn part1(input: String) {
    let reports = parse(input);
    let safe = reports.iter().filter(|r| is_safe(r.iter().copied())).count();
    println!("{safe}");
}

fn is_safe2(report: &[i32]) -> bool {
    (0..report.len()).any(|i| {  // Try with each element removed
        is_safe(report.iter().enumerate().filter(|(j, _)| *j != i).map(|(_, n)| *n))
    })
}

fn part2(input: String) {
    let reports = parse(input);
    let safe = reports.iter().filter(|r| is_safe2(r)).count();
    println!("{safe}");
}

util::aoc_main!();

C

First went through the input in one pass, number by number, but unfortunately that wouldn't fly for part 2.

::: spoiler Code

#include "common.h"

static int
issafe(int *lvs, int n, int skip)
{
	int safe=1, asc=0,prev=0, ns=0,i;

	for (i=0; safe && i<n; i++) {
		if (i == skip)
			{ ns = 1; continue; }
		if (i-ns > 0)
			safe = safe && lvs[i] != prev &&
			    lvs[i] > prev-4 && lvs[i] < prev+4;
		if (i-ns == 1)
			asc = lvs[i] > prev;
		if (i-ns > 1)
			safe = safe && (lvs[i] > prev) == asc;

		prev = lvs[i];
	}

	return safe;
}

int
main(int argc, const char **argv)
{
	char buf[64], *rest, *tok;
	int p1=0,p2=0, lvs[16],n=0, i;

	if (argc > 1)
		DISCARD(freopen(argv[1], "r", stdin));

	while ((rest = fgets(buf, sizeof(buf), stdin))) {
		for (n=0; (tok = strsep(&rest, " ")); n++) {
			assert(n < (int)LEN(lvs));
			lvs[n] = (int)strtol(tok, NULL, 10);
		}

		for (i=-1; i<n; i++)
			if (issafe(lvs, n, i))
				{ p1 += i == -1; p2++; break; }
	}

	printf("02: %d %d\n", p1, p2);
}

:::

https://github.com/sjmulder/aoc/blob/master/2024/c/day02.c

Haskell

runningDifference :: [Int] -> [Int]
runningDifference (a:[]) = []
runningDifference (a:b:cs) = a - b : (runningDifference (b:cs))

isSafe :: [Int] -> Bool
isSafe ds = (all (> 0) ds || all (< 0) ds) && (all (flip elem [1, 2, 3] . abs) ds) 

isSafe2 :: [Int] -> Bool
isSafe2 ds = any (isSafe2') (zip [0..length ds] (cycle [ds]))

isSafe2' (i, ls) = isSafe . runningDifference $ list
        where
                list = dropIndex i ls

dropIndex _ []     = []
dropIndex 0 (a:as) = dropIndex (-1) as
dropIndex i (a:as) = a : dropIndex (i - 1) as

main = do
        c <- getContents
        let reports = init . lines $ c
        let levels  = map (map read . words) reports :: [[Int]]
        let differences = map runningDifference levels
        let safety = map isSafe differences
        let safety2 = map isSafe2 levels

        putStrLn . show . length . filter (id) $ safety
        putStrLn . show . length . filter (id) $ safety2

        return ()

Took me way too long to figure out that I didn't have to drop one of them differences but the initial Number

Uiua

Uiua is still developing very quickly, and this code uses the experimental tuples function, hence the initial directive.

Try it Live!

# Experimental!
"7 6 4 2 1\n1 2 7 8 9\n9 7 6 2 1\n1 3 2 4 5\n8 6 4 4 1\n1 3 6 7 9"
⊜(⊜⋕⊸≠@\s)⊸≠@\n # Partition at \n, then at space, parse ints.

IsSorted ← +⊃(≍⇌⍆.|≍⍆.)        # Compare with sorted array.
IsSmall  ← /××⊃(>0|<4)⌵↘¯1-↻1. # Copy offset by 1, check diffs.
IsSafe   ← ×⊃IsSmall IsSorted  # Safe if Small steps and Ordered.
IsSafer  ← ±/+≡IsSafe ⧅<-1⧻.   # Choose 4 from 5, check again.

&p/+≡IsSafe .            # Part1 : Is each row safe?
&p/+≡(±+⊃IsSafe IsSafer) # Part2 : Is it safe or safer?

#Rust

initially, for part two I was trying to ignore a bad pair not a bad value - read the question!

Only installed Rust on Sunday, day 1 was a mess, today was more controlled. Need to look at some of the rust solutions for std library methods I don't know about.

very focussed on getting it to actually compile/work over making it short or nice!

::: spoiler long! `

pub mod task_2 {

pub fn task_1(input: &str) -> i32{
    let mut valid_count = 0;

    let reports = process_input(input);

    for report in reports{
        let valid = is_report_valid(report);

        if valid{
            valid_count += 1;
        }
    }

    println!("Valid count: {}", valid_count);
    valid_count
}

pub fn task_2(input: &str) -> i32{
    let mut valid_count = 0;

    let reports = process_input(input);

    for report in reports{
        let mut valid = is_report_valid(report.clone());

        if !valid
        {
            for position_to_delete in 0..report.len()
            {
                let mut updated_report = report.clone();
                updated_report.remove(position_to_delete);
                valid = is_report_valid(updated_report);

                if valid { break; }
            }
        }

        if valid{
            valid_count += 1;
        }
    }

    println!("Valid count: {}", valid_count);
    valid_count
}

fn is_report_valid(report:Vec<i32>) -> bool{
    let mut increasing = false;
    let mut decreasing = false;
    let mut valid = true;

    for position in 1..report.len(){
        if report[position-1] > report[position]
        {
            decreasing = true;
        }
        else if report[position-1] < report[position]
        {
            increasing = true;
        }
        else
        {
            valid = false;
            break;
        }

        if (report[position-1] - report[position]).abs() > 3
        {
            valid = false;
            break;
        }

        if increasing && decreasing
        {
            valid = false;
            break;
        }
    }

    return valid;
}

pub fn process_input(input: &str) -> Vec<Vec<i32>>{
    let mut reports: Vec<Vec<i32>> = Vec::new();
    for report_string in input.split("\n"){
        let mut report: Vec<i32> = Vec::new();
        for value in report_string.split_whitespace() {
            report.push(value.parse::<i32>().unwrap());
        }
        reports.push(report);
    }

    return reports;
}

}

` :::

Of course I ended up with a off-by-one error for the second part, so things took a bit longer than they really should've.

But either way, behold, messy C#: ::: spoiler C#

int[][] reports = new int[0][];

public void Input(IEnumerable<string> lines)
{
  reports = lines.Select(l => l.Split(' ').Select(p => int.Parse(p)).ToArray()).ToArray();
}

public void Part1()
{
  int safeCount = reports.Where(report => CheckReport(report)).Count();
  Console.WriteLine($"Safe: {safeCount}");
}
public void Part2()
{
  int safeCount = reports.Where(report => {
    if (CheckReport(report))
      return true;

    for (int i = 0; i < report.Length; ++i)
      if (CheckReport(report.Where((_, j) => j != i)))
        return true;

    return false;
  }).Count();

  Console.WriteLine($"Safe: {safeCount}");
}

bool CheckReport(IEnumerable<int> report)
{
  var diffs = report.SkipLast(1).Zip(report.Skip(1)).Select(v => v.Second - v.First);
  return diffs.All(v => Math.Abs(v) <= 3) && (diffs.All(v => v > 0) || diffs.All(v => v < 0));
}

:::

Nim

Got correct answer for part 1 on first try, but website rejected it. Wasted some time debugging and trying different methods. Only to have the same answer accepted minutes later. =(

proc isSafe(report: seq[int]): bool =
  let diffs = collect:
    for i, n in report.toOpenArray(1, report.high): n - report[i]
  (diffs.allIt(it > 0) or diffs.allIt(it < 0)) and diffs.allIt(it.abs in 1..3)

proc solve(input: string): AOCSolution[int, int] =
  let lines = input.splitLines()
  var reports: seq[seq[int]]
  for line in lines:
    reports.add line.split(' ').map(parseInt)

  for report in reports:
    if report.isSafe():
      inc result.part1
      inc result.part2
    else:
      for t in 0..report.high:
        var mReport = report
        mReport.delete t
        if mReport.isSafe():
          inc result.part2
          break

Codeberg repo

Factor

: get-input ( -- reports )
  "vocab:aoc-2024/02/input.txt" utf8 file-lines
  [ split-words [ string>number ] map ] map ;

: slanted? ( report -- ? )
  { [ [ > ] monotonic? ] [ [ < ] monotonic? ] } || ;

: gradual? ( report -- ? )
  [ - abs 1 3 between? ] monotonic? ;

: safe? ( report -- ? )
  { [ slanted? ] [ gradual? ] } && ;

: part1 ( -- n )
  get-input [ safe? ] count ;

: fuzzy-reports ( report -- reports )
  dup length <iota> [ remove-nth-of ] with map ;

: tolerable? ( report -- ? )
  { [ safe? ] [ fuzzy-reports [ safe? ] any? ] } || ;

: part2 ( -- n )
  get-input [ tolerable? ] count ;

This is my very naive rust solution, part 2 is mostly just an extra function, so they’re bother covered in this one.

AoC day 2

I forgot that this started yesterday, so I'm already behind. I quite like my solution for part one, but part two will have to wait edit: part 2 was a lot simpler than I thought after a night's sleep.

Rust

use color_eyre::eyre;
use std::{fs, num, str::FromStr};

#[derive(Debug, PartialEq, Eq)]
struct Report(Vec<isize>);

impl FromStr for Report {
    type Err = num::ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let v: Result<Vec<isize>, _> = s
            .split_whitespace()
            .map(|num| num.parse::<isize>())
            .collect();
        Ok(Report(v?))
    }
}

impl Report {
    fn is_safe(&self) -> bool {
        let ascending = self.0[1] > self.0[0];
        let (low, high) = if ascending { (1, 3) } else { (-3, -1) };
        self.0.windows(2).all(|w| {
            let a = w[0];
            let b = w[1];
            b >= a + low && b <= a + high
        })
    }

    fn is_dampsafe(&self) -> bool {
        if self.is_safe() {
            return true;
        }
        for i in 0..self.0.len() {
            let damped = {
                let mut v = self.0.clone();
                v.remove(i);
                Self(v)
            };
            if damped.is_safe() {
                return true;
            }
        }
        false
    }
}

fn main() -> eyre::Result<()> {
    color_eyre::install()?;

    let part1 = part1("d02/input.txt")?;
    let part2 = part2("d02/input.txt")?;
    println!("Part 1: {part1}\nPart 2: {part2}");
    Ok(())
}

fn part1(filepath: &str) -> eyre::Result<isize> {
    let mut num_safe = 0;
    for l in fs::read_to_string(filepath)?.lines() {
        if Report::from_str(l)?.is_safe() {
            num_safe += 1;
        }
    }
    Ok(num_safe)
}

fn part2(filepath: &str) -> eyre::Result<isize> {
    let mut num_safe = 0;
    for l in fs::read_to_string(filepath)?.lines() {
        if Report::from_str(l)?.is_dampsafe() {
            num_safe += 1;
        }
    }
    Ok(num_safe)
}

::: spoiler Tests

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sample_part1() {
        assert_eq!(part1("test.txt").unwrap(), 2);
    }

    #[test]
    fn sample_part2() {
        assert_eq!(part2("test.txt").unwrap(), 4);
    }
}

:::

Lisp

::: spoiler Part 1

(defun p1-process-line (line)
  (mapcar #'parse-integer (str:words line)))

(defun line-direction-p (line)
  "make sure the line always goes in the same direction"
  (loop for x in line
        for y in (cdr line)
        count (> x y) into dec
        count (< x y) into inc
        when (and (> dec 0 ) (> inc 0)) return nil
        when (= x y) return nil
        finally (return t)))

(defun line-in-range-p (line)
  "makes sure the delta is within 3"
  (loop for x in line
        for y in (cdr line)
        for delta = (abs (- x y))
        when (or (> delta 3) )
          return nil 
        finally (return t)))

(defun test-line-p (line)
  (and (line-in-range-p line) (line-direction-p line)))

(defun run-p1 (file) 
  (let ((data (read-file file #'p1-process-line)))
    (apply #'+ (mapcar (lambda (line) (if (test-line-p line) 1 0)) data))))

::: ::: spoiler Part 2

(defun test-line-p2 (line)
  (or (test-line-p (cdr line))
      (test-line-p (cdr (reverse line)))
  (loop for back on line
        collect (car back) into front
        when (test-line-p (concatenate 'list front (cddr back)))
          return t
        finally (return nil)
  )))

(defun run-p2 (file) 
  (let ((data (read-file file #'p1-process-line)))
    (loop for line in data
          count (test-line-p2 line))))

:::

Rust

use crate::utils::read_lines;

pub fn solution1() {
    let reports = get_reports();
    let safe_reports = reports
        .filter(|report| report.windows(3).all(window_is_valid))
        .count();

    println!("Number of safe reports = {safe_reports}");
}

pub fn solution2() {
    let reports = get_reports();
    let safe_reports = reports
        .filter(|report| {
            (0..report.len()).any(|i| {
                [&report[0..i], &report[i + 1..]]
                    .concat()
                    .windows(3)
                    .all(window_is_valid)
            })
        })
        .count();

    println!("Number of safe reports = {safe_reports}");
}

fn window_is_valid(window: &[usize]) -> bool {
    matches!(window[0].abs_diff(window[1]), 1..=3)
        && matches!(window[1].abs_diff(window[2]), 1..=3)
        && ((window[0] > window[1] && window[1] > window[2])
            || (window[0] < window[1] && window[1] < window[2]))
}

fn get_reports() -> impl Iterator<Item = Vec<usize>> {
    read_lines("src/day2/input.txt").map(|line| {
        line.split_ascii_whitespace()
            .map(|level| {
                level
                    .parse()
                    .expect("Reactor level is always valid integer")
            })
            .collect()
    })
}

Definitely trickier than yesterday's. I feel like the windows solution isn't the best, but it was what came to mind and ended up working for me.

Haskell

Had some fun with arrows.

import Control.Arrow
import Control.Monad

main = getContents >>= print . (part1 &&& part2) . fmap (fmap read . words) . lines

part1 = length . filter isSafe
part2 = length . filter (any isSafe . removeOne)

isSafe = ap (zipWith (-)) tail >>> (all (between 1 3) &&& all (between (-3) (-1))) >>> uncurry (||)
 where
  between a b = (a <=) &&& (<= b) >>> uncurry (&&)

removeOne [] = []
removeOne (x : xs) = xs : fmap (x :) (removeOne xs)

JavaScript

Also wrote a solution in JavaScript to play around with list comprehension. Wrote some utility functions for expressiveness (and lazy evaluation).

::: spoiler Code

const fs = require("fs");
const U = require("./util");

const isSafe = xs =>
    U.pairwise(xs).every(([a,b]) => a!==b && a-b > -4 && a-b < 4) &&
    new Set(U.pairwise(xs).map(([a,b]) => a < b)).size === 1;

const rows = fs
    .readFileSync(process.argv[2] || process.stdin.fd, "utf8")
    .split("\n")
    .filter(x => x != "")
    .map(x => x.split(/ +/).map(Number));

const p1 = U.countBy(rows, isSafe);
const p2 = U.countBy(rows, row =>
    isSafe(row) || U.someBy(U.indices(row),
        i => isSafe([...row.slice(0, i), ...row.slice(i+1)])));

console.log("02:", p1, p2);

:::

https://github.com/sjmulder/aoc/blob/master/2024/js/day02.js

Nim

import strutils, times, sequtils, sugar

# check if level transition in record is safe
proc isSafe*(sign:bool, d:int): bool =
  sign == (d>0) and d.abs in 1..3;

#check if record is valid
proc validate*(record:seq[int]): bool =
  let sign = record[0] > record[1];
  return (0..record.len-2).allIt(isSafe(sign, record[it] - record[it+1]))

# check if record is valid as-is
# or if removing any item makes the record valid
proc validate2*(record:seq[int]): bool =
  return record.validate or (0..<record.len).anyIt(record.dup(delete(it)).validate)

proc solve*(input:string): array[2,int] =
  let lines = input.readFile.strip.splitLines;
  let records = lines.mapIt(it.splitWhitespace.map(parseInt));
  result[0] = records.countIt(it.validate);
  result[1] = records.countIt(it.validate2);

I got stuck on part 2 trying to check everything inside a single loop, which kept getting more ugly. So then I switched to just deleting one item at a time and re-checking the record.

Reworked it after first finding the solution to compress the code a bit, though the range iterators don't really help with readability.

I did learn about the sugar import, which I used to make the sequence duplication more compact: record.dup(delete(it).

Elixir

defmodule AdventOfCode.Solution.Year2024.Day02 do
  use AdventOfCode.Solution.SharedParse

  @impl true
  def parse(input) do
    for line <- String.split(input, "\n", trim: true),
        do: String.split(line) |> Enum.map(&String.to_integer/1)
  end

  def part1(input) do
    Enum.count(input, &is_safe(&1, false))
  end

  def part2(input) do
    Enum.count(input, &(is_safe(&1, true) or is_safe(tl(&1), false)))
  end

  def is_safe([a, b, c | rest], can_fix) do
    cond do
      (b - a) * (c - b) > 0 and abs(b - a) in 1..3 and abs(c - b) in 1..3 ->
        is_safe([b, c | rest], can_fix)

      can_fix ->
        is_safe([a, c | rest], false) or is_safe([a, b | rest], false)

      true ->
        false
    end
  end

  def is_safe(_, _), do: true
end

Kotlin

A bit late to the party, but here you go.

import kotlin.math.abs

fun part1(input: String): Int {
    return solve(input, ::isSafe)
}

fun part2(input: String): Int {
    return solve(input, ::isDampSafe)
}

private fun solve(input: String, condition: (List<Int>) -> Boolean): Int {
    var safeCount = 0
    input.lines().forEach { line ->
        if (line.isNotBlank()) {
            val nums = line.split("\\s+".toRegex()).map { it.toInt() }
            safeCount += if (condition(nums)) 1 else 0
        }
    }
    return safeCount
}

private fun isSafe(list: List<Int>): Boolean {
    val safeDiffs = setOf(1, 2, 3)
    var incCount = 0
    var decCount = 0
    for (idx in 0..<list.lastIndex) {
        if (!safeDiffs.contains(abs(list[idx] - list[idx + 1]))) {
            return false
        }
        if (list[idx] <= list[idx + 1]) incCount++
        if (list[idx] >= list[idx + 1]) decCount++
    }
    return incCount == 0 || decCount == 0
}

private fun isDampSafe(list: List<Int>): Boolean {
    if (isSafe(list)) {
        return true
    } else {
        for (idx in 0..list.lastIndex) {
            val shortened = list.toMutableList()
            shortened.removeAt(idx)
            if (isSafe(shortened)) {
                return true
            }
        }
    }
    return false
}

Uiua

Took me a bit longer to get this one but still quite simple overall.
Spent quite some time on getting to know the try and assert operators better.

Run with example input here

# Get the indices matching the ascending/
# descending criteria
CheckAsc ← ≡°□⍚(⍣(⊸⍤.≍⍆.)⍣(⊸⍤.≍⇌⍆.)0)
# Get the indices matching the distance criteria
CheckDist ← ≡°□⍚(⍣(⊸⍤.≠1∈:0)0×⊓≥≤1,3⌵⧈-)
Split     ← ⊙(▽≠1)▽,,

PartOne ← (
  &rs ∞ &fo "input-2.txt"
  ⊜(□⊜⋕≠@ .)≠@\n.
  CheckAsc.
  ▽
  CheckDist
  ⧻⊚
)

PartTwo ← (
  &rs ∞ &fo "input-2.txt"
  ⊜(□⊜⋕≠@ .)≠@\n.
  CheckAsc.
  Split
  CheckDist.
  Split
  ⊙(⊂)
  ⧻
  :
  ⍚(≡(▽:°⊟)⍜¤⊞⊟:≠1⊞=.⇡⧻.)
  ≡(⧻⊚CheckDist▽CheckAsc.°□)
  +⧻◴⊚
)

&p "Day 2:"
&pf "Part 1: "
&p PartOne
&pf "Part 2: "
&p PartTwo

G'MIC solution ::: spoiler spoiler

it day2
crop. 0,0,0,{h#-1-2}
split. -,{_'\n'}
foreach { replace_str. " ",";" ({t}) rm.. }

safe_0,safe_1=0
foreach {
	({h}) a[-2,-1] y
	num_of_attempts:=da_size(#-1)+1
	store temp

	repeat $num_of_attempts {

		$temp

		if $> eval da_remove(#-1,$>-1) fi

		eval "
			safe=1;
			i[#-1,1]>i[#-1,0]?(
				for(p=1,p<da_size(#-1),++p,
					if(!inrange(i[#-1,p]-i[#-1,p-1],1,3,1,1),safe=0;break(););
				);
			):(
				for(p=1,p<da_size(#-1),++p,
					if(!inrange(i[#-1,p-1]-i[#-1,p],1,3,1,1),safe=0;break(););
				);
			);
			safe;"

		rm

		if $>
			if ${} safe_1+=1 break fi
		else
			if ${} safe_0,safe_1+=1 break fi
		fi

	}

}

echo Day" "2:" "${safe_0}" :: "${safe_1}

:::

python

::: spoiler solution

import re
import aoc

def setup():
    return (aoc.get_lines(2), 0)

def safe(data):
    order = 0 if data[0] < data[1] else 1
    for i in range(0, len(data) - 1):
        h = data[i]
        t = data[i + 1]
        d = abs(h - t)
        if d not in [1, 2, 3] or (order == 0 and h >= t) or (
                order == 1 and h <= t):
            return False
    return True

def one():
    lines, acc = setup()
    for l in lines:
        if safe([int(x) for x in re.findall(r'\d+', l)]):
            acc += 1
    print(acc)

def two():
    lines, acc = setup()
    for l in lines:
        data = [int(x) for x in re.findall(r'\d+', l)]
        for i in range(len(data)):
            if safe(data[:i] + data[i + 1:]):
                acc += 1
                break
    print(acc)

one()
two()

:::

R (R-Wasm)

input = file('input2024day2.txt',open='r')
lines = readLines(input)
library(stringr)
safe = 0
safe2 = 0
for (ln in lines){
  vals = as.numeric(unlist(str_split(ln,' ')))
  diffs = diff(vals)
  cond1 = min(diffs) > 0 || max(diffs) < 0
  cond2 = max(abs(diffs)) < 4
  if (cond1 && cond2){
    safe = safe + 1
  }
  else { #Problem Dampener
    dampen = FALSE
    for (omit in -1:-length(vals)){
      diffs = diff(vals[omit])
      cond1 = min(diffs) > 0 || max(diffs) < 0
      cond2 = max(abs(diffs)) < 4
      if (cond1 && cond2){
        dampen = TRUE
      }
    }
    if (dampen){
      safe2 = safe2 + 1}
  }
}
print (safe) #Part 1
print (safe + safe2) #Part 2

Elixir

defmodule Day02 do
  defp part1(reports) do
    reports
    |> Enum.map(fn report ->
      levels =
        report
        |> String.split()
        |> Enum.map(&String.to_integer/1)

      cond do
        sequence_is_safe?(levels) ->
          :safe

        true ->
          :unsafe
      end
    end)
    |> Enum.count(fn x -> x == :safe end)
  end

  defp part2(reports) do
    reports
    |> Enum.map(fn report ->
      levels =
        report
        |> String.split()
        |> Enum.map(&String.to_integer/1)

      sequences =
        0..(length(levels) - 1)
        |> Enum.map(fn i ->
          List.delete_at(levels, i)
        end)

      cond do
        sequence_is_safe?(levels) ->
          :safe

        Enum.any?(sequences, &sequence_is_safe?/1) ->
          :safe

        true ->
          :unsafe
      end
    end)
    |> Enum.count(fn x -> x == :safe end)
  end

  defp all_gaps_within_max_diff?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> abs(b - a) <= 3 end)
  end

  defp is_strictly_increasing?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> a < b end)
  end

  defp is_strictly_decreasing?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> a > b end)
  end

  defp sequence_is_safe?(numbers) do
    (is_strictly_increasing?(numbers) or
       is_strictly_decreasing?(numbers)) and all_gaps_within_max_diff?(numbers)
  end

  def run(data) do
    reports = data |> String.split("\n", trim: true)
    p1 = part1(reports)
    p2 = part2(reports)
    IO.puts(p1)
    IO.puts(p2)
  end
end

data = File.read!("input.in")
Day02.run(data)

def is_safe(report: list[int]) -> bool:
    global removed
    acceptable_range = [_ for _ in range(-3,4) if _ != 0]
    diffs = []
    if any([report.count(x) > 2 for x in report]):
        return False
    for i, num in enumerate(report[:-1]):
        cur = num
        next = report[i+1]
        difference = cur - next
        diffs.append(difference)
        if difference not in acceptable_range:
            return False
        if len(diffs) > 1:
            if diffs[-1] * diffs[-2] <= 0:
                return False
    return True

with open('input') as reports:
    list_of_reports = reports.readlines()[:-1]


count = 0

failed_first_pass = []
failed_twice = []

for reportsub in list_of_reports:
    levels = [int(l) for l in reportsub.split()]
    original = levels.copy()
    if is_safe(levels):
        safe = True
        count += 1
    else:
        failed_first_pass.append(levels)

for report in failed_first_pass:
    print(report)
    working_copy = report.copy()
    for i in range(len(report)):
        safe = False
        working_copy.pop(i)
        print("checking", working_copy)
        if is_safe(working_copy):
            count += 1
            safe = True
            break
        else:
            working_copy = report.copy()

print(count)

Kotlin:

import kotlin.math.abs
import kotlin.math.sign

data class Report(val levels: List<Int>) {
    fun isSafe(withProblemDampener: Boolean): Boolean {
        var orderSign = 0.0f  // - 1 is descending; +1 is ascending

        levels.zipWithNext().forEachIndexed { index, level ->
            val difference = (level.second - level.first).toFloat()
            if (orderSign == 0.0f) orderSign = sign(difference)
            if (sign(difference) != orderSign || abs(difference) !in 1.0..3.0) {
                // With problem dampener: Drop either element in the pair or the first element from the original list and check if the result is now safe.
                return if (withProblemDampener) {
                    Report(levels.drop(1)).isSafe(false) || Report(levels.withoutElementAt(index)).isSafe(false) || Report(levels.withoutElementAt(index + 1)).isSafe(false)
                }  else false
            }
        }

        return true
    }
}

fun main() {
    fun part1(input: List<String>): Int = input.map { Report(it.split(" ").map { it.toInt() }).isSafe(false) }.count { it }

    fun part2(input: List<String>): Int = input.map { Report(it.split(" ").map { it.toInt() }).isSafe(true) }.count { it }

    // Or read a large test input from the `src/Day01_test.txt` file:
    val testInput = readInput("Day02_test")
    check(part1(testInput) == 2)
    check(part2(testInput) == 4)

    // Read the input from the `src/Day01.txt` file.
    val input = readInput("Day02")
    part1(input).println()
    part2(input).println()
}

The Report#isSafe method essentially solves both parts.

I've had a bit of a trip up in part 2:

I initially only checked, if the report was safe, if either elements in the pair were to be removed. But in the edge case, that the first pair has different monotonic behaviour than the rest, the issue would only be detected by the second pair with indices (2, 3), whilst removing the first element in the list would yield a safe report.

Rust

Turned out alright, I am looking forward to seeing what 2d coordinate grid code I can cannibalize from last year's solutions 😄

Github link

#Zig

const std = @import("std");
const List = std.ArrayList;

const splitScalar = std.mem.splitScalar;
const parseInt = std.fmt.parseInt;
const print = std.debug.print;
const concat = std.mem.concat;

var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const alloc = gpa.allocator();

const Answer = struct {
    safe: u32,
    tolerated: u32,
};

pub fn isSafe(levels: []i32) bool {
    if (levels.len == 0) {
        return false;
    }
    // slide window in pairs, advancing by one
    var it = std.mem.window(i32, levels, 2, 1);
    const first = it.first();
    const decreasing = first[0] - first[1] > 0;
    it.reset(); // rewind the iterator

    while (it.next()) |slice| {
        const lhs: i32 = slice[0];
        const rhs: i32 = slice[1];
        if (decreasing) {
            if (lhs <= rhs) return false;
            if (lhs - rhs < 1 or lhs - rhs > 3) return false;
        } else {
            if (rhs <= lhs) return false;
            if (rhs - lhs < 1 or rhs - lhs > 3) return false;
        }
    }
    return true;
}

pub fn solve(input: []const u8) !Answer {
    var rows = splitScalar(u8, input, '\n');

    // PART 1

    // determine how many reports are safe
    var safe_reports: u32 = 0;
    var tolerated_reports: u32 = 0;
    var unsafe_reports = List([]i32).init(alloc);
    defer unsafe_reports.deinit();

    while (rows.next()) |row| {
        var levels = splitScalar(u8, row, ' ');

        var report = List(i32).init(alloc);
        defer report.deinit();

        while (levels.next()) |level| {
            const value = parseInt(i32, level, 10) catch continue;
            report.append(value) catch continue;
        }

        if (isSafe(report.items)) {
            safe_reports += 1;
        } else {
            try unsafe_reports.append(try alloc.dupe(i32, report.items));
        }
    }

    // PART 2

    // determine how many unsafe reports can be tolerated
    for (unsafe_reports.items) |report| {
        var index: usize = 0;
        while (index < report.len) : (index += 1) {
            // mutate report by removing one level
            const mutated_report = concat(
                alloc,
                i32,
                &[_][]const i32{ report[0..index], report[index + 1 ..] },
            ) catch report;
            defer alloc.free(mutated_report);

            if (isSafe(mutated_report)) {
                tolerated_reports += 1;
                break;
            }
        }
    }

    return Answer{ .safe = safe_reports, .tolerated = safe_reports + tolerated_reports };
}

pub fn main() !void {
    const answer = try solve(@embedFile("input.txt"));
    print("Part 1: {d}\n", .{answer.safe});
    print("Part 2: {d}\n", .{answer.tolerated});
}

test "test input" {
    const answer = try solve(@embedFile("test.txt"));
    try std.testing.expectEqual(2, answer.safe);
    try std.testing.expectEqual(4, answer.tolerated);

Smalltalk

Discovered a number of frustrations with this supposedly small and elegant language

1. Smalltalk's block based iteration has NO control flow
2. blocks are very dissimilar to functions
3. You cannot early return from blocks (leading to a lot of horrible nested ifs or boolean operations)
4. Smalltalk's messages (~functions) cannot take multiple arguments, instead it has these sort of combined messages, so instead of a function with three arguments, you would send 3 combined messages with one argument. This is fine until you try to chain messages with arguments, as smalltalk will interpret them as a combined message and fail, forcing you to either break into lots of temp variables, or do lisp-like parenthesis nesting, both of which I hate
5. Smalltalk's order of operations, while nice and simple, is also quite frustrating at times, similar to #4, forcing you to break into lots of temp variables, or do lisp-like parenthesis nesting. For instance (nums at: i) - (nums at: i+1) which would be nums[i] - nums[i+1] in most languages

Part 1

day2p1: input
    ^ (input lines 
        collect: [ :l | l substrings collect: [ :s | s asInteger ]])
        
        count: [ :nums |
            (nums = nums sorted or: nums = nums sorted reverse) 
                and: [
                    (1 to: nums size-1) allSatisfy: [ :i | 
                        ((nums at: i) - (nums at: i+1)) abs between: 1 and: 3
        ]    ]    ]

Part 2

day2p2: input    
    | temp |
    
    ^ (input lines 
        collect: [ :l | (l substrings collect: [ :s | s asInteger ]) asOrderedCollection ])
         
        count: [ :nums |
            
            (self day2p2helper: nums)
            or: [ 
                ((1 to: nums size) anySatisfy: [ :i |
                    temp := nums copy.
                    temp removeAt: i.
                    self day2p2helper: temp
                ])
            
            
            or: [(self day2p2helper: nums reversed)
            or: [
                (1 to: nums size) anySatisfy: [ :i |
                    temp := nums reversed.
                    temp removeAt: i.
                    self day2p2helper: temp
                ]
            ]]] .
        ]

day2p2helper: nums
    ^ (1 to: nums size - 1) allSatisfy: [ :i | 
        ((nums at: i+1) - (nums at: i)) between: 1 and: 3    
    ].