advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,68 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-15
+  :solution: |-
+    class Ingredient
+      attr_reader :capacity, :durability, :flavor, :texture, :calories
+
+      def initialize(capacity:, durability:, flavor:, texture:, calories:)
+        @capacity   = capacity
+        @durability = durability
+        @flavor     = flavor
+        @texture    = texture
+        @calories   = calories
+      end
+
+      def multiply(teaspoons)
+        Ingredient.new(
+          capacity:   teaspoons * capacity,
+          durability: teaspoons * durability,
+          flavor:     teaspoons * flavor,
+          texture:    teaspoons * texture,
+          calories:   teaspoons * calories
+        )
+      end
+    end
+
+    ingredients.map! do |ingredient|
+      Ingredient.new(
+        capacity:   ingredient.match(/capacity (-*\d+)/)[1].to_i,
+        durability: ingredient.match(/durability (-*\d+)/)[1].to_i,
+        flavor:     ingredient.match(/flavor (-*\d+)/)[1].to_i,
+        texture:    ingredient.match(/texture (-*\d+)/)[1].to_i,
+        calories:   ingredient.match(/calories (-*\d+)/)[1].to_i
+      )
+    end
+
+    best = 0
+
+    0.upto(100) do |a|
+      0.upto(100 - a) do |b|
+        0.upto(100 - a - b) do |c|
+          d = 100 - a - b - c
+
+          amounts = [a, b, c, d]
+
+          recipie = ingredients.zip(amounts).
+            map { |ingredient, teaspoons| ingredient.multiply(teaspoons) }
+
+          properties = recipie.map do |ingredient|
+            [
+              ingredient.capacity,
+              ingredient.durability,
+              ingredient.flavor,
+              ingredient.texture
+            ]
+          end
+
+          score = properties.inject(&:zip).
+            map { |property| property.flatten.inject(:+) }.
+            map { |value| [value, 0].max }.
+            inject(:*)
+
+          best = [score, best].max
+        end
+      end
+    end
+
+    puts best

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

@@ -0,0 +1,70 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-15
+  :solution: |-
+    class Ingredient
+      attr_reader :capacity, :durability, :flavor, :texture, :calories
+
+      def initialize(capacity:, durability:, flavor:, texture:, calories:)
+        @capacity   = capacity
+        @durability = durability
+        @flavor     = flavor
+        @texture    = texture
+        @calories   = calories
+      end
+
+      def multiply(teaspoons)
+        Ingredient.new(
+          capacity:   teaspoons * capacity,
+          durability: teaspoons * durability,
+          flavor:     teaspoons * flavor,
+          texture:    teaspoons * texture,
+          calories:   teaspoons * calories
+        )
+      end
+    end
+
+    ingredients.map! do |ingredient|
+      Ingredient.new(
+        capacity:   ingredient.match(/capacity (-*\d+)/)[1].to_i,
+        durability: ingredient.match(/durability (-*\d+)/)[1].to_i,
+        flavor:     ingredient.match(/flavor (-*\d+)/)[1].to_i,
+        texture:    ingredient.match(/texture (-*\d+)/)[1].to_i,
+        calories:   ingredient.match(/calories (-*\d+)/)[1].to_i
+      )
+    end
+
+    best = 0
+
+    0.upto(100) do |a|
+      0.upto(100 - a) do |b|
+        0.upto(100 - a - b) do |c|
+          d = 100 - a - b - c
+
+          amounts = [a, b, c, d]
+
+          recipie = ingredients.zip(amounts).
+            map { |ingredient, teaspoons| ingredient.multiply(teaspoons) }
+
+          properties = recipie.map do |ingredient|
+            [
+              ingredient.capacity,
+              ingredient.durability,
+              ingredient.flavor,
+              ingredient.texture
+            ]
+          end
+
+          score = properties.inject(&:zip).
+            map { |property| property.flatten.inject(:+) }.
+            map { |value| [value, 0].max }.
+            inject(:*)
+
+          if score > best && recipie.map(&:calories).inject(:+) == 500
+            best = score
+          end
+        end
+      end
+    end
+
+    puts best

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

@@ -0,0 +1,40 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-16
+  :solution: |-
+    sues.map! do |sue|
+      {
+        number:      sue.scan(/Sue (\d+)/).flatten.map(&:to_i).first,
+        children:    sue.scan(/children: (\d+)/).flatten.map(&:to_i).first,
+        cats:        sue.scan(/cats: (\d+)/).flatten.map(&:to_i).first,
+        samoyeds:    sue.scan(/samoyeds: (\d+)/).flatten.map(&:to_i).first,
+        pomeranians: sue.scan(/pomeranians: (\d+)/).flatten.map(&:to_i).first,
+        akitas:      sue.scan(/akitas: (\d+)/).flatten.map(&:to_i).first,
+        vizslas:     sue.scan(/vizslas: (\d+)/).flatten.map(&:to_i).first,
+        goldfish:    sue.scan(/goldfish: (\d+)/).flatten.map(&:to_i).first,
+        trees:       sue.scan(/trees: (\d+)/).flatten.map(&:to_i).first,
+        cars:        sue.scan(/cars: (\d+)/).flatten.map(&:to_i).first,
+        perfumes:    sue.scan(/perfumes: (\d+)/).flatten.map(&:to_i).first
+      }
+    end
+
+    compounds = {
+      children: 3,
+      cats: 7,
+      samoyeds: 2,
+      pomeranians: 3,
+      akitas: 0,
+      vizslas: 0,
+      goldfish: 5,
+      trees: 3,
+      cars: 2,
+      perfumes: 1
+    }
+
+    real_sue = sues.find do |sue|
+      compounds.all? do |compound, value|
+        sue[compound].nil? || sue[compound] == value
+      end
+    end
+
+    puts real_sue[:number]

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

@@ -0,0 +1,52 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-16
+  :solution: |-
+    sues.map! do |sue|
+      {
+        number:      sue.scan(/Sue (\d+)/).flatten.map(&:to_i).first,
+        children:    sue.scan(/children: (\d+)/).flatten.map(&:to_i).first,
+        cats:        sue.scan(/cats: (\d+)/).flatten.map(&:to_i).first,
+        samoyeds:    sue.scan(/samoyeds: (\d+)/).flatten.map(&:to_i).first,
+        pomeranians: sue.scan(/pomeranians: (\d+)/).flatten.map(&:to_i).first,
+        akitas:      sue.scan(/akitas: (\d+)/).flatten.map(&:to_i).first,
+        vizslas:     sue.scan(/vizslas: (\d+)/).flatten.map(&:to_i).first,
+        goldfish:    sue.scan(/goldfish: (\d+)/).flatten.map(&:to_i).first,
+        trees:       sue.scan(/trees: (\d+)/).flatten.map(&:to_i).first,
+        cars:        sue.scan(/cars: (\d+)/).flatten.map(&:to_i).first,
+        perfumes:    sue.scan(/perfumes: (\d+)/).flatten.map(&:to_i).first
+      }
+    end
+
+    compounds = {
+      children: 3,
+      cats: 7,
+      samoyeds: 2,
+      pomeranians: 3,
+      akitas: 0,
+      vizslas: 0,
+      goldfish: 5,
+      trees: 3,
+      cars: 2,
+      perfumes: 1
+    }
+
+    real_sue = sues.find do |sue|
+      compounds.all? do |compound, value|
+        sue[compound].nil? ||
+          case compound
+          when :cats
+            sue[compound] > value
+          when :trees
+            sue[compound] > value
+          when :pomeranians
+            sue[compound] < value
+          when :goldfish
+            sue[compound] < value
+          else
+            sue[compound] == value
+          end
+      end
+    end
+
+    puts real_sue[:number]

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

@@ -0,0 +1,18 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-17
+  :solution: |-
+    containers.map!(&:to_i)
+    liters = 150
+
+    combinations = []
+
+    1.upto(containers.count) do |container_count|
+      combos = containers.combination(container_count).select do |combination|
+        combination.inject(:+) == liters
+      end
+
+      combinations.concat combos
+    end
+
+    puts combinations.count

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

@@ -0,0 +1,21 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-17
+  :solution: |-
+    containers.map!(&:to_i)
+    liters = 150
+
+    combinations = []
+
+    1.upto(containers.count) do |container_count|
+      combos = containers.combination(container_count).select do |combination|
+        combination.inject(:+) == liters
+      end
+
+      combinations.concat combos
+    end
+
+    counts    = combinations.map(&:count)
+    min_count = counts.min
+
+    puts counts.select { |count| count == min_count }.count

data/data/solutions/github/gchan/2015/18_1.yml

@@ -0,0 +1,38 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-18
+  :solution: |-
+    grid = Array.new(100) { Array.new(100, false) }
+
+    input.each_with_index do |input, y|
+      input.strip.chars.each_with_index do |state, x|
+        grid[y][x] = state == '#'
+      end
+    end
+
+    def neighbours_on(grid, x, y)
+      x_coords = [x - 1, x, x + 1].select { |x| x.between?(0, 99) }
+      y_coords = [y - 1, y, y + 1].select { |y| y.between?(0, 99) }
+
+      x_coords.product(y_coords).
+        reject { |coords| coords == [x, y] }.
+        count { |x, y| grid[y][x] }
+    end
+
+    100.times do
+      new_grid = Array.new(100) { Array.new(100, false) }
+
+      (0..99).to_a.product((0..99).to_a).each do |x, y|
+        neighbours = neighbours_on(grid, x, y)
+
+        if grid[y][x]
+          new_grid[y][x] = neighbours.between?(2, 3)
+        else
+          new_grid[y][x] = neighbours == 3
+        end
+      end
+
+      grid = new_grid
+    end
+
+    puts grid.flatten.count { |state| state }

data/data/solutions/github/gchan/2015/18_2.yml

@@ -0,0 +1,45 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-18
+  :solution: |-
+    grid = Array.new(100) { Array.new(100, false) }
+    broken_lights = [0, 99].product([0, 99])
+
+    input.each_with_index do |input, y|
+      input.strip.chars.each_with_index do |state, x|
+        grid[y][x] = state == '#'
+      end
+    end
+
+    broken_lights.each do |x, y|
+      grid[y][x] = true
+    end
+
+    def neighbours_on(grid, x, y)
+      x_coords = [x - 1, x, x + 1].select { |x| x.between?(0, 99) }
+      y_coords = [y - 1, y, y + 1].select { |y| y.between?(0, 99) }
+
+      x_coords.product(y_coords).
+        reject { |coords| coords == [x, y] }.
+        count { |x, y| grid[y][x] }
+    end
+
+    100.times do
+      new_grid = Array.new(100) { Array.new(100, false) }
+
+      (0..99).to_a.product((0..99).to_a).each do |x, y|
+        neighbours = neighbours_on(grid, x, y)
+
+        if grid[y][x]
+          new_grid[y][x] = neighbours.between?(2, 3)
+        else
+          new_grid[y][x] = neighbours == 3
+        end
+
+        new_grid[y][x] = true if broken_lights.include?([x, y])
+      end
+
+      grid = new_grid
+    end
+
+    puts grid.flatten.count { |state| state }

data/data/solutions/github/gchan/2015/19_1.yml

@@ -0,0 +1,36 @@
+---
+- :name: day-19-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-19
+  :solution: |-
+    input     = File.readlines(file_path)
+
+    molecule     = input.pop(2).last
+    replacements = Hash.new { |h, k| h[k] = [] }
+
+    input.each do |replacement|
+      element     = replacement.scan(/\A\w*/).first
+      new_element = replacement.strip.scan(/\w*\z/).first
+
+      replacements[element] << new_element
+    end
+
+    new_molecules = Set.new
+
+    # Could be cleaner
+    molecule.length.times do |index|
+      element = molecule[index]
+      next if element.match(/[a-z]/)
+
+      second_char = molecule[index + 1]
+      if second_char && second_char.match(/[a-z]/)
+        element += second_char
+      end
+
+      replacements[element].each do |replacement|
+        new_molecule = molecule.dup
+        new_molecule.slice!(index, element.length)
+        new_molecules.add new_molecule.insert(index, replacement)
+      end
+    end
+
+    puts new_molecules.count

data/data/solutions/github/gchan/2015/19_2.yml

@@ -0,0 +1,37 @@
+---
+- :name: day-19-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-19
+  :solution: |-
+    molecule     = input.pop(2).last
+    replacements = {}
+
+    input.each do |replacement|
+      element     = replacement.scan(/\A\w*/).first
+      new_element = replacement.strip.scan(/\w*\z/).first
+
+      replacements[new_element] = element
+    end
+
+    # Brute force by randomly performing replacements
+    molecule_dup = molecule.dup
+    while !molecule_dup.match(/e+/)
+      steps        = 0
+      molecule_dup = molecule.dup
+      exhausted    = false
+
+      # Keep on trying until we run out of replacement options
+      while !exhausted
+        exhausted = true
+
+        replacements.keys.shuffle.each do |element|
+          if molecule_dup.scan(element).any?
+            molecule_dup.sub!(element, replacements[element])
+            steps     += 1
+            exhausted = false
+            break
+          end
+        end
+      end
+    end
+
+    puts steps

data/data/solutions/github/gchan/2015/20_1.yml

@@ -0,0 +1,17 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-20
+  :solution: |-
+    houses = Hash.new(0)
+
+    1.upto(target / 10) do |elf|
+      1.upto(target / 10 / elf) do |number|
+        houses[number * elf] += elf * 10
+      end
+    end
+
+    lowest_house = houses.find do |_house, presents|
+      presents >= target
+    end
+
+    puts lowest_house

data/data/solutions/github/gchan/2015/20_2.yml

@@ -0,0 +1,17 @@
+---
+- :name: day-20-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-20
+  :solution: |-
+    houses = Hash.new(0)
+
+    1.upto(target / 10) do |elf|
+      1.upto([50, target / 10 / elf].min) do |number|
+        houses[number * elf] += elf * 11
+      end
+    end
+
+    lowest_house = houses.find do |_house, presents|
+      presents >= target
+    end
+
+    puts lowest_house

data/data/solutions/github/gchan/2015/21_1.yml

@@ -0,0 +1,86 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-21
+  :solution: |-
+    # OO Overboard
+    class Person
+      attr_reader :hp, :damage, :armor
+
+      def initialize(hp, damage, armor)
+        @hp     = hp
+        @damage = damage
+        @armor  = armor
+      end
+    end
+
+    class Item
+      attr_reader :cost, :damage, :armor
+
+      def initialize(cost:, damage: 0, armor: 0)
+        @cost   = cost
+        @damage = damage
+        @armor  = armor
+      end
+    end
+
+    weapons = [
+      Item.new(cost: 8,  damage: 4),
+      Item.new(cost: 10, damage: 5),
+      Item.new(cost: 25, damage: 6),
+      Item.new(cost: 40, damage: 7),
+      Item.new(cost: 74, damage: 8)
+    ]
+
+    # One null object
+    armor = [
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 13,  armor: 1),
+      Item.new(cost: 31,  armor: 2),
+      Item.new(cost: 53,  armor: 3),
+      Item.new(cost: 75,  armor: 4),
+      Item.new(cost: 102, armor: 5),
+    ]
+
+    # Two null objects
+    rings = [
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 25,  damage: 1),
+      Item.new(cost: 50,  damage: 2),
+      Item.new(cost: 100, damage: 3),
+      Item.new(cost: 20,  armor: 1),
+      Item.new(cost: 40,  armor: 2),
+      Item.new(cost: 80,  armor: 3)
+    ]
+
+    def win?(hero, boss)
+      turns_to_defeat = (boss.hp.to_f / [(hero.damage - boss.armor), 1].max).ceil
+      turns_to_lose   = (hero.hp.to_f / [(boss.damage - hero.armor), 1].max).ceil
+
+      turns_to_defeat <= turns_to_lose
+    end
+
+    boss_hp     = boss[0].scan(/\d+/).first.to_i
+    boss_damage = boss[1].scan(/\d+/).first.to_i
+    boss_armor  = boss[2].scan(/\d+/).first.to_i
+
+    boss = Person.new(boss_hp, boss_damage, boss_armor)
+
+    combinations = weapons.product(armor, rings.combination(2).to_a)
+
+    winning_costs = combinations.map do |items|
+      items.flatten!
+      cost   = items.map(&:cost).inject(0, :+)
+      damage = items.map(&:damage).inject(0, :+)
+      armor  = items.map(&:armor).inject(0, :+)
+
+      hero = Person.new(100, damage, armor)
+
+      if win?(hero, boss)
+        cost
+      else
+        nil
+      end
+    end
+
+    puts winning_costs.compact.min

data/data/solutions/github/gchan/2015/21_2.yml

@@ -0,0 +1,86 @@
+---
+- :name: day-21-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2015/day-21
+  :solution: |-
+    # OO Overboard
+    class Person
+      attr_reader :hp, :damage, :armor
+
+      def initialize(hp, damage, armor)
+        @hp     = hp
+        @damage = damage
+        @armor  = armor
+      end
+    end
+
+    class Item
+      attr_reader :cost, :damage, :armor
+
+      def initialize(cost:, damage: 0, armor: 0)
+        @cost   = cost
+        @damage = damage
+        @armor  = armor
+      end
+    end
+
+    weapons = [
+      Item.new(cost: 8,  damage: 4),
+      Item.new(cost: 10, damage: 5),
+      Item.new(cost: 25, damage: 6),
+      Item.new(cost: 40, damage: 7),
+      Item.new(cost: 74, damage: 8)
+    ]
+
+    # One null object
+    armor = [
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 13,  armor: 1),
+      Item.new(cost: 31,  armor: 2),
+      Item.new(cost: 53,  armor: 3),
+      Item.new(cost: 75,  armor: 4),
+      Item.new(cost: 102, armor: 5),
+    ]
+
+    # Two null objects
+    rings = [
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 0,   armor: 0),
+      Item.new(cost: 25,  damage: 1),
+      Item.new(cost: 50,  damage: 2),
+      Item.new(cost: 100, damage: 3),
+      Item.new(cost: 20,  armor: 1),
+      Item.new(cost: 40,  armor: 2),
+      Item.new(cost: 80,  armor: 3)
+    ]
+
+    def win?(hero, boss)
+      turns_to_defeat = (boss.hp.to_f / [(hero.damage - boss.armor), 1].max).ceil
+      turns_to_lose   = (hero.hp.to_f / [(boss.damage - hero.armor), 1].max).ceil
+
+      turns_to_defeat <= turns_to_lose
+    end
+
+    boss_hp     = boss[0].scan(/\d+/).first.to_i
+    boss_damage = boss[1].scan(/\d+/).first.to_i
+    boss_armor  = boss[2].scan(/\d+/).first.to_i
+
+    boss = Person.new(boss_hp, boss_damage, boss_armor)
+
+    combinations = weapons.product(armor, rings.combination(2).to_a)
+
+    losing_costs = combinations.map do |items|
+      items.flatten!
+      cost   = items.map(&:cost).inject(0, :+)
+      damage = items.map(&:damage).inject(0, :+)
+      armor  = items.map(&:armor).inject(0, :+)
+
+      hero = Person.new(100, damage, armor)
+
+      if !win?(hero, boss)
+        cost
+      else
+        nil
+      end
+    end
+
+    puts losing_costs.compact.max