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.

#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

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?

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

#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!

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;
}

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 ;

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

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#:

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));
}

TypeScript

import { AdventOfCodeSolutionFunction } from "./solutions";


/**
 * this function evaluates the 
 * @param levels a list to check
 * @returns -1 if there is no errors, or the index of where there's an unsafe event
 */
export function EvaluateLineSafe(levels: Array<number>) {
    // this loop is the checking every number in the line
    let isIncreasing: boolean | null = null;
    for (let levelIndex = 1; levelIndex < levels.length; levelIndex++) {
        const prevLevel = levels[levelIndex - 1]; // previous
        const level = levels[levelIndex]; // current
        const diff = level - prevLevel; // difference
        const absDiff = Math.abs(diff); // absolute difference

        // check if increasing too much or not at all
        if (absDiff == 0 || absDiff > 3)
            return levelIndex; // go to the next report

        // set increasing if needed
        if (isIncreasing === null) {
            isIncreasing = diff > 0;
            continue; // compare the next numbers
        }

        //  check if increasing then decreasing 
        if (!(isIncreasing && diff > 0 || !isIncreasing && diff < 0))
            return levelIndex; // go to the next report
    }

    return -1;
}


export const solution_2: AdventOfCodeSolutionFunction = (input) => {
    const reports = input.split("\n");

    let safe = 0;
    let safe_damp = 0;

    // this loop is for every line
    main: for (let i = 0; i < reports.length; i++) {
        const report = reports[i].trim();
        if (!report)
            continue; // report is empty

        const levels = report.split(" ").map((v) => Number(v));

        const evaluation = EvaluateLineSafe(levels);
        if(evaluation == -1) {
            safe++;
            continue;
        }
        
        // search around where it failed
        for (let offset = evaluation - 2; offset <= evaluation + 2; offset++) {
            // delete an evaluation in accordance to the offset
            let newLevels = [...levels];
            newLevels.splice(offset, 1);
            const newEval = EvaluateLineSafe(newLevels);
            if(newEval == -1) {
                safe_damp++;
                continue main;
            }
        }
    }

    return `Part 1: ${safe} Part 2: ${safe + safe_damp}`;
}

God, I really wish my solutions weren’t so convoluted. Also, this is an O(N^3) solution…

J

There is probably a way to write this more point-free. You can definitely see here the friction involved in the way J wants to regard lists as arrays: short rows of the input matrix are zero padded, so you have to snip off the padding before you process each row, and that means you can’t lift some of the operations back up to the parent matrix because it will re-introduce the padding as it reshapes the result; this accounts for a lot of the "1 everywhere (you can interpret v"1 as “force the verb v to operate on rank 1 subarrays of the argument”).

data_file_name =: '2.data'
data =: > 0 ". each cutopen toJ fread data_file_name

NB. {. take, i. index of; this removes trailing zeros
remove_padding =: {.~ i.&0

NB. }. behead, }: curtail; this computes successive differences
diff =: }. - }:

NB. a b in_range y == a <: y <: b
in_range =: 4 : '(((0 { x) & <:) * (<: & (1 { x))) y'

NB. a row is safe if either all successive differences are in [1..3] or all in [_3.._1]
NB. +. or
ranges =: 2 2 $ 1 3 _3 _1
row_safe =: (+./"1) @: (*/"1) @: (ranges & (in_range"1 _)) @: diff @: remove_padding

result1 =: +/ safe"1 data

NB. x delete y is y without the xth element
delete =: 4 : '(x {. y) , ((>: x) }. y)'"0 _
modified_row =: 3 : 'y , (i.#y) delete y'

modified_row_safe =: 3 : '+./"1 row_safe"1 modified_row"1 y'
result2 =: +/ modified_row_safe data

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.

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).

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)

Lisp

(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))))

(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))))