Haskell

runningDifference :: [Int] -> [Int]
runningDifference (a:[]) = []
runningDifference (a:b:cs) = a - b : (runningDifference (b:cs))

isSafe :: [Int] -> Bool
isSafe ds = (all (> 0) ds || all (< 0) ds) && (all (flip elem [1, 2, 3] . abs) ds) 

isSafe2 :: [Int] -> Bool
isSafe2 ds = any (isSafe2') (zip [0..length ds] (cycle [ds]))

isSafe2' (i, ls) = isSafe . runningDifference $ list
        where
                list = dropIndex i ls

dropIndex _ []     = []
dropIndex 0 (a:as) = dropIndex (-1) as
dropIndex i (a:as) = a : dropIndex (i - 1) as

main = do
        c <- getContents
        let reports = init . lines $ c
        let levels  = map (map read . words) reports :: [[Int]]
        let differences = map runningDifference levels
        let safety = map isSafe differences
        let safety2 = map isSafe2 levels

        putStrLn . show . length . filter (id) $ safety
        putStrLn . show . length . filter (id) $ safety2

        return ()

Took me way too long to figure out that I didn’t have to drop one of them differences but the initial Number

Haskell

This was quite fun! I got a bit distracted trying to rewrite safe in point-free style, but I think this version is the most readable. There’s probably a more monadic way of writing lessOne as well, but I can’t immediately see it.

safe xs = any gradual [diffs, negate <$> diffs]
  where
    diffs = zipWith (-) (drop 1 xs) xs
    gradual = all (`elem` [1 .. 3])

lessOne [] = []
lessOne (x : xs) = xs : map (x :) (lessOne xs)

main = do
  input :: [[Int]] <- map (map read . words) . lines <$> readFile "input02"
  print . length $ filter safe input
  print . length $ filter (any safe . lessOne) input

Nim

Got correct answer for part 1 on first try, but website rejected it. Wasted some time debugging and trying different methods. Only to have the same answer accepted minutes later. =(

proc isSafe(report: seq[int]): bool =
  let diffs = collect:
    for i, n in report.toOpenArray(1, report.high): n - report[i]
  (diffs.allIt(it > 0) or diffs.allIt(it < 0)) and diffs.allIt(it.abs in 1..3)

proc solve(input: string): AOCSolution[int, int] =
  let lines = input.splitLines()
  var reports: seq[seq[int]]
  for line in lines:
    reports.add line.split(' ').map(parseInt)

  for report in reports:
    if report.isSafe():
      inc result.part1
      inc result.part2
    else:
      for t in 0..report.high:
        var mReport = report
        mReport.delete t
        if mReport.isSafe():
          inc result.part2
          break

Codeberg repo

Of course I ended up with a off-by-one error for the second part, so things took a bit longer than they really should’ve.

But either way, behold, messy C#:

int[][] reports = new int[0][];

public void Input(IEnumerable<string> lines)
{
  reports = lines.Select(l => l.Split(' ').Select(p => int.Parse(p)).ToArray()).ToArray();
}

public void Part1()
{
  int safeCount = reports.Where(report => CheckReport(report)).Count();
  Console.WriteLine($"Safe: {safeCount}");
}
public void Part2()
{
  int safeCount = reports.Where(report => {
    if (CheckReport(report))
      return true;

    for (int i = 0; i < report.Length; ++i)
      if (CheckReport(report.Where((_, j) => j != i)))
        return true;

    return false;
  }).Count();

  Console.WriteLine($"Safe: {safeCount}");
}

bool CheckReport(IEnumerable<int> report)
{
  var diffs = report.SkipLast(1).Zip(report.Skip(1)).Select(v => v.Second - v.First);
  return diffs.All(v => Math.Abs(v) <= 3) && (diffs.All(v => v > 0) || diffs.All(v => v < 0));
}

Uiua

Uiua is still developing very quickly, and this code uses the experimental tuples function, hence the initial directive.

Try it Live!

# Experimental!
"7 6 4 2 1\n1 2 7 8 9\n9 7 6 2 1\n1 3 2 4 5\n8 6 4 4 1\n1 3 6 7 9"
⊜(⊜⋕⊸≠@\s)⊸≠@\n # Partition at \n, then at space, parse ints.

IsSorted ← +⊃(≍⇌⍆.|≍⍆.)        # Compare with sorted array.
IsSmall  ← /××⊃(>0|<4)⌵↘¯1-↻1. # Copy offset by 1, check diffs.
IsSafe   ← ×⊃IsSmall IsSorted  # Safe if Small steps and Ordered.
IsSafer  ← ±/+≡IsSafe ⧅<-1⧻.   # Choose 4 from 5, check again.

&p/+≡IsSafe .            # Part1 : Is each row safe?
&p/+≡(±+⊃IsSafe IsSafer) # Part2 : Is it safe or safer?