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
Uiua
Took me a bit longer to get this one but still quite simple overall.
Spent quite some time on getting to know thetry
andassert
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
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
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 writinglessOne
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
Love to see your haskell solutions!
I am so far very amazed with the compactness of your solutions, your
lessOne
is very much mind-Bending. I have never used or seen<$>
before, is it a monadic$
?Also I can’t seem to find your logic for this safety condition:
The levels are either all increasing or all decreasing
, did you figure that it wasn’t necessary?For the last point, it isn’t needed since the differences between elements should be all positive or all negative for the report to be safe. This is tested with the combination of
negate
andgradual
.I am also enjoying these Haskell solutions. I’m still learning the language, so it’s been cool to compare my solution with these and grow my understanding of Haskell.
<$>
is justfmap
as an infix operator.>>> fmap (+1) [1,2,3] [2,3,4] >>> (+1) <\$> [1,2,3] [2,3,4]
Thanks! The other two posters already answered your questions, I think :)
Haskell makes it really easy to build complex operations out of simple functional building blocks, skipping a lot of boilerplate needed in some other languages. I find the compactness easier to read, but I realize that not everyone would agree.
BTW, I’m a relative Haskell newbie. I’m sure more experienced folks could come up with even more interesting solutions!
C
First went through the input in one pass, number by number, but unfortunately that wouldn’t fly for part 2.
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); }
What is this coding style? The function type, name and open brace placement made me think GNU at first, but the code in the body doesn’t look like GCS at all.
BSD more or less. Mostly K&R except for function declarations.
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?
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
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.
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!();
is_sorted_
is new to me, could be very useful.The
is_sorted_
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.
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!
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; }
}
`
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
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#:
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)); }
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 ;
Quite the interesting language choice. It’s so clean. I love it!
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.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
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.
Lisp
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))))
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))))