jack's advent of code 2024 ramblings

day 2

welcome to day 2! (as i’m writing this the night of day 4, hopefully getting this out before the day 5 problem is posted)

and as i’m finishing this up on day 8… sorry about that LOL

no need for preamble explaining what this is, day 1 explains that, time to jump into it

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

reports =
  input
  |> String.split("\n")
  |> Enum.map(fn line ->
    line
    |> String.split(" ")
    |> Enum.map(&String.to_integer(&1))
  end)

[
  [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]
]

defmodule RedNoseReports do
  def process([a | [b | t]]) do
    if a - b > 0 do
      process([a | [b | t]], :up)
    else
      process([a | [b | t]], :down)
    end
  end
  
  def process([a | [b | t]], direction) do
    correct_direction = case direction do
      :up -> a - b > 0
      :down -> a - b < 0
    end
  
    diff = abs(b - a)
    if (diff > 3 or diff == 0) or not correct_direction do
      false
    else
      process([b | t], direction)
    end
  end

  def process(report, _direction) when is_list(report) and length(report) == 1 do
    true
  end
end

defmodule RedNoseReports do
  def process([a | [b | t]]) do ...
  
  def process([a | [b | t]], direction) do ...

  def process(report, _direction) when is_list(report) and length(report) == 1 do ...
end

[a | [b | t]] = list

[7, 6, 4, 2, 1]

RedNoseReports.process(report)

def process([a | [b | t]]) do
  if a - b > 0 do
    process([a | [b | t]], :up)
  else
    process([a | [b | t]], :down)
  end
end

def process([a | [b | t]], direction) do ...

def process(report, _direction) when is_list(report) and length(report) == 1 do ...

def process([a | [b | t]], direction) do
  correct_direction = case direction do
    :up -> a - b > 0
    :down -> a - b < 0
  end

  diff = abs(b - a)
  if (diff > 3 or diff == 0) or not correct_direction do
    false
  else
    process([b | t], direction)
  end
end

def process(report, _direction) when is_list(report) and length(report) == 1 do
  true
end

for report <- reports do
  RedNoseReports.process(report)
end
|> Enum.count(&(&1))

for report <- reports do
  if RedNoseReports.process(report) do
    true
  else
    for index_to_remove <- 0..length(reports) do
      modified_report = 
        report
        |> Enum.with_index()
        |> Enum.reject(fn {_value, index} -> index == index_to_remove end)
        |> Enum.map(fn {value, _index} -> value end)

      RedNoseReports.process(modified_report)
    end
    |> Enum.any?
  end
end
|> Enum.count(&(&1))

others

i added some code to the stuff i use [behind the scenes] to make these rambles easier, to randomize the list i review submissions in

ill be honest, if you’re near the end of my review session, i will likely have less to say since i’ve likely already said it about someone elses solution first

but, hopefully less of that if every time i export the day template, i get a fresh ordering of others

therefore, your placement is now beholden to /dev/urandom or something

lets get to it

nice part 1 solution, no part 2 here though, sadness

isStrictlySorted is cool, while i live in functional land sometimes i do see some code that just loops over things and mutates stuff without much care in the world, and i think, wouldn’t that be nice

but alas, i have chosen the functional path, so i must call you a heathen (while internally i’m secretly malding)

clean rust solution, variable names make the logic for testing if an instance of a list makes it quite easy to read

this solution is doing the keep removing indexes until it works approach, but is actually doing a while loop to stop checking future iterations once it knows its found a valid one

while !safe && i < levels.len() {
    let mut levels_subset = levels.clone();
    levels_subset.remove(i);
    safe = is_safe(&mut levels_subset);
    i += 1;
}

tidy

daniel pulling out a lil’ enum here

enum SafeStepResult {
  Safe,
  Unsafe(usize),
}

i was just thinking, why enum rather than just boolean, but then, i see that you’re encoding the index the validation step fails on, to use to then remove the values from three different versions of the list, with different elements removed

levels_a.remove(i.try_into().unwrap());
levels_b.remove((i + 1).try_into().unwrap());
levels_c.remove((0).try_into().unwrap());
if matches!(is_safe(levels_a), SafeStepResult::Safe)
    || matches!(is_safe(levels_b), SafeStepResult::Safe)
    || matches!(is_safe(levels_c), SafeStepResult::Safe)
{
    safe += 1;
}

tidy, good job dan

i was expecting similar to dj, some sort of while here, but no, you’re better than that

:snake:-lang solution

i like the function named doesProblemDampenerHelp :D, it sounds like you’re referring too a machine that is sputtering, that maybe with a little bit of grease will kick into gear and start up again!

however, while this is so minor i know, :snake:-lang, asks for [snake_case] :P

more evan go, lets go

as discussed yesterday, [Math.abs] is a thing

nice little removeNthItem utility function that does some makein and some copyin

some ‘Safe’ reports, and ‘Safe-ish’ reports, nice

very nice go solution! each thing broken out into little functions

bufio scanner for going through the file, defer file closing

nice part 2 isDroppedReportSafe function that does the return to the outer function once at least one valid version of the report is found

very nice

seems like my intended dice roll of which persons solution i go over decided to put most golang solutions together!

ill be honest this one does not visually look as nice as eric’s

i assume check1 / check2 are checking for something, would be nice if they had more descriptive names

also pushing 138 lines for a day 2 solution

out here regardless, stars are stars

nice and cozy elixir solution here

no pulling out entire module here, only a nice quaint safe_report anon. function!

safe_report = fn list ->
  chunks = Enum.chunk_every(list, 2, 1, :discard)

  diffs =
    Enum.map(chunks, fn pair ->
      List.first(pair) - List.last(pair)
    end)

  cond do
    Enum.all?(diffs, fn x -> x < 0 and x >= -3 end) -> true
    Enum.all?(diffs, fn x -> x > 0 and x <= 3 end) -> true
    true -> false
  end
end

take in the list, do some chunking to get pairs of two, and then create a list of only the diffs

and then, the clever bit that does what i was doing in the first step before, but instead ensuring that all diffs are a single sign by either all going in one direction with the right amount

i think myself reaching for abs too quickly which removed the information about the sign caused me to separate these two parts

very clean mudkip, thank u

more elixir!

this one pulls out an entire module, but could also just be anon. functions like mudkip

my recommendation is to make the module named something funny in relation with the lore, like ColoringBook or SignalFinder2000 :)

lets look at the safe checking function here:

def is_report_safe(array) do
  chunked_array = array |> Enum.chunk_every(2, 1, :discard)

  length(chunked_array) ==
    abs(
      chunked_array
      |> Enum.map(fn [x, y] -> y - x end)
      |> Enum.filter(&(0 != &1 && abs(&1) < 4))
      |> Enum.map(&if &1 > 0, do: 1, else: -1)
      |> Enum.sum()
    )
end

i like the filter being used to remove too high numbers from the list, and before returning from the function, check the length of the filtered list to see if any were removed as the way to figure out if any values were too big :D

he’s back

pretty nice again this day as well, seems like a problem sell suited for the excel function god

expressions def. getting a bit crazy though, the ascending check reads as so:

=AND(ARRAYFORMULA(IF((NOT(ISBLANK($B2:$H2)))*(NOT(ISBLANK($A2:$G2))), $B2:$H2 >= $A2:$G2, TRUE)))

it looks like for part 2, you opted to do some stuff a bit more manually (or i have a skill issue in finding where you put the logic cells for columns Q and beyond, but still…

nice reportIsSafe func

let reportIsSafe (report: int[]) : bool =
    let sortedAscending = Array.sort report
    let sortedDescending = Array.sortDescending report

    (report = sortedAscending || report = sortedDescending)
    && report
       |> Array.windowed 2
       |> Array.map (fun pair -> pair[0] - pair[1] |> abs)
       |> Array.forall (fun diff -> diff >= 1 && diff <= 3)

this is clever syntax for doing the same piece of work twice, looking at the report sorted in both directions to see if its either always going up, or always going down

and then some lovely windowing to iterate throught he pairs, calculating the diffs, and ensuring that every diff is within range

tidy

arafat has returned to the ol’ trusted python i see

this is nice

but

def isInc(arr):
    ...

def isDec(arr):
    ...

def is_safe(arr):
    ...

stay to one casing please!

either live_by_the_snake 🐍

or dieByTheCamel 🐪

but i must say, pulling out ^ for a bitwise or operator, and np.diff for getting a calculation of the differences between values?

that is very clean

your uncleanliness of casing is forgiven

its time to review solution

a bit verbose here marty, but it is lua which does not exactly have the most bustling of stdlibs

also

TIL

lua has a [goto] statement

local function is_safe_report(report)
    local valid_report = false
    local loop = 0
    while loop < 2 and not valid_report do
        local is_increasing = loop % 2 == 0
        for i = 1, #report - 1 do
            local current = report[i]
            local next = report[i + 1]
            if not is_valid_level(current, next, is_increasing) then
                goto continue
            end
        end
        valid_report = true
        ::continue::
        loop = loop + 1
    end
    return valid_report
end

its a restrictive form of goto, but still…

some guts out here pulling out a goto, but i respect it

🍝

very similar to riley, same sorted trick at the start, followed by calculating a absolute value diff and checking its in-bounds

v-nice

pulling out some structs here, getting nice and tidy and fancy i see?

i see the calculation on if the report is decreasing or increasing, and then using a switch statement to figure out which direction it should go in also just keepign a counter on which are unsafe, nice

ah but part 2 is where some copy-pasterino comes around, but very iterative i must add, so i assume fast

its good to go :P

very compact solutions, a part 2 thats 26 lines (basically 22), nice and cozy

def get_diff(report):
    return [abs(report[i] - report[i - 1]) for i in range(1, len(report))]

def main():
    data = open("input.txt", "r")
    data = [line.strip() for line in data]

    safe_count = 0
    for report in data:
        levels = [int(level) for level in report.split(" ")]

        for i in range(len(levels)):
            # try removing one of the levels
            modified_levels = levels.copy()
            del modified_levels[i]

            diff = get_diff(modified_levels)
            if (modified_levels == sorted(modified_levels) or modified_levels == sorted(modified_levels, reverse=True)) and max(diff) <= 3 and min(diff) >= 1:
                safe_count += 1
                break

    print(safe_count)

if __name__ == "__main__":
    main()

i feel i won’t be able to stuff entire solutions into here often, so here is your part 2 for others to gawk at

nice

its giving indent hadouken, but its also quite small, and giving the answer

nice

only part 1 here, but a nice part 1 with some looping n breaking logic

im gonna say it

nice

i managed to finish this on the evening of day 8, since i myself was quite busy, well:

• starting a new job at [Spellbook]
• un-jet-lagging myself from a trip to the uk the two weeks prior to advent of code
• getting stuck on day 4 part 2, and then needing to play catch-up this weekend to have all of the the stars, and sadly, i must get my stars before i can review other people getting their stars

godspeed self, on doing more of these, if i can do more than 2022 i’d be appy :)

any thoughts about any of the above?

reach out: