advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/erikw/2018/21_1.yml

@@ -0,0 +1,8 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/21
+  :solution: |-
+    require_relative 'computer'
+
+    instructions = ARGF.each_line.map { |l| l.chomp.split }
+    puts Computer.new.execute(instructions, watch_line: 28, watch_action: :halt).registers[1]

data/data/solutions/github/erikw/2018/21_2.yml

@@ -0,0 +1,8 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/21
+  :solution: |-
+    require_relative 'computer'
+
+    instructions = ARGF.each_line.map { |l| l.chomp.split }
+    puts Computer.new.execute(instructions, watch_line: 28, watch_action: :detect_repeat, watch_reg: 1).registers[1]

data/data/solutions/github/erikw/2018/22_1.yml

@@ -0,0 +1,14 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/22
+  :solution: |-
+    require_relative 'lib'
+
+    depth, target = read_input
+    erosions = erosion_levels(target, depth)
+    cave = types(erosions, target, depth)
+
+    # print_cave(erosions, target, depth)
+
+    total_risk_level = cave.values.sum
+    puts total_risk_level

data/data/solutions/github/erikw/2018/22_2.yml

@@ -0,0 +1,94 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/22
+  :solution: |-
+    require_relative 'lib'
+
+    require 'set'
+    require 'lazy_priority_queue'
+
+    class LazyPriorityQueue
+      def upsert(element, key)
+        change_priority(element, key)
+      rescue StandardError
+        enqueue(element, key)
+      end
+    end
+
+    TIME_MOVE = 1
+    TIME_SWITCH_TOOL = 7
+
+    TYPE_TOOLS = {
+      TYPE_ROCKY => %i[tool_climbing tool_torch],
+      TYPE_WET => %i[tool_climbing tool_neither],
+      TYPE_NARROW => %i[tool_torch tool_neither]
+    }
+
+    NEIGHBOUR_DELTAS = [-1, 1, -1i, 1i]
+
+    # Modified Dijkstra's algorithm from given starting coordinate:
+    # - Only adds nodes to queue as they are discovered, to avoid having to BFS all currently available positions before the algoritm.
+    # - Quit early when finding target, as the cave could be infinite
+    # - Each node defined by positon and tool type when entring it.
+    # - Adding self-edge to each node for a change of tool.
+    def dijkstra(erosions, target, depth)
+      dist = Hash.new(Float::INFINITY)
+      dist[[POS_MOUTH, :tool_torch]] = 0
+      prev = {}
+      visited = Set.new
+
+      q = MinPriorityQueue.new
+      q.push([POS_MOUTH, :tool_torch], dist[[POS_MOUTH, :tool_torch]])
+      until q.empty?
+        pos, tool = q.pop
+        return [dist, prev] if pos == target && tool == :tool_torch
+
+        visited << [pos, tool]
+        type_cur = type(erosions, target, depth, pos)
+
+        # Add edge to self with tooling change
+        other_tool = (TYPE_TOOLS[type_cur] - [tool]).first
+        alt_self = dist[[pos, tool]] + TIME_SWITCH_TOOL
+        if !visited.include?([pos, other_tool]) && alt_self < dist[[pos, other_tool]]
+          dist[[pos, other_tool]] = alt_self
+          prev[[pos, other_tool]] = [pos, tool]
+          q.upsert([pos, other_tool], dist[[pos, other_tool]])
+        end
+
+        NEIGHBOUR_DELTAS.each do |delta|
+          pos_n = pos + delta
+          next if pos_n.real.negative? || pos_n.imag.negative?
+
+          type_n = type(erosions, target, depth, pos_n)
+          alt = dist[[pos, tool]] + TIME_MOVE
+          next unless !visited.include?([pos_n, tool]) && TYPE_TOOLS[type_n].include?(tool) && alt < dist[[pos_n, tool]]
+
+          dist[[pos_n, tool]] = alt
+          prev[[pos_n, tool]] = [pos, tool]
+          q.upsert([pos_n, tool], alt)
+        end
+      end
+      [dist, prev]
+    end
+
+    def construct_path(prev, source, target)
+      path = []
+      u = target
+      t = :tool_torch
+      if prev.key?([u, t]) || u == source && t == :tool_torch
+        until u.nil?
+          path.unshift(u)
+          u, t = prev[[u, t]]
+        end
+      end
+      path
+    end
+
+    depth, target = read_input
+    erosions = erosion_levels(target, depth)
+    dist, prev = dijkstra(erosions, target, depth)
+
+    # path = construct_path(prev, POS_MOUTH, target)
+    # print_cave(erosions, target, depth, path)
+
+    puts dist[[target, :tool_torch]]

data/data/solutions/github/erikw/2018/23_1.yml

@@ -0,0 +1,18 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/23
+  :solution: |-
+    def manhattan_distance(pos1, pos2)
+      pos1.zip(pos2).map { |a, b| (a - b).abs }.sum
+    end
+
+    nanobots = ARGF.each_line.map do |line|
+      x, y, z, r = line.scan(/-?\d+/).map(&:to_i)
+      [[x, y, z], r]
+    end
+
+    strongest = nanobots.max_by(&:last)
+    in_range = nanobots.count do |nanobot|
+      manhattan_distance(strongest[0], nanobot[0]) <= strongest.last
+    end
+    puts in_range

data/data/solutions/github/erikw/2018/23_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/23
+  :solution: |-
+    require 'z3'
+
+    ORIGIN = [0, 0, 0]
+
+    def dist(pos1, pos2)
+      pos1.zip(pos2).map { |a, b| (a - b).abs }.sum
+    end
+
+    def z3_abs(x)
+      Z3.IfThenElse(x >= 0, x, -x)
+    end
+
+    def z3_dist(pos1, pos2)
+      pos1.zip(pos2).map { |a, b| z3_abs(a - b) }.sum
+    end
+
+    nanobots = ARGF.each_line.map do |line|
+      x, y, z, r = line.scan(/-?\d+/).map(&:to_i)
+      [[x, y, z], r]
+    end
+
+    pos_sol = %w[x y z].each.map { |c| Z3.Int(c) }
+
+    cluster = Z3.Int('cluster')
+    cluster_expr = 0
+    nanobots.each do |pos, radius|
+      cluster_expr += Z3.IfThenElse(z3_dist(pos_sol, pos) <= radius, 1, 0)
+    end
+
+    optimizer = Z3::Optimize.new
+    optimizer.assert(cluster == cluster_expr)
+    optimizer.maximize(cluster)
+    optimizer.minimize(z3_dist(ORIGIN, pos_sol))
+    optimizer.check
+
+    model = optimizer.model
+    pos_sol_int = pos_sol.map { |c| model[c].to_i }
+    # puts "Solved position: #{pos_sol_int.join(', ')}"
+    # puts "Number in range: #{model[cluster]}"
+    puts dist(ORIGIN, pos_sol_int)

data/data/solutions/github/erikw/2018/24_1.yml

@@ -0,0 +1,8 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/24
+  :solution: |-
+    require_relative 'lib'
+
+    groups = parse_input
+    puts battle(groups)[0]

data/data/solutions/github/erikw/2018/24_2.yml

@@ -0,0 +1,22 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/24
+  :solution: |-
+    require_relative 'lib'
+
+    groups = parse_input.sort_by(&:name)
+    groups_orig = Marshal.load(Marshal.dump(groups))
+
+    units = nil
+    boost = 0
+    winner = nil
+    until winner == :immune
+      groups.each_with_index do |group, i|
+        group.units = groups_orig[i].units
+        group.damage = groups_orig[i].damage + boost if group.army == :immune
+      end
+
+      units, winner = battle(groups)
+      boost += 1
+    end
+    puts units

data/data/solutions/github/erikw/2018/25_1.yml

@@ -0,0 +1,50 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/25
+  :solution: |-
+    # https://cp-algorithms.com/data_structures/disjoint_set_union.html
+    class DisjointSetUnion
+      def initialize
+        @parent = {}
+        @size = {}
+      end
+
+      def make_set(v)
+        @parent[v] = v
+        @size[v] = 1
+        v
+      end
+
+      def find(v)
+        @parent[v] = @parent[v] == v ? v : find(@parent[v])
+      end
+
+      def union(a, b)
+        sa = find(a) || make_set(a)
+        sb = find(b) || make_set(b)
+        unless sa == sb
+          sa, sb = sb, sa if @size[sa] < @size[sb]
+          @parent[sb] = sa
+          @size[sa] += @size[sb]
+          @size.delete(sb)
+        end
+      end
+
+      def size
+        @size.length
+      end
+    end
+
+    def manhattan_distance(pa, pb)
+      pa.zip(pb).map { |x| x.inject(&:-).abs }.sum
+    end
+
+    points = ARGF.each_line.map { |l| l.split(',').map(&:to_i) }
+
+    constellations = DisjointSetUnion.new
+    points.each { |p| constellations.make_set(p) }
+    points.combination(2) do |pa, pb|
+      constellations.union(pa, pb) if manhattan_distance(pa, pb) <= 3
+    end
+
+    puts constellations.size

data/data/solutions/github/erikw/2019/01_1.yml

@@ -0,0 +1,4 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/01
+  :solution: puts ARGF.each_line.map { |l| l.to_i / 3 - 2 }.sum

data/data/solutions/github/erikw/2019/01_2.yml

@@ -0,0 +1,10 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/01
+  :solution: |-
+    def fuel(mass)
+      f = mass / 3 - 2
+      f <= 0 ? 0 : f + fuel(f)
+    end
+
+    puts ARGF.each_line.map { |l| fuel(l.to_i) }.sum

data/data/solutions/github/erikw/2019/02_1.yml

@@ -0,0 +1,10 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/02
+  :solution: |-
+    require_relative 'computer'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    intcode[IP_NOUN] = 12
+    intcode[IP_VERB] = 2
+    puts Computer.new.execute(intcode).memory[0]

data/data/solutions/github/erikw/2019/02_2.yml

@@ -0,0 +1,32 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/02
+  :solution: |-
+    require_relative 'computer'
+
+    SEARCHED = 19_690_720
+    VAL_RANGE = 0..99
+
+    def compute(computer, intcode, noun, verb)
+      intcode[IP_NOUN] = noun
+      intcode[IP_VERB] = verb
+      computer.execute(intcode).memory[0]
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    noun = 0
+    verb = 0
+    computer = Computer.new
+    catch :found do
+      VAL_RANGE.each do |n|
+        VAL_RANGE.each do |v|
+          next unless compute(computer, intcode, n, v) == SEARCHED
+
+          noun = n
+          verb = v
+          throw :found
+        end
+      end
+    end
+    puts 100 * noun + verb

data/data/solutions/github/erikw/2019/03_1.yml

@@ -0,0 +1,32 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/03
+  :solution: |-
+    require 'set'
+
+    def manhattan_dist(p1, p2)
+      p1.zip(p2).map { |x1, x2| (x1 - x2).abs }.sum
+    end
+
+    wires = ARGF.each_line.map do |line|
+      line.chomp.split(',').map { |instr| [instr[0], instr[1..].to_i] }
+    end
+
+    grid = Hash.new { |h, k| h[k] = Set.new } # [x, y] => Int
+    wires.each_with_index do |wire, i|
+      x = 0
+      y = 0
+      wire.each do |dir, len|
+        len.times do
+          case dir
+          when 'U' then x -= 1
+          when 'R' then y += 1
+          when 'D' then x += 1
+          when 'L' then y -= 1
+          end
+          grid[[x, y]] << i
+        end
+      end
+    end
+
+    puts grid.select { |_c, visitors| visitors.length > 1 }.map { |c, _| manhattan_dist(c, [0, 0]) }.min

data/data/solutions/github/erikw/2019/03_2.yml

@@ -0,0 +1,41 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/03
+  :solution: |-
+    require 'set'
+
+    def manhattan_dist(p1, p2)
+      p1.zip(p2).map { |x1, x2| (x1 - x2).abs }.sum
+    end
+
+    wires = ARGF.each_line.map do |line|
+      line.chomp.split(',').map { |instr| [instr[0], instr[1..].to_i] }
+    end
+
+    grid = Hash.new { |h, k| h[k] = Set.new } # [x, y] => Int
+    intersect_dists = Hash.new(0)
+    wires.each_with_index do |wire, i|
+      x = 0
+      y = 0
+      steps = 0
+      wire.each do |dir, len|
+        len.times do
+          case dir
+          when 'U' then x -= 1
+          when 'R' then y += 1
+          when 'D' then x += 1
+          when 'L' then y -= 1
+          end
+          steps += 1
+          unless grid[[x, y]].include?(i)
+            grid[[x, y]] << i
+            intersect_dists[[x, y]] += steps
+          end
+        end
+      end
+    end
+
+    min_delay = grid.select { |_coord, visitors| visitors.length > 1 }.map do |coord, _visitors|
+      intersect_dists[coord]
+    end.min
+    puts min_delay

data/data/solutions/github/erikw/2019/04_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/04
+  :solution: |-
+    def valid(num)
+      repeated = false
+      increasing = true
+
+      last = 10
+      until num == 0
+        digit = num % 10
+
+        repeated = true if digit == last
+        increasing = false if digit > last
+
+        num /= 10
+        last = digit
+      end
+      repeated && increasing
+    end
+
+    lo, hi = ARGF.readline.chomp.split('-').map(&:to_i)
+    num_valid = (lo..hi).count { |pw| valid(pw) }
+    puts num_valid

data/data/solutions/github/erikw/2019/04_2.yml

@@ -0,0 +1,32 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/04
+  :solution: |-
+    def valid(num)
+      repeated = false
+      increasing = true
+
+      last = 10
+      rep_cnt = 0
+      until num == 0
+        digit = num % 10
+
+        if digit != last
+          repeated = true if rep_cnt == 2
+          rep_cnt = 0
+        end
+        rep_cnt += 1
+
+        increasing = false if digit > last
+
+        num /= 10
+        last = digit
+      end
+      repeated = true if rep_cnt == 2
+
+      repeated && increasing
+    end
+
+    lo, hi = ARGF.readline.chomp.split('-').map(&:to_i)
+    num_valid = (lo..hi).count { |pw| valid(pw) }
+    puts num_valid

data/data/solutions/github/erikw/2019/05_1.yml

@@ -0,0 +1,11 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/05
+  :solution: |-
+    require_relative 'computer'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new
+    computer.stdin << 1
+    computer.execute(intcode)
+    puts computer.stdout.last

data/data/solutions/github/erikw/2019/05_2.yml

@@ -0,0 +1,11 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/05
+  :solution: |-
+    require_relative 'computer'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new
+    computer.stdin << 5
+    computer.execute(intcode)
+    puts computer.stdout.last

data/data/solutions/github/erikw/2019/06_1.yml

@@ -0,0 +1,22 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/06
+  :solution: |-
+    CENTER_OF_MASS = 'COM'
+
+    def steps_to(target, orbits, orbiter)
+      steps = 0
+      until orbiter == target
+        orbiter = orbits[orbiter]
+        steps += 1
+      end
+      steps
+    end
+
+    orbits = {} # orbiter -> orbitee
+    ARGF.each_line do |line|
+      orbitee, orbiter = line.chomp.split(')')
+      orbits[orbiter] = orbitee
+    end
+
+    puts orbits.keys.map { |orbiter| steps_to(CENTER_OF_MASS, orbits, orbiter) }.sum

data/data/solutions/github/erikw/2019/06_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/06
+  :solution: |-
+    require 'lazy_priority_queue'
+
+    class LazyPriorityQueue
+      def upsert(element, key)
+        change_priority(element, key)
+      rescue StandardError
+        enqueue(element, key)
+      end
+    end
+
+    OBJ_YOU = 'YOU'
+    OBJ_SANTA = 'SAN'
+
+    def dijkstra(edges, source, target)
+      dist = Hash.new(Float::INFINITY)
+      dist[source] = 0
+      prev = {}
+
+      q = MinPriorityQueue.new
+      q.push(source, dist[[source]])
+      until q.empty?
+        node = q.pop
+        return [dist, prev] if node == target
+
+        edges[node].each do |neighbour|
+          alt = dist[node] + 1
+          next unless alt < dist[neighbour]
+
+          dist[neighbour] = alt
+          prev[neighbour] = node
+          q.upsert(neighbour, alt)
+        end
+      end
+      [dist, prev]
+    end
+
+    orbits = Hash.new { |h, k| h[k] = [] } # orbit -> [orbit]
+    ARGF.each_line do |line|
+      orbitee, orbiter = line.chomp.split(')')
+      orbits[orbiter] << orbitee
+      orbits[orbitee] << orbiter
+    end
+
+    dist, _prev = dijkstra(orbits, OBJ_YOU, OBJ_SANTA)
+    puts dist[OBJ_SANTA] - 2

data/data/solutions/github/erikw/2019/07_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/07
+  :solution: |-
+    require_relative 'computer'
+
+    NUM_AMPLIFIERS = 5
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    amplifiers = NUM_AMPLIFIERS.times.map { Computer.new }
+
+    highest = 0
+    (0...NUM_AMPLIFIERS).to_a.permutation do |phases|
+      prev_output = 0
+      (0...NUM_AMPLIFIERS).each do |i|
+        amplifiers[i].stdin << phases[i]
+        amplifiers[i].stdin << prev_output
+        amplifiers[i].execute(intcode)
+        prev_output = amplifiers[i].stdout.pop
+      end
+      highest = [highest, prev_output].max
+    end
+
+    puts highest

data/data/solutions/github/erikw/2019/07_2.yml

@@ -0,0 +1,36 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/07
+  :solution: |-
+    require_relative 'computer'
+
+    NUM_AMPLIFIERS = 5
+    PHASE_RANGE = 5..9
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    prev_stdout = nil
+    amplifiers = []
+    NUM_AMPLIFIERS.times do |_i|
+      amplifiers << Computer.new(stdin: prev_stdout)
+      prev_stdout = amplifiers.last.stdout
+    end
+    amplifiers[0].stdin = amplifiers[-1].stdout
+
+    highest = 0
+    PHASE_RANGE.to_a.permutation do |phases|
+      (0...NUM_AMPLIFIERS).each do |i|
+        amplifiers[i].stdin << phases[i]
+      end
+      amplifiers[0].stdin << 0
+      threads = amplifiers.map do |amp|
+        Thread.new do
+          amp.execute(intcode)
+        end
+      end
+      threads.each { |t| t.join }
+      output = amplifiers.last.stdout.pop
+      highest = [highest, output].max
+    end
+
+    puts highest

data/data/solutions/github/erikw/2019/08_1.yml

@@ -0,0 +1,11 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/08
+  :solution: |-
+    IMG_W = 25
+    IMG_H = 6
+
+    ans = ARGF.readline.chomp.split('').map(&:to_i).each_slice(IMG_W * IMG_H).min_by do |layer|
+      layer.count { |d| d.zero? }
+    end.tally.reject { |k, _v| k == 0 }.values.inject(&:*)
+    puts ans

data/data/solutions/github/erikw/2019/08_2.yml

@@ -0,0 +1,20 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/08
+  :solution: |-
+    IMG_W = 25
+    IMG_H = 6
+
+    COLOR_TRANS = 2
+    PRINT_MAP = { 0 => ' ', 1 => '#' }
+
+    image = ARGF.readline.chomp.split('').map(&:to_i).each_slice(IMG_W * IMG_H).reverse_each.reduce do |img, layer|
+      img.length.times do |i|
+        img[i] = layer[i] unless layer[i] == COLOR_TRANS
+      end
+      img
+    end
+
+    image.map { |d| PRINT_MAP[d] }.each_slice(IMG_W) do |row|
+      puts row.join
+    end

data/data/solutions/github/erikw/2019/09_1.yml

@@ -0,0 +1,15 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/09
+  :solution: |-
+    require_relative 'computer'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    computer = Computer.new
+    computer.stdin << 1
+    computer.execute(intcode)
+
+    output = []
+    output << computer.stdout.pop until computer.stdout.empty?
+    puts output.join(',')