Day 2: Red-Nosed Reports
Megathread guidelines
- Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
- You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://blocks.programming.dev if you prefer sending it through a URL
FAQ
- What is this?: Here is a post with a large amount of details: https://programming.dev/post/22323136
- Where do I participate?: https://adventofcode.com/
- Is there a leaderboard for the community?: We have a programming.dev leaderboard with the info on how to join in this post: https://programming.dev/post/6631465
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.# 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?
This looks so alien! Does it work with the full set? The comment says 5, choose 4, but I guess it’s written as n, choose n-1?
Yes, it should do. I do run the solutions against the live data, but sometimes tweak the solutions afterwards, so can’t always guarantee them :-). I left the comment as 5 choose 4 as it felt clearer in the context of the test data.
It does still feel very alien at times, but I do love being able to think about how to adopt a more arrays-based approach to solving these problems.
How do you write this, not conceptually but physically. Do you have a char picker open at all times?
Haha, you can do it that way, in fact the online Uiua Pad editor has all the operators listed along the top.
But all the operators have ascii names, so you can type e.g.
IsSmall = reduce mul mul fork(>0|<4) abs drop neg 1 - rot 1 dup
and the formatter will reduce that toIsSmall ← /××⊃(>0|<4)⌵↘¯1-↻1.
whenever you save or execute code.That works in the Pad, and you can enable similar functionality in other editors.
i can only imagine doing it with a drawing tablet
I like to assume people using array programming languages just have a crystal ball that they use to call upon magic runes on the screen
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!();
The
is_sorted_by
is a really nice approach. I originally tried using that function thinking that|a, b| a > b
or|a, b| a < b
would cut it but it didn’t end up working. I never thought to handle the check for the step being between 1 and 3 in the callback closure for that though.is_sorted_by
is new to me, could be very useful.
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 interpretv"1
as “force the verbv
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
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 waitedit: 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) }
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); } }
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.TypeScript
Solution
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…
I don’t think your solution is O(N^3). Can you explain your reasoning?
3 nested for loops
It’s not as simple as that. You can have 20 nested for loops with complexity of O(1) if all of them only ever finish one iteration.
Or you can have one for loop that iterates 2^N times.
What do you think my complexity is?
I think it could be maybe O(n^2) because the other for loop which tries elements around the first error will only execute a constant of 5 times in the worst case? I’m unsure.
It’s O(n).
If you look at each of the levels of all reports, you will access it a constant number of times: at most twice in each call to
EvaluateLineSafe
, and you will callEvaluateLineSafe
at most six times for each report.It really depends on what your parameter n is. If the only relevant size is the number of records (let’s say that is n), then this solution takes time in O(n), because it loops over records only once at a time. This ignores the length of records by considering it constant.
If we also consider the maximum length of records (let’s call it m), then your solution, and most others I’ve seen in this thread, has a time complexity in O(n * m^2) for part 2.
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)
I like the branched pipelines in
isSafe
! Very cute.
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)
.Cool to see another solution in Nim here =)
(0..<record.len).anyIt(record.dup(delete(it)).validate)
That’s smart. I haven’t thought of using iterators to loop over indexes (except in a
for loop
).I got stuck on part 2 trying to check everything inside a single loop, which kept getting more ugly.
Yeah I’ve thought of simple ways to do this and found none. And looking at the input - it’s too easy to bruteforce, especially in compiled lang like Nim.
#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!
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; }
}
`
This is my very naive rust solution, part 2 is mostly just an extra function, so they’re bother covered in this one.
JavaScript
Also wrote a solution in JavaScript to play around with list comprehension. Wrote some utility functions for expressiveness (and lazy evaluation).
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
G’MIC solution
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
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