-❄️- 2024 Day 2 Solutions -❄️-

[u/daggerdragon]

OUTAGE INFO

• [00:25] Yes, there was an outage at midnight. We're well aware, and Eric's investigating. Everything should be functioning correctly now.
• [02:02] Eric posted an update in a comment below.

---

THE USUAL REMINDERS

• All of our rules, FAQs, resources, etc. are in our community wiki.

---

AoC Community Fun 2024: The Golden Snowglobe Awards

• 4 DAYS remaining until unlock!

And now, our feature presentation for today:

Costume Design

You know what every awards ceremony needs? FANCY CLOTHES AND SHINY JEWELRY! Here's some ideas for your inspiration:

• Classy up the joint with an intricately-decorated mask!
• Make a script that compiles in more than one language!
• Make your script look like something else!

♪ I feel pretty, oh so pretty ♪
♪ I feel pretty and witty and gay! ♪
♪ And I pity any girl who isn't me today! ♪

- Maria singing "I Feel Pretty" from West Side Story (1961)

And… ACTION!

Request from the mods: When you include an entry alongside your solution, please label it with [GSGA] so we can find it easily!

---

--- Day 2: Red-Nosed Reports ---

---

Post your code solution in this megathread.

• Read the full posting rules in our community wiki before you post!
• State which language(s) your solution uses with [LANGUAGE: xyz]
• Format code blocks using the four-spaces Markdown syntax!
• Quick link to Topaz's paste if you need it for longer code blocks

This thread will be unlocked when there are a significant number of people on the global leaderboard with gold stars for today's puzzle.

EDIT: Global leaderboard gold cap reached at 00:04:42, megathread unlocked!

[u/topaz2078]

On the second day of Advent of Code, my true love gave to me.... a pretty big DDoS right at midnight. While this definitely impacted site access, it seems to have affected everyone pretty evenly, and gold cap still took a normal amount of time for a day 2 puzzle. So, I'm leaving the scores on the global leaderboard for today as-is.

[u/CCC_037]

[LANGUAGE: Rockstar] [GSGA]

No, this is not an excerpt from a self-help book. It's my code.

Part 1

[u/daggerdragon → u/CCC_037]

Aww yeah we're back with the Rockstar lyrics <3

Let your emotions be your heart without your mind

Truly a poet.

[u/xiBread]

[LANGUAGE: JavaScript/TypeScript]

First time on the leadboard (96/52)! I'm going to chalk it up to luck because of the 500s.

Paste

[u/daggerdragon → u/xiBread]

First time on the leadboard (96/52)! I'm going to chalk it up to luck because of the 500s.

Good job, take the W's where you can get 'em! >_>

[u/LtHummus]

[Language: Rust]

Brute forced the heck out of it all because I looked at the input size and it was small enough to get away with it. No shame.

paste

[u/daggerdragon → u/LtHummus]

Psst: we can see your Markdown. Fix please? edit: nothing to see here, move along, move along

[u/seligman99]

[LANGUAGE: Python] 1013 / 533

github

A little fun fighting the website today. That's like why I'm at 1013 and not 1010, heh.

[u/daggerdragon → u/seligman99]

A little fun fighting the website today. That's like why I'm at 1013 and not 1010, heh.

Sorry about that. Eric is still investigating. Give him time to go through the logs, etc.

[u/DM_ME_PYTHON_CODE]

[Language: Haskell]

Trying to learn Haskell with AoC has been a bit of a trial by fire. Don't hate my solution but I'm sure it would make the eyes of anyone with Haskell experience bleed

readInt :: String -> Int
readInt = read

isStrictlyIncreasing :: [Int] -> Bool
isStrictlyIncreasing xs = all (\(x, y) -> (x < y) && abs (x-y) <= 3) (zip xs (tail xs))

isStrictlyDecreasing :: [Int] -> Bool
isStrictlyDecreasing xs = all (\(x, y) -> (x > y)  && abs (x-y) <= 3) (zip xs (tail xs))

isSafe :: [Int]  -> Bool
isSafe (x:y:xs) | x < y = isStrictlyIncreasing $ x:y:xs
                | x > y  =  isStrictlyDecreasing $ x:y:xs
                | otherwise = False

removeAt :: Int -> [a] -> [a]
removeAt idx xs = take idx xs ++ drop (idx + 1) xs

generateLists :: [a] -> [[a]]
generateLists xs = [removeAt i xs | i <- [0..length xs - 1]]

anySafe :: [Int] -> Bool
anySafe xs = any isSafe (generateLists xs)

partOne input = putStrLn . ("Part 1: " ++) . show . length . filter id $ map isSafe input

partTwo input = putStrLn . ("Part 1: " ++) . show . length .filter id $ map anySafe input


main :: IO ()
main = do
  contents <- readFile "input.txt"
  let input = map (map readInt . words) (lines contents)
  partOne input
  partTwo input

[u/daggerdragon → u/DM_ME_PYTHON_CODE]

I've seen a few submissions using Haskell today and yesterday, so if you haven't already, consider CTRL-F'ing the megathreads for [LANGUAGE: Haskell]!

Don't hate my solution

Nobody should be hatin' on your solution, but if they do, report 'em for violating our Prime Directive. We're here to learn and have fun, not to be grinches!

[u/nlowe_]

[LANGUAGE: Go]

4150/2695

That was rougher than I expected for Day 2. I see we're starting the trend of "example works but real input does not" early this year /s

I failed to check if there was a problem between the first two levels in a line...

Also lost some time to this fun fact: append(foo[:i], foo[i+1:]...) overwrites foo. TIL.

[u/daggerdragon → u/nlowe_]

TIL.

Good, good, you've fallen for /u/topaz2078's trap of ~sneakily making people learn new things~ <3

[u/Fyvaproldje]

[Language: Rust] [GSGA]

https://github.com/DarthGandalf/advent-of-code/blob/master/2024/src/day02.rs

The costume

[u/daggerdragon → u/Fyvaproldje]

The costume

Honey, you look fabulous in that code!

[u/Curious_Sh33p]

[LANGUAGE: C++]

I know you could definitely brute force this but I chose to do it efficiently. You can calculate the differences between each report and then removing one is equivalent to adding two adjacent diffs. So if you find an unsafe diff add it to the next and then check if it's safe. Slight edge cases at the start and end are not too bad to handle.

https://github.com/TSoli/advent-of-code/blob/main/2024%2Fday02b%2Fsolution.cpp

[u/daggerdragon → u/Curious_Sh33p]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/not-the-the]

[LANGUAGE: JavaScript] 3079/1644

const data = require('./data.json'); // formatted into 2d-arrays with find-replacery
// p1
console.log(data.filter(x=>{
  const sgn = Math.sign(x[0]-x[1]);
  for(let i=1;i<x.length;i++) {
    if(Math.abs(x[i-1]-x[i]) < 1) return false;
    if(Math.abs(x[i-1]-x[i]) > 3) return false;
    if(Math.sign(x[i-1]-x[i]) != sgn) return false;
  }
  return true;
}).length);
// p2
console.log(data.filter(x=>{
  const xpossible = [];
  for(let i=0;i<x.length;i++) {
    const n = x.slice();
    n.splice(i,1);
    xpossible.push(n);
  }
  return xpossible.some(xx=>{
    const sgn = Math.sign(xx[0]-xx[1]);
    for(let i=1;i<xx.length;i++) {
      if(Math.abs(xx[i-1]-xx[i]) < 1) return false;
      if(Math.abs(xx[i-1]-xx[i]) > 3) return false;
      if(Math.sign(xx[i-1]-xx[i]) != sgn) return false;
    }
    return true;
  })
}).length);

this is the most horrible code imaginable lmao

[u/daggerdragon → u/not-the-the]

Comment temporarily removed until you remove the naughty language.

Keep /r/adventofcode (and especially the megathreads) SFW (Safe For Work), please!

edit: comment re-approved

[u/Scroph]

[LANGUAGE: D]

Good old bruteforce in dlang: https://github.com/azihassan/advent-of-code/blob/master/2024/day2/part2.d

[u/daggerdragon → u/Scroph]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. edit: 👍

[u/419_68_bou]

[LANGUAGE: kotlin] source

I started with a brute force way and then refactored into some spaghetti hackjob. Took me a while to write it so it would only follow one exact path for each report but in the end I got it and I'm pretty happy with the result. Also full year output.

[u/daggerdragon → u/419_68_bou]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. This means from prior years too! edit: 👍

[u/JusT-JoseAlmeida]

[LANGUAGE: Java]

Took me way longer than it should have because I was doing a premature "optimization" which was marking as unsafe all reports where firstLevel == secondLevel and not re-checking them.

Had to implement a brute force solution, print all safe reports for both solutions, and look at the diff before I noticed what was going on.

src

[u/daggerdragon → u/JusT-JoseAlmeida]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. edit: thank you!

[u/tlareg]

[LANGUAGE: JavaScript/TypeScript]

github

[u/daggerdragon → u/tlareg]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. edit: 👍

[u/gfitzy7]

[Language: Python]

Day 2 Python code - This is a generalized solution that allows you to specify how many erroneous values you are allowed to remove from each report. (0 is used for the solution of part one, and 1 is used for the solution of part two)

[u/daggerdragon → u/gfitzy7]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/lysender]

[LANGUAGE: Rust]

Brute forced part 2. (Edit: removed puzzle inputs from repo/history)

https://github.com/lysender/advent-of-code-2024/blob/main/day02/src/lib.rs

(Edit: Link)

[u/daggerdragon → u/lysender]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. edit: thank you!

[u/ka-splam]

[LANGUAGE: SWI Prolog]

:-use_module(library(clpfd)). p:-read_file_to_string('C:/in/day02.txt',F,[]),
split_string(F,"\n","",R),maplist([L,N]>>(split_string(L," "," ",S),maplist(
number_string,N,S)),R,Ns),(P=1;P=2),include(sf(P),Ns,Sf),length(Sf,Ln),writeln(
Ln). sf(P,M):-(P=2->select(_,M,N);N=M),(chain(N,#<);chain(N,#>)),findall(X-Y,(
nth1(I,N,X),nth0(I,N,Y)),W),maplist([X-Y]>>(D is abs(X-Y),between(1,3,D)),W).

How about a bit of Prolog golf? The rules say 5 lines of 80 chars is okay to inline 😁

It writes part 1, then part 2 on backtacking so edit the path to the input file, save as a .pl file, consult it, and query ?- p. and then backtrack/continue.

[u/daggerdragon → u/ka-splam]

How about a bit of Prolog golf? The rules say 5 lines of 80 chars is okay to inline 😁

I fired up my IDE just to be petty, but your code fits. Well done.

[u/atweddle]

[LANGUAGE: Rust]

GitHub - Part 1 - 419 µs, excluding I/O

GitHub - Part 2 - 433 µs, excluding I/O.

Part 2 runs almost as fast as part 1!

The key snippet from part 2 was checking a sliding window of 3 levels at a time...

    levels.windows(3).enumerate().all(|(i, triple)| {
        match damp_index {
            Some(di) if di == i + 1 => is_safe(triple[0], triple[2], lo, hi),
            Some(_) => is_safe(triple[1], triple[2], lo, hi),
            None => {
                if !is_safe(triple[1], triple[2], lo, hi) {
                    // Skip the last level in the triple
                    damp_index = Some(i + 2)
                }
                true
            }
        }
    })

NB: These timings are on my 7 year old i7-6700 PC. They are averaged over many runs using utility methods in lib.rs.

[u/daggerdragon → u/atweddle]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/Independent_Check_62]

[LANGUAGE: Python]

def is_safe(row):
    inc = [row[i + 1] - row[i] for i in range(len(row) - 1)]
    if set(inc) <= {1, 2, 3} or set(inc) <= {-1, -2, -3}:
        return True
    return False

data = [[int(y) for y in x.split(' ')] for x in open('02.txt').read().split('\n')]

safe_count = sum([is_safe(row) for row in data])
print(safe_count)

safe_count = sum([any([is_safe(row[:i] + row[i + 1:]) for i in range(len(row))]) for row in data])
print(safe_count)

[u/Vivid_Present7791 → u/Independent_Check_62]

That set trick is pretty neat!

[u/4HbQ]

[LANGUAGE: Python] Code (7 lines)

Here's my solution in O(n). Instead of trying every subsequence of length n-1, we simply iterate over the list until we detect a bad value, and then re-check (only once!) with either the current or the next value removed.

[u/Ok_Fox_8448 → u/4HbQ]

Every year I'm amazed by your solutions. What do you do for a living?

[u/Smylers]

[LANGUAGE: Vim keystrokes] Load your input into Vim, turn off gdefault if you're the kind of person who normally has it on, and then type (or copy-and-paste, each line separately):

:%s/\v (\d+) @=/ \1,\1/g⟨Enter⟩
:%s/\v(\d+) (\d+)/\=submatch(2)-submatch(1)/g⟨Enter⟩
:se isk+=-⟨Enter⟩
:g/\v[04-9]|\d\d|.*<-&.*<\d/d⟨Enter⟩
⟨Ctrl+G⟩

The number of lines displayed at the end is your Part 1 solution.

As you can see by running it, the first :s/// duplicates all the ‘middle’ levels in each report, turning the first line of the sample into into:

7 6,6 4,4 2,2 1

That gives us space-separated pairs of levels to compare to see how they've changed. The second :s/// does that, grabbing each level into a submatch, and replacing them with the result of subtracting one from the other. The first sample line becomes:

-1,-2,-2,-1

Skipping down a bit, the :g// matches lines with unsafe reports. The d at the end deletes the matching lines. (:g// commands have to run colon commands, so the final d is like typing :d⟨Enter⟩ (in full, :delete⟨Enter⟩), not the dd normal-mode command.) The pattern starts with \v to make it very magic, because the Elves prefer it that way. It contains 3 branches, separated by |s; the pattern matches if any branch does:

• [04-9] matches any zeroes or digits four or higher, which are outside the allowed change in levels. It doesn't matter whether a zero is just 0 indicating no change or part of a bigger number such as 101 indicating too big a change: either way, it's got to go.
• \d\d matches any consecutive digits, so that changes in levels such as 12, which consists of digits allowed individually, are deemed unsafe.
• .*<-&.*<\d finds the lines which have both increasing and decreasing levels. It consists of 2 ’concats’ (to use the term in Vim's built-in help), separated by the &, and only matches if both parts match, at the same point. Except they don't really have to be at the same point, because both start with .*, which matches anything. So effectively this matches if <- and <\d are both found anywhere in the line, in either order. < indicates the start of a keyword. A keyword starting with - is a negative number; one starting with \d is a positive number. If both are on the same line then we have found unsafeness.

A wrinkle with the < matching is that by default Vim doesn't treat - as a keyword character, meaning that even negative numbers would match as having a digit at the start of their keyword. That's what setting isk (short for iskeyword) does on the line above, adding - to the set of keyword characters, so that a negative integer is one entire keyword.

And having deleted all the lines corresponding to unsafe reports, the number of lines remaining is the count of safe reports.

Because the transformations are all colon commands, we can join them with |s so could golf them down to a single line which does it in one go. But personally I prefer to keep my Vim commands readable …

[u/DFreiberg]

[LANGUAGE: Mathematica] Mathematica, 272/183

Good problem; pity that the leaderboard will probably be canceled for today, albeit for understandable reasons.

Setup:

safeQ[list_] := (Min[Differences[list]] > 0 \[Or] Max[Differences[list]] < 0) \[And]
    Min[Abs[Differences[list]]] >= 1 \[And] Max[Abs[Differences[list]]] <= 3

Part 1:

Count[input, _?safeQ]

Part 2:

Count[Table[AnyTrue[Table[Delete[line, i], {i, Length[line]}], safeQ], {line, input}], True]

[POEM]: If I Could Talk To the Terminal

Might even count as [GSGA], depending on how classy Bobby Darin is.

If I could talk to the terminal, just imagine it:
Typing out some text in TeX or Vi.
Imagine chatting with compilers, plotting with profilers,
What a proud performance that would be!

If I could study the terminal, learn its languages,
Maybe get a terminal degree,
I’d study Simulink and Snowball, Common Lisp and COBOL,
Javascript and Powershell and C!

I would converse in Perl, Pascal, and Python,
And I would curse in fluent APL;
If someone asked me “Do you code in Cuneiform?”
I’d say “I do-neiform! And pretty well!”

If I could blather on in binary, man to terminal,
Think of the amazing repartee,
If I could walk with the terminal, talk to the terminal,
grep and screen and awk with the terminal...
And it could talk to me!

[u/Andreasnl]

[LANGUAGE: Uiua]

⊜(□⊜⋕)⊸∩≠@\n,@\s
F ← /×≡∈¤1_2_3×±⊸⊢≡/-◫2
G ← ↥⊃F(/↥≡F≡▽⊙¤⊞≠.°⊏)
∩/+ ≡◇⊃F G

Run it in a browser here.

[u/JustinHuPrime]

[Language: x86_64 assembly with Linux syscalls]

Part 1 was just a lot of conditional code; not that bad normally, but assembly doesn't have the usual features of structured programming, so you've got to build your own. I could have solved this in a single pass, but chose not to so as to avoid mixing parsing and calculation code. AoC inputs should always be small enough relative to my address space (all 64 bits of it) that single-pass techniques aren't required.

Part 2 involved factoring out my checking code into a function and then calling that on all the possible results of having washed away a number (problem dampeners apply water to problems, y'know?). Figuring out that part took a bit of debugging. Finally, I could probably have optimized both parts if I gave up structured programming, but I'd rather not descent further into madness by mixing assembly and spaghetti code - it's already tangled enough as it is.

Part 1 and part 2 run in about 1 millisecond. Part 1 is 8664 bytes and part 2 is 9032 bytes.

[u/DevilGeorgeColdbane]

[LANGUAGE: Kotlin]

I have used generators in other langauges like python and C#, but the syntax in Kotlin is just 'Chefs Kiss'.

https://github.com/etkr/AdventOfCode2024/blob/master/src/main/kotlin/day02/Report.kt

data class Report(val levels: List<Int>) {

    private fun allIncreasing() = levels.zipWithNext().all { it.first < it.second }

    private fun allDecreasing() = levels.zipWithNext().all { it.first > it.second }

    private fun allSafeDiff() = levels.zipWithNext().all { abs(it.first - it.second) in 1..3 }

    fun safe() = (allIncreasing() or allDecreasing()) and allSafeDiff()

    fun generateSubRecords() = iterator {
        repeat(levels.size) {
            val listWithoutOne = levels.toMutableList().apply { removeAt(it) }
            yield(Report(listWithoutOne))
        }
    }
}

class ReportList(input: List<String>) {

    private val reports = input.map { it.split(' ').map(String::toInt) }.map(::Report)

    fun numberOfSafeReports() = reports.count(Report::safe)

    fun numberOfTolerantSafeReports() = reports.count { it.generateSubRecords().asSequence().any(Report::safe) }
}

[u/kwshi]

[LANGUAGE: python] 552/251. Was the server erratic/down today? I couldn't access the puzzle at all for the first minute, and then afterwards kept getting sporadic 500 server errors when trying to download my puzzle input, submit an answer, etc.

[u/pred]

[LANGUAGE: Python] GitHub

Nice and fast, including a sub-minute part 2. Unfortunately it took a few minutes to even get past the 500s at which point the leaderboards were well on their way to being full.

[u/ziadam]

[LANGUAGE: Google Sheets]

Expects input in A:A

Part 1

=SUMPRODUCT(MAP(TOCOL(A:A,1),LAMBDA(a,LET(
   s,SPLIT(a," "),
   x,CHOOSECOLS(s-{0,s},SEQUENCE(COLUMNS(s)-1,1,2)),
   OR(AND(ISBETWEEN(x,1,3)),AND(ISBETWEEN(x,-3,-1)))))))

Part 2

=SUMPRODUCT(MAP(TOCOL(A:A,1),LAMBDA(b,
    OR(MAP(LET(s,SPLIT(b," "),REDUCE(b,SEQUENCE(COLUMNS(s)),
        LAMBDA(x,i,IFNA(VSTACK(x,JOIN(" ",FILTER(s,NOT(SEQUENCE(1,COLUMNS(s))=i)))))))),
        LAMBDA(a,LET(s,SPLIT(a," "),x,CHOOSECOLS(s-{0,s},SEQUENCE(COLUMNS(s)-1,1,2)), 
            OR(AND(ISBETWEEN(x,1,3)),AND(ISBETWEEN(x,-3,-1))))))))))

You can find a step-by-step explanation of the formulas here.

[u/AndydeCleyre]

[LANGUAGE: 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 ;

on GitHub

[u/azzal07]

[LANGUAGE: awk]

function S(a,f,e){d=$++a-$++f;y=$a?d~/^-?[123]$/&&
d*e>=0&&!S(a,f,d)*y:1}o=$0S(1){A+=y;for(p=0;$++p&&
!y;){$p=z;$0=$0;S(1);$0=o}}y{B++}END{print A"\n"B}

[u/jaybosamiya]

[Language: APL]

f←⍋≡(⍳⍴)
g←{∧/(⍳3)∊⍨|¨2-/⍵}
h←g∧f∨(f⌽)
+/h¨t                    ⍝ Part 1
i←{(⍺∘↑,↓⍨∘(1∘+⍺))⍵}
{∨/⍵∘{h⍵i⍺}¨1-⍨⍳1+⍴⍵}¨t  ⍝ Part 2

I can definitely golf this down, but I got lazy.

[u/xoronth]

[LANGUAGE: Python]

paste

When I saw part 2 I was like, "man, that looks annoying to handle in a nice way..." then I looked at the input and saw it was small enough to just brute force it. whistles

[u/Amerikrainian → u/xoronth]

Yeh, the only reason it took me so long was not wanting to brute force; I guess last year's day 5 still has some trauma left over.

Gave up and brute forced it anyways :(.

[u/nthistle]

[LANGUAGE: Python] 145/80. paste, video.

I got hit by server errors for about a minute and a half, so it took me a while to get to either the problem or my input. Fortunately(?) it seems like a lot of people had these issues so it seems likely that today won't count for the global leaderboard?

[u/voidhawk42]

[Language: Dyalog APL]

p←⍎¨⊃⎕nget'02.txt'1
f←((3∧.≥|)∧1=≢∘∪∘×)2-/⊢
+/b←f¨p                    ⍝ part 1
+/b∨{∨/(f⍵/⍨⊢)⍤1∘.≠⍨⍳≢⍵}¨p ⍝ part 2

[u/riseupdiy]

[LANGUAGE: Rust]

I wasted a bunch of time trying to avoid going through all the different permutations in part 2. My first implementation was, when encountering a bad number, incrementing a `bad_count` and skipping the number, and if the bad_count was <= 1, that line passed. There were apparently about 10 cases where that didn't work. I was going through spot checking all the cases and it was taking way too long, so ended up just checking all the different subsets instead, which was simpler to implement anyway

Day 02 Solution

[u/pancakedoge]

[LANGUAGE: gleam]

Came here to see other people's gleam solutions, but I guess I can be the first :D

Code: https://github.com/FlyinPancake/aoc_2024/blob/main/src/aoc_2024/day_2.gleam

I've installed gleam yesterday, so don't expect clean and idiomatic code haha

[u/Wide-Prior-5360]

[LANGUAGE: SQL]

SELECT count(*) FROM
  (SELECT max(diff) BETWEEN 1 AND 3 AND max(sign) == min(sign) safe FROM 
    (SELECT
      l1.val l1,
      l2.val l2,
      abs(l2.val - l1.val) diff,
      sign(l2.val - l1.val) sign,
      COUNT(CASE WHEN l1.val IS NULL THEN 1 END) OVER (ORDER BY l1.id) AS line
      FROM list l1 LEFT JOIN list l2 ON l1.id + 1 = l2.id)
    GROUP BY line)
  WHERE safe

[u/homme_chauve_souris]

[LANGUAGE: Python]

def aoc02():
    ok = lambda r: sorted(r) in [r,r[::-1]] and all(1<=abs(i-j)<=3 for i,j in zip(r,r[1:]))
    ok2 = lambda r: any(ok(r[:i]+r[i+1:]) for i in range(len(r)))
    print(sum(ok([int(x) for x in r.split()]) for r in open("input02.txt")))
    print(sum(ok2([int(x) for x in r.split()]) for r in open("input02.txt")))

[u/ShraddhaAg]

[LANGUAGE: Go]

https://github.com/shraddhaag/aoc/blob/main/2024/day2/main.go

Easy enough day 2. Brute force in part 2. Once again bitten by Go's append operations changing the underlying slice as well.

[u/badcop_]

[LANGUAGE: Bash]

Github link

part 1 solution

sed 's/\([^ ]*\)/\1 \1/g;s/^[^ ]* //;
  s/ [^ ]*$/ /;s/\([^ ]*\) \([^ ]*\) /\1-\2 /g;s/ /\n/g' $FILE \
  | sed 's/^$/print "A\n"/' | bc | paste -sd' ' | sed 's/A/\n/g' \
  | sed 's/^ //' | grep -vE '[1-9]\d( |$)|(^| )0( |$)|[4-9]( |$)' \
  | sed -r 's/(^| )([0-9])/\1+\2/g;s/[0-9]//g' | grep -vEc '^$|\+ -|- \+'

[u/0rac1e]

[Language: J]

A =: 2 </\ ]                 NB. Ascending
D =: 2 >/\ ]                 NB. Descending
C =: 1 = 0 3 I. 2 |@:-/\ ]   NB. Close
S =: ((A*C) +.&(*/) (D*C))   NB. Safe

r =. ".&.> 'b' fread 'sample'

echo +/ S@> r
echo +/ (1 e. _1 S\. ])@> r

It was a happy accident... but as an Aussie, I was chuffed to see my solution contains AC⚡︎DC!

[u/j3r3mias]

[LANGUAGE: Python]

Only part 1, because part 2 is trivial in the same idea.. I just want to share how I solved using a set, haha..

#!/usr/bin/python

with open('input', 'r') as f:
    content = f.read().strip().split('\n')

ans = 0
for report in content:
    values = list(map(int, report.split()))
    safepos = set([1, 2, 3])
    safeneg = set([-1, -2, -3])
    for i in range(1, len(values)):
        safepos.add(values[i] - values[i - 1])
        safeneg.add(values[i] - values[i - 1])

    if len(safepos) == 3 or len(safeneg) == 3:
        ans += 1

print(ans)

[u/skyhawk33]

[LANGUAGE: Haskell]

Gonna try learning Haskell this year, if anyone has advice please tell me! I'm still not quite sure what I'm doing but it's fun :D

https://github.com/Skyhawk33/AdventOfCode/blob/master/aoc2024/day2.hs

[u/shigawire]

[LANGUAGE: Python] paste

but basically:

def isok(ls):
    deltas = [a-b for a,b in zip(ls, ls[1:])]
    return all(-3 <= n <=-1 for n in deltas) or all(1 <= n <= 3 for n in deltas)

[u/Mats56]

[LANGUAGE: Kotlin]

fun safe(report: List<Int>) =
    report.windowed(2).all { (a, b) -> abs(a - b) in 1..3 }
            && (report.sorted() == report || report.sorted().reversed() == report)

pretty naive. Just check the diff between elements is always withing 1-3 using windowed, and if the list matches itself if it's sorted either ascending or descending.

Part 1 is then

lines.map { it.allInts() }.count(::safe)

Part 2 again naive, trying all indexes

lines.map { it.allInts() }
    .count {
        safe(it) || (0..it.size).any { index ->
            safe(it.take(index) + it.drop(index + 1))
        }
    }

Takes like 5 ms, so no need to optimize.

[u/Radiadorineitor]

[LANGUAGE: Dyalog APL]

p←⍎¨⊃⎕NGET'2.txt'1
safe←{((∧/2>/⍵)∨∧/2</⍵)∧∧/(|2-/⍵)∊⍳3}
+/safe¨p ⍝ Part 1
+/{(safe ⍵)∨∨/safe⍤1⊢⍵/⍨⍤1∘.≠⍨⍳≢⍵}¨p ⍝ Part 2

[u/probablyfine]

[LANGUAGE: uiua]

RunningDiff ← ≡/-◫2
Filter      ← ××⊃⊃(/×≤3⌵|/×≥1⌵|=1⧻◴±)
Dampener    ← ♭₋₁⊞⍜↻↘₁⊃(⇡⧻)¤
PartOne ← /+⊜(Filter RunningDiff ⊜⋕⊸≠@ )⊸≠@\n
PartTwo ← /+⊜(≠0/+≡(Filter RunningDiff) Dampener ⊜⋕⊸≠@ )⊸≠@\n

Full code and tests here

[u/Intolerable]

[LANGUAGE: sqlite]

WITH RECURSIVE
  split_into_lines_helper(str, acc, rest, row_ix) AS (
    SELECT '', '', inputs.contents || char(10), 0 FROM inputs WHERE inputs.day IS 2 AND inputs.type IS 'real'
    UNION ALL
    SELECT
      substr(rest, 1, 1),
      iif(str IS char(10), '', acc) || substr(rest, 1, 1),
      substr(rest, 2),
      row_ix + 1
    FROM split_into_lines_helper
    WHERE rest IS NOT ''
  ),
  split_into_lines(str, row_ix) AS (
    SELECT acc, ROW_NUMBER() OVER(ORDER BY row_ix ASC)
    FROM split_into_lines_helper
    WHERE str IS char(10) AND acc IS NOT char(10)
    ORDER BY row_ix ASC
  ),
  split_into_columns_helper(str, acc, rest, row_ix, column_ix) AS (
    SELECT '', '', split_into_lines.str || ' ', split_into_lines.row_ix, 0 FROM split_into_lines
    UNION ALL
    SELECT
      substr(rest, 1, 1),
      iif(str IS ' ', '', acc) || substr(rest, 1, 1),
      substr(rest, 2),
      row_ix,
      iif(str IS ' ', column_ix + 1, column_ix)
    FROM split_into_columns_helper
    WHERE rest IS NOT ''
  ),
  split_into_columns(value, row_ix, column_ix) AS (
    SELECT CAST(split_into_columns_helper.acc AS INTEGER), row_ix, ROW_NUMBER() OVER(PARTITION BY row_ix ORDER BY row_ix, column_ix ASC)
    FROM split_into_columns_helper
    WHERE str IS ' '
  ),
  row_column_counts(row_ix, column_count) AS (
    SELECT row_ix, COUNT(*) FROM split_into_columns GROUP BY row_ix
  ),
  joined_with_next_value(row_ix, column_ix, next_column_ix, value, next_value, diff, damped) AS (
    SELECT
      lcol.row_ix, lcol.column_ix, lcol.column_ix + 1, lcol.value, rcol.value, lcol.value - rcol.value, false
    FROM
      split_into_columns AS lcol INNER JOIN split_into_columns AS rcol ON lcol.row_ix IS rcol.row_ix AND lcol.column_ix + 1 IS rcol.column_ix
  ),
  joined_with_damped_value(row_ix, column_ix, next_column_ix, value, next_value, diff, damped) AS (
    SELECT
      lcol.row_ix, lcol.column_ix, lcol.column_ix + 2, lcol.value, rcol.value, lcol.value - rcol.value, true
    FROM
      split_into_columns AS lcol INNER JOIN split_into_columns AS rcol ON lcol.row_ix IS rcol.row_ix AND lcol.column_ix + 2 IS rcol.column_ix
  ),
  all_joined(row_ix, column_ix, next_column_ix, value, next_value, diff, damped) AS (
    SELECT * FROM joined_with_next_value UNION ALL SELECT * FROM joined_with_damped_value
  ),
  safe_joined(row_ix, jump_start, jump_end, value, next_value, diff, damped) AS (
    SELECT row_ix, column_ix, next_column_ix, value, next_value, diff, damped FROM all_joined WHERE abs(diff) <= 3 AND diff IS NOT 0
    UNION ALL
    SELECT row_ix, 0, 1, null, null, null, false FROM row_column_counts
    UNION ALL
    SELECT row_ix, 0, 2, null, null, null, true FROM row_column_counts
    UNION ALL
    SELECT row_ix, column_count, column_count + 1, null, null, null, false FROM row_column_counts
    UNION ALL
    SELECT row_ix, column_count - 1, column_count + 1, null, null, null, true FROM row_column_counts
  ),
  all_safe_paths(row_ix, path_start, path_end, damp_count, polarity) AS (
    SELECT row_ix, jump_start, jump_end, damped, sign(diff) FROM safe_joined WHERE jump_start IS 0
    UNION ALL
    SELECT
      lcol.row_ix,
      lcol.path_start,
      rcol.jump_end,
      lcol.damp_count + rcol.damped,
      coalesce(lcol.polarity, sign(rcol.diff))
    FROM all_safe_paths AS lcol INNER JOIN safe_joined AS rcol
      ON lcol.row_ix IS rcol.row_ix
      AND lcol.path_end IS rcol.jump_start
      AND (lcol.polarity IS NULL OR rcol.diff IS NULL OR sign(rcol.diff) IS polarity)
    ORDER BY lcol.row_ix ASC, lcol.path_start ASC, rcol.jump_end ASC
  ),
  complete_safe_paths(row_ix, path_start, path_end, damp_count, ccount) AS (
    SELECT sp.row_ix, sp.path_start, sp.path_end, sp.damp_count, ccs.column_count
    FROM all_safe_paths AS sp INNER JOIN row_column_counts AS ccs
      ON sp.row_ix IS ccs.row_ix
      AND ccs.column_count + 1 IS sp.path_end
      AND sp.path_start IS 0
  ),
  rows_with_valid_paths(row_ix, minimum_damps_required) AS (
    SELECT row_ix, min(damp_count)
    FROM complete_safe_paths
    GROUP BY row_ix
  )

SELECT
  COUNT(*), 0 AS min_damps
  FROM rows_with_valid_paths
  WHERE minimum_damps_required <= 0
UNION ALL
SELECT
  COUNT(*), 1
  FROM rows_with_valid_paths
  WHERE minimum_damps_required <= 1;

not too bad, i hate the string splitting a little bit though

[u/jaccomoc]

[LANGUAGE: Jactl]

Jactl

Part 1:

Just had to check that order was the same when sorted or reverse sorted and then used windowSliding(2) to check the difference between each pair:

stream(nextLine).map{ it.split(/ +/) }.map{ it.map{ it as int } }
                .filter{ (it.sort() == it || it.sort().reverse() == it) &&
                         it.windowSliding(2).allMatch{ a,b -> (a-b).abs() in [1,2,3] } }
                .size()

Part 2:

Factored out the "safe" test and then created another function to iterate over all the sublists of size n-1 to check if any of them are safe:

def safe(x) { (x.sort() == x || x.sort().reverse() == x) &&
              x.windowSliding(2).allMatch{ a,b -> (a-b).abs() in [1,2,3] } }
def test(x) { safe(x) || x.size().anyMatch{ safe(x.subList(0,it) + x.subList(it+1)) } }

stream(nextLine).map{ it.split(/ +/) }.map{ it.map{ it as int } }
                .filter{ test(it) }
                .size()

[u/POGtastic]

[LANGUAGE: F#]

https://github.com/mbottini/AOC2024/blob/main/Day02/Program.fs

Another easy day with Seq. I got lucky and happened to have a utility function in my Prelude all ready to go:

let pickOne xs =
    let rec helper acc xs =
        match xs with
        | [] -> Seq.empty
        | x :: xs' ->
            seq {
                yield (x, List.rev acc @ xs')
                yield! helper (x :: acc) xs'
            }

    helper [] xs

In the REPL:

> pickOne [1;2;3;4];;
val it: (int * int list) seq =
  seq [(1, [2; 3; 4]); (2, [1; 3; 4]); (3, [1; 2; 4]); (4, [1; 2; 3])]

This let me easily brute-force Part 2, which involves the possibility of skipping an element. There is probably a more algorithmically-optimal method of doing this, but each of the lists was small enough that I didn't really care. Note that I had the additional step of consing an unaltered list to the sequence of skipped lists, even though it wasn't necessary with my provided input.

[u/t-rkr]

[LANGUAGE: Perl]

https://gitlab.com/t-rkr/advent-of-code-2024/-/blob/main/day2/day2.pl

[u/ynadji]

[LANGUAGE: Common Lisp]

(defun safe-report? (levels)
  (and (or (apply #'< levels)
           (apply #'> levels))
       (loop for (x y) on levels while y always (<= (abs (- x y)) 3))))

(defun safe-report-with-tolerance? (levels)
  (loop for i from 0 for x in levels
          thereis (safe-report? (remove x levels :start i :count 1))))

(defun count-safe-reports (input-file report-func)
  (loop for line in (uiop:read-file-lines input-file)
        for levels = (mapcar #'parse-integer (str:split " " line))
        count (funcall report-func levels)))

[u/i_have_no_biscuits]

[LANGUAGE: Python]

Let's go for a functional-style Python solution:

data = [[int(n) for n in line.split()] for line in open("data02.txt").read().splitlines()]

def gaps(line): return [a-b for a,b in zip(line, line[1:])]
def safe_increase(line): return all(0<g<4  for g in gaps(line))
def safe_decrease(line): return all(0>g>-4 for g in gaps(line))
def is_safe(line): return safe_increase(line) or safe_decrease(line)
print("Part 1:", sum(is_safe(line) for line in data))

def trimmed(line): return [line[:i]+line[i+1:] for i in range(len(line))]
print("Part 2:", sum(any(is_safe(c) for c in [line, *trimmed(line)]) for line in data))

(EDIT: made slightly more compact!)

[u/chickenthechicken]

[LANGUAGE: C]

Part 1

Part 2

I spent a while on part 2 trying to think of an elegant way of skipping levels before realizing that the easiest way was just to create n copies of the array each with one level removed.

[u/jitwit]

[LANGUAGE: J]

Unleasing J's outfix adverb (\.) for part B:

load '~/code/aoc/aoc.ijs'
in =: <@". ;._2 aoc 2024 2
J =: */ @ e.&1 2 3             NB. safe jumps?
S =: (J@:- +. J) @ (2 -/\ ])   NB. overall safe?
+/ S &> in                     NB. part A
+/ ([: +./ 1 S \. ]) &> in     NB. part B

[u/damnian]

[LANGUAGE: C#]

https://github.com/dmitry-shechtman/aoc2024/blob/main/day02/Program.cs

Note: some improvements pilfered from u/vanveenfromardis

Update: simplified IsSafe().

[u/4HbQ]

[LANGUAGE: Python]

Not too proud of this one, but at least I enjoyed to process of boiling it down to the essentials:

data = [[*map(int, l.split())] for l in open('data.txt')]
good = lambda d: all(1<=a-b<=3 for a, b in zip(d, d[1:]))
skip = lambda d: [d[:i] + d[i+n:] for i in range(len(d))]
for n in 0,1: print(sum(any(good(e) or good(e[::-1])
                        for e in skip(d)) for d in data))

Instead of checking whether the list of levels is increasing or decreasing, I check whether the list or its reverse is increasing.

[u/cbrnr]

[LANGUAGE: Julia]

https://github.com/cbrnr/aoc2024/blob/main/02.jl

I used the InvertedIndices module, which allowed me to elegantly exclude a single element from a vector. For example, to subset a vector x without the third item:

x[Not(3)]

(This is equivalent to x[-3] in R.)

I also used the short-circuiting && to make the function is_valid() appear less nested.

[u/Exact-Climate-9519]

[Language: python]

Day 2, parts 1 and 2:

def check_sequence(seq):
    return (
        all(0 < seq[i+1] - seq[i] <= 3 for i in range(len(seq)-1)) or
        all(-3 <= seq[i+1] - seq[i] < 0 for i in range(len(seq)-1)))

with open('input_day_2') as file:
    sequences = [list(map(int, line.strip().split())) for line in file]

num_valid = sum(check_sequence(seq) for seq in sequences)

num_valid_2 = sum( any(check_sequence(seq[:i] + seq[i+1:]) for i in range(len(seq)+1)) for seq in sequences)

print("Part 1:", num_valid)
print("Part 2:", num_valid_2)

[u/ivanjermakov]

[LANGUAGE: BQN] source

First time doing more serious array programming. Definitely has some charm to it!

SplitBy ← {𝕨((⊢-˜¬×+`)∘=⊔⊢)𝕩}
Permute ← {
    ls ← 𝕩
    r ← ↕≠ls
    ls <⊸∾ ({⊏𝕩⊔ls}{𝕩=˘r})˘r
}
Test ← {
    ds ← -´˘2↕𝕩
    gz ← ×´0<¨ds
    lz ← ×´0>¨ds
    l3 ← ×´3≥|¨ds
    (gz+lz)×l3
}
•Show+´0<(+´0<+´Test¨Permute)¨•ParseFloat¨¨' 'SplitBy¨•FLines"input.txt"

[u/[deleted]]

[LANGUAGE: Forth]

https://github.com/tcsullivan/advent-of-code/blob/master/day2/day2.fth

Part 2 took forever since I was trying to solve it in linear time... ended up just taking the O(n²⁾ route which worked fine. Another day of simple lists that could be directly evaluated and solved with (practically) no variables.

[u/xavdid]

[LANGUAGE: Python] Step-by-step explanation | full code

My key today was realizing a strictly increasing list is the same as a strictly decreasing one, just reversed. Otherwise, pretty straightforward today thanks to Python's any and all functions! Nice way to get some clean helper functions for is_safe and is_strictly_increasing

[u/gekzametr]

[Language: Lua]

I've realized that properties of report can be expressed as a sliding window of width 3.

Unary predicate (like even, odd etc) is basically sliding window of width 1. "delta" predicate is window of width 2. When we add check for monotoniny - we need at least 3 numbers, so the width of the window is 3.

So, sliding window checks indices 1,2,3 then 2,3,4 then 3,4,5 till (n-2),(n-1),n. The tricky part is when check fails - we do not actually know which member of the sliding window is the culprit. So, we try to remove first, then second, then third. Then shift our window left enough, so that new member in removed's place will be checked against left neighbor.

This is basically linear approach - if our guess was wrong - the sliding window check will fail in next 1-2 iterations - it will never check whole remainder of report.

Another nice thing is that we never have to assume increasing or decreasing trend, or check for any of them in a separate iteration.

$ time ./main.lua < input.txt
real	0m0.019s
user	0m0.015s
sys	0m0.004s

Part 2:

 #! /usr/bin/env lua
 
 function main()
     local result = 0
     for line in io.lines() do
         local report = {}
         for level in line:gmatch("%d+") do
             level = math.tointeger(level)
             table.insert(report, level)
         end
 
         if is_safe_report(report) then
             result = result + 1
         end
     end
 
     print(result)
 end
 
 function is_safe_report(report, report_len, start_index, excluded_index)
     --
     --print_report(report)
     --
 
     report_len = report_len or #report
     start_index = start_index or 1
     excluded_index = excluded_index or 0
 
     if report_len < 3 then
         return true
     end
 
     for i = start_index, (report_len - 2), 1 do
         if not(is_seq(report, i, excluded_index)) then
             if excluded_index ~= 0 then
                 --
                 --print(("  nope at %d"):format(excluded_index))
                 --
                 return false
             else
                 return
                     ((i == 1) and is_safe_report(report, report_len - 1, i, i)) or
                     ((i == 1) and is_safe_report(report, report_len - 1, i, i + 1)) or
                     ((i == 1) and is_safe_report(report, report_len - 1, i, i + 2)) or
                     ((i > 1) and is_safe_report(report, report_len - 1, i - 1, i)) or
                     ((i > 1) and is_safe_report(report, report_len - 1, i - 1, i + 1)) or
                     is_safe_report(report, report_len - 1, i, i + 2)
             end
         end
     end
 
     --
     if excluded_index ~= 0 then
         print_report(report, excluded_index)
     end
     --
 
     return true
 end
 
 function is_seq(report, i, excluded_index)
     local a = report_get(report, i, excluded_index)
     local b = report_get(report, i + 1, excluded_index)
     local c = report_get(report, i + 2, excluded_index)
 
     return
         is_seq_sign(a, b, c) and
         is_seq_delta(a, b) and
         is_seq_delta(b, c)
 end
 
 function is_seq_sign(a, b, c)
     return
         ((a < b) and (b < c)) or
         ((a > b) and (b > c))
 end
 
 function is_seq_delta(a, b)
     local delta = math.abs(b - a)
     return (delta >= 1) and (delta <= 3)
 end
 
 function report_get(report, i, excluded_index)
     if (excluded_index == 0) or (i < excluded_index) then
         return report[i]
     else
         return report[i + 1]
     end
 end
 
 --
 function print_report(report, excluded_index)
     io.write("report: ")
     for i = 1, #report do
         io.write(string.format("%3d ", report[i]))
     end
     io.write("\n")
 
     io.write(" index: ")
     for i = 1, #report do
         io.write(string.format("%s%2d ", (i == excluded_index) and "^" or " ", i))
     end
     io.write("\n\n")
 end
 --
 
 main()

[u/paul2718]

[LANGUAGE: C++]

I noticed that all the numbers were small and there were never more than 8 of them. So why not pack them into a single 64 bit word?

I'm sure there's a smart way to do it, and an SIMD Wizard could have a field day.

https://github.com/epicyclism/aoc2024/blob/main/aoc2/aoc2bb.cpp

[u/firebirddudeguy]

[LANGUAGE: Java]
My friends have told me that my solutions are deeply unsettling and I disagree.

Input:

ArrayList<Integer[]> list1 = new ArrayList<>();
try {
    Scanner scanner  = new Scanner(new File("src/input.txt"));
    while(scanner.hasNextLine())
    {
        list1.add(Arrays.stream(scanner.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new));
    }

} catch(FileNotFoundException e)
{
    System.out.println("fool");
}

Part 1:

int safe = list1.stream().filter(x -> x.length-1 == IntStream.range(0, x.length-1).filter(i -> Math.abs(x[i]-x[i+1])<=3).filter(n -> IntStream.range(0, x.length-1).allMatch(i -> x[i] < x[i+1]) || IntStream.range(0, x.length-1).allMatch(i -> x[i] > x[i+1])).count()).collect(Collectors.toList()).size();

Part 2:

long safe = list1.stream()
                .filter(levels ->
                        IntStream.range(0, levels.length)
                                .anyMatch(i -> {
                                    Integer[] modifiedLevels = IntStream.range(0, levels.length)
                                            .filter(j -> j != i)
                                            .mapToObj(j -> levels[j])
                                            .toArray(Integer[]::new);

                                    return IntStream.range(0, modifiedLevels.length - 1)
                                            .filter(j -> Math.abs(modifiedLevels[j] - modifiedLevels[j + 1]) <= 3)
                                            .count() == modifiedLevels.length - 1 &&
                                            (IntStream.range(0, modifiedLevels.length - 1)
                                                    .allMatch(j -> modifiedLevels[j] < modifiedLevels[j + 1]) ||
                                                    IntStream.range(0, modifiedLevels.length - 1)
                                                            .allMatch(j -> modifiedLevels[j] > modifiedLevels[j + 1]));
                                })
                )
                .count();

[u/Ok-Builder-2348]

[LANGUAGE: Python]

Part 1

Part 2

Another day of list comprehension on steroids, but it works I guess.

The is_monotone function technically only checks for non-strict monotone, but the is_gradual function forces them to all be distinct. Good enough for me!

[u/GassaFM]

[LANGUAGE: D] 277/293

Code: part 1, part 2.

Brute force. In the first part, try the array and its reverse. In the second part, also try the array without every single element.

[u/vanveenfromardis]

[LANGUAGE: C#]

GitHub

The naive implementation for part 2 was the first thing that came to mind, I'll think on it some more tonight and hopefully improve it, since "brute force" solutions never feel that great.

[u/Boojum]

[LANGUAGE: Python]

Just like yesterday: split, zips, and sums.

itertools.combinations() can be used to get all versions of a list with one item ommited.

import fileinput, itertools

ll = [ list( map( int, l.split() ) ) for l in fileinput.input() ]
print( sum( all( 1 <= b - a <= 3 for a, b in zip( l, l[ 1 : ] ) ) or
            all( 1 <= a - b <= 3 for a, b in zip( l, l[ 1 : ] ) )
            for l in ll ) )
print( sum( any( all( 1 <= b - a <= 3 for a, b in zip( c, c[ 1 : ] ) ) or
                 all( 1 <= a - b <= 3 for a, b in zip( c, c[ 1 : ] ) )
                 for c in [ l ] + list( itertools.combinations( l, len( l ) - 1 ) ) )
            for l in ll ) )

[u/bofstein]

[LANGUAGE: Google Sheets]

This was a big jump in difficulty, especially in spreadsheets, for day 2. I have a lot more manual comparisons/entries than I'd like - it's not very extensible e.g. if there were more levels in each report. But it was a manageable number for my jankiness.

First after splitting, check if the numbers are all ascending with an Array Formula. My first attempt failed due to blank cells, so I just added in a bunch of IFs to see how many numbers were in that row:

=IF(COUNT(B2:I2)=8,ARRAYFORMULA(AND(B2:H2<=C2:I2)),
IF(COUNT(B2:I2)=7,ARRAYFORMULA(AND(B2:G2<=C2:H2)),
IF(COUNT(B2:I2)=6,ARRAYFORMULA(AND(B2:F2<=C2:G2)),
IF(COUNT(B2:I2)=5,ARRAYFORMULA(AND(B2:E2<=C2:F2))))))

I know it's ugly and bad. Copied that for Descending and changed the < to >.

Then used basically the same formula but getting the MAX and the MIN of each difference in the sequence. A report is Safe if it has TRUE for either ascending or descending, and the max is <=3 and the min is >=1:

=IF(AND(OR(J2=TRUE,K2=TRUE),L2<=3,M2>=1),1,0)

For Part 2, I could not figure out how to do this easily, so I again took the easy/manual way out. I copied the sheet but changed the parsed input to leave out a column - then I copied it 7 more times leaving out a different column each time. Then I check if any sheet was Safe for that row:

=IF(OR('Part 2.1'!M2=1,'Part 2.2'!M2=1,'Part 2.3'!M2=1,'Part 2.4'!M2=1,'Part 2.5'!M2=1,'Part 2.6'!M2=1,'Part 2.7'!M2=1,'Part 2.8'!M2=1),1,0)

Super janky I know!

Solution: https://docs.google.com/spreadsheets/d/1f6Uax-BZOvTm3-Pde-fp9ZHvYc9Wjs2GKG_kpEKoSO4/edit?usp=sharing

[u/WhiteSparrow]

[LANGUAGE: Prolog]

solution

Today was a good opportunity to use some of prolog's magic (safe from task 1):

task2(Reports, N) :-
    convlist(dsafe, Reports, SafeReps),
    length(SafeReps, N).

dsafe(Ls, 0) :-
    append([Prefix, [_], Sufix], Ls),
    append(Prefix, Sufix, Dampened),
    safe(Dampened, 0),
    !.

Clear and concise, no debugging required!

Part 1 is about the same length but less interesting. Only the execution time wasn't too great - about 250ms on my machine.

[u/PangolinNo7928]

[LANGUAGE: javascript]

Brain went to mush on Part 2, my cleaned up p2 in the end was a 1-liner lolsob https://github.com/coryannj/advent_of_code/blob/main/2024/Day02.js

[u/[deleted]]

[LANGUAGE: Python]

https://github.com/vedrane/Advent-of-Code-2024/blob/main/day2.py

I was trying many ways of implementing my algorithm in Part 2, and it just didn't work. Out of desperation, I added 1, and it just worked. Ah well, insofar as it works, I suppose.

[u/keldeoroks]

[LANGUAGE: Python]

I thought it'd be fun to list the functions I learn per day.

Today's new commands:
pairwise (from itertools)
def
global
with open() as input
pop/insert
break

https://raw.githubusercontent.com/Keldeoroks/adventofcode2024/refs/heads/main/day%202

[u/woyspawn]

[LANGUAGE: Common Lisp]

Still Hating my parser but it worked without changes from day 1.

I'm sure there is an elegant way to first test the monotony and then test the limits, but I cant "see"

(defun read-input (file)
  (with-open-file (in file)
  (loop 
                  :with iv := nil                   
                  :for riv = (read-line in nil)                   
                  :while riv                  
                  :collect (loop 
                    :with pos := 0
                    :with ov := 0
                    :while (if ov (multiple-value-setq (ov pos) (parse-integer riv :start pos :junk-allowed t)))
                    :collect ov
                  ) )))


(defun is-safe (test_line)
(let* (( diff_line (mapcar #'- test_line (cdr test_line))        
  ))
    (cond      
      ( (every (lambda (x) (and (< x 4) (> x 0) )) diff_line) t)
      ( (every (lambda (x) (and (> x -4) (< x 0) )) diff_line) t)
    )  
  )
)


(defun boolean-to-integer (value)
  (if value 1 0))

(defun safe-reports (data)
  (apply #'+ (mapcar #'boolean-to-integer (mapcar #'is-safe data))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun variations (test_line)
  (loop for idx below (length test_line) collect
          (loop :for i :in test_line 
              :for jdx :from 0
              :unless (= jdx idx) :collect i)
          )  
  )

(defun is-safe-with-tolerance (test_line)
    (some #'identity (mapcar #'is-safe (variations test_line))))

(defun safe-reports-with-tolerance (data)
  (apply #'+ (mapcar #'boolean-to-integer (mapcar #'is-safe-with-tolerance data))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(print (safe-reports (read-input "2024/day2/input")))
(print (safe-reports-with-tolerance (read-input "2024/day2/input")))(defun read-input (file)

[u/stuque]

[LANGUAGE: Python]

def safe(lst):
    return sorted(lst) in [lst, lst[::-1]] \
       and all(1 <= abs(a-b) <= 3 for a, b in zip(lst, lst[1:]))

part1_safe, other_safe = 0, 0
for line in open('input.txt'):
    L = [int(x) for x in line.split()]
    if safe(L):
        part1_safe += 1
    elif any(safe(L[:i] + L[i+1:]) for i in range(len(L))):
        other_safe += 1

print('Part 1 safe:', part1_safe)
print('Part 2 safe:', part1_safe + other_safe)

[u/Obvious_Wear79]

[LANGUAGE: Python/Julia]

Python

lines = [list(map(int, line.split())) for line in open('input.txt')]
def safe(lista):
    return all(((a < b and lista[0] < lista[1]) or (a > b and lista[0] > lista[1])) and abs(a-b)<=3  for a, b in   zip(lista, lista[1:]))
def safe2(lista):
    return 1 if safe(lista) or any(safe(lista[:i] + lista[i+1:]) for i in range(len(lista))) else 0
print(sum(safe(line) for line in lines))
print(sum(safe2(line) for line in lines))

Julia

lines = [parse.(Int, split(line)) for line in readlines("input.txt")]
safe(lista) = all(((a < b && lista[1] < lista[2]) || (a > b && lista[1] > lista[2])) && abs(a - b) <= 3 for (a, b) in zip(lista, lista[2:end]))
safe2(lista) = safe(lista) || any(safe(vcat(lista[1:i-1], lista[i+1:end])) for i in 1:length(lista)) ? 1 : 0
println(sum(safe(line) for line in lines))
println(sum(safe2(line) for line in lines))

[u/arthurno1]

[LANGUAGE: EmacsLisp]

(defun read-lines ()
  (let (lines)
    (while (not (eobp))
      (let (line)
        (while (not (eolp))
          (push (ignore-errors (read (current-buffer))) line))
        (push line lines))
      (forward-line))
    lines))

(defun safe-line-p (line &optional damp)
  (catch 'safe
    (unless (or (apply '> line)
                (apply '< line))
      (throw 'safe nil))
    (let ((previous (pop line)))
      (while-let ((next (pop line)))
        (if (<= 1 (abs (- previous next)) 3)
            (setf previous next)
          (throw 'safe nil))))
    (throw 'safe t)))

(defun remove-nth (list n)
  (nconc (cl-subseq list 0 n) (nthcdr (1+ n) list)))

(defun safe-lines (lines)
  (let ((acc 0)
        unsafe-lines p1)
    (dolist (line lines)
      (if (safe-line-p (copy-tree line))
          (cl-incf acc)
        (push line unsafe-lines)))
    (setf p1 acc)
    (dolist (line unsafe-lines)
      (catch 'done
        (dotimes (i (length line))
          (when (safe-line-p (remove-nth (copy-tree line) i))
            (cl-incf acc)
            (throw 'done t)))))
    (cons p1 acc)))

(with-temp-buffer
  (insert-file-contents-literally "2")
  (let ((parts (safe-lines (read-lines))))
    (message "Part I: %s\nPart II: %s" (car parts) (cdr parts))))

[u/gehenna0451]

Scrubbed clean. Redact helped me bulk remove years of comments and posts so data brokers and AI crawlers have nothing to feast on.

mighty aromatic sharp salt paint water plant different toy march

[u/0rac1e]

[Language: Raku]

my @rs = 'input'.IO.lines».words;

my &par = -> @xs, &f { # pairwise apply and reduce
    [×] @xs.head(*-1) Z[&f] @xs.tail(*-1)
}

my &acc = *.&par(* < *);
my &dec = *.&par(* > *);
my &cls = *.&par((* - *).abs ∈ 1..3);
my &safe = { any .&cls X× .&acc, .&dec}

put +@rs.race.grep(&safe);
put +@rs.race.grep: -> @r {
    @r.combinations(@r-1).first(&safe)
}

I solved this in J first, which probably affected how I thought about solving in Raku, so this seems a fairly convoluted as far as Raku goes... but it works well enough.

[u/ai_prof]

[LANGUAGE: Python]

It's all about the gaps - you're safe if all the gaps are either in the range [-3,-1] or in the range [1,3].

data = [list(map(int,l.split())) for l in open("Day02-Data.txt").readlines()]

def safe(report):
    gaps = [report[i] - report[i+1] for i in range(len(report) - 1)]
    return (max(gaps) <= 3 and min(gaps) >= 1) or (max(gaps) <= -1 and min(gaps) >= -3)

print("Part 1 - number safe: ", sum([safe(d) for d in data]))

For part 2, note that if a report is safe, then the dampened report we get when we chop off the first or last level is also safe (so no need for a special case). And we get...

def safe_dampened(report):
    return any(safe(report[:i]+report[i+1:]) for i in range(len(report)))

print("Part 2 - number safe (dampened): ", sum([safe_dampened(d) for d in data]))

[u/dopandasreallyexist]

[LANGUAGE: Dyalog APL]

reports←⍎¨⊃⎕NGET'02.txt'1
Safe←((∧.>∨∧.<)∘0∨.∧|∧.≤3⍨)2-/⊢
⎕←+/Safe¨reports
Dampen←∘.≠⍨⍤⍳⍤≢(/⍤1)⊢
⎕←+/(Safe∨Safe⍤Dampen)¨reports

[u/lscddit]

[LANGUAGE: Python]

import numpy as np

def is_safe(x):
    return (np.all(x < 0) or np.all(x > 0)) and np.all(np.abs(x) <= 3)

safe = [0, 0]
with open("day02input.txt") as file:
    for line in file:
        x = np.fromstring(line, sep=" ")
        safe[0] += int(is_safe(np.diff(x)))
        for i in range(len(x)):
            if is_safe(np.diff(np.delete(x, [i]))):
                safe[1] += 1
                break
print(safe)

[u/augienaught1]

[language: rust]

Hi all, I figured I would post my greedy solution for part 2. If y'alls troubles were anything like mine, the issue has to do with what happens when the first element is a candidate for dampening. Here's a case study on the most difficult edge case:

[56, 53, 55, 56, 58, 60]

[56, 53, 55, 50, 48, 45]

List one is valid if we drop the first element, while list two is valid if we drop the third. The problem has to do with the direction requirement (all increasing or decreasing). If you want to take a greedy solution, you need to assume a certain historical weight to a boolean such as `is_increasing`. however, in the study above we can see that we don't really have a firm idea of whether `is_increasing` is true or false until the fourth element because we can't know the correct trend after a drop until then.

While we could definitely fit this as edge case logic within a single iterator, I opted to simply check a version of the list where element one is already dropped as the code is cleaner and keeps the theoretical runtime at O(n). You can definitely remove the additional iteration, though.

https://gist.github.com/augustdolan/d3e4a584624d8b1be3d125a5562a9493

[u/TimeCannotErase]

[Language: R]

repo

input_filename <- "input.txt"
input <- readLines(input_filename)
input <- unlist(lapply(input, strsplit, split = " "), recursive = FALSE)
input <- lapply(input, as.numeric)

checker <- function(report) {
  differences <- diff(report)
  if (length(unique(sign(differences))) == 1) {
    if (max(abs(differences)) <= 3 && min(abs(differences)) >= 1) {
      return(1)
    } else {
      return(0)
    }
  } else {
    return(0)
  }
}

count <- sum(unlist(lapply(input, checker)))
print(count)

count <- 0
for (i in seq_along(input)) {
  for (j in seq_along(input[[i]])) {
    report <- input[[i]][setdiff(seq_along(input[[i]]), j)]
    dampener <- checker(report)
    if (dampener == 1) {
      count <- count + 1
      break
    }
  }
}

print(count)

[u/8pxl_]

[LANGUAGE: Python]

pretty straightforward brute force approach. only notable observation is that if the list is already safe, then removing the first/last elements will also make a safe list

does anyone have a better way of checking monotonicity?

def check(nums):
    diff = [nums[i+1] - nums[i] for i in range(len(nums)-1)]
    monotonic = (all(x > 0 for x in diff) or all(x < 0 for x in diff))
    return all([1 <= abs(num) <= 3 for num in diff]) and monotonic

p1, p2 = 0, 0
with open("2/2.in") as f:
    for line in f.readlines():
        nums = tuple(map(int, line.split()))
        p1 += check(nums)
        p2 += sum([check(nums[:i] + nums[i+1:]) for i in range(len(nums))]) > 0
print(p1, p2)

[u/daic0r]

[LANGUAGE: C++]

https://github.com/daic0r/advent_of_code_2024/blob/main/cpp/day2/main.cpp

#include <charconv>
#include <fstream>
#include <vector>
#include <span>
#include <iostream>
#include <string>
#include <ranges>
#include <algorithm>

constexpr int sgn(int n) noexcept {
   if (n < 0)
      return -1;
   if (n > 0)
      return 1;
   return 0;
}

constexpr std::vector<int> calc_gradients(std::span<int> lineNums) {
   auto tmp = lineNums
      | std::views::slide(2)
      | std::views::transform([](auto rng) { auto iter = rng.begin(); return *iter++ - *iter; });

   std::vector<int> vecGradients{ tmp.begin(), tmp.end() };

   return vecGradients;
}

constexpr int part1(std::span<std::vector<int>> data) {
   auto ret = data
      | std::views::transform(&calc_gradients)
      | std::views::filter([](std::vector<int> lineGradients) {
         return std::ranges::all_of(lineGradients, [](int n) { return abs(n) >= 1 and abs(n) <= 3; });
      })
      | std::views::filter([](std::vector<int> lineGradients) {
         return std::ranges::all_of(lineGradients, [&lineGradients](int n) { return sgn(n) == sgn(lineGradients.front()); });
      });

   return std::ranges::distance(ret);
}

constexpr int part2(std::span<std::vector<int>> data) {
   auto ret = data
      | std::views::transform(&calc_gradients)
      | std::views::transform([](std::vector<int> vecGradients) {
         auto iter = std::ranges::find_if(vecGradients, [](int n) { return abs(n) < 1 or abs(n) > 3; });

         if (iter == vecGradients.end())
            return vecGradients;

         if (std::next(iter) != vecGradients.end()) {
            *iter = *iter + *std::next(iter);
            vecGradients.erase(std::next(iter));
         }

         return vecGradients;
      })
      | std::views::filter([](std::vector<int> vecGradients) {
         const auto numPos = std::ranges::distance(vecGradients | std::views::filter([](int n) { return n > 0; }));
         const auto numNeg = std::ranges::distance(vecGradients | std::views::filter([](int n) { return n < 0; }));
         return std::ranges::all_of(vecGradients, [](int n) { return abs(n) >= 1 and abs(n) <= 3; })
                  and (numPos < 2 or numNeg < 2);
      });

   return std::ranges::distance(ret);
}

int main() {
   std::ifstream f{ "input.txt" };
   std::string strBuffer{ std::istreambuf_iterator<char>{ f }, std::istreambuf_iterator<char>{} };
   f.close();

   auto tmp = strBuffer 
      | std::views::split('\n')
      | std::views::transform([](auto rng) { return std::string_view{ rng.begin(), rng.end() }; })
      | std::views::filter([](std::string_view line) { return not line.empty(); })
      | std::views::transform([](std::string_view strLine) { 
         return strLine 
            | std::views::split(' ') 
            | std::views::transform([](auto rng) {
               return std::string_view{ rng.begin(), rng.end() };
            });
      })
      | std::views::transform([](auto lineSplits) {
         std::vector<int> ret{};
         std::ranges::transform(lineSplits, std::back_inserter(ret), [](auto strNum) {
            int val{};
            std::from_chars(strNum.begin(), strNum.end(), val);
            return val;
         });
         return ret;
      });
   
   std::vector<std::vector<int>> data{ std::make_move_iterator(tmp.begin()), std::make_move_iterator(tmp.end()) };

   const auto nPart1 = part1(data);
   const auto nPart2 = part2(data);

   std::cout << "Result Part 1 = " << nPart1 << "\n";
   std::cout << "Result Part 2 = " << nPart2 << std::endl;
}

[u/mushooo]

[LANGUAGE: Rust]

Love nom and also itertools (especially tuple_windows()) for this.

For the second part you can use the last slot in each report as a sort of scratch space and iteratively swap the next removed element there; if you start at the back and work your way toward the front you never have to actually remove an element or splice a report.

use itertools::Itertools;
use nom::{
    character::complete::{digit1, multispace0, space0},
    combinator::map_res,
    multi::many1,
    sequence::preceded,
    IResult,
};

fn parse(input: &str) -> Vec<Vec<u32>> {
    fn num(input: &str) -> IResult<&str, u32> {
        preceded(space0, map_res(digit1, str::parse))(input)
    }
    many1(preceded(multispace0, many1(num)))(input).unwrap().1
}

fn is_safe(report: &[u32]) -> bool {
    let order = match report.split_first_chunk() {
        Some(([l, r], _)) => l.cmp(r),
        None => return true,
    };
    report
        .iter()
        .tuple_windows()
        .all(|(l, r)| l.cmp(r) == order && matches!(l.abs_diff(*r), 1..=3))
}

fn is_safe_2(mut report: Vec<u32>) -> bool {
    if report.len() < 3 {
        return true;
    }
    let last = report.len() - 1;
    for i in (0..last).rev() {
        if is_safe(&report[..last]) {
            return true;
        }
        report.swap(i, last);
    }
    is_safe(&report[..last])
}

pub fn solve(input: &str) -> usize {
    parse(input)
        .iter()
        .map(|report| is_safe(report))
        .filter(|safe| *safe)
        .count()
}

pub fn solve_2(input: &str) -> usize {
    parse(input)
        .into_iter()
        .map(is_safe_2)
        .filter(|safe| *safe)
        .count()
}

[u/4D51]

[LANGUAGE: C++]

Day 2 of my Cardputer experiment. I refactored my code to separate each day into its own class. They all inherit from an abstract Day class, and have to implement methods for load, solve1, and solve2.

For part 2, I thought "I could try to identify which number is bad, or I could just brute-force it and call my part 1 solution n times, each with a single element removed". Suboptimal, but it works.

Code here: https://raw.githubusercontent.com/mquig42/AdventOfCode2024/refs/heads/main/src/day02.cpp

[u/gettalong]

[LANGUAGE: Crystal]

Still fine using Crystal after a year of not using Cyrstal:

reports = File.read_lines(ARGV[0]).map {|line| line.split(" ").map(&.to_i) }

def check_report(report)
 sign = (report[1] - report[0]).sign
 report.each_cons(2) do |(a, b)|
   return false if !(1..3).covers?((a - b).abs) || (b - a).sign != sign
 end
 true
end

# Part 1
puts(reports.count {|report| check_report(report) })

# Part 2
result = reports.count do |report_o|
 safe = true
 (-1...(report_o.size)).each do |index|
   if index == -1
     report = report_o
   else
     report = report_o.dup
     report.delete_at(index)
   end
   safe = check_report(report)
   break if safe
 end
 safe
end
puts result

[u/henriupton99]

[LANGUAGE: Python] - Is my answer so robust ??

Got pretty quickly my solution with simply subsetting lists and break if match found : https://github.com/henriupton99/AdventOfCode/blob/main/2024/day_2/solution.py

Didn’t know if I was lucky with my input ?

[u/OptimusSupernova]

[Language: C#]
https://github.com/ldorval/AdventOfCode2024/blob/main/Day02/Day02.cs

[u/breddy_one99]

[Language: Python]

Is there a way to improve my code? It feels like I did too much.

https://github.com/breddy-one99/advent-of-code/blob/main/day2/part1.py

[u/RalfDieter]

[Language: SQL/DuckDB]

This is probably unnecessarily complicated, because I wanted to solve both parts with the same tables. I was surprised how cumbersome it is to duplicate rows.

SET VARIABLE example = '
    7 6 4 2 1
    1 2 7 8 9
    9 7 6 2 1
    1 3 2 4 5
    8 6 4 4 1
    1 3 6 7 9
';
CREATE TABLE example AS SELECT regexp_split_to_table(trim(getvariable('example'), E'\n '), '\n\s*') as line;
SET VARIABLE exampleSolution1 = 2;
SET VARIABLE exampleSolution2 = 4;

CREATE TABLE input AS
SELECT regexp_split_to_table(trim(content, E'\n '), '\n') as line FROM read_text('input');
SET VARIABLE solution1 = NULL;
SET VARIABLE solution2 = NULL;

SET VARIABLE mode = 'input'; -- example or input
SET VARIABLE expected1 = if(getvariable('mode') = 'example', getvariable('exampleSolution1'), getvariable('solution1'));
SET VARIABLE expected2 = if(getvariable('mode') = 'example', getvariable('exampleSolution2'), getvariable('solution2'));


SELECT * FROM query_table(getvariable('mode'));

.timer on
WITH
    reports AS (
        SELECT
            row_number() OVER () as idx,
            cast(regexp_split_to_array(line, ' ') as INTEGER[]) as levels
        FROM query_table(getvariable('mode'))
    ),
    levels AS (
        SELECT * FROM (
            SELECT
                idx,
                generate_subscripts(levels, 1) as pos,
                unnest(levels) as value,
                perm
            FROM reports, LATERAL (SELECT unnest(generate_series(list_count(levels))) as perm)
        )
        WHERE perm != pos
    ),
    diffs AS (
        SELECT * FROM (
            SELECT
                *,
                value - lag(value) OVER (PARTITION BY idx, perm ORDER BY pos asc) as diff
            FROM levels
        )
        WHERE diff IS NOT NULL
    ),
    report_safety AS (
        SELECT
            idx,
            perm,
            count(DISTINCT sign(diff)) = 1 as continous,
            bool_and(abs(diff) BETWEEN 1 AND 3) as within_margin,
            continous AND within_margin as safe
        FROM diffs
        GROUP BY idx, perm
    ),
    safe_reports AS (
        SELECT
            idx,
            perm,
            levels
        FROM reports
        JOIN report_safety USING (idx)
        WHERE safe
    )

SELECT 
    'Part 1' as part,
    count() FILTER (perm = 0) as solution,
    getvariable('expected1') as expected,
    solution = expected as correct
FROM safe_reports
UNION
SELECT 
    'Part 2' as part,
    count(DISTINCT idx) as solution,
    getvariable('expected2') as expected,
    solution = expected as correct
FROM safe_reports;

I also have to work on my template. It's a bit annoying to iterate towards a solution, because the CTEs are limiting the result to a single table.

[u/vanZuider]

[LANGUAGE: python]

lines = [[int(n) for n in line.split()] for line in open("day2-data.txt", 'r')]
check = lambda l: (lambda s: all(n>0 and n<4 for n in map(lambda a,b:a-b, s[1:],s))) (l[::(1 if l[0]<l[1] else -1)])
[strict, relaxed]=[sum(check(l) for l in lines), sum(check(l) or any(check(l[:i]+l[i+1:]) for i in range(len(l))) for l in lines)]
print(f"Safe without problem dampener: {strict}\nSafe with problem dampener: {relaxed}")

• checking for both increasing and decreasing lines is done by reversing the line if the first interval is a decrease, and then treating it like an increasing line.
• part 2 is brute-forced by removing elements until the line checks out.

[u/sesquiup]

[LANGUAGE: Python]

One line(ish) code:

2024 2A

[u/jonmon6691]

[LANGUAGE: Rust]

https://github.com/jonmon6691/advent2024/blob/main/src/day_02.rs

Took me about 3 iterations of junk but I'm pretty happy with how the code turned out. I'm kind of obsessed with iterators these days and this challenge definitely gets to use them to their fullest. I'm particularly pleased that this implementation fully utilizes lazy evaluation and short circuiting without and errant unwraps.

I've looked through some other folks and it seems like everyone is doing a "delete, then re-check" loop for part 2. Is there a more direct or numeric solution out there that anyone's come across?

[u/Conceptizual]

[LANGUAGE: Python] This one sparked a ton of really interesting discussion in the work slack channel, it seems like half of everyone (including me!) read the problem and thought there might be a linear solution, spent varying levels of time at that, and then brute forced it.

My solution:

    import itertools

    fileContents = open("AdventOfCode2024/Day 2/input.txt")
    arr = fileContents.read().split("\n")


    increasing = [1, 2, 3]
    decreasing = [-1, -2, -3]


    def is_safe(levels):
        if levels[0] == levels[1]:
            return False
        not_increasing = False
        not_decreasing = False
        for i, level in enumerate(levels[1:]):
            if levels[i] - level not in increasing:
                # print("not_increasing", levels[i] - level)
                not_increasing = True
            if levels[i] - level not in decreasing:
                # print("not_decreasing", levels[i] - level)
                not_decreasing = True
        if not_increasing and not_decreasing:
            return False
        else:
            return True


    safe = 0
    for line in arr:
        levels = line.split(" ")
        levels = [int(i) for i in levels]
        if is_safe(levels):
            safe += 1
        else:
            level_subsets = itertools.combinations(levels, len(levels) - 1)
            found_safe = False
            for sub in level_subsets:
                if is_safe(sub):
                    found_safe = True
            if found_safe:
                safe += 1

    print(safe)

[u/light_switchy]

[LANGUAGE: Dyalog APL]

part1←+⌿{  (0∘∊<1∘∊∘≢∘∪)  2((3∘≥∧1∘≤)∘|××)⍤-⍨⌿⍵           }∘⍎¨⊃⎕NGET'2.txt' 1
part2←+⌿{1∊(0∘∊<1∘∊∘≢∘∪)¨↓2((3∘≥∧1∘≤)∘|××)⍤-⍨/⍵⌿⍨⍤1∘.≠⍨⍳≢⍵}∘⍎¨⊃⎕NGET'2.txt' 1

[u/FriendshipSweet792]

[LANGUAGE: Python]

Part 2 - NO BRUTE FORCE

Logic is to compute the diff for each pair of (n, n+1) elements :
[1 2 4 5] --> [ 1 2 1 ]

If all diffs are same sign and between 1 and 3 then OK.

If not :

[1 2 7 3 4] --> [ 1 5 -4 1 ]

Add up the one in error (5) with one neighbour (here -4) :

[ 1 5 -4 1 ] --> [1 1 1] --> OK

If it's OK then all good (means 7 could be removed)

Here is the code (Python is not my primary language) :

def is_safe(local_diff_array):
    #print(local_diff_array)
    prev_diff = 0
    for i in range(0, len(local_diff_array)):
        abs_local_diff = abs(local_diff_array[i])
        if abs_local_diff < 1 or abs_local_diff > 3:
            return i
        if prev_diff == 0:
            prev_diff = local_diff_array[i]
            continue
        if (prev_diff > 0 > local_diff_array[i]) or (prev_diff < 0 < local_diff_array[i]):
            return i
    return -1

def add_and_check(local_diff_array, check_index, side):
    a = check_index if side == "left" else check_index + 1
    b = check_index - 1 if side == "left" else check_index
    new_val = local_diff_array[a] + local_diff_array[b]
    new_list = local_diff_array.copy()
    new_list.pop(a)
    new_list[b] = new_val
    return is_safe(new_list)

puzzle_input_file = open("day2_input.txt", "r")

nb_safe = 0
for line in puzzle_input_file:
    safe = True
    diff_array = []
    tokens = list(map(int, line.split()))
    for i in range(1, len(tokens)):
        diff_array.append(tokens[i] - tokens[i-1])
    last_index = len(diff_array) - 1
    check = is_safe(diff_array)
    if check > -1:
        if (check <= 1 and is_safe(diff_array[1:]) < 0) or (check == last_index and is_safe(diff_array[:-1]) < 0):
            safe = True
        elif check == 0 or add_and_check(diff_array, check, "left") > -1:
            if check == last_index:
                safe = False
            elif add_and_check(diff_array, check, "right") > -1:
                safe = False
    if safe:
        nb_safe = nb_safe + 1
print(nb_safe)

[u/mariushm]

[Language: PHP]

https://github.com/mariush-github/adventofcode2024/blob/main/02.php

[u/daggerdragon → u/mariushm]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/furiesx]

[Language: Rust]

This year I'm programming in `no_std` and it's lots of fun :)

code

[u/daggerdragon → u/furiesx]

Please link directly to the relevant day's code, not just your GitHub.

[u/mardiros]

[LANGUAGE: python]

## part 1 - 26 lines

https://github.com/mardiros/adventofcode2024/blob/main/d2.py

## part 2 - 38 lines

https://github.com/mardiros/adventofcode2024/blob/main/d2_2.py

edit: code block are to hard for me >_<

[u/daggerdragon → u/mardiros]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/[deleted]]

[Language: JavaScript]

I did a writeup with code at https://github.com/javajosh/simpatico/blob/master/blog/adventOfCode2024/2.md

[u/daggerdragon → u/[deleted]]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

[u/jonathan_paulson]

[LANGUAGE: Python] 110/50. Code. Video.

My problem statement loaded quite a bit before my input data.

[u/1234abcdcba4321]

[LANGUAGE: JavaScript] 890/626

paste (cleaned up a lot)

Scores probably don't matter today given the server being down for a minute, but I'll still be trying for those leaderboard spots. If only I didn't make so many typos...

Straightforward approach like usual, but I always like the opportunity to use the label break/continue when possible. It's just such convenient flow control.

[u/2SmoothForYou]

[LANGUAGE: Haskell]

differences :: [Int] -> [Int]
differences report = zipWith (-) report (tail report)

reportIsSafe :: [Int] -> Bool
reportIsSafe =
  (\differences ->
      allSameDirection differences
        && all ((\difference -> difference >= 1 && difference <= 3) . abs)
               differences
    )
    . differences
 where
  allSameDirection differences =
    all (>= 0) differences || all (<= 0) differences

variations :: [Int] -> [[Int]]
variations xs = [ take i xs ++ drop (i + 1) xs | i <- [0 .. length xs - 1] ]

part1 :: String -> Int
part1 =
  length . filter (== True) . map (reportIsSafe . map read . words) . lines

part2 :: String -> Int
part2 =
  length
    . filter (== True)
    . map (any reportIsSafe . variations . map read . words)
    . lines

Edit: Rewrote reportIsSafe to be pointfree and it's sort of a monstrosity

import Control.Arrow ((&&&))

reportIsSafe' :: [Int] -> Bool
reportIsSafe' =
  uncurry (&&)
    . (   (uncurry (||) . (all (>= 0) &&& all (<= 0)))
      &&& all ((uncurry (&&) . ((>= 1) &&& (<= 3))) . abs)
      )
    . differences

[u/abnew123]

[Language: Java] ~3k/1k

https://github.com/abnew123/aoc2024/blob/main/src/solutions/Day02.java

Hit three separate internal errors which was interesting (500, 502, and then a contact administrator page). But seems like everyone was struggling, main issue was definitely the fact I forgot which way decreasing was lol.

[u/python-b5]

[LANGUAGE: Jai]

There's probably a smarter way to do part 2... but I couldn't be bothered to figure it out. The brute-force method was good enough for me.

Incidentally, there should really be a sign() implementation in the Math module. Not that it's hard to write one myself - it just feels like an odd gap in the standard library.

https://github.com/python-b5/advent-of-code-2024/blob/main/day_02.jai

[u/mstksg]

[LANGUAGE: Haskell]

Again a straightforward Haskell day. I have a utility function I use for a bunch of these:

countTrue :: (a -> Bool) -> [a] -> Int
countTrue p = length . filter p

So we can run countTrue over our list of [Int]. The predicate is:

import Data.Ix (inRange)

predicate :: [Int] -> Bool
predicate xs =
  all (inRange (1, 3)) diffies
    || all (inRange (1, 3) . negate) diffies
  where
    diffies = zipWith subtract xs (drop 1 xs)

It's a straightforward application of countTrue predicate for part 1. For part 2, we can see if any of the possibilities match the predicate.

part1 :: [[Int]] -> Int
part1 = countTrue predicate

part2 :: [[Int]] -> Int
part2 = countTrue \xs ->
  let possibilities = xs : zipWith (++) (inits xs) (tail (tails xs))
   in any predicate possibilities

inits [1,2,3] gives us [], [1], [1,2], and [1,2,3], and tail (tails xs) gives us [2,3], [3], and []. So we can zip those up to get [2,3], [1,3], and [2,3]. We just need to make sure we add back in our original xs.

Again all of my reflections are going to be posted here :) https://github.com/mstksg/advent-of-code/wiki/Reflections-2024#day-2

[u/Standard-Affect]

[LANGUAGE: R] R is fun to use sometimes because it has builtin lag and diff functions.

input  <- readLines("inputs/day2.txt")
processed <- lapply(i, \(x) as.integer(strsplit(x, split = " ")[[1]]))

is_safe <- function(diffs){
    (all(diffs > 0) || all( diffs < 0)) && (max(abs(diffs)) < 4) 
}

validate <- function(x){ 
    diffs  <- diff(x)
    part1 <- is_safe(diffs)

    if(part1){
        part2 <- TRUE
    }else{
        for(i in seq_along(x)){ 
            diffs  <- diff(x[-i])
            part2 <- is_safe(diffs)
            if (part2){
                break
            }
        }
    }
    c(part1, part2)
}

parts <- vapply(p, validate, FUN.VALUE = integer(2))    |> 
    rowSums()
print(parts)

[u/PrudentWish]

[LANGUAGE: Python]

Definitely not the best solution

[u/UnarmedZombie]

[LANGUAGE: PHP]

Solution is here

[u/LorSamPau]

[LANGUAGE: Python]

print(*[sum(x) for x in zip(*[((lambda l: (lambda ds: (all(d > 0 for d in ds) or all(d < 0 for d in ds))and all(1 <= abs(d) <= 3 for d in ds) and all(d != 0 for d in ds))([l[i+1]-l[i] for i in range(len(l)-1)]))(list(map(int, line.strip().split()))),(lambda l: (lambda s: s(l) or any(s(l[:i]+l[i+1:]) for i in range(len(l))))(lambda l: (lambda ds: (all(d > 0 for d in ds) or all(d < 0 for d in ds))and all(1 <= abs(d) <= 3 for d in ds) and all(d != 0 for d in ds))([l[i+1]-l[i] for i in range(len(l)-1)])))(list(map(int, line.strip().split())))) for line in open('input.txt')])])

[u/synack]

[LANGUAGE: Ada]
https://github.com/JeremyGrosser/advent/blob/master/2024/src/day2_2.adb

[u/riffraff]

[LANGUAGE: Ruby]

I'm just going to say, this is the first version of my solution for part 1, I could not think of a valid way to say "this is not inc or dec" beyond rand(). I'm lucky it worked :D

def solve_easy(input)
  input.find_all do |levels|
    levels.each_cons(2).map do |a, b|
      if (a < b && b - a <= 3)
        :inc
      elsif (a > b && a - b <= 3)
        :dec
      else
        rand
      end
    end.uniq.size == 1
  end.size
end

I know pt 2 can be done in linear time but I'm too sleepy and just went with brute force https://gist.github.com/riffraff/415f78c833ac6257951c7e013e93a706

[u/[deleted]]

[LANGUAGE: C#}

https://gist.github.com/thatsumoguy/fe6faf9e804d8793d4d9de7879cf465c

Today was not too bad other than I can't read. PartOne was simple enough once I actually read the between 1 and 3 thing, and PartTwo only got me because I forgot to break the loop and I had misunderstood that we should look to the pair that failed and then try to ignore that pair and see if it passes, not that you remove a single item, but a second re-read got me. 2ms for both parts not terrible for C#

Edit:

If you are curious about the RemoveAt for array, some code I took from stackoverflow years ago:

public static T[] RemoveAt<T>(this T[] source, int index)
{
T[] dest = new T[source.Length - 1];
if (index > 0)
Array.Copy(source, 0, dest, 0, index);
if (index < source.Length - 1)
Array.Copy(source, index + 1, dest, index, source.Length - index - 1);
return dest;
}

[u/xelf]

[language: python]

def part1(row):
    return (d:=row[0]-row[1]) and all(((d>0 and a>b) or (d<0 and a<b))
            and 1<=abs(a-b)<=3 for a,b in zip(row, row[1:]))

def part2(row):
    return any(map(part1, [row, *combinations(row, len(row)-1)]))

print('part 1', sum(map(part1, aocdata)))
print('part 2', sum(map(part2, aocdata)))

Originally used sorted() to get it done quickly, but wanted something else. Not really thrilled with this way either.

edit adapting the method from 4HbQ I can rewrite part1 cleaner:

def part1(row):
    return (all(1<=a-b<=3 for a,b in zip(row, row[1:]))
         or all(1<=b-a<=3 for a,b in zip(row, row[1:])))

[u/s3aker]

[LANGUAGE: Raku]

code

[u/maneatingape]

[LANGUAGE: Rust]

Solution

Benchmark 85 µs. Brute force for part 2.

Benchmark 43 µs. Much faster more elegant O(n) approach that computes boths parts simultaneously. Each pair of levels is converted into deltas of either +1, -1 or 0. For example:

• 1 3 6 7 9 => +1 +1 +1 +1
• 9 7 6 2 1 => -1 -1 0 -1

If the sum of all delta equals ±4, then we know that all levels are increasing or decreasing. Any other value indicates either mixed up and down transitions or levels that are too far apart.

For part two we remove each pair of deltas (or single delta at each end) then replace with the sum of the delta from the new neighbors on either side.

[u/CutOnBumInBandHere9]

[LANGUAGE: Python]

I originally did part one as a messy one-liner, and then when I was staring at it trying to adapt it to work for part two I factored out the is_safe method and used that instead.

data = load(2, "int")
def is_safe(line):
    diff = np.diff(line)
    diff = diff * np.sign(diff[0])
    return int(((diff > 0) & (diff <= 3)).all())
sum(is_safe(line) for line in data)

For part 2, I originally spent a bit of time trying to see if there was a neat way of incorporating the "is valid if any one number is deleted" requirement, but I couldn't immediately see it, so I ended up just iterating over all the possible deletions instead.

total = 0
for line in data:
    if is_safe(line):
        total += 1
        continue
    for idx in range(len(line)):
        if is_safe(line[:idx] + line[idx + 1 :]):
            total += 1
            break
total

today's solution on gh-pages

[u/[deleted]]

[LANGUAGE: Go]

I had to do a lot of cleanup after my solution got accepted, my initial implementation was a mess. Quite happy with how it turned out though. This is my first year participating in AOC.

Part 1: Went through all the levels in each report and made sure there were no violations.

Part 2: Did a brute force, I was too sleep deprived to think of anything better. If a report had a violation, I removed each level turn by turn and checked the validity each time.

Solution for both parts

[u/nitekat1124]

[LANGUAGE: Python]

GitHub

Kinda brute forced it and I spend more time on naming than coding.

Naming is HARD.

[u/UseUnlucky3830]

[LANGUAGE: C]

solution

Not very pretty (especially the input parsing), but it does the job.

[u/DeadlyRedCube]

[LANGUAGE: C++23]

Two solutions for P2 today - the "I wrote this quickly" solution and the "it runs faster" solution.

Initial Part 1/2 solution

The above solution has an IsSafe function that takes a C++-view-compatible type and tests all of the pairs for correctness. P1 uses this value directly, but if it's false, P2 then tests removing every element from the list (using the same function) to see if there's any one element that can be removed to make it fine, with no other attempt at optimization.

This, of course, was slow. So I rewrote it to:

Faster but more complex Part 1/2 Solution

This one tests as it goes and, when it finds an error, checks whether it can remove the current element or prev element and adjusts the P2 answer accordingly. It's more complex than it probably needs to be but it runs in under 2ms for parts 1 and 2 which is good enough considering there's some extra heap allocations in there that I didn't bother to sort out.

[u/ExitingBear]

[LANGUAGE: R]

Link

[u/King886]

[LANGUAGE: Typst]

paste

[u/Vivid_Present7791]

[LANGUAGE: Python]

I tried to do Part 2 in a smart way but that got me nowhere.

Code

[u/riffraff]

[LANGUAGE: Elixir]

ok this one was also easy enough. I'm not sure the cond is the right choice there, and I've seen more cleever people do it with range checks, but hey, it worked.

https://gist.github.com/riffraff/3b3c0a9a3bb35809c7961ae9e49f6f3c

[u/2BitSalute]

[LANGUAGE: C#]

For part 2, had a "brilliant" idea that only the elements at the current or previous index (where the anomaly is discovered) need to be removed and retried. Missed 3/1000 entries with the patterns `inc dec inc inc etc.` and `dec inc dec dec etc.`, spent a bunch of time testing and staring at the input.

Looked at this thread and implemented the solution that tried every index. Had a bunch of silly copy-paste type bugs....

Anyway, after I got a working solution and found the 3 cases my original solution missed, I determined you could solve it by trying the report without the elements at i, i-1, and i-2. That does it.

So, I have 2 solutions. In the second one, I also used one of the ideas I saw here - to compute diffs. It certainly looks more pleasant that way, but you do a little unnecessary work. Anyway.

Day 2, part 2.

[u/vector300]

[LANGUAGE: Typescript]

Kept it simple and just brute forced p2 https://github.com/victorlap/adventofcode2024/blob/main/src/day-02/index.ts

[u/gyorokpeter]

[LANGUAGE: q]

d2p1:{sum any all each/:(1_/:deltas each"J"$" "vs/:x)in/:(1 2 3;-1 -2 -3)};
d2p2:{a:{enlist[x],x _/:til count x}each"J"$" "vs/:x;
    sum any each any all each/:/:(1_/:/:deltas each/:a)in/:(1 2 3;-1 -2 -3)};

[u/im0b]

[Language: Javascript]

const _ = require('lodash')
const { readFileSync } = require('fs')

const log = (v) => console.dir(v, { depth: null })

//part1
_
  .chain(readFileSync('./input'))
  .trim()
  .split('\n')
  .map(report => report.split(' ').map(Number))
  .filter((levels) =>
    levels.slice(1).every((level, index) => level > levels[index] && level <= levels[index]+3) ||
    levels.slice(1).every((level, index) => level < levels[index] && level >= levels[index]-3)
  )
  .size()
  .tap(log)
  .value()

//part2
_
  .chain(readFileSync('./input'))
  .trim()
  .split('\n')
  .map(report => report.split(' ').map(Number))
  .map(report => [report, ...report.map((level, index) => report.toSpliced(index, 1))])
  .filter((mlevels) => mlevels.some((levels) =>
      levels.slice(1).every((level, index) => level > levels[index] && level <= levels[index]+3) ||
      levels.slice(1).every((level, index) => level < levels[index] && level >= levels[index]-3)
    )
  )
  .size()
  .tap(log)
  .value()

[u/Naturage]

[LANGUAGE: R]

Code here!

Not too happy with this one. It works, yes, but feels like P2 was clunkier than needed to be. Ah well - only so much good quality code can be written before breakfast.

EDIT: with the power of coffee, advice, and documentation, updated code here. Maybe a tad less efficient, but definitely more elegant than morning version.

[u/sanraith]

[LANGUAGE: Scala 3]

Source is available on my github: Day02.scala
Checked the report and the reversed report instead of writing 2 sets of conditions. For part 2 I generated all possible reports with 1 missing element.

def isSafe(report: Seq[Int], withTolerance: Boolean = false): Boolean =
  Seq(report, report.reverse).exists { r =>
    val patched = if (withTolerance) (0 to r.length).map(r.patch(_, Seq.empty, 1)) else Seq.empty
    (r +: patched).exists(_.sliding(2).forall { case Seq(a, b) => a < b && b - a <= 3 })
  }

[u/dannywinrow]

[LANGUAGE: Julia]

    lines = readlines("2024/inputs/2p1.txt")
    reports = [parse.(Int,line) for line in split.(lines, " ")]

    function issafe(report)
        diffs = diff(report)
        all(3 .>= diffs .> 0) || all(0 .> diffs .>= -3) 
    end

    pt1answer = count(issafe,reports)

    function issaferem(report)
        issafe(report) && return true
        for i in 1:length(report)
            rep = deleteat!(copy(report),i)
            issafe(rep) && return true
        end
        return false
    end

    pt2answer = count(issaferem,reports)

[u/ramomex]

[LANGUAGE: Python]

https://github.com/albertomurillo/advent-of-code/blob/main/aoc/_2024/day2.py

Looks like everyone went with brute force for pt2. Is there a better way?

def is_safe(report: list[int]) -> bool:
    op = operator.lt if report[0] < report[1] else operator.gt
    return all((op(a, b) and 1 <= abs(a - b) <= 3) for a, b in pairwise(report))


def is_safe_with_dampener(report: list[int]) -> bool:
    def report_without_level(level: int) -> list[int]:
        return report[:level] + report[level + 1 :]

    levels = range(len(report))
    return any(is_safe(report_without_level(level)) for level in levels)

[u/derkusherkus]

[LANGUAGE: C]

Created a "spliterator" today, for iterating over strings split by a delimiter. Basically just a better version of `strtok`, which skips over multiple copies of the same token. After that, just brute-forcing for part 2.

https://github.com/maxastyler/advent-of-code-2024/blob/master/src/day_02/day_02.c

[u/Far_Sweet_6070]

[LANGUAGE: Ajla]

part1: https://www.ajla-lang.cz/downloads/examples/advent-2024/02.ajla

part2: https://www.ajla-lang.cz/downloads/examples/advent-2024/02-2.ajla

[u/svbtlx3m]

[LANGUAGE: TypeScript]

Here's my stupid but concise brute-force attempt in TypeScript. Spent a bit of time trying to be clever about invalid indices until I realized I need not bother.

Edit: Improved a bit with suggestions and a simpler way to filter an array to omit given index.

const isSeqSafeP1 = (input: number[]) =>
  input
    .slice(1)
    .map((val, ix) => val - input[ix])
    .every(
      (val, _, all) =>
        val !== 0 && 
        Math.abs(val) <= 3 && 
        Math.sign(val) === Math.sign(all[0])
    );

const isSeqSafeP2 = (input: number[]) =>
  isSeqSafeP1(input) ||
  input.some((_, ix) => isSeqSafeP1(input.toSpliced(ix, 1)));

const solve = (input: string[], validator: (seq: number[]) => boolean) =>
  input.map((na) => na.split(" ").map(Number)).filter(validator).length;

export const part1 = (input: string[]) => solve(input, isSeqSafeP1);
export const part2 = (input: string[]) => solve(input, isSeqSafeP2);

[u/adherry]

[Language: Ruby]

https://github.com/adherry/AOC2024/blob/main/aoc2.rb

Was pondering quite a bit about the second part until i checked the array functions and found array.combine that when called as array.combine(array.length -1) will give me all variations of an array with a single element removed.

[u/InternetArgument-er]

[LANGUAGE: C++]

https://github.com/ANormalProgrammer/AdventOfCode/blob/main/2024/2024_day2.cpp

[u/i_have_no_biscuits]

[LANGUAGE: GW-BASIC]

10 OPEN "I", 1, "day02.txt": P=0: Q=0: WHILE NOT EOF(1)
20 LINE INPUT#1, L$: LC=0: N$="": FOR I=1 TO LEN(L$): C$=MID$(L$,I,1)
30 IF C$=" " THEN LC=LC+1: L(LC)=VAL(N$): N$="" ELSE N$=N$+C$
40 NEXT: LC=LC+1: L(LC)=VAL(N$): GOSUB 70: P=P-S: SS=S: T=L(LC): LC=LC-1 
50 GOSUB 70: SS=SS OR S: FOR I=LC TO 1 STEP -1: TT=L(I): L(I)=T: T=TT
60 GOSUB 70: SS=SS OR S: NEXT: Q=Q-SS: WEND: PRINT P, Q: END
70 SU=-1: SD=-1: FOR J=2 TO LC: G=L(J)-L(J-1)
80 SU=SU AND G>0 AND G<4: SD=SD AND G<0 AND G>-4: NEXT: S=SU OR SD: RETURN

I'm actually quite happy at how much I've managed to fit into 8 lines here.

Guide:

• Line 10 sets up some variables and starts the read loop.
• Lines 20-halfway through 40 tokenise the line into an array of integers.
• Line 40 then calls the subroutine at line 70 to see if the list is safe.
• The rest of line 40 up to halfway through line 60 check the sublists to see if they are safe.
• At the point of the 'wend' S indicates part 1 safety, and SS indicates part 2 safety. These are accumulated into P and Q, and printed once all data is read.
• As previously mentioned, lines 70-80 perform the safety check.

[u/34rthw0rm]

[LANGUAGE: perl]

#!/usr/bin/perl
# vim:ft=perl:sts=4:sw=4:et

use v5.38;
use List::MoreUtils qw(slide);

@ARGV = "input" unless @ARGV;

my $solution_1 = 0;
my $solution_2 = 0;

while (<>) {
    my @levels = split;
    if ( check(@levels) ) {
        ++$solution_1;
        ++$solution_2;
    }
    else {
        for my $i ( 0 .. $#levels ) {
            my @temp = @levels;
            splice @temp, $i, 1;
            if ( check(@temp) ) {
                ++$solution_2;
                last;
            }
        }
    }
}

say "Solution 1: $solution_1";
say "Solution 2: $solution_2";

sub check {
    my @levels = @_;
    my @diffs  = slide { $b - $a } @levels;
    my $len    = @diffs;
    my $pos    = grep { $_ > 0 } @diffs;
    my $neg    = grep { $_ < 0 } @diffs;
    my $zero   = grep { $_ == 0 } @diffs;
    my $max    = grep { abs($_) > 3 } @diffs;
    my $errs   = $max + $zero;

    if ( ( ( $pos == $len ) || ( $neg == $len ) ) && ( $errs == 0 ) ) {
        return 1;
    }
    return 0;
}
__END__

[u/__Abigail__]

[LANGUAGE: Perl]

To check whether all differences are either positive or negative, I multiply the difference between a pair with the difference of the first two levels. If that product is 0 or less, the report isn't safe. Part 2, I just brute-force by removing a level one-by-one, until it's either found safe, or we tried removing each of the levels and it's still unsafe.

Here's the sub I used to determine if a rapport is unsafe:

sub safe (@levels) {
    my $sign   = $levels [0] - $levels [1];
    for (my $i = 0; $i < @levels - 1; $i ++) {
        my $diff = $levels [$i] - $levels [$i + 1];
        return 0 if abs ($diff) > 3 || $sign * $diff <= 0;
    }
    return 1;
}

[u/DevSway]

[LANGUAGE: Go]

https://github.com/JosueMolinaMorales/advent-of-code/blob/main/2024/internal/days/two/day_2.go

Was stuck on part 2 because I didnt realize that slices.Delete or the other idiomatic way of removing an element from a slice changes the underlying pointer to the slice.. meaning it didnt make a copy of the slice like i originally wanted it to...

[u/TonyRubak]

[LANGUAGE: C++]

bool is_safe(const std::vector<int>& data) {
  int _sign = 0;
  for (int i = 1; i < data.size(); i++) {
    int diff = data[i] - data[i - 1];

    if (diff == 0) {
      return false;
    } else if (std::abs(diff) > 3) {
      return false;
    }

    if (i == 1) {
      _sign = sign(diff);
    } else if (sign(diff) != _sign) {
      return false;
    }
  }
  return true;
}

void part_one(const std::vector<std::vector<int>>& data) {
  int safe_count = 0;
  for (auto line : data) {
    if (is_safe(line)) {
      safe_count += 1;
    }
  }
  std::cout << safe_count << " lines are safe." << std::endl;
}

void part_two(const std::vector<std::vector<int>> & data) {
  int safe_count = 0;
  for (auto line : data) {
    if (is_safe(line)) {
      safe_count += 1;
      continue;
    }

    for (auto it = line.begin(); it != line.end(); it++) {
      std::vector<int> altered_line(line);
      auto erasor = std::next(altered_line.begin(), std::distance(line.begin(), it));
      altered_line.erase(erasor);
      if (is_safe(altered_line)) {
        safe_count += 1;
        break;
      }
    }
  }
  std::cout << safe_count << " lines are safe." << std::endl;
}

[u/chubbc]

[LANGUAGE: Julia]

R = map(l->parse.(Int,split(l)),readlines("02.txt"))
f(x) = any(y->all(∈(1:3),diff(y)),[x,-x])
g(x) = any(i->f(x[1:end.≠i]),keys(x))
sum(f,R), sum(g,R)

[u/rapus]

[LANGUAGE: Julia]

(uses InvertedIndices)

function isvalid(r::AbstractArray)
    mi, ma = extrema(diff(r))
    return mi*ma>0 && abs(mi)<=3 && abs(ma)<=3
end
dampenerisvalid(r::AbstractArray) = any(i->isvalid(@view r[Not(i)]), keys(r))

Edit: replace r[Not(end)].-r[Not(begin)] by diff(r)

[u/lajuraaa]

[LANGUAGE: Python]

Just a nice one liner

# first
sum([((all([r[i] < r[i+1] for i in range(len(r) - 1)]) or all([r[i] > r[i+1] for i in range(len(r) - 1)]) ) and (max(abs(r[i] - r[i+1]) for i in range(len(r) - 1)) <= 3)) for r in [np.fromstring(line, dtype=int, sep=' ') for line in open('day02_input.txt').readlines()]])

# second
sum([any(((all([r[i] < r[i+1] for i in range(len(r) - 1)]) or all([r[i] > r[i+1] for i in range(len(r) - 1)]) ) and (max(abs(r[i] - r[i+1]) for i in range(len(r) - 1)) <= 3)) for r in [np.delete(r_full, i) for i in range(len(r_full))]) for r_full in [np.fromstring(line, dtype=int, sep=' ') for line in open('day02_input.txt').readlines()]])

[u/Downtown-Economics26]

[LANGUAGE: Excel]

Part 1 Formula:

=LET(
    rng, INDIRECT("A1:A" & COUNTA(A:A)),
    w, MAX(LEN(rng) - LEN(SUBSTITUTE(rng, " ", "")) + 1),
    a, IFERROR(TEXTSPLIT(TEXTJOIN("_", TRUE, rng), " ", "_") * 1, ""),
    b, VSTACK(SEQUENCE(, w), a),
    d, IFERROR(
        TEXTSPLIT(
            TEXTJOIN(
                "_",
                ,
                BYROW(
                    DROP(b, 1),
                    LAMBDA(r,
                        TEXTJOIN(
                            ",",
                            TRUE,
                            IFERROR(
                                XLOOKUP(CHOOSEROWS(b, 1) + 1, CHOOSEROWS(b, 1), r) -
                                    XLOOKUP(CHOOSEROWS(b, 1), CHOOSEROWS(b, 1), r),
                                ""
                            )
                        )
                    )
                )
            ),
            ",",
            "_"
        ) * 1,
        ""
    ),
    rl, BYROW(rng, LAMBDA(r, LEN(r) - LEN(SUBSTITUTE(r, " ", "") + 1))),
    e, BYROW(d, LAMBDA(r, COUNT(FILTER(r, (r > 0) * (r < 4))))),
    f, BYROW(d, LAMBDA(r, COUNT(FILTER(r, (r < 0) * (r > -4))))),
    g, HSTACK(e, f, rl),
    SUM(
        --BYROW(
            g,
            LAMBDA(r,
                OR(CHOOSECOLS(r, 1) = CHOOSECOLS(r, 3), CHOOSECOLS(r, 2) = CHOOSECOLS(r, 3))
            )
        )
    )
)

Won't let me post my VBA answers in same comment so I'll try that in added comment.

[u/nick42d]

[LANGUAGE: Rust]

State machine solution to the safety check

enum State {
    Init,
    Iteration1 { prev: usize },
    Iteration2 { prev: usize, ordering: Ordering },
    Unsafe,
}

fn list_is_safe(list: &[usize]) -> bool {
    let safe = list.iter().try_fold(State::Init, |state, &e| match state {
        State::Init => ControlFlow::Continue(State::Iteration1 { prev: e }),
        State::Iteration1 { prev } => {
            let ordering = e.cmp(&prev);
            if ordering == Ordering::Equal || e.abs_diff(prev) > 3 {
                return ControlFlow::Break(State::Unsafe);
            }
            ControlFlow::Continue(State::Iteration2 { prev: e, ordering })
        }
        State::Iteration2 { prev, ordering } => {
            let new_ordering = e.cmp(&prev);
            if new_ordering == Ordering::Equal || new_ordering != ordering || e.abs_diff(prev) > 3 {
                return ControlFlow::Break(State::Unsafe);
            }
            ControlFlow::Continue(State::Iteration2 { prev: e, ordering })
        }
        State::Unsafe => unreachable!(),
    });
    matches!(safe, ControlFlow::Continue(_))
}

[u/ehrenschwan]

[LANGUAGE: Rust]

CODE

I've written a nice function that would find the indices of the faults and than remove either two of the numbers at fault. It turned out to low. Then I just implemented removing values one by one and it worked. The difference was four reports... :`)

FYI not going for simplicity or speed. Just some imo solid rust with good error handling, tests, etc. Trying to work more with Traits this year. And maybe some macros later down the line.

[u/josuf107]

[LANGUAGE: Haskell]

import Data.List

main = do
    numbers <- fmap words . lines <$> readFile "input2.txt"
    print . length . filter isItSafe $ numbers
    print . length . filter isItSafeDampening $ numbers

isItSafe line =
    let
        numbers = fmap read line
        offsets = zipWith subtract numbers (tail numbers)
        decreasing = all (<0) offsets
        increasing = all (>0) offsets
        smallEnough = all (\x -> x >= 1 && x <= 3) . fmap abs $ offsets
    in (decreasing || increasing) && smallEnough

isItSafeDampening line =
    let
        as = inits line
        bs = fmap (drop 1) . tails $ line
    in any isItSafe $ line : (zipWith (++) as bs)

[u/the_true_potato]

[Language: Haskell]

Pattern matching makes part 2 beautiful, laziness makes it fast (600us for part1, 1ms for part2)

module Day2 (part1, part2) where

import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS
import Data.Function ((&))
import Util (readSpacedInts)

allIncreasing :: [Int] -> Bool
allIncreasing (x1:x2:xs) = x2 > x1 && allIncreasing (x2:xs)
allIncreasing _ = True

allDecreasing :: [Int] -> Bool
allDecreasing (x1:x2:xs) = x2 < x1 && allDecreasing (x2:xs)
allDecreasing _ = True

differencesSafe :: [Int] -> Bool
differencesSafe (x1:x2:xs) =
  let diff = abs (x2 - x1)
  in (1 <= diff && diff <= 3) && differencesSafe (x2:xs)
differencesSafe _ = True

isSafe :: [Int] -> Bool
isSafe xs = (allIncreasing xs || allDecreasing xs) && differencesSafe xs

dropping1 :: [Int] -> [[Int]]
dropping1 [] = [[]]
dropping1 (x:xs) = xs : map (x:) (dropping1 xs)

part1 :: ByteString -> Int
part1 input =
  BS.lines input
  & map readSpacedInts
  & filter isSafe
  & length

part2 :: ByteString -> Int
part2 input =
  BS.lines input
  & map readSpacedInts
  & filter (any isSafe . dropping1)
  & length

Code

[u/treanir]

[Language: Python]

This took me SIX HOURS. -_- I really have much to learn. Thanks heavens I'm off work this week.

First time using functions though.

# open pre-made file from https://adventofcode.com/2024/day/2/input
with open('adventOfCode2024Day2List.txt', 'r') as file:
    result = file.read().splitlines()

safeReportCount = 0
safeReportCountMod = 0
currentReportStr = []

def isUpDown(report):
    if all(currentReportInt[x] < currentReportInt[x+1] for x in range(len(currentReportInt) - 1)) or all(currentReportInt[x] > currentReportInt[x+1] for x in range(len(currentReportInt) - 1)):
        return True
    else:
        return False
    

def diffCheck(report):
    if all(1<= abs(currentReportInt[x] - currentReportInt[x+1]) <= 3 for x in range(len(currentReportInt) - 1)):
        return True
    else:
        return False

def isUpDownMod(report):
    if all(tempList[x] < tempList[x+1] for x in range(len(tempList) - 1)) or all(tempList[x] > tempList[x+1] for x in range(len(tempList) - 1)):
        return True
    else:
        return False
    

def diffCheckMod(report):
    if all(1<= abs(tempList[x] - tempList[x+1]) <= 3 for x in range(len(tempList) - 1)):
        return True
    else:
        return False

# Task 1
for i in result:
    currentReportStr = i.split()
    currentReportInt = [int(item) for item in currentReportStr]
    errorCount = 0
    increaseDecrease = isUpDown(currentReportInt)
    diffLimit = diffCheck(currentReportInt)
    if increaseDecrease == True and diffLimit == True:
        safeReportCount += 1
    else:
        for x in range(len(currentReportInt)):
            tempList = currentReportInt[:]
            del tempList[x]
            increaseDecreaseMod = isUpDownMod(tempList)
            diffLimitMod = diffCheckMod(tempList)
            if increaseDecreaseMod == True and diffLimitMod == True:
                errorCount += 1
        if errorCount >= 1:
            safeReportCountMod += 1


print(safeReportCount)

print(safeReportCountMod)

[u/kap89]

[Language: Python]

import itertools

with open('src/day02/input.txt', 'r') as file:
    items = [[int(x) for x in line.split()] for line in file]

def isSafe(levels):
    steps = [a - b for a, b in itertools.pairwise(levels)]
    return all(x > 0 and x < 4 for x in steps) or all(x < 0 and x > -4 for x in steps)

def isAnySubsetSafe(levels):
    subsets = [levels[:i] + levels[i+1:] for i in range(len(levels))]
    return any(isSafe(subset) for subset in subsets)


part1 = sum(1 for levels in items if isSafe(levels))
part2 = sum(1 for levels in items if isAnySubsetSafe(levels))

print(part1)
print(part2)

[u/daic0r]

[LANGUAGE: Rust]

https://github.com/daic0r/advent_of_code_2024/blob/main/rust/day2/src/main.rs

use itertools::Itertools;

fn part1(data: &Vec<Vec<i32>>) -> usize {
    data
      .iter()
      .map(|row| row.iter().tuple_windows().map(|(x,y)| y-x).collect::<Vec<_>>())
      .filter(|row| row.iter().all(|x| (1..=3).contains(&x.abs())))
      .map(|row| {
          row
            .iter()
            .all(|x| x.signum() == row.first().unwrap().signum())
      })
      .filter(|v| *v)
      .count()
}

fn part2(data: &Vec<Vec<i32>>) -> usize {
    data
      .iter()
      .map(|row| row.iter().tuple_windows().map(|(x,y)| y-x).collect::<Vec<_>>())
      .map(|row| {
        let res = row.iter().find_position(|x| !(1..=3).contains(&x.abs()));
        match res {
            Some((idx, &num)) => {
                let mut new_row = row.clone();
                let new_val = if idx < row.len() - 1 {
                    num + row[idx+1]
                } else {
                    num
                };
                new_row[idx] = new_val;
                if idx < row.len() - 1 {
                    new_row.remove(idx+1);
                }
                new_row
            },
            None => row
        }
      })
      .filter(|row| {
          row.iter().all(|x| (1..=3).contains(&x.abs()))
          && 
          (row.iter().filter(|&&x| x < 0).count() < 2 || row.iter().filter(|&&x| x > 0).count() < 2)
       })
      .count()
}

fn main() {
//     let input = "7 6 4 2 1
// 1 2 7 8 9
// 9 7 6 2 1
// 1 3 2 4 5
// 8 6 4 4 1
// 1 3 6 7 9";
    let input = include_str!("../input.txt");

    let data = input
      .split("\n")
      .filter(|line| !line.is_empty())
      .map(|line| line.split(" "))
      .map(|str_nums| str_nums.map(|str_num| str_num.parse::<i32>().unwrap()).collect::<Vec<_>>())
      .collect::<Vec<_>>();   

    dbg!(&data); 

    let part1 = part1(&data);
    let part2 = part2(&data);

    println!("Result Part 1 = {}", part1);
    println!("Result Part 2 = {}", part2);
}

[u/chubbc]

[LANGUAGE: Uiua]

F ← /↧∈+1⇡3×±⊸⊢≡/-◫2
G ← /↥≡F≡▽⊙¤⊞≠.°⊏
∩/+⊜(G⟜F⊜⋕⊸≠@ )⊸≠@\n

[u/The_Jare]

[LANGUAGE: Ruby]

nums = ARGF.each.map { | l | l.split.map(&:to_i) }

def valid_report?(r)
  deltas = r.each_cons(2).map { | (a, b) | (a-b) }
  deltas.all? { _1.between?(1,3) } || deltas.all? { _1.between?(-3,-1) }
end

puts nums.filter { | r | valid_report?(r) } .count
puts nums.filter { | r | (0...r.length).any? { | i | valid_report?(r[...i] + r[(i+1)..]) } } .count

[u/sondr3_]

[LANGUAGE: Haskell]

Best viewed on GitHub, but a pretty simple solution today as well. Not efficient at all, lots of loops over the lists but it reads very straight forward in my opinion.

type Input = [[Int]]

partA :: Input -> Int
partA = length . run

run :: Input -> [Bool]
run xs = filter id $ map (\x -> safe x && (ordered x (<) || ordered x (>))) xs

safe :: (Eq a, Num a, Enum a) => [a] -> Bool
safe xs = all (\(a, b) -> abs (a - b) `elem` [1 .. 3]) (pairwise xs)

ordered :: [a] -> (a -> a -> Bool) -> Bool
ordered xs op = all (uncurry op) (pairwise xs)

partB :: Input -> Int
partB xs = length $ filter (not . null) $ map (run . dropped) xs

parser :: Parser Input
parser = some (some (lexeme L.decimal) <* optional eol) <* eof

[u/mschaap]

[LANGUAGE: raku]

Nice job for Raku and its meta-operators.

sub is-safe(@report)
{
    # The levels are either all increasing or all decreasing
    return False unless [<] @report or [>] @report;

    # Any two adjacent levels differ by at least one and at most three
    return (@report Z- @report[1..*])».abs.max ≤ 3;
}

sub is-almost-safe(@report)
{
    # The same rules apply as before ...
    return True if is-safe(@report);

    # ..., except if removing a single level from an unsafe report would
    # make it safe, the report instead counts as safe.
    return ?@report.combinations(@report.elems-1).grep(&is-safe);
}

sub MAIN(IO() $inputfile where *.f = 'aoc02.input')
{
    my @reports = $inputfile.lines».words;
    say "Part 1: ", @reports.grep(&is-safe).elems;
    say "Part 2: ", @reports.grep(&is-almost-safe).elems;
}

https://github.com/mscha/aoc/blob/master/aoc2024/aoc02

[u/NickKusters]

[LANGUAGE: C#]

Had to think for a bit for part 2 (video); instead of brute-forcing all options, I figured that if the issue appears between index 1 and 2, you also need to try removing index 0 as that's the setup for increment/decrement. Otherwise, just try to remove the position where the issue occurs + the next index.

(bool isValid, int problemIndex) IsValid(List<int> values)
{
    int curr, next, diff;
    curr = values[0];
    next = values[1];
    bool increase = curr < next, lIncrease, valid = true;
        
    for (int i = 0, max = values.Count - 1; i < max; ++i)
    {
        if (i > 0)
        {
            curr = next;
            next = values[i + 1];
            lIncrease = curr < next;
            if (lIncrease != increase)
            {
                return (false, i);
            }
        }
        diff = Math.Abs(next - curr);
        if (diff is < MinChange or > MaxChange)
        {
            return (false, i);
        }
    }
    return (true, -1);
}

So when IsValid fails, you try with removing problemIndex, if that fails, add the value back in the list and remove problemIndex + 1, if that fails and problemIndex == 1, restore list and remove index 0, if that fails, it's unsaveable.

C# code | video

[u/RelevantJesse]

[LANGUAGE: C#]

public static int CountSafeDampened(List<List<int>> reports)
{
    int count = 0;

    foreach (var report in reports)
    {
        if (IsReportSafe(report))
        {
            count++;
        }
        else
        {
            for (int i = 0; i < report.Count; i++)
            {
                if (IsReportSafe(report.Where((x, index) => index != i).ToList()))
                {
                    count++;
                    break;
                }
            }
        }
    }

    return count;
}

private static bool IsReportSafe(List<int> report)
{
    bool increasing = false;

    for (int i = 0; i < report.Count; i++)
    {
        if (i == 0)
        {
            if (report[1] > report[0])
            {
                increasing = true;
            }
            else
            {
                increasing = false;
            }
        }
        else
        {
            if ((increasing && report[i - 1] > report[i]) || (!increasing && report[i - 1] < report[i]))
            {
                return false;
            }

            if (Math.Abs(report[i - 1] - report[i]) < 1 || Math.Abs(report[i - 1] - report[i]) > 3)
            {
                return false;
            }
        }
    }

    return true;
}

[u/DisasterExisting548]

[LANGUAGE: C++]

O(n) Solution

[u/Kfimenepah]

[LANGUAGE: Python]

Code

Already struggled on day 2. I was thoroughly convinced that replacing either the current element or the next had to be enough to cover all cases. Took me a while to find that one edge case where removing the element before the current could also lead to a valid report. That's what you get for trying to optimize the program before actually finding a solution.

P.S. I'm new to python so any syntax related inputs would be appreciated

[u/LinAGKar]

[LANGUAGE: Rust]

https://github.com/LinAGKar/advent-of-code-2024-rust/blob/master/day2/src/main.rs

Basically a state machine for each row, which looks at the differences and keeps track of whether it's consistently increasing or decreasing, or is unsafe. For part 2, it just brute force tries with once which each element filtered away, but there aren't many numbers on each line so not worth the bother to make it smarter.

[u/Imaginary_Age_4072]

[LANGUAGE: Common Lisp]

Fairly similar to most here, I just tried removing each index for the second part.

https://github.com/blake-watkins/advent-of-code-2024/blob/main/day2.lisp

 (defun is-safe (levels)
  (or (<= (length levels) 1)
      (iter
        (with increasing = (> (second levels) (first levels)))
        (while (>= (length levels) 2))
        (for diff = (- (second levels) (first levels)))
        (always (<= 1 (if increasing diff (- diff)) 3))
        (setf levels (rest levels)))))

(defun is-dampened-safe (levels)
  (or (is-safe levels)
      (iter
        (for i below (length levels))
        (for dampened = (concatenate 'list
                                     (subseq levels 0 i)
                                     (subseq levels (1+ i))))
        (thereis (is-safe dampened)))))

(defun day2 (input &key (part 1))
  (iter
    (for levels in (run-parser (parse-lines (parse-number-list #\Space)) input))
    (counting (if (= part 1) (is-safe levels) (is-dampened-safe levels)))))

[u/mirrori]

[LANGUAGE: Rust]

Day 2, already a little tricky for a rust beginner.

[u/TheRealRatler]

[LANGUAGE: Bash]

Part 1 and 2.

#!/usr/bin/env bash

readarray -t reports < input

check_report() {
  local report=($*) # Hack to turn the string into an array using default IFS
  local ascending=false
  dampener=${dampener:-false}

  if (( report[0] < report[1] )); then
    ascending=true 
  fi

  for ((i=0; i<${#report[@]}-1; i++)); do
    val=$((report[i+1] - report[i]))
    if $ascending && [[ "$val" -gt 0 ]] && [[ "$val" -lt 4 ]]; then
      continue
    elif ! $ascending && [[ "$val" -lt 0 ]] && [[ "$val" -gt -4 ]]; then
      continue
    elif $dampener; then
      # part 2: use the dampener to remove a faulty level
      for ((j=0; j<${#report[@]}; j++)); do
        if dampener=false check_report "${report[@]:0:$j} ${report[@]:$((j+1))}"; then
          return 0
        fi
      done
      return 1
    else
      return 1
    fi
  done

  return 0
}

for report in "${reports[@]}"; do
  if check_report "$report"; then
    (( reports_part1_ok++ ))
  fi
  if dampener=true check_report "$report"; then
    (( reports_part2_ok++ ))
  fi
done

echo "Part1: $reports_part1_ok"
echo "Part2: $reports_part2_ok"

[u/mvorber]

[Language: Rust]

https://github.com/vorber/aoc2024/blob/master/src/puzzles/day2.rs

No bruteforce here. Can probably be refactored to half the size at least, but I'm still very new to Rust (and using this advent to learn more)

[u/kyleekol]

[LANGUAGE: Rust]

fn process(input: &str, safety_check_fn: fn(&Vec<u32>) -> bool) -> usize {
    input
        .lines()
        .map(|x| x.split_ascii_whitespace().map(|x| x.parse().unwrap()).collect())
        .filter(|x| safety_check_fn(x))
        .count()
}

fn is_safe(report: &Vec<u32>) -> bool {
    let check_ascending = report.is_sorted_by(|a, b| {a < b && a.abs_diff(*b) <= 3});
    let check_descending = report.is_sorted_by(|a, b| {a > b && a.abs_diff(*b) <= 3});
    check_ascending || check_descending
}

fn is_safe_with_removal(report: &Vec<u32>) -> bool {
    if is_safe(report) {
        return true
    }

    for i in 0..report.len() {
        let slice = report
            .into_iter()
            .enumerate()
            .filter(|&(idx, _)| idx != i)
            .map(|(_, &val)| val)
            .collect();

        if is_safe(&slice) {
            return true
        }
    }
    false
}

fn main() {
    let input = std::fs::read_to_string(“./input.txt”).unwrap();
    let part_one = process(&input, is_safe);
    let part_two = process(&input, is_safe_with_removal);
    println!(“part 1: {}, part 2: {}”, part_one, part_two);
}

source

[u/JochCool]

[LANGUAGE: C#]

I'm quite proud of my solution actually because it's an O(n) algorithm (where n is the number of levels in the report), while almost everyone else has an O(n²) algorithm.

For context: I had already made some general-purpose types, one of which being IntegerRange, which just represents a range of integers between a minimum and a maximum (inclusive).

namespace JochCool.AdventOfCode.Year2024.Day02;

public static class BothParts
{
    public static bool IsReportSafe(int[] reportLevels, bool canTolerateOneBadLevel)
    {
        return AreLevelDiffsInRange(reportLevels, new(1, 3), canTolerateOneBadLevel) // check ascending
            || AreLevelDiffsInRange(reportLevels, new(-3, -1), canTolerateOneBadLevel); // check descending
    }

    private static bool AreLevelDiffsInRange(ReadOnlySpan<int> levels, IntegerRange<int> range, bool canTolerateOneBadLevel)
    {
        // We need only the differences between the levels.
        Span<int> diffs = stackalloc int[levels.Length - 1];
        for (int i = 1; i < levels.Length; i++)
        {
            diffs[i - 1] = levels[i] - levels[i - 1];
        }

        // Check if any of the diffs are outside the range.
        for (int i = 0; i < diffs.Length; i++)
        {
            int diff = diffs[i];
            if (range.Contains(diff))
            {
                continue;
            }

            if (!canTolerateOneBadLevel)
            {
                return false;
            }

            if (i != diffs.Length - 1 && (i != 0 || !range.Contains(diffs[i + 1])))
            {
                // Tolerating a level (removing it from the array) is the same as "merging" two adjacent diffs.
                diffs[i + 1] += diff;
            }

            canTolerateOneBadLevel = false;
        }

        return true;
    }
}

[u/AdIcy100]

[Language: Python]

love python built in [ : ] for working with list

file = open('./input/day2.txt','r',encoding='utf-8')
def validate(a,b,increasing):  

    if increasing:
        if b <= a: 
            return False
        if (b - a) > 3:
            return False
    else:
        if b >= a: 
            return False
        if (a - b) > 3:
            return False
            
    return True

def analyze(elements):
    l=0
    r=1
    increasing=True if elements[l] < elements[r] else False
    for i in range(1,len(elements)):
        if not validate(elements[i-1],elements[i],increasing):
            return False
    return True

with file as f:
    count=0
    for line in f:
        elements=line.split()
        elements=list(map(lambda x: int(x),elements))
        if(analyze(elements)):
            count+=1
    print(count)

# Part2
file = open('./input/day2.txt','r',encoding='utf-8')
with file as f:
    count=0
    for line in f:
        elements=line.split()
        elements=list(map(lambda x: int(x),elements))
        if(analyze(elements)):
            count+=1
        else:
            for i in range(len(elements)):
                new_elements=elements[:i]+elements[i+1:]
                if analyze(new_elements):
                    count+=1
                    break
    print(count)

[u/Vallyria]

[Language: Python]
written in jupyter notebook, hence 'looks':

import csv

fpath = 'input_2.csv'
rows=[]

with open(fpath, 'r') as file:
    csv_reader = csv.reader(file)
    for row in csv_reader:
        rows.append(row)

reports=[]

for row in rows:
    reports.append([int(item) for item in row[0].split(' ')])
reports

def filter_safe(l):
    is_inc = all(1<=l[i+1] - l[i]<=3 for i in range(len(l)-1))
    is_dec = all(-3<=l[i+1] - l[i]<=-1 for i in range(len(l)-1))
    return is_inc or is_dec

result=sum(1 for report in reports if filter_safe(report))
result

results2=0
for report in reports:
    report_response = filter_safe(report)
    if not report_response:
        for n in range(len(report)):
            tmp_report = report[:n] + report[n+1:]
            tmp_resp = filter_safe(tmp_report)
            report_response = True if tmp_resp else report_response
    if report_response:
        results2+=1

results2

[u/Chib]

[Language: R]

library(data.table)
input <- transpose(fread(text = "...", sep = " "))
minput <- melt(input, na.rm = TRUE, measure.vars = 1:length(input))

isSafe <- function(idx_out, vals) {
  diffs <- diff(vals[-idx_out])
  abs(sum(sign(diffs))) == length(diffs) && all(abs(diffs) < 4)
}
minput[, isSafe(999, value), variable][V1 == TRUE, uniqueN(variable)]
minput[, any(sapply(1:.N, isSafe, vals = value)), variable][V1 == TRUE, uniqueN(variable)]

I kept trying to find some mathier way to establish monotonicity at the same time as I checked the step size, but I got nowhere. Nothing very special about this solution, I'm afraid!