advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ZogStriP/2018/04_2.yml

@@ -0,0 +1,23 @@
+---
+- :name: 04_repose_record.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    guards = Hash.new { |h, k| h[k] = Hash.new(0) }
+    guard  = nil
+    asleep = nil
+
+    DATA.each_line.sort.each do |l|
+      if l["Guard"]
+        guard = l[/#(\d+)/, 1].to_i
+      elsif l["falls asleep"]
+        asleep = l[/:(\d+)/, 1].to_i
+      elsif l["wakes up"]
+        awake = l[/:(\d+)/, 1].to_i
+        (asleep...awake).each { |m| guards[guard][m] += 1 }
+      end
+    end
+
+    %i(sum max).each { |f|
+      g, m = guards.max_by { |_, m| m.values.send(f) }
+      p g * m.max_by(&:last)[0]
+    }

data/data/solutions/github/ZogStriP/2018/05_1.yml

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

data/data/solutions/github/ZogStriP/2018/05_2.yml

@@ -0,0 +1,14 @@
+---
+- :name: 05_alchemical_reduction.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    polymer = DATA.read.strip
+
+    def react(polymer)
+      result = []
+      polymer.each_char { |c| c == result[-1]&.swapcase ? result.pop : result << c }
+      result.size
+    end
+
+    p react(polymer)
+    p ("a".."z").map { |u| react(polymer.tr(u + u.upcase, "")) }.min

data/data/solutions/github/ZogStriP/2018/06_1.yml

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

data/data/solutions/github/ZogStriP/2018/06_2.yml

@@ -0,0 +1,42 @@
+---
+- :name: 06_chronal_coordinates.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    points = DATA.each_line.map { |l| l.scan(/\d+/).map(&:to_i) }
+
+    xmin, xmax = points.map(&:first).minmax
+    ymin, ymax = points.map(&:last).minmax
+
+    areas = Hash.new(0)
+    edges = {}
+    safe  = 0
+
+    (xmin..xmax).each { |x|
+      (ymin..ymax).each { |y|
+        best_p = nil
+        best_d = Float::INFINITY
+        total  = 0
+
+        points.each { |p|
+          d = (p[0] - x).abs + (p[1] - y).abs
+          total += d
+
+          if d < best_d
+            best_p = p
+            best_d = d
+          elsif d == best_d
+            best_p = nil
+          end
+        }
+
+        safe += 1 if total < 10_000
+
+        next unless best_p
+
+        edges[best_p] ||= x == xmin || x == xmax || y == ymin || y == ymax
+        areas[best_p] += 1
+      }
+    }
+
+    p points.select { |p| !edges[p] }.map { |p| areas[p] }.max
+    p safe

data/data/solutions/github/ZogStriP/2018/07_1.yml

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

data/data/solutions/github/ZogStriP/2018/07_2.yml

@@ -0,0 +1,41 @@
+---
+- :name: 07_the_sum_of_its_parts.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    s = {}
+
+    DATA.each_line { |l|
+      a, b = l.scan(/[A-Z]/).drop(1)
+      s[a] ||= []
+      s[b] ||= []
+      s[b] << a
+    }
+
+    d = Marshal.load(Marshal.dump(s))
+    until d.empty?
+      c = d.select { |_, v| v.empty? }.keys.sort[0]
+      d.delete(c)
+      d.each { |_, v| v.delete(c) }
+      putc c
+    end
+
+    puts
+
+    w = {}
+    d = Marshal.load(Marshal.dump(s))
+
+    p 0.step { |t|
+      w.delete_if { |k, v|
+       v == 1 && (d.delete(k); d.each { |_, v| v.delete(k) }; true)
+      }
+
+      d.select { |_, v| v.empty? }.keys.sort.each { |c|
+        if w[c]
+          w[c] -= 1
+        elsif w.size < 5
+          w[c] = c.ord - 4
+        end
+      }
+
+      break t if d.empty?
+    }

data/data/solutions/github/ZogStriP/2018/08_1.yml

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

data/data/solutions/github/ZogStriP/2018/08_2.yml

@@ -0,0 +1,13 @@
+---
+- :name: '08_memory_maneuver.rb'
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    tree = DATA.read.split.map(&:to_i)
+
+    def process(t, &b)
+      c, m = t.shift(2)
+      yield c.times.map { process(t, &b) }, t.shift(m)
+    end
+
+    p process(tree.dup) { |c, m| c.sum + m.sum }
+    p process(tree.dup) { |c, m| c.empty? ? m.sum : m.sum { |i| c[i - 1] || 0 } }

data/data/solutions/github/ZogStriP/2018/09_1.yml

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

data/data/solutions/github/ZogStriP/2018/09_2.yml

@@ -0,0 +1,26 @@
+---
+- :name: '09_marble_mania.rb'
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    def play(players, marbles)
+      scores   = [0] * players
+      nexts    = [nil] * (marbles + 1)
+      nexts[0] = current = 0
+
+      (1..marbles).each { |m|
+        if m % 23 == 0
+          n = nexts[m - 5]
+          scores[m % players] += m + n
+          current = nexts[m - 5] = nexts[n]
+        else
+          nexts[m] = nexts[nexts[current]]
+          nexts[nexts[current]] = m
+          current = m
+        end
+      }
+
+      scores.max
+    end
+
+    p play(430, 71_588)
+    p play(430, 71_588 * 100)

data/data/solutions/github/ZogStriP/2018/10_1.yml

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

data/data/solutions/github/ZogStriP/2018/10_2.yml

@@ -0,0 +1,28 @@
+---
+- :name: 10_the_stars_align.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    pv = DATA.each_line.map { |l| l.scan(/-?\d+/).map(&:to_i) }
+
+    all_positive = 1.step.find { |s| pv.all? { |x, y, xx, yy| (x + xx * s) > 0 && (y + yy * s) > 0 } }
+
+    best_height  = Float::INFINITY
+    best_points = nil
+
+    p all_positive.step { |s|
+      points = pv.map { |x, y, xx, yy| [x + xx * s, y + yy * s] }
+      height = points.map(&:last).minmax.reduce(:-).abs
+      break s - 1 if height > best_height
+      best_height = height
+      best_points = points
+    }
+
+    xmin, xmax = best_points.map(&:first).minmax
+    ymin, ymax = best_points.map(&:last).minmax
+
+    (ymin..ymax).each { |y|
+      (xmin..xmax).each { |x|
+        putc best_points.include?([x, y]) ? "#" : " "
+      }
+      puts
+    }

data/data/solutions/github/ZogStriP/2018/11_1.yml

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

data/data/solutions/github/ZogStriP/2018/11_2.yml

@@ -0,0 +1,36 @@
+---
+- :name: 11_chronal_charge.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    SIZE   =  300
+    SERIAL = 6042
+
+    # https://en.wikipedia.org/wiki/Summed_area_table
+    @grid = Array.new(SIZE) { Array.new(SIZE, 0) }
+
+    (1...SIZE).each { |x|
+      (1...SIZE).each { |y|
+        power = ((((x + 10) * y + SERIAL) * (x + 10)).digits[2] || 0) - 5
+        @grid[x][y] = power + @grid[x][y - 1] + @grid[x - 1][y] - @grid[x - 1][y - 1]
+      }
+    }
+
+    best_squares = (1..SIZE).map { |s|
+      best_power = 0
+      best_square = nil
+
+      (s...SIZE).each { |x|
+        (s...SIZE).each { |y|
+          power = @grid[x][y] + @grid[x - s][y - s] - @grid[x - s][y] - @grid[x][y - s]
+          if power > best_power
+            best_power = power
+            best_square = [x - s + 1, y - s + 1, s]
+          end
+        }
+      }
+
+      [best_power, best_square]
+    }
+
+    p best_squares[2]
+    p best_squares.max_by(&:first)

data/data/solutions/github/ZogStriP/2018/12_1.yml

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

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

@@ -0,0 +1,21 @@
+---
+- :name: 12_subterranean_sustainability.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    rules = DATA.each_line.map { |l| [l[0, 5].chars, l[9]] }.to_h
+
+    index = 0
+    empty = "....".chars
+    state = "###.#..#..##.##.###.#.....#.#.###.#.####....#.##..#.#.#..#....##..#.##...#.###.#.#..#..####.#.##.#".chars
+
+    sums = []
+
+    loop {
+      state = (empty + state + empty).each_cons(5).map(&rules)
+      index -= 2
+      sums << state.zip(index.step).sum { |c, i| c["#"] ? i : 0 }
+      break if sums.size > 2 && sums[-3..-1].each_cons(2).map { |a, b| a - b }.uniq.size == 1
+    }
+
+    p sums[19]
+    p (50_000_000_000 - sums.size) * (sums[-1] - sums[-2]) + sums[-1]

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

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

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

@@ -0,0 +1,68 @@
+---
+- :name: 13_mine_cart_madness.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    tracks = IO.read("13.input").split("\n").map(&:chars)
+
+    fail "invalid input" unless tracks.map(&:size).uniq.size == 1
+
+    carts = []
+
+    DIRECTIONS = [
+      [-1,  0], # up
+      [ 0,  1], # right
+      [ 1,  0], # down
+      [ 0, -1], # left
+    ]
+
+    CARTS = ["^", ">", "v", "<"]
+    CURVE_RIGHT = [1, 0, 3, 2]
+    CURVE_LEFT  = [3, 2, 1, 0]
+
+    tracks.each_with_index { |r, y|
+      r.each_with_index { |c, x|
+        if c["^"]
+          carts << [y, x, 0, 0]
+          r[x] = "|"
+        elsif c["v"]
+          carts << [y, x, 2, 0]
+          r[x] = "|"
+        elsif c["<"]
+          carts << [y, x, 3, 0]
+          r[x] = "-"
+        elsif c[">"]
+          carts << [y, x, 1, 0]
+          r[x] = "-"
+        end
+      }
+    }
+
+    crashed_carts = []
+
+    while carts.size > 1
+      carts.sort_by { |c| c[0, 2] }.each { |c|
+        d = DIRECTIONS[c[2]]
+        n = [c[0] + d[0], c[1] + d[1]]
+        t = tracks[n[0]][n[1]]
+
+        if cc = carts.find { |cc| n == cc[0, 2] }
+          crashed_carts << carts.delete(c) << carts.delete(cc)
+        elsif t["/"]
+          c[2] = CURVE_RIGHT[c[2]]
+        elsif t["\\"]
+          c[2] = CURVE_LEFT[c[2]]
+        elsif t["+"]
+          if c[3] == 0 # left
+            c[2] = (c[2] - 1) % 4
+          elsif c[3] == 2 # right
+            c[2] = (c[2] + 1) % 4
+          end
+          c[3] = (c[3] + 1) % 3
+        end
+
+        c[0, 2] = n
+      }
+    end
+
+    p crashed_carts[0][0, 2].reverse
+    p carts[0][0, 2].reverse

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: 14_chocolate_charts.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    INPUT = "760221"
+
+    scores = [3, 7]
+    a, b = 0, 1
+
+    16_000_000.times {
+      s = scores[a] + scores[b]
+      s > 9 ? scores << 1 << s - 10 : scores << s
+      a = (a + scores[a] + 1) % scores.size
+      b = (b + scores[b] + 1) % scores.size
+    }
+
+    puts scores[INPUT.to_i, 10].join
+
+    sequence = INPUT.chars.map(&:to_i)
+
+    p INPUT.to_i.step { |i|
+      break i if scores[i] == sequence[0] &&
+        scores[i + 1] == sequence[1] &&
+        scores[i + 2] == sequence[2] &&
+        scores[i + 3] == sequence[3] &&
+        scores[i + 4] == sequence[4] &&
+        scores[i + 5] == sequence[5]
+    }

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

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

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

@@ -0,0 +1,97 @@
+---
+- :name: 15_beverage_bandits.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    input = DATA.read.split("\n")
+
+    @open  = []
+    @width = input[0].size
+
+    Unit = Struct.new(:position, :elf, :hp, :att)
+
+    starting_units = []
+
+    input.each_with_index { |r, y|
+      r.each_char.with_index { |c, x|
+        p = x + y * @width
+        case c
+        when "E"
+          starting_units << Unit.new(p, true, 200, 3)
+          @open[p] = true
+        when "G"
+          starting_units << Unit.new(p, false, 200, 3)
+          @open[p] = true
+        when "."
+          @open[p] = true
+        when "#"
+          @open[p] = false
+        end
+      }
+    }
+
+    def adjacents(p)
+      [
+        p - @width, # up
+        p - 1,      # left
+        p + 1,      # right
+        p + @width, # down
+      ]
+    end
+
+    def round(units)
+      units.sort_by(&:position).each do |unit|
+        next if unit.hp <= 0
+
+        targets = units.select { |u| u.elf != unit.elf }.map { |u| [u.position, u] }.to_h
+        return false if targets.empty?
+
+        # move
+        unless target = adjacents(unit.position).map(&targets).compact.sort_by(&:position).first
+          occupied = units.map { |u| [u.position, true] }.to_h
+
+          goals = targets.flat_map { |p, _| adjacents(p) }.map { |p| [p, true] }.to_h
+          prev  = { unit.position => nil }
+          queue = [unit.position]
+          found = []
+
+          until queue.empty?
+            q = []
+            while c = queue.shift
+              found << c if goals[c]
+              next if !found.empty?
+              adjacents(c)
+                .select { |a| @open[a] && !occupied[a] && !prev.has_key?(a) }
+                .each { |a| q << a; prev[a] = c }
+            end
+            queue = q if found.empty?
+          end
+
+          if !found.empty?
+            p = found.min
+            p = prev[p] while prev[p] != unit.position
+            unit.position = p
+          end
+        end
+
+        # attack
+        if target = adjacents(unit.position).map(&targets).compact.sort_by { |u| [u.hp, u.position] }.first
+          target.hp -= unit.att
+          units.delete(target) if target.hp <= 0
+        end
+      end
+
+      true
+    end
+
+    units = Marshal.load(Marshal.dump(starting_units))
+    rounds = 0.step.find { !round(units) }
+    p units.sum(&:hp) * rounds
+
+    4.step { |att|
+      units = Marshal.load(Marshal.dump(starting_units))
+      units.select(&:elf).each { |u| u.att = att }
+      rounds = 0.step.find { !round(units) }
+      if units.count(&:elf) == starting_units.count(&:elf)
+        break p units.sum(&:hp) * rounds
+      end
+    }

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

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

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

@@ -0,0 +1,60 @@
+---
+- :name: 16_chronal_classification.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    samples, program = DATA.read.split("\n\n\n\n")
+
+    instructions = {
+      addr: ->(a, b, c, r) { r[c] = r[a] + r[b] },
+      addi: ->(a, b, c, r) { r[c] = r[a] + b },
+      mulr: ->(a, b, c, r) { r[c] = r[a] * r[b] },
+      muli: ->(a, b, c, r) { r[c] = r[a] * b },
+      banr: ->(a, b, c, r) { r[c] = r[a] & r[b] },
+      bani: ->(a, b, c, r) { r[c] = r[a] & b },
+      borr: ->(a, b, c, r) { r[c] = r[a] | r[b] },
+      bori: ->(a, b, c, r) { r[c] = r[a] | b },
+      setr: ->(a, b, c, r) { r[c] = r[a] },
+      seti: ->(a, b, c, r) { r[c] = a },
+      gtir: ->(a, b, c, r) { r[c] = a > r[b] ? 1 : 0 },
+      gtri: ->(a, b, c, r) { r[c] = r[a] > b ? 1 : 0 },
+      gtrr: ->(a, b, c, r) { r[c] = r[a] > r[b] ? 1 : 0 },
+      eqir: ->(a, b, c, r) { r[c] = a == r[b] ? 1 : 0 },
+      eqri: ->(a, b, c, r) { r[c] = r[a] == b ? 1 : 0 },
+      eqrr: ->(a, b, c, r) { r[c] = r[a] == r[b] ? 1 : 0 },
+    }
+
+    names = Array.new(instructions.size) { instructions.keys }
+
+    p samples.split("\n\n").count { |sample|
+      before, instruction, after = sample.split("\n")
+      before = eval before[8..-1]
+      opcode, a, b, c = instruction.split.map(&:to_i)
+      after = eval after[8..-1]
+
+      possibles = instructions.select { |_, instr|
+        r = before.dup
+        instr[a, b, c, r]
+        r == after
+      }
+
+      names[opcode] &= possibles.keys
+      possibles.size >= 3
+    }
+
+    opcodes = [nil] * instructions.size
+
+    until opcodes.all?
+      op = names.index { |n| n.size == 1 }
+      name = names[op][0]
+      opcodes[op] = instructions[name]
+      names.each { |n| n.delete(name) }
+    end
+
+    r = [0, 0, 0, 0]
+
+    program.split("\n").each { |l|
+      opcode, a, b, c = l.split.map(&:to_i)
+      opcodes[opcode][a, b, c, r]
+    }
+
+    p r[0]

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

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

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

@@ -0,0 +1,59 @@
+---
+- :name: 17_reservoir_research.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    CLAY = "#"
+    FLOW = "|"
+    REST = "~"
+
+    @map = Hash.new { |h, k| h[k] = {} }
+
+    DATA.each_line { |l|
+      v = l.scan(/\d+/).map(&:to_i)
+      l[0] == "x" ?
+        (v[1]..v[2]).each { |y| @map[y][v[0]] = CLAY } :
+        (v[1]..v[2]).each { |x| @map[v[0]][x] = CLAY }
+    }
+
+    @ymin, @ymax = @map.keys.minmax
+
+    def spread(xx, yy, d)
+      (xx + d).step(by: d) { |x|
+        return [false, x] if @map[yy + 1][x] != CLAY && @map[yy + 1][x] != REST
+        return [true, x]  if @map[yy][x] == CLAY
+      }
+    end
+
+    def flood(xx, yy, flooded)
+      return if flooded[[xx, yy]]
+      flooded[[xx, yy]] = true
+
+      unless b = (yy..@ymax).find { |y| @map[y][xx] == CLAY || @map[y][xx] == REST }
+        (yy..@ymax).each { |y| @map[y][xx] = FLOW }
+        return
+      end
+
+      (yy..b - 1).each { |y| @map[y][xx] = FLOW }
+
+      (b - 1).step(by: -1) { |y|
+        lw, lx = spread(xx, y, -1)
+        rw, rx = spread(xx, y,  1)
+
+        if lw && rw
+          (lx..rx).each { |x| @map[y][x] = REST unless @map[y][x] == CLAY }
+        else
+          (lx..rx).each { |x| @map[y][x] = FLOW unless @map[y][x] == CLAY }
+          flood(lx, y, flooded) unless @map[y][lx] == CLAY
+          flood(rx, y, flooded) unless @map[y][rx] == CLAY
+          break
+        end
+      }
+    end
+
+    flood(500, 0, {})
+
+    rest = (@ymin..@ymax).sum { |y| @map[y].values.count(REST) }
+    flow = (@ymin..@ymax).sum { |y| @map[y].values.count(FLOW) }
+
+    p rest + flow
+    p rest

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

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

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

@@ -0,0 +1,45 @@
+---
+- :name: 18_settlers_of_the_north_pole.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    adjacents = [
+      [-1, -1], [ 0, -1], [ 1, -1],
+      [-1,  0],           [ 1,  0],
+      [-1,  1], [ 0,  1], [ 1,  1],
+    ]
+
+    maps = {}
+    map  = DATA.each_line.map { |l| l.chomp.chars }
+
+    minutes = 0.step { |m|
+      break m if maps[map]
+      maps[map] = m
+
+      map = map.map.with_index { |r, y|
+        r.map.with_index { |c, x|
+          adj = adjacents
+                  .map { |a, b| [x + a, y + b] }
+                  .select { |xx, yy| xx >= 0 && xx < r.size && yy >= 0 && yy < map.size }
+                  .map { |xx, yy| map[yy][xx] }
+
+          t = adj.count("|")
+          l = adj.count("#")
+
+          if c["."] && t >= 3
+            "|"
+          elsif c["|"] && l >= 3
+            "#"
+          elsif c["#"] && (t == 0 || l == 0)
+            "."
+          else
+            c
+          end
+        }
+      }
+    }
+
+    m = maps.key(10)
+    p m.sum { |r| r.count("#") } * m.sum { |r| r.count("|") }
+
+    m = maps.key(1_000_000_000 % (minutes - maps[map]) + maps[map])
+    p m.sum { |r| r.count("#") } * m.sum { |r| r.count("|") }

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

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

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

@@ -0,0 +1,10 @@
+---
+- :name: 19_go_with_the_flow.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    def sum_of_factors(n)
+      (1..n).select { |f| n % f == 0 }.sum
+    end
+
+    p sum_of_factors(948)
+    p sum_of_factors(10_551_348)

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

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