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

  • @[email protected]
    link
    fedilink
    57 months ago

    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

  • @[email protected]
    link
    fedilink
    5
    edit-2
    7 months ago

    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?
    
    • @[email protected]
      link
      fedilink
      37 months ago

      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?

      • @[email protected]
        link
        fedilink
        17 months ago

        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.

    • @[email protected]
      link
      fedilink
      77 months ago

      How do you write this, not conceptually but physically. Do you have a char picker open at all times?

      • @[email protected]
        link
        fedilink
        47 months ago

        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 to IsSmall ← /××⊃(>0|<4)⌵↘¯1-↻1. whenever you save or execute code.

        That works in the Pad, and you can enable similar functionality in other editors.

        • @[email protected]
          link
          fedilink
          47 months ago

          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

  • @[email protected]
    link
    fedilink
    English
    57 months ago

    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!();
    
    • Sleepless One
      link
      fedilink
      English
      27 months ago

      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.

    • Deebster
      link
      fedilink
      English
      27 months ago

      is_sorted_by is new to me, could be very useful.

  • @[email protected]
    link
    fedilink
    37 months ago

    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.&amp;0
    
    NB. }. behead, }: curtail; this computes successive differences
    diff =: }. - }:
    
    NB. a b in_range y == a &lt;: y &lt;: b
    in_range =: 4 : '(((0 { x) &amp; &lt;:) * (&lt;: &amp; (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 &amp; (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
    
  • Deebster
    link
    fedilink
    2
    edit-2
    7 months ago

    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)
    }
    
    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);
        }
    }
    
    
  • Sleepless One
    link
    fedilink
    English
    37 months ago

    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.

  • @[email protected]
    link
    fedilink
    37 months ago

    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…

        • @[email protected]
          link
          fedilink
          27 months ago

          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.

          • @[email protected]
            link
            fedilink
            17 months ago

            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.

            • @[email protected]
              link
              fedilink
              37 months ago

              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 call EvaluateLineSafe at most six times for each report.

            • @[email protected]
              link
              fedilink
              37 months ago

              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.

  • @[email protected]
    link
    fedilink
    27 months ago

    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)
    
    • Amy
      link
      fedilink
      17 months ago

      I like the branched pipelines in isSafe! Very cute.

  • Zarlin
    link
    fedilink
    27 months ago

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

    • janAkali
      link
      fedilink
      English
      2
      edit-2
      7 months ago

      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.

  • @[email protected]
    link
    fedilink
    English
    4
    edit-2
    7 months ago

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

    }

    `

  • @[email protected]
    link
    fedilink
    27 months ago

    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

  • @[email protected]
    link
    fedilink
    1
    edit-2
    7 months ago

    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}
    
  • TunaCowboy
    link
    fedilink
    1
    edit-2
    7 months ago

    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()
    
  • @[email protected]
    link
    fedilink
    17 months ago

    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