Haskell

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

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.

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. =(

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

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

Uiua

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

C

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

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

github.com/sjmulder/aoc/blob/master/…/day02.c

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.

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

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

rust #[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); } }

Rust

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.

TypeScript

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…

Haskell

Had some fun with arrows.

Nim

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

#Rust

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

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

python

import re import aoc def setup(): return (aoc.get_lines(2, stripped=True), 0) def one(): lines, acc = setup() for l in lines: data = [int(x) for x in re.findall(r’\d+‘, l)] if 0 if data[0] < data[1] else 1: order = all(x > y for x, y in zip(data, data[1:])) else: order = all(x < y for x, y in zip(data, data[1:])) if order: if all(abs(x - y) > 0 and abs(x - y) < 4 for x, y in zip(data, data[1:])): acc += 1 print(acc) def issafe(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 h == t or ( order == 0 and h >= t) or (order == 1 and h <= t): return False return True def two(): lines, acc = setup() for l in lines: data = [int(x) for x in re.findall(r’\d+', l)] if issafe(data): acc += 1 continue safe = False for i in range(len(data)): nd = data[:i] + data[i + 1:] if issafe(nd): safe = True break if safe: acc += 1 print(acc) one() two()

G’MIC solution

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}

JavaScript

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

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

github.com/sjmulder/aoc/blob/master/…/day02.js

R (R-Wasm)

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

Lisp

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

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

C#

Kotlin

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

Elixir

Factor

Kotlin:

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.

#Zig

Smalltalk

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

Part 1

Part 2

Elixir

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