day15.cr

@@ -1,282 +0,0 @@
-require "./common.cr"
-
-lines = STDIN.gets_to_end.split("\n")
-lines.pop
-
-units = [] of NamedTuple(type: Symbol, power: Int32, hp: Int32, x: Int32, y: Int32)
-lines.each_with_index do |line, y|
-  line.each_char_with_index do |char, x|
-    units << { type: :elf, power: 3, hp: 200, x: x, y: y } if char == 'E'
-    units << { type: :goblin, power: 3, hp: 200, x: x, y: y } if char == 'G'
-  end
-end
-map = lines.map &.chars
-
-alias Spot = NamedTuple(x: Int32, y: Int32)
-
-def nearby_spots(map, x, y)
-  spots = [] of Spot
-  spots << { x: x, y: y - 1} if y > 0
-  spots << { x: x - 1, y: y } if x > 0
-  spots << { x: x + 1, y: y } if x < map[0].size - 1
-  spots << { x: x, y: y + 1} if y < map.size - 1
-  return spots
-end
-
-def all_open_spots(map, units, type)
-  open_spots = [] of Spot
-  units.select &.[:type].==(type)
-  units.each do |unit|
-    next unless unit[:type] == type
-    x = unit[:x]
-    y = unit[:y]
-
-    open_spots.concat nearby_spots(map, x, y)
-  end
-  open_spots.select! do |spot|
-    map[spot[:y]][spot[:x]] != '#'
-  end
-  sort_reading_order(open_spots)
-  return open_spots
-end
-
-def sort_reading_order(collection)
-  collection.sort_by! do |item|
-    item[:y] * 100 + item[:x]
-  end
-end
-
-def in_range(map, units, spot, type)
-  nearby_spots(map, spot[:x], spot[:y]).select do |spot|
-    units.any? { |u| u[:x] == spot[:x] && u[:y] == spot[:y] && u[:type] == type }
-  end
-end
-
-def occupied(map, units, x, y)
-  return (map[y][x] == '#') || units.any? { |u| (u[:x] == x) && (u[:y] == y) }
-end
-
-def filter_reachable(map, units, start_spot, open_spots)
-  open_spots.select do |spot|
-    shortest_path(map, units, start_spot, spot)
-  end
-end
-
-def opposite_type(type)
-  return :goblin if type == :elf
-  return :elf
-end
-
-def dist(one, other)
-  (one[:x] - other[:x]).abs + (one[:y] - other[:y]).abs
-end
-
-def path(came_from : Hash(T|R, T|R), start : R) forall T, R
-  path = [ start ] of (T|R)
-  while came_from.has_key? start
-    start = came_from[start]
-    path << start
-  end
-  return path.reverse!
-end
-
-def astart_path(map, units, from, to)
-  done = Set(Spot).new
-  open = Set(Spot).new
-  start = {x: from[:x], y: from[:y] }
-  open << start
-  fscore = {} of Spot => Int32
-  gscore = { start => 0 }
-  came_from = {} of Spot => Spot
-  while !open.empty?
-    min = open.min_by { |spot| fscore[spot]? || 100000000 }
-    return path(came_from, min) if min == to
-
-    open.delete min
-    done << min
-
-    min_gscore = gscore[min]? || (100000000)
-    nearby_spots(map, min[:x], min[:y]).select { |spot| !occupied(map, units, spot[:x], spot[:y]) }.each do |neighbor|
-      next if done.includes? neighbor
-      neighbor_gscore = gscore[neighbor]? || (100000000)
-      new_score = min_gscore + 1
-      open << neighbor if !open.includes? neighbor
-      next if new_score >= neighbor_gscore
-
-
-      came_from[neighbor] = min
-      gscore[neighbor] = new_score
-      fscore[neighbor] = new_score + (neighbor[:y] - min[:y]) * 2 + (neighbor[:x] - min[:x]) # + (dist(neighbor, to)) # + ((neighbor[:y] - min[:y]) * 10))
-    end
-  end
-end
-
-def shortest_path(map, units, from, to)
-  visited = Set(Spot).new
-  open = Deque(Spot).new(1, { x: from[:x], y: from[:y] } )
-  from_hash = {} of Spot => Spot
-  return [{ x: from[:x], y: from[:y] }] if from[:x] == to[:x] && from[:y] == to[:y]
-
-  while !visited.includes?(to) && !open.empty?
-    current = open.first
-    open.delete current
-    visited << current
-    x, y = current[:x], current[:y]
-
-    nearby_spots(map, x, y).each do |it|
-      next if visited.includes? it
-      visited << it
-      next if occupied(map, units, it[:x], it[:y])
-      from_hash[it] = current
-      open << it
-    end
-  end
-  return path(from_hash, to) if visited.includes? to
-  return nil
-end
-
-def moved_unit(map, units, unit)
-  all_spots = all_open_spots(map, units, opposite_type(unit[:type]))
-  # puts "all spots: #{all_spots}"
-  all_spots.select! do |spot|
-    next true if spot[:x] == unit[:x] && spot[:y] == unit[:y]
-    next !occupied(map, units, spot[:x], spot[:y])
-  end
-  # puts "spots not occupied: #{all_spots}"
-  all_paths = all_spots.compact_map do |spot|
-    shortest_path(map, units, unit, spot)
-  end
-  # puts "all paths: #{all_paths}"
-  path = all_paths.min_by? &.size
-  # puts "picked path: #{path}"
-  new_spot = path.try &.[1]?
-  return unit unless new_spot
-  return { x: new_spot[:x], y: new_spot[:y], power: unit[:power], hp: unit[:hp], type: unit[:type] }
-end
-
-def unit_at?(units, x, y)
-  units.select { |u| u[:x] == x && u[:y] == y }.first?
-end
-
-def unit_at(units, x, y)
-  units.select { |u| u[:x] == x && u[:y] == y }.first
-end
-
-def attacked_unit(map, units, unit)
-  all_spots = nearby_spots(map, unit[:x], unit[:y])
-  enemy_spots = all_spots.select! do |spot|
-    next false unless enemy = unit_at?(units, spot[:x], spot[:y])
-    enemy[:type] == opposite_type(unit[:type])
-  end
-  return nil if enemy_spots.empty?
-  min_hp = enemy_spots.min_of do |spot|
-    unit_at(units, spot[:x], spot[:y])[:hp]
-  end
-  enemy_spots.select! do |spot|
-    unit_at(units, spot[:x], spot[:y])[:hp] == min_hp
-  end
-  return nil if enemy_spots.empty?
-
-  sort_reading_order(enemy_spots)
-  attacked_spot = enemy_spots[0]
-  attacked_index = units.index do |unit|
-    unit[:x] == attacked_spot[:x] && unit[:y] == attacked_spot[:y]
-  end
-  return nil unless attacked_index
-  attacked_unit = units[attacked_index]
-  return { attacked_index, { x: attacked_unit[:x],
-                             y: attacked_unit[:y],
-                             power: attacked_unit[:power],
-                             hp: attacked_unit[:hp] - unit[:power],
-                             type: attacked_unit[:type] } }
-end
-
-def draw(map, units)
-  min_x = 0
-  max_x = map[0].size - 1
-  min_y = 0
-  max_y = map.size - 1
-
-  (min_y..max_y).each do |y|
-    (min_x..max_x).each do |x|
-      unit = unit_at?(units, x, y)
-      if unit
-        STDOUT << ((unit[:type] == :elf) ? 'E' : 'G')
-      else
-        STDOUT << (map[y][x] == '#' ? '#' : '.')
-      end
-    end
-    puts
-  end
-end
-
-def step(map, units)
-  sort_reading_order(units)
-  index = 0
-  elf_death_count = 0
-  while index < units.size
-    return nil if (units.count &.[:type].==(:elf)) == 0
-    return nil if (units.count &.[:type].==(:goblin)) == 0 
-
-    unit = units[index]
-    unit = moved_unit(map, units, unit)
-    units[index] = unit
-    attacked_u = attacked_unit(map, units, unit)
-    if attacked_u
-      attacked_index, attacked_unit = attacked_u
-      if attacked_unit[:hp] <= 0
-        elf_death_count += 1 if attacked_unit[:type] == :elf
-        units.delete_at attacked_index
-        index -= 1 if index >= attacked_index
-      else
-        units[attacked_index] = attacked_unit
-      end
-    end
-    index += 1
-  end
-
-  return elf_death_count
-end
-
-def check_win(units)
-  current_winning = nil
-  units.each do |u|
-    if current_winning
-      return nil if current_winning != u[:type]
-    else
-      current_winning = u[:type]
-    end
-  end
-  return current_winning
-end
-
-def winning_score(units, type)
-  units.select(&.[:type].==(type)).sum &.[:hp]
-end
-
-power = 3
-loop do
-  simulating_units = units.dup.map do |unit|
-    next unit unless unit[:type] == :elf
-    { x: unit[:x], y: unit[:y], hp: unit[:hp], type: :elf, power: power }
-  end
-  steps = 0
-  died = false
-  # draw(map, simulating_units)
-  until won = check_win(simulating_units) || died
-    result = step(map, simulating_units)
-    if result
-      steps += 1 
-      died = result > 0
-    end
-    # draw(map, simulating_units)
-    sort_reading_order(simulating_units)
-    # simulating_units.each do |unit|
-    #   puts "health (#{unit[:type]}): #{unit[:hp]}"
-    # end
-    # puts "-- (end of roun #{steps})"
-  end
-  puts "(power: #{power}) #{steps} * #{winning_score(simulating_units, won)} = #{steps * winning_score(simulating_units, won)}"
-  break if !died && won != :goblin
-  power += 1
-end