Kotlin

A bit late to the party, but here you go.

import kotlin.math.abs

fun part1(input: String): Int {
    return solve(input, ::isSafe)
}

fun part2(input: String): Int {
    return solve(input, ::isDampSafe)
}

private fun solve(input: String, condition: (List<Int>) -> Boolean): Int {
    var safeCount = 0
    input.lines().forEach { line ->
        if (line.isNotBlank()) {
            val nums = line.split("\\s+".toRegex()).map { it.toInt() }
            safeCount += if (condition(nums)) 1 else 0
        }
    }
    return safeCount
}

private fun isSafe(list: List<Int>): Boolean {
    val safeDiffs = setOf(1, 2, 3)
    var incCount = 0
    var decCount = 0
    for (idx in 0..<list.lastIndex) {
        if (!safeDiffs.contains(abs(list[idx] - list[idx + 1]))) {
            return false
        }
        if (list[idx] <= list[idx + 1]) incCount++
        if (list[idx] >= list[idx + 1]) decCount++
    }
    return incCount == 0 || decCount == 0
}

private fun isDampSafe(list: List<Int>): Boolean {
    if (isSafe(list)) {
        return true
    } else {
        for (idx in 0..list.lastIndex) {
            val shortened = list.toMutableList()
            shortened.removeAt(idx)
            if (isSafe(shortened)) {
                return true
            }
        }
    }
    return false
}

Elixir

defmodule AdventOfCode.Solution.Year2024.Day02 do
  use AdventOfCode.Solution.SharedParse

  @impl true
  def parse(input) do
    for line <- String.split(input, "\n", trim: true),
        do: String.split(line) |> Enum.map(&String.to_integer/1)
  end

  def part1(input) do
    Enum.count(input, &is_safe(&1, false))
  end

  def part2(input) do
    Enum.count(input, &(is_safe(&1, true) or is_safe(tl(&1), false)))
  end

  def is_safe([a, b, c | rest], can_fix) do
    cond do
      (b - a) * (c - b) > 0 and abs(b - a) in 1..3 and abs(c - b) in 1..3 ->
        is_safe([b, c | rest], can_fix)

      can_fix ->
        is_safe([a, c | rest], false) or is_safe([a, b | rest], false)

      true ->
        false
    end
  end

  def is_safe(_, _), do: true
end

Elixir

defmodule Day02 do
  defp part1(reports) do
    reports
    |> Enum.map(fn report ->
      levels =
        report
        |> String.split()
        |> Enum.map(&String.to_integer/1)

      cond do
        sequence_is_safe?(levels) ->
          :safe

        true ->
          :unsafe
      end
    end)
    |> Enum.count(fn x -> x == :safe end)
  end

  defp part2(reports) do
    reports
    |> Enum.map(fn report ->
      levels =
        report
        |> String.split()
        |> Enum.map(&String.to_integer/1)

      sequences =
        0..(length(levels) - 1)
        |> Enum.map(fn i ->
          List.delete_at(levels, i)
        end)

      cond do
        sequence_is_safe?(levels) ->
          :safe

        Enum.any?(sequences, &sequence_is_safe?/1) ->
          :safe

        true ->
          :unsafe
      end
    end)
    |> Enum.count(fn x -> x == :safe end)
  end

  defp all_gaps_within_max_diff?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> abs(b - a) <= 3 end)
  end

  defp is_strictly_increasing?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> a < b end)
  end

  defp is_strictly_decreasing?(numbers) do
    numbers
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.all?(fn [a, b] -> a > b end)
  end

  defp sequence_is_safe?(numbers) do
    (is_strictly_increasing?(numbers) or
       is_strictly_decreasing?(numbers)) and all_gaps_within_max_diff?(numbers)
  end

  def run(data) do
    reports = data |> String.split("\n", trim: true)
    p1 = part1(reports)
    p2 = part2(reports)
    IO.puts(p1)
    IO.puts(p2)
  end
end

data = File.read!("input.in")
Day02.run(data)