require "set" require "minitest" require "minitest/pride" class EndCombat < StandardError; end class Combat def initialize(map, elf_attack) @map = map @attack = { Elf => elf_attack, Goblin => 3, } end def fight return enum_for(__method__) unless block_given? yield @map loop do turn_order.each do |pos| next if @map[pos].nil? # don't take a turn for units that just died turn = Turn.new(@map, pos) if move = turn.move unit = @map.delete(pos) @map[move] = unit turn.pos = move end if attack = turn.attack unit = @map.fetch(turn.pos) target = @map.fetch(attack) target.hp -= @attack.fetch(unit.class) @map.delete(attack) if target.hp <= 0 end end yield @map end rescue EndCombat # yield @map end def turn_order @map.units.keys.sort end end class TestCombat < Minitest::Test def test_move map = Map.parse(<<~MAP) ######### #G..G..G# #.......# #.......# #G..E..G# #.......# #.......# #G..G..G# ######### MAP combat = Combat.new(map, 3) rounds = combat.fight rounds.next # skip the first round assert_equal <<~MAP.chomp, rounds.next.to_s ######### #.G...G.# #...G...# #...E..G# #.G.....# #.......# #G..G..G# #.......# ######### MAP assert_equal <<~MAP.chomp, rounds.next.to_s ######### #..G.G..# #...G...# #.G.E.G.# #.......# #G..G..G# #.......# #.......# ######### MAP assert_equal <<~MAP.chomp, rounds.next.to_s ######### #.......# #..GGG..# #..GEG..# #G..G...# #......G# #.......# #.......# ######### MAP end def test_fight map = Map.parse(<<~MAP) ####### #.G...# #...EG# #.#.#G# #..G#E# #.....# ####### MAP combat = Combat.new(map, 3) rounds = combat.fight rounds.next # skip the initial state rounds.next # skip the first found map = rounds.next # second round assert_equal 188, map.fetch(Position[2,4]).hp 20.times { rounds.next } assert_equal <<~MAP.chomp, rounds.next.to_s ####### #...G.# #..G.G# #.#.#G# #...#E# #.....# ####### MAP end def test_turn_order map = Map.parse(<<~MAP) ####### #.G.E.# #E.G.E# #.G.E.# ####### MAP combat = Combat.new(map, 3) expected = [[1,2], [1,4], [2,1], [2,3], [2,5], [3,2], [3,4]].map {|pos| Position[*pos]} assert_equal expected, combat.turn_order end end class Turn attr_accessor :pos def initialize(map, pos) @map, @pos = map, pos @unit = @map.fetch(@pos) end def move raise EndCombat if targets.empty? return if can_attack? return if nearest.empty? chosen = nearest.min haystack = @map.in_range(@pos) dijkstra(chosen) .select {|pos,_| haystack.include?(pos) } .min_by {|pos,distance| [distance, pos] } .first end def attack attackable.min_by {|pos, target| [target.hp, pos] }&.first end def targets @map.units.select {|_, other| other.is_a?(@unit.enemy) } end def attackable targets.select {|pos, _| @pos.adjacent.include?(pos) } end def can_attack? !attackable.empty? end def in_range targets.flat_map {|pos, _| @map.in_range(pos) }.uniq end def reachable dijkstra(@pos).select {|pos,_| in_range.include?(pos) } end def nearest nearest = Hash.new {|h,k| h[k] = [] } reachable.each do |pos, distance| nearest[distance] << pos end return [] if nearest.empty? nearest.min_by(&:first).last end private def dijkstra(pos) distances = { pos => 0 } queue = [ pos ] while pos = queue.shift distance = distances.fetch(pos) + 1 @map.in_range(pos).reject {|pos| distances.has_key?(pos) }.each do |pos| distances[pos] = distance queue << pos end end distances end end class TestTurn < Minitest::Test def setup map = Map.parse(<<~MAP) ####### #E..G.# #...#.# #.G.#G# ####### MAP @turn = Turn.new(map, Position[1,1]) end def test_targets assert_equal [[1,4], [3,2], [3,5]].to_set, @turn.targets.keys.map(&:to_a).to_set end def test_in_range assert_equal [[1,3], [1,5], [2,2], [2,5], [3,1], [3,3]].to_set, @turn.in_range.map(&:to_a).to_set end def test_reachable assert_equal [[1,3], [2,2], [3,1], [3,3]].to_set, @turn.reachable.keys.map(&:to_a).to_set end def test_nearest assert_equal [[1,3], [2,2], [3,1]].to_set, @turn.nearest.map(&:to_a).to_set end def test_move assert_equal Position[1,2], @turn.move turn = Turn.new(Map.parse(<<~MAP), Position[1,2]) ####### #.E...# #.....# #...G.# ####### MAP assert_equal Position[1,3], turn.move end end class Map def self.parse(s) occupied = {} s.chomp.lines.each.with_index do |row, y| row.chomp.chars.each.with_index do |square, x| case square when ?# occupied[Position[y, x]] = Wall.new when ?E occupied[Position[y, x]] = Elf.new when ?G occupied[Position[y, x]] = Goblin.new when ?. else fail "Invalid character: #{square.inspect}" end end end self.new(occupied) end def initialize(occupied) @occupied = occupied end def [](pos) @occupied[pos] end def []=(pos, square) @occupied[pos] = square end def fetch(pos) @occupied.fetch(pos) end def delete(pos) @occupied.delete(pos) end def units @occupied.select {|_, sq| sq.is_a?(Unit) } end def in_range(pos) pos .adjacent .reject {|pos| @occupied.has_key?(pos) } end def to_s max_y = @occupied.keys.map(&:y).max max_x = @occupied.keys.map(&:x).max (0..max_y).map {|y| (0..max_x).map {|x| case @occupied[Position[y, x]] when Wall ?# when Elf ?E when Goblin ?G when nil ?. else fail "Unexpected object: #{@occupied[Position[y, x]]}" end }.join }.join(?\n) end end class TestMap < Minitest::Test def test_parse map = Map.parse(<<~MAP) ####### #E..G.# #...#.# #.G.#G# ####### MAP assert_instance_of Wall, map[Position[0,0]] assert_instance_of Wall, map[Position[2,4]] assert_instance_of Wall, map[Position[4,6]] assert_instance_of Elf, map[Position[1,1]] assert_instance_of Goblin, map[Position[1,4]] assert_instance_of Goblin, map[Position[3,5]] assert_nil map[Position[1,2]] assert_nil map[Position[2,5]] end def test_units map = Map.parse(<<~MAP) ####### #E..G.# #...#.# #.G.#G# ####### MAP assert_equal 4, map.units.length end end Position = Struct.new(:y, :x) do def self.[](y, x) self.new(y, x) end def <=>(other) [self.y, self.x] <=> [other.y, other.x] end def adjacent [-1, 1] .flat_map {|d| [[y, x+d], [y+d, x]] } .map {|pos| Position[*pos] } end def to_a [y, x] end def to_s to_a.to_s end end class Unit attr_accessor :hp def initialize @hp = 200 end def to_s "#{self.class.name.chars.first}(#{hp})" end end class Wall end class Elf < Unit def enemy Goblin end end class Goblin < Unit def enemy Elf end end def solve(input) (3..Float::INFINITY).each do |elf_attack| map = Map.parse(input) outcome = simulate(map, elf_attack) next if outcome.nil? return outcome end end def simulate(map, elf_attack) elf_count = map.units.count {|_, unit| unit.is_a?(Elf) } combat = Combat.new(map, elf_attack) map, count = combat.fight.map.with_index .inject(nil) {|last,(map,count)| return if map.units.count {|_, unit| unit.is_a?(Elf) } < elf_count # puts map, map.units.values.map(&:to_s).inspect [map, count] } return if map.units.count {|_, unit| unit.is_a?(Elf) } < elf_count map.units.values.map(&:hp).sum * count end class TestSolve < Minitest::Test def test_solve # assert_equal 27730, solve(<<~INPUT) assert_equal 4988, solve(<<~INPUT) ####### #.G...# #...EG# #.#.#G# #..G#E# #.....# ####### INPUT # assert_equal 36334, solve(<<~INPUT) ######## ##G..#E# ##E#E.E# ##G.##.# ##...#E# ##...E.# ######## #INPUT # assert_equal 39514, solve(<<~INPUT) assert_equal 31284, solve(<<~INPUT) ####### #E..EG# #.#G.E# #E.##E# #G..#.# #..E#.# ####### INPUT # assert_equal 27755, solve(<<~INPUT) assert_equal 3478, solve(<<~INPUT) ####### #E.G#.# #.#G..# #G.#.G# #G..#.# #...E.# ####### INPUT # assert_equal 28944, solve(<<~INPUT) assert_equal 6474, solve(<<~INPUT) ####### #.E...# #.#..G# #.###.# #E#G#G# #...#G# ####### INPUT # assert_equal 18740, solve(<<~INPUT) assert_equal 1140, solve(<<~INPUT) ######### #G......# #.E.#...# #..##..G# #...##..# #...#...# #.G...G.# #.....G.# ######### INPUT end end if __FILE__ == $0 require "minitest/autorun" and exit if ENV["TEST"] puts solve(ARGF.read) end