advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,117 @@
+---
+- :name: day-23-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-23
+  :solution: |-
+    input = File.read(file_path)
+
+    bots = input.split("\n")
+
+    class Bot
+      attr_reader :x, :y, :z, :r
+
+      def initialize(x, y, z, r)
+        @x = x
+        @y = y
+        @z = z
+        @r = r
+      end
+
+      def intersect?(xr, yr, zr)
+        distance_to_edge(x, xr.first, xr.last) +
+          distance_to_edge(y, yr.first, yr.last) +
+          distance_to_edge(z, zr.first, zr.last) <= r
+      end
+
+      def distance_to_edge(a, min, max)
+        if a >= min && a < max
+          0
+        elsif a < min
+          min - a
+        else
+          a - max + 1
+        end
+      end
+    end
+
+    class Cube
+      attr_reader :x, :y, :z, :count
+
+      def initialize(x, y, z, count = nil)
+        @x = x
+        @y = y
+        @z = z
+        @count = count
+      end
+
+      def divide
+        x_mid = (x.last + x.first) / 2
+
+        x0 = x.first..x_mid
+        x1 = x_mid..x.last
+
+        y_mid = (y.last + y.first) / 2
+
+        y0 = y.first..y_mid
+        y1 = y_mid..y.last
+
+        z_mid = (z.last + z.first) / 2
+
+        z0 = z.first..z_mid
+        z1 = z_mid..z.last
+
+        [[x0, x1], [y0, y1], [z0, z1]]
+          .inject(&:product).map(&:flatten)
+      end
+
+      def size
+        x.size - 1
+      end
+    end
+
+    bots.map! do |bot|
+      x, y, z, r = bot.scan(/-*\d+/).map(&:to_i)
+
+      Bot.new(x, y, z, r)
+    end
+
+    x = Range.new *bots.map(&:x).minmax
+    y = Range.new *bots.map(&:y).minmax
+    z = Range.new *bots.map(&:z).minmax
+
+    max_range = [x, y, z].sort_by(&:size).last
+
+    cube_width = (max_range.size.to_f ** 0.5).ceil ** 2
+
+    range = (-cube_width / 2)..(cube_width / 2)
+
+    cube = Cube.new(range, range, range, bots.size)
+
+    queue = [cube]
+
+    best = nil
+
+    # 1. Split search space into 8 cubes
+    # 2. Continue spliting each cube into smaller cubes
+    # 3. Priortise cubes with the greatest number of bots
+    # 4. A solution is reached when a cube is broken into 8 x, y, z
+    # positions. The position with greatest number of bots is the
+    # solution. (prioritise position closest to origin)
+    while queue.any?
+      queue = queue.sort_by(&:count).reverse
+      cube = queue.shift
+
+      break if best && cube.count < best.count
+
+      if cube.size == 1
+        best = cube if best.nil? || cube.count > best.count
+      else
+        cube.divide.map do |x, y, z|
+          count = bots.count { |bot| bot.intersect?(x,y,z) }
+
+          queue << Cube.new(x, y, z, count)
+        end
+      end
+    end
+
+    puts best.x.first + best.y.first + best.z.first
+    puts best.count

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

@@ -0,0 +1,131 @@
+---
+- :name: day-24-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-24
+  :solution: |-
+    input = File.read(file_path)
+
+    class Group
+      attr_reader :units, :initiative, :attack, :infection
+
+      def initialize(units, health, weak, immune, attack, damage, initiative, infection, boost = 0)
+        @units      = units
+        @health     = health
+        @weak       = weak || []
+        @immune     = immune || []
+        @attack     = attack
+        @damage     = damage + boost
+        @initiative = initiative
+        @infection  = infection == :infection
+      end
+
+      def effective_power
+        @units * @damage
+      end
+
+      def potential_damage(attacker)
+        damage_points = attacker.effective_power
+        type = attacker.attack
+
+        if @immune.include?(type)
+          0
+        elsif @weak.include?(type)
+          damage_points * 2
+        else
+          damage_points
+        end
+      end
+
+      def attacked(attacker)
+        damage_taken = potential_damage(attacker)
+
+        units_lost = damage_taken / @health
+
+        @units = [units - units_lost, 0].max
+
+        units_lost
+      end
+    end
+
+    def parse_group(group_string, infection, boost = 0)
+      units, health, damage, attack, initiative =
+        group_string.scan(/(\d+).*with (\d+).*does (\d+) (.*) damage.*initiative (\d+)/)[0]
+
+      units = units.to_i
+      health = health.to_i
+      damage = damage.to_i
+      initiative = initiative.to_i
+
+      immune = group_string.scan(/immune to ([\w, ]*)/)[0]
+      immune = immune[0].split(", ") if immune
+
+      weak = group_string.scan(/weak to ([\w, ]*)/)[0]
+      weak = weak[0].split(", ") if weak
+
+      Group.new(units, health, weak, immune, attack, damage, initiative, infection, boost)
+    end
+
+    def solve(input, boost = 0)
+      immune, infection = input.split("\n\n")
+
+      groups = []
+
+      immune.split("\n")[1..-1].map do |group|
+        groups << parse_group(group, :immune, boost)
+      end
+
+      infection = infection.split("\n")[1..-1].map do |group|
+        groups << parse_group(group, :infection)
+      end
+
+      while groups.select(&:infection).any? && groups.reject(&:infection).any?
+        targets = {}
+
+        groups
+          .sort_by { |group| [-group.effective_power, -group.initiative] }
+          .each { |attacking|
+            target = groups
+              .reject { |group| group.infection == attacking.infection }
+              .reject { |group| targets[group] }
+              .max_by { |defending|
+                [
+                  defending.potential_damage(attacking),
+                  defending.effective_power,
+                  defending.initiative
+                ]
+              }
+
+            next unless target && target.potential_damage(attacking) > 0
+
+            targets[target] = attacking
+          }
+
+        units_lost = targets
+          .sort_by { |_, attacking| -attacking.initiative }
+          .map { |defending, attacking| defending.attacked(attacking) }
+
+        return [] if units_lost.inject(:+) == 0
+
+        groups.reject! { |group| group.units == 0 }
+      end
+
+      groups
+    end
+
+    # Part 1
+    puts solve(input).map(&:units).inject(:+)
+
+    # Part 2
+    min = 0
+    max = 10_000
+
+    while max > min
+      mid = (min + max) / 2
+
+      if solve(input, mid).reject(&:infection).any?
+        max = mid
+      else
+        min = mid + 1
+      end
+    end
+
+    puts solve(input, min).reject(&:infection).map(&:units).inject(:+) || 0

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

@@ -0,0 +1,131 @@
+---
+- :name: day-24-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-24
+  :solution: |-
+    input = File.read(file_path)
+
+    class Group
+      attr_reader :units, :initiative, :attack, :infection
+
+      def initialize(units, health, weak, immune, attack, damage, initiative, infection, boost = 0)
+        @units      = units
+        @health     = health
+        @weak       = weak || []
+        @immune     = immune || []
+        @attack     = attack
+        @damage     = damage + boost
+        @initiative = initiative
+        @infection  = infection == :infection
+      end
+
+      def effective_power
+        @units * @damage
+      end
+
+      def potential_damage(attacker)
+        damage_points = attacker.effective_power
+        type = attacker.attack
+
+        if @immune.include?(type)
+          0
+        elsif @weak.include?(type)
+          damage_points * 2
+        else
+          damage_points
+        end
+      end
+
+      def attacked(attacker)
+        damage_taken = potential_damage(attacker)
+
+        units_lost = damage_taken / @health
+
+        @units = [units - units_lost, 0].max
+
+        units_lost
+      end
+    end
+
+    def parse_group(group_string, infection, boost = 0)
+      units, health, damage, attack, initiative =
+        group_string.scan(/(\d+).*with (\d+).*does (\d+) (.*) damage.*initiative (\d+)/)[0]
+
+      units = units.to_i
+      health = health.to_i
+      damage = damage.to_i
+      initiative = initiative.to_i
+
+      immune = group_string.scan(/immune to ([\w, ]*)/)[0]
+      immune = immune[0].split(", ") if immune
+
+      weak = group_string.scan(/weak to ([\w, ]*)/)[0]
+      weak = weak[0].split(", ") if weak
+
+      Group.new(units, health, weak, immune, attack, damage, initiative, infection, boost)
+    end
+
+    def solve(input, boost = 0)
+      immune, infection = input.split("\n\n")
+
+      groups = []
+
+      immune.split("\n")[1..-1].map do |group|
+        groups << parse_group(group, :immune, boost)
+      end
+
+      infection = infection.split("\n")[1..-1].map do |group|
+        groups << parse_group(group, :infection)
+      end
+
+      while groups.select(&:infection).any? && groups.reject(&:infection).any?
+        targets = {}
+
+        groups
+          .sort_by { |group| [-group.effective_power, -group.initiative] }
+          .each { |attacking|
+            target = groups
+              .reject { |group| group.infection == attacking.infection }
+              .reject { |group| targets[group] }
+              .max_by { |defending|
+                [
+                  defending.potential_damage(attacking),
+                  defending.effective_power,
+                  defending.initiative
+                ]
+              }
+
+            next unless target && target.potential_damage(attacking) > 0
+
+            targets[target] = attacking
+          }
+
+        units_lost = targets
+          .sort_by { |_, attacking| -attacking.initiative }
+          .map { |defending, attacking| defending.attacked(attacking) }
+
+        return [] if units_lost.inject(:+) == 0
+
+        groups.reject! { |group| group.units == 0 }
+      end
+
+      groups
+    end
+
+    # Part 1
+    puts solve(input).map(&:units).inject(:+)
+
+    # Part 2
+    min = 0
+    max = 10_000
+
+    while max > min
+      mid = (min + max) / 2
+
+      if solve(input, mid).reject(&:infection).any?
+        max = mid
+      else
+        min = mid + 1
+      end
+    end
+
+    puts solve(input, min).reject(&:infection).map(&:units).inject(:+) || 0

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

@@ -0,0 +1,34 @@
+---
+- :name: day-25-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-25
+  :solution: |-
+    constellations = []
+
+    points = input.split("\n").map do |line|
+      line.split(",").map(&:to_i)
+    end
+
+    def distance(point, other)
+      point.zip(other)
+        .map { |(p1, p2)| (p1 - p2).abs }
+        .inject(:+)
+    end
+
+    points.each do |point|
+      matches = constellations.select do |constellation|
+        constellation.any? { |other_point| distance(point, other_point) <= 3 }
+      end
+
+      case matches.count
+      when 0
+        constellations << [point]
+      when 1
+        matches.first << point
+      else
+        matches.each { |constellation| constellations.delete(constellation) }
+        constellation = matches.inject(&:concat) << point
+        constellations << constellation
+      end
+    end
+
+    puts constellations.count

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

@@ -0,0 +1,13 @@
+---
+- :name: day-01-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-01
+  :solution: |-
+    fuel = 0
+
+    modules = input.split("\n").map(&:to_i)
+
+    modules.each do |mass|
+      fuel += mass / 3 - 2
+    end
+
+    puts fuel

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

@@ -0,0 +1,16 @@
+---
+- :name: day-01-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-01
+  :solution: |-
+    fuel = 0
+
+    modules = input.split("\n").map(&:to_i)
+
+    modules.each do |mass|
+      while mass > 0
+        mass = mass / 3 - 2
+        fuel += mass
+      end
+    end
+
+    puts fuel

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

@@ -0,0 +1,26 @@
+---
+- :name: day-02-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-02
+  :solution: |-
+    codes = input.split(",").map(&:to_i)
+
+    codes[1] = 12
+    codes[2] = 2
+
+    i = 0
+
+    loop do
+      case codes[i]
+      when 1
+        op = :+
+      when 2
+        op = :*
+      when 99
+        puts codes[0]
+        exit
+      end
+
+      codes[codes[i+3]] = codes[codes[i+1]].send(op, codes[codes[i+2]])
+
+      i += 4
+    end

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

@@ -0,0 +1,37 @@
+---
+- :name: day-02-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-02
+  :solution: |-
+    codes = input.split(",").map(&:to_i)
+
+    def run(noun, verb, codes)
+      codes[1] = noun
+      codes[2] = verb
+
+      i = 0
+
+      loop do
+        case codes[i]
+        when 1
+          op = :+
+        when 2
+          op = :*
+        when 99
+          return codes[0]
+        end
+
+        codes[codes[i+3]] = codes[codes[i+1]].send(op, codes[codes[i+2]])
+
+        i += 4
+      end
+    end
+
+    100.times do |n|
+      100.times do |v|
+        result = run(n, v, codes.clone)
+        if result == 19690720
+          puts 100 * n + v
+          exit
+        end
+      end
+    end

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

@@ -0,0 +1,40 @@
+---
+- :name: day-03-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-03
+  :solution: |-
+    input     = File.read(file_path)
+
+    def walk(path)
+      visited = Set.new
+      x, y = 0, 0
+
+      path.split(",").each do |instr|
+        dir = instr[0]
+        steps = instr[1..].to_i
+
+        steps.times do
+          case dir
+          when "U"
+            y += 1
+          when "D"
+            y -= 1
+          when"L"
+            x -= 1
+          when "R"
+            x += 1
+          end
+
+          visited.add [x,y]
+        end
+      end
+
+      visited
+    end
+
+    path_one, path_two = input.split("\n")
+
+    intersection = walk(path_one) & walk(path_two)
+
+    puts intersection.
+      map { |x, y| x.abs + y.abs }.
+      min

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

@@ -0,0 +1,43 @@
+---
+- :name: day-03-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-03
+  :solution: |-
+    def walk(path)
+      visited = {}
+      x, y = 0, 0
+      step = 1
+
+      path.split(",").each do |instr|
+        dir = instr[0]
+        steps = instr[1..].to_i
+
+        steps.times do
+          case dir
+          when "U"
+            y += 1
+          when "D"
+            y -= 1
+          when"L"
+            x -= 1
+          when "R"
+            x += 1
+          end
+
+          visited[[x,y]] = step unless visited[[x,y]]
+          step += 1
+        end
+      end
+
+      visited
+    end
+
+    path_one, path_two = input.split("\n")
+
+    visited_one = walk(path_one)
+    visited_two = walk(path_two)
+
+    intersection = visited_one.keys & visited_two.keys
+
+    puts intersection.
+      map { |x, y| visited_one[[x,y]] + visited_two[[x,y]] }.
+      min

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

@@ -0,0 +1,23 @@
+---
+- :name: day-04-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-04
+  :solution: |-
+    from, to = input.split("-").map(&:to_i)
+
+    count = 0
+
+    (from..to).each do |pw|
+      digits = pw.digits
+
+      increasing = digits.each_cons(2).all? do |a, b|
+        a >= b
+      end
+
+      adjacent = digits.each_cons(2).any? do |a, b|
+        a == b
+      end
+
+      count += 1 if increasing && adjacent
+    end
+
+    puts count

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

@@ -0,0 +1,23 @@
+---
+- :name: day-04-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-04
+  :solution: |-
+    from, to = input.split("-").map(&:to_i)
+
+    count = 0
+
+    (from..to).each do |pw|
+      digits = pw.to_i.digits
+
+      increasing = digits.each_cons(2).all? do |a, b|
+        a >= b
+      end
+
+      double = digits.chunk(&:itself).any? do |_, chunk|
+        chunk.size == 2
+      end
+
+      count += 1 if increasing && double
+    end
+
+    puts count

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

@@ -0,0 +1,46 @@
+---
+- :name: day-05-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-05
+  :solution: |-
+    codes = input.split(",").map(&:to_i)
+    inp = 1
+
+    i = 0
+
+    loop do
+      opcode = codes[i] % 100
+
+      modes = (codes[i] / 100).digits
+      3.times { modes << 0 }
+
+      refs = modes.map.with_index do |m, idx|
+        address = i + idx + 1
+
+        if m == 1
+          address
+        else
+          codes[address]
+        end
+      end
+
+      case opcode
+      when 1
+        op = :+
+      when 2
+        op = :*
+      when 3
+        codes[refs[0]] = inp
+      when 4
+        puts codes[refs[0]]
+      when 99
+        exit
+      end
+
+      codes[refs[2]] = codes[refs[0]].send(op, codes[refs[1]]) if op
+
+      if [1, 2].include?(opcode)
+        i += 4
+      else
+        i += 2
+      end
+    end