advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ZogStriP/2022/12_2.yml

@@ -0,0 +1,42 @@
+---
+- :name: 12_hill_climbing_algorithm.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    map = DATA.map { _1.chop.bytes }
+    Y = map.size
+    X = map[0].size
+    map.flatten!
+
+    goal = start = nil
+    goals = {}
+
+    Y.times { |y|
+      X.times { |x|
+        case map[c = y * X + x].chr
+        when ?a; goals[c] = true
+        when ?S; goals[c] = true; map[goal = c] = ?a.ord
+        when ?E; map[start = c] = ?z.ord
+        end
+      }
+    }
+
+    steps = -> (goals) {
+      q = [start]
+      d = Array.new(map.size, map.size + 1)
+      d[start] = 0
+
+      while c = q.shift
+        return d[c] if goals[c]
+
+        y, x = c.divmod(X)
+
+        [
+          (c - X if y > 0),
+          (c - 1 if x > 0),
+          (c + 1 if x + 1 < X),
+          (c + X if y + 1 < Y),
+        ].each { (d[_1] = d[c] + 1; q << _1) if _1 && map[_1] >= map[c] - 1 && d[_1] > d[c] + 1 }
+      end
+    }
+
+    p steps[{ goal => true }], steps[goals]

data/data/solutions/github/ZogStriP/2022/13_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/13_2.yml

@@ -0,0 +1,4 @@
+---
+- :name: 13_distress_signal.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: "pairs = DATA.read.split(\"\\n\\n\").map { |l| l.split.map { eval _1 } }\n\ndef \U0001F680(a, b)\n  case [a, b]\n  in [Integer, Integer]\n    a <=> b\n  in [Array, Array]\n    [a.size, b.size].min.times {\n      r = \U0001F680(a[_1], b[_1])\n      return r if r != 0\n    }\n    a.size <=> b.size\n  else\n    \U0001F680([a].flatten(1), [b].flatten(1))\n  end\nend\n\np pairs.each.with_index(1).sum { |(l, r), i| \U0001F680(l, r) < 0 ? i : 0 }\n\ndividers = [[[2]], [[6]]]\npairs = (pairs.flatten(1) + dividers).sort &method(:\U0001F680)\n\np dividers.map { pairs.index(_1) + 1 }.reduce :*"

data/data/solutions/github/ZogStriP/2022/14_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/14_2.yml

@@ -0,0 +1,35 @@
+---
+- :name: 14_regolith_reservoir.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    grid = Hash.new { |h, k| h[k] = {} }
+
+    DATA.each { |line|
+      line.scan(/\d+/).map(&:to_i).each_slice(2).each_cons(2) { |(a, b), (x, y)|
+        a == x ?
+          ([b, y].min..[b, y].max).each { grid[_1][a] = true } :
+          ([a, x].min..[a, x].max).each { grid[b][_1] = true }
+      }
+    }
+
+    rested = 0
+    abyss = grid.keys.max + 1
+    first = false
+
+    grid[abyss + 1] = Hash.new(true)
+
+    sand = -> (y, x) {
+      return if grid[y][x]
+
+      (first = true; p rested) if y >= abyss && !first
+
+      sand[y + 1, x]
+      sand[y + 1, x - 1]
+      sand[y + 1, x + 1]
+
+      rested += 1
+      grid[y][x] = true
+    }
+
+    sand[0, 500]
+    p rested

data/data/solutions/github/ZogStriP/2022/15_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/15_2.yml

@@ -0,0 +1,47 @@
+---
+- :name: 15_beacon_exclusion_zone.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    Y = 2_000_000
+    M = Y * 2
+
+    beacons = {}
+
+    sensors = DATA.map {
+      sx, sy, bx, by = _1.scan(/-?\d+/).map &:to_i
+      beacons[bx] = true if by == Y
+      [sx, sy, (sx - bx).abs + (sy - by).abs]
+    }
+
+    ranges = sensors.filter_map { |sx, sy, r|
+      d = (sy - Y).abs
+      (sx - r + d) .. (sx + r - d) if d <= r
+    }
+
+    min = ranges.map(&:min).min
+    max = ranges.map(&:max).max
+
+    p max - min - beacons.size + 1
+
+    # y = mx + c
+    # m = either 1 or -1
+    # only keep track of unique c
+
+    pos, neg = [1, -1].map { |m|
+      sensors.map { |x, y, r| x + m * y - r - 1 } &
+      sensors.map { |x, y, r| x + m * y + r + 1 }
+    }
+
+    # check intersections between positive and negative slopes
+
+    pos.product(neg).filter_map { |c_pos, c_neg|
+      xx = c_pos + c_neg
+      next if xx.odd?
+      x = xx / 2
+      next if x < 0 || x > M
+      y = c_pos - x
+      next if y < 0 || y > M
+      [x, y]
+    }.find { |x, y|
+      sensors.none? { |sx, sy, r| (sx - x).abs + (sy - y).abs <= r }
+    }.tap { |x, y| p x * 4_000_000 + y }

data/data/solutions/github/ZogStriP/2022/16_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/16_2.yml

@@ -0,0 +1,52 @@
+---
+- :name: 16_proboscidea_volcanium.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    N = {}
+    R = {}
+
+    DATA.each {
+      from, *tos = _1.scan(/[A-Z]{2}/)
+      N[from] = tos
+      R[from] = _1[/(\d+)/, 1].to_i
+    }
+
+    R.filter! { _2 > 0 }
+
+    bfs = -> from {
+      queue = [from]
+      steps = { from => 0 }
+
+      while current = queue.shift
+        N[current].each { |n| !steps[n] && queue << n && steps[n] = steps[current] + 1 }
+      end
+
+      steps
+    }
+
+    graph = Hash.new { |h, k| h[k] = {} }
+
+    (R.keys + ["AA"]).each { |a|
+      bfs[a].each { |b, d| a != b && R[b] && graph[a][b] = graph[b][a] = d }
+    }
+
+    ids = R.each_key.with_index.to_h
+
+    best = Hash.new(0)
+
+    dfs = -> (minutes, valve = "AA", open = {}, pressure = 0) {
+      k = open.keys.sum { 1 << ids[_1] }
+      best[k] = [best[k], pressure].max
+      return if minutes <= 2
+      graph[valve].each { |n, d| n != "AA" && !open[n] && minutes > d && dfs[minutes - d - 1, n, open.merge(n => true), pressure + R[n] * (minutes - d - 1)] }
+    }
+
+    dfs[30]
+
+    p best.values.max
+
+    best = Hash.new(0)
+
+    dfs[26]
+
+    p best.keys.combination(2).select { _1 & _2 == 0 }.map { best[_1] + best[_2] }.max

data/data/solutions/github/ZogStriP/2022/17_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/17_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: 17_pyroclastic_flow.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    WIDTH = 7
+
+    ROCKS = [
+      [[0, 0], [1, 0], [2, 0], [3, 0]],
+      [[1, 0], [0, 1], [1, 1], [2, 1], [1, 2]],
+      [[0, 0], [1, 0], [2, 0], [2, 1], [2, 2]],
+      [[0, 0], [0, 1], [0, 2], [0, 3]],
+      [[0, 0], [1, 0], [0, 1], [1, 1]],
+    ].map { [_1, _1.map(&:first).max, _1.map(&:last).max] }.cycle
+
+    JETS = DATA.read.chomp.chars.map { _1[?<] ? -1 : 1 }.cycle
+
+    y_max = 0
+    stopped = Hash.new { |h, k| h[k] = {} }
+    ys = []
+
+    5000.times { |t|
+      rock, width, height = ROCKS.next
+      left = 2
+      bottom = y_max + 3
+
+      loop {
+        # move
+        jet = JETS.next
+        left += jet if left + jet >= 0 && left + jet + width < WIDTH && rock.all? { !stopped[_1 + left + jet][_2 + bottom] }
+        # fall
+        if bottom == 0 || rock.any? { stopped[_1 + left][_2 + bottom - 1] }
+          rock.each { stopped[_1 + left][_2 + bottom] = true }
+          ys << y_max = [y_max, bottom + height + 1].max
+          p y_max if t == 2021
+          break
+        else
+          bottom -= 1
+        end
+      }
+    }
+
+    p 2000.downto(0) { |size|
+      a = ys[-1 - size, size]
+      b = ys[-1 - size * 2, size]
+      diff = a[0] - b[0]
+      next if a.zip(b).any? { _1 - _2 != diff }
+      complete, incomplete = (1000000000000 - 5000).divmod(size)
+      break y_max + complete * diff + a[incomplete] - a[0]
+    }

data/data/solutions/github/ZogStriP/2022/18_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/18_2.yml

@@ -0,0 +1,33 @@
+---
+- :name: 18_boiling_boulders.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    adj = -> ((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 = DATA.to_h { [_1.split(?,).map(&:to_i), true] }
+    faces = cubes.keys.flat_map &adj
+
+    p faces.count { !cubes[_1] }
+
+    xs, ys, zs = cubes.keys.transpose.map {
+      min, max = _1.minmax
+      min - 1 .. max + 1
+    }
+
+    queue = [[0, 0, 0]]
+    air = { [0, 0, 0] => true }
+
+    while current = queue.shift
+      adj[current].each { !air[_1] && !cubes[_1] && xs === _1[0] && ys === _1[1] && zs === _1[2] && air[_1] = true && queue << _1 }
+    end
+
+    p faces.count { !cubes[_1] && air[_1] }

data/data/solutions/github/ZogStriP/2022/19_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/19_2.yml

@@ -0,0 +1,63 @@
+---
+- :name: 19_not_enough_minerals.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    def most(time, ore_ore, clay_ore, obsidian_ore, obsidian_clay, geode_ore, geode_obsidian)
+      best = 0
+      q = [[time, 0, 0, 0, 0, 1, 0, 0, 0]]
+      seen = {}
+      max_ore = [ore_ore, clay_ore, obsidian_ore, geode_ore].max
+
+      while current = q.shift
+        t, ore, clay, obsidian, geode, ore_bots, clay_bots, obsidian_bots, geode_bots = current
+
+        best = [best, geode].max
+
+        next if t <= 0
+
+        tt = t - 1
+
+        ore_bots = [ore_bots, max_ore].min
+        clay_bots = [clay_bots, obsidian_clay].min
+        obsidian_bots = [obsidian_bots, geode_obsidian].min
+
+        ore = [ore, t * max_ore - tt * ore_bots].min
+        clay = [clay, t * obsidian_clay - tt * clay_bots].min
+        obsidian = [obsidian, t * geode_obsidian - tt * obsidian_bots].min
+
+        k = t | ore << 5 | clay << 10 | obsidian << 15 | geode << 20 | ore_bots << 25 | clay_bots << 30 | obsidian_bots << 35 | geode_bots << 40
+
+        next if seen[k]
+        seen[k] = true
+
+        o = ore + ore_bots
+        c = clay + clay_bots
+        ob = obsidian + obsidian_bots
+        g = geode + geode_bots
+
+        q << [tt, o, c, ob, g, ore_bots, clay_bots, obsidian_bots, geode_bots]
+        q << [tt, o - ore_ore, c, ob, g, ore_bots + 1, clay_bots, obsidian_bots, geode_bots] if ore >= ore_ore
+        q << [tt, o - clay_ore, c, ob, g, ore_bots, clay_bots + 1, obsidian_bots, geode_bots] if ore >= clay_ore
+        q << [tt, o - obsidian_ore, c - obsidian_clay, ob, g, ore_bots, clay_bots, obsidian_bots + 1, geode_bots] if ore >= obsidian_ore && clay >= obsidian_clay
+        q << [tt, o - geode_ore, c, ob - geode_obsidian, g, ore_bots, clay_bots, obsidian_bots, geode_bots + 1] if ore >= geode_ore && obsidian >= geode_obsidian
+      end
+
+      best
+    end
+
+    p1 = 0
+    p2 = 1
+
+    DATA.each.with_index(1) {
+      w = _1.split
+
+      ore_ore = w[6].to_i
+      clay_ore = w[12].to_i
+      obsidian_ore, obsidian_clay = w[18].to_i, w[21].to_i
+      geode_ore, geode_obsidian = w[27].to_i, w[30].to_i
+
+      p1 += _2 * most(24, ore_ore, clay_ore, obsidian_ore, obsidian_clay, geode_ore, geode_obsidian)
+      p2 *= most(32, ore_ore, clay_ore, obsidian_ore, obsidian_clay, geode_ore, geode_obsidian) if _2 <= 3
+    }
+
+    p p1, p2

data/data/solutions/github/ZogStriP/2022/20_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/20_2.yml

@@ -0,0 +1,51 @@
+---
+- :name: 20_grove_positioning_system.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    Node = Struct.new(:v, :l, :r)
+
+    def decrypt(s, t)
+      z = nil
+
+      s.size.times { |i|
+        s[i].l = s[(i - 1) % s.size]
+        s[i].r = s[(i + 1) % s.size]
+      }
+
+      t.times {
+        s.each { |n|
+          next z = n if n.v == 0
+
+          n.l.r = n.r
+          n.r.l = n.l
+
+          r = n.v % (s.size - 1)
+          l = s.size - 1 - r
+
+          if r <= l
+            k = n.r
+            r.times { k = k.r }
+            n.r = k
+            n.l = k.l
+          else
+            k = n.l
+            l.times { k = k.l }
+            n.l = k
+            n.r = k.r
+          end
+
+          n.r.l = n
+          n.l.r = n
+        }
+      }
+
+      3.times.sum { 1000.times { z = z.r }; z.v }
+    end
+
+    s = DATA.map { Node.new(_1.to_i) }
+
+    p decrypt(s, 1)
+
+    s.each { _1.v *= 811589153 }
+
+    p decrypt(s, 10)

data/data/solutions/github/ZogStriP/2022/21_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/21_2.yml

@@ -0,0 +1,4 @@
+---
+- :name: 21_monkey_math.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: "monkeys = DATA.to_h { _1.split ?: }.transform_values { _1[/\\d/] ? _1.to_i : _1.split }\n\ndef \U0001F9EE(monkeys)\n  Hash.new { |h, k|\n    v = monkeys[k]\n    h[k] = Integer === v ? v : h[v[0]].send(v[1], h[v[2]])\n  }\nend\n\np \U0001F9EE(monkeys)[\"root\"]\n\nl, _, r = monkeys[\"root\"]\n\np (0..).bsearch { \U0001F9EE(monkeys.merge(\"humn\" => _1))[l] <=> \U0001F9EE(monkeys)[r] }"

data/data/solutions/github/ZogStriP/2022/22_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/22_2.yml

@@ -0,0 +1,84 @@
+---
+- :name: 22_monkey_map.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    DIRS = [[0, 1], [1, 0], [0, -1], [-1, 0]] # [r, c]
+
+    RIGHT = 0
+    DOWN = 1
+    LEFT = 2
+    UP = 3
+
+    map, code = DATA.read.split("\n\n")
+
+    map = map.split("\n").map { _1.ljust(150) }
+
+    c = map[0].index ?.
+
+    walk = -> r, c, d, fold {
+      code.scan(/\d+|[LR]/).each {
+        case _1
+        when ?L; d = (d - 1) % DIRS.size
+        when ?R; d = (d + 1) % DIRS.size
+        else
+          _1.to_i.times {
+            nd = d
+            if fold
+              nr, nc = r + DIRS[d][0], c + DIRS[d][1]
+              case d
+              when RIGHT
+                if nc == 150 && (0..49) === nr
+                  nr, nc, nd = 149 - nr, 99, LEFT
+                elsif nc == 100 && (50..99) === nr
+                  nr, nc, nd = 49, nr + 50, UP
+                elsif nc == 100 && (100..149) === nr
+                  nr, nc, nd = 149 - nr, 149, LEFT
+                elsif nc == 50 && (150..199) === nr
+                  nr, nc, nd = 149, nr - 100, UP
+                end
+              when DOWN
+                if nr == 50 && (100..149) === nc
+                  nr, nc, nd = nc - 50, 99, LEFT
+                elsif nr == 150 && (50..99) === nc
+                  nr, nc, nd = nc + 100, 49, LEFT
+                elsif nr == 200 && (0..49) === nc
+                  nr, nc = 0, nc + 100
+                end
+              when LEFT
+                if nc < 50 && (0..49) === nr
+                  nr, nc, nd = 149 - nr, 0 , RIGHT
+                elsif nc < 50 && (50..99) === nr
+                  nr, nc, nd = 100, nr - 50, DOWN
+                elsif nc < 0 && (100..149) === nr
+                  nr, nc, nd = 149 - nr, 50, RIGHT
+                elsif nc < 0 && (150..199) === nr
+                  nr, nc, nd = 0, nr - 100, DOWN
+                end
+              when UP
+                if nr < 0 && (50..99) === nc
+                  nr, nc, nd = nc + 100, 0, RIGHT
+                elsif nr < 0 && (100..149) === nc
+                  nr, nc = 199, nc - 100
+                elsif nr < 100 && (0..49) === nc
+                  nr, nc, nd = nc + 50, 50, RIGHT
+                end
+              end
+            else
+              nr, nc = r, c
+              loop {
+                nr = (nr + DIRS[d][0]) % map.size
+                nc = (nc + DIRS[d][1]) % map[0].size
+                break if map[nr][nc] != " "
+              }
+            end
+
+            break if map[nr][nc][?#]
+            r, c, d = nr, nc, nd
+          }
+        end
+      }
+
+      1000 * (r + 1) + 4 * (c + 1) + d
+    }
+
+    p walk[0, c, 0, false], walk[0, c, 0, true]

data/data/solutions/github/ZogStriP/2022/23_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/23_2.yml

@@ -0,0 +1,51 @@
+---
+- :name: 23_unstable_diffusion.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    require "set"
+
+    elves = DATA.each_line.flat_map.with_index { |line, y|
+      line.each_char.filter_map.with_index { |char, x|
+        x + y * 1i if char[?#]
+      }
+    }.to_set
+
+    D = [-1i, +1i, -1, +1]
+    N = [-1 - 1i, -1i, 1 - 1i, -1, +1, -1 + 1i, +1i, 1 + 1i]
+    M = {
+      -1i => [-1 - 1i, -1i, 1 - 1i],
+      +1i => [-1 + 1i, +1i, 1 + 1i],
+      -1  => [-1 - 1i, -1, -1 + 1i],
+      +1  => [+1 - 1i, +1, +1 + 1i],
+    }
+
+    p 1.step { |t|
+      proposed = Hash.new { |h, k| h[k] = [] }
+
+      elves.each { |elve|
+        next if N.none? { elves.include?(elve + _1) }
+
+        D.each { |d|
+          break proposed[elve + d] << elve if M[d].none? { elves.include?(elve + _1) }
+        }
+      }
+
+      still = true
+
+      proposed.each { |to, froms|
+        next if froms.size > 1
+        elves.delete(froms[0])
+        elves.add(to)
+        still = false
+      }
+
+      break t if still
+
+      if t == 10
+        xmin, xmax = elves.map(&:real).minmax
+        ymin, ymax = elves.map(&:imag).minmax
+        p (xmax - xmin + 1) * (ymax - ymin + 1) - elves.size
+      end
+
+      D.rotate!(1)
+    }

data/data/solutions/github/ZogStriP/2022/24_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2022/24_2.yml

@@ -0,0 +1,54 @@
+---
+- :name: 24_blizzard_basin.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    blizzards = DATA.each_line.flat_map.with_index { |line, y|
+      line.each_char.filter_map.with_index { |char, x|
+        case char
+        when ?<; [y - 1, x - 1, 0, -1]
+        when ?>; [y - 1, x - 1, 0, +1]
+        when ?^; [y - 1, x - 1, -1, 0]
+        when ?v; [y - 1, x - 1, +1, 0]
+        end
+      }
+    }
+
+    Y = blizzards.map { _1[0] }.max + 1
+    X = blizzards.map { _1[1] }.max + 1
+    C = Y.lcm(X)
+
+    blizzards_at = C.times.map { |m|
+      blizzards.to_h { |y, x, dy, dx|
+        yy = (y + m * dy) % Y
+        xx = (x + m * dx) % X
+        [yy * X + xx, true]
+      }
+    }
+
+    minutes = -> (start, goal, m = 0) {
+      q = [start]
+
+      until q.include?(goal)
+        q = q.flat_map { |c|
+          y, x = c.divmod(X)
+
+          [
+            (c - X if y > 0 || (y == 0 && x == 0)),
+            (c + X if y < Y - 1 || (y == Y - 1 && x == X - 1)),
+            (c - 1 if y < Y && x > 0),
+            (c + 1 if y >= 0 && x < X - 1),
+            c,
+          ].select { _1 && !blizzards_at[(m + 1) % C][_1] }
+        }.uniq
+
+        m += 1
+      end
+
+      m
+    }
+
+    a = -X
+    b = Y * X + X - 1
+
+    p t = minutes[a, b]
+    p minutes[a, b, minutes[b, a, t]]

data/data/solutions/github/ZogStriP/2022/25_1.yml

@@ -0,0 +1,8 @@
+---
+- :name: 25_full_of_hot_air.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2022
+  :solution: |-
+    s = ""
+    n = DATA.sum { |l| l.chop.chars.reduce(0) { _1 * 5 + "=-012".index(_2) - 2 } }
+    (n, r = n.divmod(5); s = "012=-"[r] + s; r > 2 && n += 1) while n > 0
+    puts s

data/data/solutions/github/ZogStriP/2023/01_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2023/01_2.yml

@@ -0,0 +1,12 @@
+---
+- :name: 01_trebuchet.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2023
+  :solution: |-
+    n = %w[one two three four five six seven eight nine].each.with_index(1).to_h
+
+    puts DATA.each.with_object([0, 0]) { |l, s|
+      a = l.scan(/\d/)
+      b = l.scan(/(?=(\d|#{n.keys * ?|}))/).flatten
+      s[0] += [a[0], a[-1]].join.to_i
+      s[1] += [b[0], b[-1]].map { n[_1] || _1 }.join.to_i
+    }

data/data/solutions/github/ZogStriP/2023/02_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2023/02_2.yml

@@ -0,0 +1,11 @@
+---
+- :name: 02_cube_conundrum.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2023
+  :solution: |-
+    puts DATA.each.with_object([0, 0]) { |l, s|
+      c = {}
+      game, cubes = l.split ?:
+      cubes.scan(/(\d+) (\w)/) { c[_2] = [c[_2], _1].map(&:to_i).max }
+      s[0] += game[5..].to_i if c[?r] <= 12 && c[?g] <= 13 && c[?b] <= 14
+      s[1] += c.values.reduce :*
+    }

data/data/solutions/github/ZogStriP/2023/03_1.yml

@@ -0,0 +1 @@
+--- []