advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,122 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    Unit = Struct.new(:x, :y, :hp, :type) do
+      def elf?
+        type == ?E
+      end
+
+      def enemy_type
+        elf? ? ?G : ?E
+      end
+
+      def pos
+        [x, y]
+      end
+    end
+
+    map = input.split("\n").map(&:chars)
+
+    units = []
+
+    map.each.with_index do |row, y|
+      row.each.with_index do |cell, x|
+        case cell
+        when ?.
+        when ?G
+          units << Unit.new(x, y, 200, cell)
+        when ?E
+          units << Unit.new(x, y, 200, cell)
+        when ?#
+        end
+      end
+    end
+
+    # Reading order - U, L, R, D
+    def adjacent(x, y, map)
+      [[x, y - 1], [x - 1, y], [x + 1, y], [x, y + 1]].select do |x, y|
+        (0..map.length-1).cover?(y) &&
+          (0..map[0].length-1).cover?(x)
+      end
+    end
+
+    def chosen(x, y, enemy_type, map)
+      bfs(x, y, map, ->(x1, y1) { map[y1][x1] == enemy_type })
+    end
+
+    def next_step(x, y, xt, yt, map)
+      bfs(x, y, map, ->(x1, y1) { x1 == xt && y1 == yt })
+    end
+
+    def bfs(x, y, map, goal)
+      stack = [[x, y]]
+      visited = Set.new
+
+      while stack.any?
+        x, y = stack.shift
+
+        adjacent(x, y, map).each do |x1, y1|
+          return [x, y] if goal.call(x1, y1)
+          next if visited.include?([x1, y1]) || map[y1][x1] != ?.
+          visited.add([x1, y1])
+          stack.push [x1, y1]
+        end
+      end
+    end
+
+    def print_map(map)
+      puts map.map(&:join).join("\n")
+    end
+
+    rounds = 0
+
+    loop do
+      units.sort_by { |unit| [unit.y, unit.x] }.each do |unit|
+        # Chose nearest reachable position adjacent to enemy
+        # (reading order breaks ties)
+        chosen_pos = chosen(*unit.pos, unit.enemy_type, map)
+
+        # Move towards the chosen position (shortest path)
+        if chosen_pos && chosen_pos != unit.pos
+          sx, sy = next_step(*chosen_pos, *unit.pos, map)
+
+          map[unit.y][unit.x] = ?.
+          map[sy][sx] = unit.type
+
+          unit.x = sx
+          unit.y = sy
+        end
+
+        # Target adjacent enemy with lowest hp (reading order breaks ties)
+        target_unit = units
+          .select { |target| target.type == unit.enemy_type }
+          .select { |target| adjacent(*unit.pos, map).include?(target.pos) }
+          .sort_by { |unit| [unit.hp, unit.y, unit.x] }
+          .first
+
+        # Attack if there is an adjacent enemy
+        if target_unit
+          target_unit.hp -= 3
+          if target_unit.hp <= 0
+            units.delete(target_unit)
+            map[target_unit.y][target_unit.x] = ?.
+          end
+        end
+      end
+
+      print_map(map)
+
+      break if units.partition(&:elf?).any?(&:empty?)
+
+      rounds += 1
+    end
+
+    hp = units.map(&:hp).sum
+
+    puts rounds
+    puts hp
+
+    puts hp * rounds

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

@@ -0,0 +1,135 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    Unit = Struct.new(:x, :y, :hp, :type) do
+      def elf?
+        type == ?E
+      end
+
+      def enemy_type
+        elf? ? ?G : ?E
+      end
+
+      def pos
+        [x, y]
+      end
+    end
+
+    # Reading order - U, L, R, D
+    def adjacent(x, y, map)
+      [[x, y - 1], [x - 1, y], [x + 1, y], [x, y + 1]].select do |x, y|
+        (0..map.length-1).cover?(y) &&
+          (0..map[0].length-1).cover?(x)
+      end
+    end
+
+    def chosen(x, y, enemy_type, map)
+      bfs(x, y, map, ->(x1, y1) { map[y1][x1] == enemy_type })
+    end
+
+    def next_step(x, y, xt, yt, map)
+      bfs(x, y, map, ->(x1, y1) { x1 == xt && y1 == yt })
+    end
+
+    def bfs(x, y, map, goal)
+      stack = [[x, y]]
+      visited = Set.new
+
+      while stack.any?
+        x, y = stack.shift
+
+        adjacent(x, y, map).each do |x1, y1|
+          return [x, y] if goal.call(x1, y1)
+          next if visited.include?([x1, y1]) || map[y1][x1] != ?.
+          visited.add([x1, y1])
+          stack.push [x1, y1]
+        end
+      end
+    end
+
+    def print_map(map)
+      puts map.map(&:join).join("\n")
+    end
+
+    def battle(units, map, elf_power)
+      rounds = 0
+
+      loop do
+        units.sort_by { |unit| [unit.y, unit.x] }.each do |unit|
+          # Chose nearest reachable position adjacent to enemy
+          # (reading order breaks ties)
+          chosen_pos = chosen(*unit.pos, unit.enemy_type, map)
+
+          # Move towards the chosen position (shortest path)
+          if chosen_pos && chosen_pos != unit.pos
+            sx, sy = next_step(*chosen_pos, *unit.pos, map)
+
+            map[unit.y][unit.x] = ?.
+            map[sy][sx] = unit.type
+
+            unit.x = sx
+            unit.y = sy
+          end
+
+          # Target adjacent enemy with lowest hp (reading order breaks ties)
+          target_unit = units
+            .select { |target| target.type == unit.enemy_type }
+            .select { |target| adjacent(*unit.pos, map).include?(target.pos) }
+            .sort_by { |unit| [unit.hp, unit.y, unit.x] }
+            .first
+
+          # Attack if there is an adjacent enemy
+          if target_unit
+            target_unit.hp -= unit.elf? ? elf_power : 3
+            if target_unit.hp <= 0
+              units.delete(target_unit)
+              map[target_unit.y][target_unit.x] = ?.
+            end
+          end
+        end
+
+        print_map(map)
+
+        break if units.partition(&:elf?).any?(&:empty?)
+
+        rounds += 1
+      end
+
+      hp = units.map(&:hp).sum
+
+      #puts rounds
+      #puts hp
+
+      units.map(&:hp).sum * rounds
+    end
+
+    (3..200).each do |elf_power|
+      map = input.split("\n").map(&:chars)
+
+      units = []
+
+      map.each.with_index do |row, y|
+        row.each.with_index do |cell, x|
+          case cell
+          when ?.
+          when ?G
+            units << Unit.new(x, y, 200, cell)
+          when ?E
+            units << Unit.new(x, y, 200, cell)
+          when ?#
+          end
+        end
+      end
+
+      num_elves = units.count(&:elf?)
+
+      battle(units, map, elf_power)
+
+      if units.count(&:elf?) == num_elves
+        puts elf_power
+        exit
+      end
+    end

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

@@ -0,0 +1,115 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    samples = input.split(/\n{2,3}/)
+    instructions = samples.pop.split("\n")
+
+    def operation(reg, op, a, b, c)
+      case op
+      when 'addr'
+        reg[c] = reg[a] + reg[b]
+      when 'addi'
+        reg[c] = reg[a] + b
+      when 'mulr'
+        reg[c] = reg[a] * reg[b]
+      when 'muli'
+        reg[c] = reg[a] * b
+      when 'banr'
+        reg[c] = reg[a] & reg[b]
+      when 'bani'
+        reg[c] = reg[a] & b
+      when 'boor'
+        reg[c] = reg[a] | reg[b]
+      when 'bori'
+        reg[c] = reg[a] | b
+      when 'setr'
+        reg[c] = reg[a]
+      when 'seti'
+        reg[c] = a
+      when 'gtir'
+        reg[c] = a > reg[b] ? 1 : 0
+      when 'gtri'
+        reg[c] = reg[a] > b ? 1 : 0
+      when 'gtrr'
+        reg[c] = reg[a] > reg[b] ? 1 : 0
+      when 'eqir'
+        reg[c] = a == reg[b] ? 1 : 0
+      when 'eqri'
+        reg[c] = reg[a] == b ? 1 : 0
+      when 'eqrr'
+        reg[c] = reg[a] == reg[b] ? 1 : 0
+      end
+
+      reg
+    end
+
+    ops = %w(addr addi mulr muli banr bani boor bori setr seti gtir gtri
+      gtrr eqir eqri eqrr)
+
+    possible_codes = []
+
+    count = 0
+
+    samples.each do |sample|
+      before, instr, after = sample.split("\n")
+
+      before = before.scan(/\[(.*)\]/).flatten.first.split(",").map(&:to_i)
+      after = after.scan(/\[(.*)\]/).flatten.first.split(",").map(&:to_i)
+
+      code, a, b, c = instr.split(" ").map(&:to_i)
+
+      matches = 0
+      matching_ops = []
+
+      ops.each do |op|
+        output = operation(before.clone, op, a, b, c)
+
+        if output == after
+          matches += 1
+          matching_ops << op
+        end
+      end
+
+      if possible_codes[code].nil?
+        possible_codes[code] = matching_ops
+      else
+        possible_codes[code] &= matching_ops
+      end
+
+      count += 1 if matches >= 3
+    end
+
+    puts count # part 1 solution
+
+    # Depth-first search
+    # Didn't needed to do this as there was an opcode with only one possibility
+    def find_solution(possibilities, *rest)
+      return [possibilities.first] if rest.empty?
+
+      possibilities.each do |inst|
+        copy = rest.map(&:clone)
+
+        copy.each { |instrs| instrs.delete(inst) }
+
+        codes = [inst].concat(find_solution(*copy))
+
+        return codes if codes.none?(&:nil?)
+      end
+
+      [nil]
+    end
+
+    op_codes = find_solution(*possible_codes)
+
+    reg = [0, 0, 0, 0]
+
+    instructions.each do |instruction|
+      op_code, a, b, c = instruction.split(" ").map(&:to_i)
+      next if op_code.nil?
+      reg = operation(reg, op_codes[op_code], a, b, c)
+    end
+
+    puts reg[0] # part 2 solution

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

@@ -0,0 +1,115 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    samples = input.split(/\n{2,3}/)
+    instructions = samples.pop.split("\n")
+
+    def operation(reg, op, a, b, c)
+      case op
+      when 'addr'
+        reg[c] = reg[a] + reg[b]
+      when 'addi'
+        reg[c] = reg[a] + b
+      when 'mulr'
+        reg[c] = reg[a] * reg[b]
+      when 'muli'
+        reg[c] = reg[a] * b
+      when 'banr'
+        reg[c] = reg[a] & reg[b]
+      when 'bani'
+        reg[c] = reg[a] & b
+      when 'boor'
+        reg[c] = reg[a] | reg[b]
+      when 'bori'
+        reg[c] = reg[a] | b
+      when 'setr'
+        reg[c] = reg[a]
+      when 'seti'
+        reg[c] = a
+      when 'gtir'
+        reg[c] = a > reg[b] ? 1 : 0
+      when 'gtri'
+        reg[c] = reg[a] > b ? 1 : 0
+      when 'gtrr'
+        reg[c] = reg[a] > reg[b] ? 1 : 0
+      when 'eqir'
+        reg[c] = a == reg[b] ? 1 : 0
+      when 'eqri'
+        reg[c] = reg[a] == b ? 1 : 0
+      when 'eqrr'
+        reg[c] = reg[a] == reg[b] ? 1 : 0
+      end
+
+      reg
+    end
+
+    ops = %w(addr addi mulr muli banr bani boor bori setr seti gtir gtri
+      gtrr eqir eqri eqrr)
+
+    possible_codes = []
+
+    count = 0
+
+    samples.each do |sample|
+      before, instr, after = sample.split("\n")
+
+      before = before.scan(/\[(.*)\]/).flatten.first.split(",").map(&:to_i)
+      after = after.scan(/\[(.*)\]/).flatten.first.split(",").map(&:to_i)
+
+      code, a, b, c = instr.split(" ").map(&:to_i)
+
+      matches = 0
+      matching_ops = []
+
+      ops.each do |op|
+        output = operation(before.clone, op, a, b, c)
+
+        if output == after
+          matches += 1
+          matching_ops << op
+        end
+      end
+
+      if possible_codes[code].nil?
+        possible_codes[code] = matching_ops
+      else
+        possible_codes[code] &= matching_ops
+      end
+
+      count += 1 if matches >= 3
+    end
+
+    puts count # part 1 solution
+
+    # Depth-first search
+    # Didn't needed to do this as there was an opcode with only one possibility
+    def find_solution(possibilities, *rest)
+      return [possibilities.first] if rest.empty?
+
+      possibilities.each do |inst|
+        copy = rest.map(&:clone)
+
+        copy.each { |instrs| instrs.delete(inst) }
+
+        codes = [inst].concat(find_solution(*copy))
+
+        return codes if codes.none?(&:nil?)
+      end
+
+      [nil]
+    end
+
+    op_codes = find_solution(*possible_codes)
+
+    reg = [0, 0, 0, 0]
+
+    instructions.each do |instruction|
+      op_code, a, b, c = instruction.split(" ").map(&:to_i)
+      next if op_code.nil?
+      reg = operation(reg, op_codes[op_code], a, b, c)
+    end
+
+    puts reg[0] # part 2 solution

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

@@ -0,0 +1,96 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-17
+  :solution: |-
+    input     = File.read(file_path)
+
+    clay_locations = input.split("\n").map do |clay|
+      clay.split(", ")
+    end
+
+    x, y = clay_locations.flatten.partition { |clay| clay[0] == ?x }
+
+    xs = x.map { |x| x.scan(/\d+/) }.flatten.map(&:to_i)
+    ys = y.map { |x| x.scan(/\d+/) }.flatten.map(&:to_i)
+
+    x_min = xs.min - 1
+    x_max = xs.max + 1
+
+    y_min, y_max = ys.minmax
+
+    width = x_max - x_min + 1
+    height = y_max + 1
+
+    grid = Array.new(height) { Array.new(width, ?.) }
+
+    clay_locations.each do |from, to|
+      range = Range.new(*to.scan(/\d+/).map(&:to_i))
+      from_idx = from.scan(/\d+/)[0].to_i
+
+      range.each do |idx|
+        if from[0] == ?x
+          grid[idx][from_idx - x_min] = ?#
+        else
+          grid[from_idx][idx - x_min] = ?#
+        end
+      end
+    end
+
+    def flow(grid, x, y)
+      while grid[y + 1][x] == ?.
+        y += 1
+        grid[y][x] = ?|
+        return if y + 1 == grid.length
+        return if grid[y + 1][x] == ?|
+      end
+
+      left = x
+      right = x
+
+      # Rest water
+      loop do
+        # Find left/right clay or no bottom water/clay
+        left = x
+
+        while left > 0 && grid[y][left - 1].match(/[\.\|]/) && grid[y + 1][left - 1] != ?.
+          left -= 1
+        end
+
+        right = x
+
+        while right < grid[0].length && grid[y][right + 1].match(/[\.\|]/) && grid[y + 1][right + 1] != ?.
+          right += 1
+        end
+
+        # No left and right clay
+        break if grid[y][left - 1] == ?. || grid[y][right + 1] == ?.
+
+        (left..right).each do |idx|
+          grid[y][idx] = ?~
+        end
+
+        y -= 1
+      end
+
+      # Overflow
+      (left..right).each do |idx|
+        grid[y][idx] = ?|
+      end
+
+      # Overflow right
+      if grid[y][right + 1] == ?.
+        grid[y][right + 1] = ?|
+        flow(grid, right + 1, y)
+      end
+
+      # Overflow left
+      if grid[y][left - 1] == ?.
+        grid[y][left - 1] = ?|
+        flow(grid, left - 1, y)
+      end
+    end
+
+    flow(grid, 500 - x_min, 0)
+
+    puts grid[y_min..-1].flatten.count { |cell| cell == ?| || cell == ?~ } # part 1
+    puts grid[y_min..-1].flatten.count { |cell| cell == ?~ } # part 2

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

@@ -0,0 +1,96 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-17
+  :solution: |-
+    input     = File.read(file_path)
+
+    clay_locations = input.split("\n").map do |clay|
+      clay.split(", ")
+    end
+
+    x, y = clay_locations.flatten.partition { |clay| clay[0] == ?x }
+
+    xs = x.map { |x| x.scan(/\d+/) }.flatten.map(&:to_i)
+    ys = y.map { |x| x.scan(/\d+/) }.flatten.map(&:to_i)
+
+    x_min = xs.min - 1
+    x_max = xs.max + 1
+
+    y_min, y_max = ys.minmax
+
+    width = x_max - x_min + 1
+    height = y_max + 1
+
+    grid = Array.new(height) { Array.new(width, ?.) }
+
+    clay_locations.each do |from, to|
+      range = Range.new(*to.scan(/\d+/).map(&:to_i))
+      from_idx = from.scan(/\d+/)[0].to_i
+
+      range.each do |idx|
+        if from[0] == ?x
+          grid[idx][from_idx - x_min] = ?#
+        else
+          grid[from_idx][idx - x_min] = ?#
+        end
+      end
+    end
+
+    def flow(grid, x, y)
+      while grid[y + 1][x] == ?.
+        y += 1
+        grid[y][x] = ?|
+        return if y + 1 == grid.length
+        return if grid[y + 1][x] == ?|
+      end
+
+      left = x
+      right = x
+
+      # Rest water
+      loop do
+        # Find left/right clay or no bottom water/clay
+        left = x
+
+        while left > 0 && grid[y][left - 1].match(/[\.\|]/) && grid[y + 1][left - 1] != ?.
+          left -= 1
+        end
+
+        right = x
+
+        while right < grid[0].length && grid[y][right + 1].match(/[\.\|]/) && grid[y + 1][right + 1] != ?.
+          right += 1
+        end
+
+        # No left and right clay
+        break if grid[y][left - 1] == ?. || grid[y][right + 1] == ?.
+
+        (left..right).each do |idx|
+          grid[y][idx] = ?~
+        end
+
+        y -= 1
+      end
+
+      # Overflow
+      (left..right).each do |idx|
+        grid[y][idx] = ?|
+      end
+
+      # Overflow right
+      if grid[y][right + 1] == ?.
+        grid[y][right + 1] = ?|
+        flow(grid, right + 1, y)
+      end
+
+      # Overflow left
+      if grid[y][left - 1] == ?.
+        grid[y][left - 1] = ?|
+        flow(grid, left - 1, y)
+      end
+    end
+
+    flow(grid, 500 - x_min, 0)
+
+    puts grid[y_min..-1].flatten.count { |cell| cell == ?| || cell == ?~ } # part 1
+    puts grid[y_min..-1].flatten.count { |cell| cell == ?~ } # part 2