Advent of Code 2022 in Ruby (sort of)

00-ADVENT-OF-CODE-2022-RUBY.md

Advent of Code 2022 solutions in Perl Ruby

Just for kicks, I'm trying to solve them with semi-golfed Ruby. That is:

• As short as possible, but
• Have some whitespace to make them somewhat readable
• Avoid single-letter identifiers to keep them somewhat readable
• Don't make them too short when they are short enough

Each solution parses the input file and outputs the answer.

01.rb

p File.read('input').split(/\n\n/).map { _1.scan(/\d+/).map(&:to_i).sum }.max
p File.read('input').split(/\n\n/).map { _1.scan(/\d+/).map(&:to_i).sum }.max(3).sum

02.rb

p File.read('input').tr(' ', '').split.sum { %w(_ BX CY AZ AX BY CZ CX AY BZ).index _1 }
p File.read('input').tr(' ', '').split.sum { %w(_ BX CX AX AY BY CY CZ AZ BZ).index _1 }

02.wtf.rb

p File.read('input').lines.sum { ' Mn6DFChul'.index _1.crypt('aa')[3] }
p File.read('input').lines.sum { ' MhDuFnC6l'.index _1.crypt('aa')[3] }

03.rb

def score(g) = g.map { _1.map(&:chars).reduce(:&)[0] }.sum { [0, *?a..?z, *?A..?Z].index _1 }

p score File.read('input').lines.map { |s| [s[...s.size/2], s[s.size/2..]] }
p score File.read('input').lines.each_slice(3)

04.rb

ranges = File.read('input').lines.map { _1.scan(/\d+/).map(&:to_i) }.map { |(a, b, c, d)| [a..b, c..d] }

p ranges.count { |a, b| a.cover?(b) || b.cover?(a) }
p ranges.count { |a, b| a.begin <= b.end && b.begin <= a.end }

05.rb

def solve(fn)
  first, second = File.read('input').split("\n\n")

  stacks = first.split("\n").map(&:chars).transpose.each_slice(4).map { _1[1].grep(/[A-Z]/).reverse }

  second.lines.each do |line|
    num, from, to = line.scan(/\d+/).map(&:to_i)
    stacks[to-1] += fn.(num.times.map { stacks[from-1].pop }.compact)
  end

  stacks.map(&:last).join
end

puts solve -> { _1 }
puts solve -> { _1.reverse }

06.rb

p File.read('input').chars.each_cons(4).with_index.select { |w, i| w.uniq == w }.map { _1.size + _2 }.first
p File.read('input').chars.each_cons(14).with_index.select { |w, i| w.uniq == w }.map { _1.size + _2 }.first

07.rb

require 'pathname'

cwd = Pathname('/')
sizes = {cwd => 0}

File.read('input').lines.each do |line|
  case line
  when /^\$ cd (.*)/ then cwd /= $1
  when /^dir (.*)/ then sizes[cwd / "#$1/"] = 0
  when /^(\d+) (.*)$/ then sizes[cwd / $2] = $1.to_i
  end
end

dirs = sizes.keys.map(&:to_s).grep(/\/$/).to_h { |d| [d, sizes.filter { _1.to_s.start_with? d }.sum { _2 }] }

delta = dirs['/'] - 40000000

p dirs.values.filter { _1 <= 100_000 }.sum
p dirs.values.filter { _1 >= delta }.min

08.rb

require 'matrix'

visible, score, grid = 0, 0, Matrix[*File.read('input').lines.map { _1.chomp.chars.map(&:to_i) }]

grid.each_with_index do |h, x, y|
  lines = [grid.row(x)[...y], grid.row(x)[y+1...].reverse, grid.column(y)[...x], grid.column(y)[x+1...].reverse]
  visible += 1 if lines.any? { |line| line.all? { _1 < h } }
  score = [score, lines.map { |line| line.reverse.chunk_while { _1 < h }.first&.count || 0 }.reduce(:*)].max
end

p visible, score

09.rb

one, two, rope = {}, {}, 10.times.map { 0i }

File.read('input').lines.each do |line|
  line[2..].to_i.times do
    rope[0] += 1i ** 'LURD'.index(line[0])
    1.upto(9).lazy.map { [rope[_1 - 1] - rope[_1], _1] }.each do |d, i|
      rope[i] += Complex(*d.rect.map { _1 <=> 0 }) unless d.abs2 <= 2
    end
    one[rope[1]], two[rope[9]] = true, true
  end
end

p one.keys.size, two.keys.size

10.rb

cycle, reg, sum, screen = 0, 1, 0, 6.times.map { "" }

File.read('input').lines.each do |line|
  (line =~ /addx/ ? 2 : 1).times do
    screen[cycle / 40][cycle % 40] = (reg - cycle % 40).abs <= 1 ? ?# : ?.
    cycle += 1
    sum += reg * cycle if cycle % 40 == 20
  end

  reg += line[5..].to_i
end

puts sum, screen

11.rb

input = File.read('input').split("\n\n")
  .map { [_1[/.*O/m].scan(/\d+/).map(&:to_i)[1..], _1[/= (.*)/, 1], *_1[/T.*/m].scan(/\d+/).map(&:to_i), 0] }

mod = input.map { _1[2] }.reduce(:*)

{20 => -> { _1 / 3 }, 10000 => -> { _1 % mod }}.each do |turns, fn|
  monkeys = input.map { _1.map(&:dup) }
  turns.times do
    monkeys.each do |monkey|
      monkey[0].each do |old|
        new = fn[eval(monkey[1])]
        monkeys[monkey[3 + (new % monkey[2] <=> 0)]][0] << new
        monkey[5] += 1
      end.clear
    end
  end
  p monkeys.map(&:last).max(2).reduce(:*)
end

11.wtf.rb

m,c,_=[],[0]*9,File.read('input');{/M.*(\d+):\n.*:(.*)/=>'i=\1;BEGIN{m[\1]||=[\2]}',/O.*:/=>"while old=m[i].pop;",/T.* (.*)\n/=>'new/=3;m[0==new% \1?',/ I.*?(\d+).*?(\d+)/m=>'\1:\2]<<new;c[i]+=1end'}.each{_.gsub! *_1};eval _*20;p eval c.max(2)*?*;m,c=[],[0]*9;_.gsub!'/=3',"%=#{eval _.scan(/% (\d+)/)*?*}";eval _*10000;p eval c.max(2)*?*

12.rb

map = File.read('input').lines.flat_map.with_index { |l, x| l.chars.map.with_index { [x + _2.i, _1] } }.to_h

start, target = map.invert['S'], map.invert['E']
map[start], map[target] = 'a', 'z'
seen, left = {}, [[target, 0]]

until left.empty?
  p, steps = left.shift
  next if seen[p] && seen[p] <= steps
  seen[p] = steps
  left += [p + 1, p - 1, p + 1i, p - 1i].select { map[_1] && map[_1].ord + 1 >= map[p].ord }.map { [_1, steps + 1] }
end

p seen[start]
p map.filter { |k, v| v == 'a' }.map { |k, v| seen[k] }.compact.min

13.rb

def cmp(a, b)
  case [a, b]
  in Integer, Integer then a <=> b
  in Array, Array then a.take(b.size).zip(b).lazy.map { cmp _1, _2 }.detect { _1 != 0 } || a.size <=> b.size
  else cmp Array(a), Array(b)
  end
end

pairs = File.read('input').split("\n\n").map { |c| c.lines.map { eval _1 } }

p pairs.map.with_index.sum { cmp(*_1) <= 0 ? _2 + 1 : 0 }
p pairs.reduce(:+).concat([[[2]], [[6]]]).sort { cmp _1, _2 }.then { _1.index([[2]]).succ * _1.index([[6]]).succ }

14.rb

map = File.read('input').lines.flat_map { |l| l.split(' -> ').map { _1.scan(/-?\d+/).map(&:to_i) }.each_cons(2).to_a }
  .flat_map { |pair| pair.transpose.map(&:minmax).map { [*_1.._2] }.reduce(:product).map { _1 + _2.i } }.to_set

def flow(map, point, max, &)
  return if map.include?(point) || point.imag == max + 2
  [0, -1, 1].each { |d| flow(map, point + d + 1i, max, &) }
  map.add point
  yield point
end

origin, max = 500, map.map(&:imag).max
p enum_for(:flow, map.dup, origin, max).find_index { _1.imag > max }
p enum_for(:flow, map.dup, origin, max).count

15.rb

SPAN = 0..4000000
input = File.read('input').lines.map { _1.scan(/-?\d+/).map(&:to_i).each_slice(2).map { |x, y| x + y.i } }

def dist(a, b) = (a - b).rect.map(&:abs).sum
def project((s, b), y) = (dist(b, s) - dist(s, s.real + y.i)).then { s.real - _1 .. s.real + _1 }
def overlaps?(a, b) = a.begin <= b.end && b.begin <= a.end
def merge(a, b) = [a.begin, b.begin].min .. [a.end, b.end].max

def ranges(input, y)
  ranges = input.map { project(_1, y) }.filter { _1.size > 0 && overlaps?(SPAN, _1) }.sort_by(&:begin)
  old, ranges = ranges, ranges.chunk_while(&method(:overlaps?)).map { _1.reduce(&method(:merge)) } while ranges != old
  ranges
end

rs = ranges(input, SPAN.end / 2)
p rs.sum(&:size) - input.filter { |b, s| s.imag == SPAN.end / 2 && rs.any? { _1 === s.real } }.uniq { _2.real }.size

p SPAN.lazy
  .flat_map { |y| ranges(input, y).each_cons(2).filter { _1.end+2 == _2.begin && SPAN === _1.end+1 }.map { [_2, y] } }
  .map { _1.begin.pred * 4000000 + _2 }.first

16.rb

$valves = File.read('input').lines.to_h { [_1[6..7], [_1[/\d+/].to_i, _1[/to \w+ (.*)/, 1].split(', ')]] }

def flow(open) = open.uniq.map { |k| $valves[k][0] }.sum

def go(t, a, b, s, seen, open, move_one, &)
  yield s if t == 1
  return if t == 1 || seen.fetch([a, b, t], -1) >= s
  seen[[a, b, t]] = s

  possible = (!open.index(a) && $valves[a][0] > 0 ? [[a, open + [a]]] : []) + $valves[a][1].map { [_1, open] }
  possible = [[a, open]] unless move_one

  possible.each do |a, open|
    go(t - 1, a, b, s + flow(open + [b]), seen, open + [b], move_one, &) if !open.index(b) && $valves[b][0] > 0
    $valves[b][1].each { |b| go(t - 1, a, b, s + flow(open), seen, open, move_one, &) }
  end
end

p enum_for(:go, 30, 'AA', 'AA', 0, {}, [], false).max
p enum_for(:go, 26, 'AA', 'AA', 0, {}, [], true).max

17.rb

SHAPES = [[0, 1, 2, 3], [1, 1i, 1+1i, 2+1i, 1+2i], [0, 1, 2, 2+1i, 2+2i], [0, 1i, 2i, 3i], [0, 1, 1i, 1+1i]]

def move(dots, cave, dir) = dots.map { _1 + dir }.then { fits?(cave, _1) ? _1 : dots }
def fits?(cave, dots) = dots.all? { 0 <= _1.imag && (0..6).include?(_1.real) && !cave.include?(_1) }

tick, rock, cave, max, seen, done, wind = 0, nil, Set[], -1, {}, nil, File.read('input').chomp.chars.map { _1.ord - 61 }

wind.each.with_index.cycle.each do |delta, beat|
  rock, tick = SHAPES[tick % SHAPES.size].map { _1 + max.i + 5i + 2 }, tick + 1 if rock.nil?
  rock = rock.then { move _1, cave, -1i }.then { move _1, cave, delta }

  next if move(rock, cave, -1i) != rock

  cave, max = cave + rock, [max, *rock.map(&:imag)].max
  rock, finger = nil, [tick % SHAPES.size, beat, [*0..30].product([*0..6]).map { cave.member? max.i - _1.i + _2 }]

  if done
    done[0] -= 1
    puts "Part 2: #{max + 1 + done[1]}" if done[0] == 0
    exit if done[0] <= 0 && tick > 2022
  elsif match = seen[finger]
    height, left = (10**12 - tick).divmod(tick - match[0])
    done = [left, height * (max + 1 - match[1])]
  end

  seen[finger] = [tick, max + 1]
  puts "Part 1: #{max + 1}" if tick == 2022
end

18.rb

def sides((x, y, z)) = [[x + 1, y, z], [x - 1, y, z], [x, y + 1, z], [x, y - 1, z], [x, y, z + 1], [x, y, z - 1]]

cubes = File.read('input').lines.map { _1.scan(/\d+/).map(&:to_i) }.to_set
span = cubes.flat_map { _1 }.minmax.then { _1 - 1 .. _2 + 1 }

left, seen, sum = [[span.begin] * 3], {}, 0

until left.empty?
  point = left.pop
  next if seen[point]
  seen[point] = point

  sum += sides(point).count { cubes.include?(_1) }
  left += sides(point).reject { _1.grep(span).count < 3 || seen[_1] || cubes.member?(_1) }
end

p (cubes.flat_map { sides(_1) } - cubes.to_a).size, sum

19.rb

def solve((_, a, b, c, d, e, f), t, seen = Set[])
  ->(go, yielder, s) do
    yielder << s[-1] if s[0] == 0

    s[1..3] = s[1..3].zip([[a, b, c, e].max, d, f]).map(&:min)
    s[5..7] = s[5..7].zip(s[1..3], [[a, b, c, e].max, d, f]).map { |c, r, m| [c, s[0] * m - r * (s[0] - 1)].min }

    return unless seen.add?(s) and s[0] > 0

    base = s.zip([-1, 0, 0, 0, 0, *s[1..4]]).map { _1 + _2 }
    go.call go, yielder, base.dup
    go.call go, yielder, base.dup.tap { _1[1] += 1; _1[5] -= a } if s[5] >= a
    go.call go, yielder, base.dup.tap { _1[2] += 1; _1[5] -= b } if s[5] >= b
    go.call go, yielder, base.dup.tap { _1[3] += 1; _1[5] -= c; _1[6] -= d } if s[5] >= c and s[6] >= d
    go.call go, yielder, base.dup.tap { _1[4] += 1; _1[5] -= e; _1[7] -= f } if s[5] >= e and s[7] >= f
  end.then { |go| Enumerator.new { go.(go, _1, [t, 1, 0, 0, 0, 0, 0, 0, 0]) }.max }
end

p File.read('input').lines.map { _1.scan(/\d+/).map(&:to_i) }.sum { _1[0] * solve(_1, 24) }
p File.read('input').lines.map { _1.scan(/\d+/).map(&:to_i) }.take(3).map { solve _1, 32 }.reduce(:*)

20.rb

Node = Struct.new :val, :before, :after

def numbers() = File.read('input').lines.map(&:to_i)
def answer(ns) = Enumerator.produce(ns.find { _1.val == 0 }.after, &:after).each_slice(1000).take(3).sum { _1.last.val }
def parse() = numbers.map { Node.new _1.to_i }.tap { (_1 + [_1[0]]).each_cons(2) { |a, b| a.after, b.before = b, a } }

def rotate(items)
  items.each do |item|
    item.before.after, item.after.before = item.after, item.before
    (item.val % items.count.pred).times { item.before, item.after = item.after, item.after.after }
    item.after.before = item.before.after = item
  end
end

p answer(rotate(parse)), answer(10.times.reduce(parse.each { _1.val *= 811589153 }) { rotate _1 })

21.rb

eval File.read('input').gsub(/^(\w+): /, 'def \1() =')
p root

class Proc
  def +(other) = -> { _1 ? call(_1 - other.real) : call(other) }
  def *(other) = -> { call _1 / other.real }
  def -(other) = -> { call other.real? ? other.real + _1 : other.real - _1 }
  def /(other) = -> { call other.real? ? other.real * _1 : other.real / _1 }
  def coerce(other) = [self, other + 1i]
end

def humn() = ->(x) { x }
p root.(nil)

22.rb

SIZE, IDS, ADJ, EDGES = 50, [1, 2, 4, 6, 7, 9], {1+0i => 0, 1i => 1, -1+0i => 1+1i, -1i => 1i}, {
 2+1i => [9, 1], 9-1i => [2, 1], 1 => [7, -1], 6 => [2, -1], 2 => [6, -1], 7 => [1, -1], 1+1i => [9, 1i],
 10 => [1, -1i], 6+1i => [4, 1i], 5 => [6, -1i], 7-1i => [9, 1i], 8 => [7, -1i], 2-1i => [4, 1i], 3 => [2, -1i]
}.transform_keys(&:to_c)

def id(pos) = (pos.imag / SIZE) * 3 + pos.real / SIZE
def origin(face) = ((face / 3) * SIZE).i + ((face % 3) * SIZE)
def clamp(point) = point.real % SIZE + (point.imag % SIZE).i
def step(p, d) = IDS.include?(id(p + d)) && [p + d, d]
def wrap(grid, p, d) = step(p, d) || [Enumerator.produce(p) { _1 - d }.take_while { grid[_1] }.last, d]
def cube(_, p, d) = step(p, d) || EDGES[id(p) - d].then { [origin(_1) + clamp(p * _2 + d * _2 - ADJ[_2.to_c]), _2 * d] }

def solve(grid, path)
  dir, pos = 1.to_c, grid.keys.min_by { [_1.imag, _1.real] }

  path.scan(/\d+|[LR]/) do |match|
    dir *= {?L => -1i, ?R => 1i}.fetch(match, 1)
    match.to_i.times.lazy.take_while { grid[yield(pos, dir)[0]] != '#' }.each { pos, dir = yield pos, dir }
  end

  1000 * pos.imag.succ + 4 * pos.real.succ + [1, 1i, -1, -1i].map(&:to_c).index(dir)
end

a, b = File.read('input22.txt').split(/\n\n/)
grid = a.lines.flat_map.with_index { |l, x| l.chomp.chars.map.with_index { [x.i + _2, _1] }.reject { _2 == ' ' } }.to_h
p solve(grid, b) { wrap(grid, _1, _2) }, solve(grid, b) { cube(grid, _1, _2) }

23.rb

SQUARE = [-1, 0, 1].product([-1, 0, 1]).map { _1 + _2.i }.reject(&:zero?)

def free?(grid, point, dirs) = dirs.none? { grid.member? point + _1 }
def proposal(grid, rules, pos) = rules.detect { |x| free? grid, pos, SQUARE.map { _1 + 2 * x }.filter { _1.abs2 <= 2 } }
def round(grid, rules) = grid.group_by { _1 + proposal(grid, rules, _1).to_c }.flat_map { _2.size == 1 ? [_1] : _2 }
def bounds(elves) = Range.new(*elves.map(&:imag).minmax).to_a.product(Range.new(*elves.map(&:real).minmax).to_a)
def score(elves) = bounds(elves).count { !elves.member?(_1.i + _2) }

lines = File.read('input').lines
elves = lines.flat_map.with_index { |l, x| l.chars.map.with_index { _1 == ?# ? x.i + _2 : nil } }.compact.to_set
seq = Enumerator.produce([elves, [0, -1i, 1i, -1, 1]]) { [round(_1, _2).to_set, _2[0..0] + _2[2..] + _2[1..1]] }

p seq.take(11).last.then { score(_1.first) }
p seq.with_index.each_cons(2).detect { |a, b| a[0][0] == b[0][0] }[1][1]

24.rb

def clamp(pos) = (pos.imag % H).i + pos.real % W

input = File.read('input').lines.flat_map.with_index { |l, x| l.chomp.chars.map.with_index { |c, y| [x, y, c] } }
blizzards = input.map { |x, y, c| c != '.' && c != '#' ? [x.pred.i + y - 1, 1i ** '>v<^'.index(c)] : nil }.compact
H, W = input.map { _1[0] }.max - 1, input.map { _1[1] }.max - 1
mod, free = H.lcm(W), ([[-1, 0], [H, W - 1]] + [*0...H].product([*0...W])).map { |x, y| x.i + y }.to_set
time = Enumerator.produce(blizzards) { |b| b.map { [clamp(_1 + _2), _2] } }.take(mod).map { free - _1.map(&:first) }

start, goal = -1i, H.i + W - 1
left, seen, first, second = [[start, 0, 0]], Set[], 2 ** 62 - 1, 2 ** 62 - 1

until left.empty?
  p, tick, phase = left.shift
  next unless seen.add?([p, tick, phase]) && tick < second

  first = [first, tick].min if phase == 0 && p == goal
  second = [second, tick].min if phase == 2 && p == goal
  phase = {[0, goal] => 1, [1, start] => 2}[[phase, p]] || phase
  left += (time[tick.succ % mod] & [p, p + 1, p - 1, p + 1i, p - 1i]).map { [_1, tick + 1, phase] }
end

p first, second

25.rb

def snafu(s) = s.chars.reverse.map.with_index { ("=-012".index(_1) - 2) * 5 ** _2 }.sum
def invert(n) = n == 0 ? "" : invert(n.succ.succ / 5) + "012=-"[n % 5]

p File.read('input').lines.map(&:chomp).map { snafu(_1) }.sum.then { invert _1 }