advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ahorner/2015/22_2.yml

@@ -0,0 +1,153 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    class Character
+      class Dead < RuntimeError; end
+
+      attr_accessor :attack, :armor, :mp, :mana_used
+      attr_reader :hp
+
+      def initialize(hp, attack, mp = 0)
+        @hp = hp
+        @mp = mp
+        @attack = attack
+        @armor = 0
+        @mana_used = 0
+      end
+
+      def hp=(value)
+        @hp = value
+        raise Dead if value < 0
+      end
+
+      def hit(power)
+        self.hp -= [(power - @armor), 1].max
+      end
+
+      def debuff
+        @armor = 0
+      end
+    end
+
+    class Skill
+      attr_reader :name, :cost
+
+      def initialize(name, cost, cooldown = 0, &callback)
+        @name = name
+        @cost = cost
+        @cooldown = cooldown
+        @effect = callback
+        @timer = 0
+      end
+
+      def cast(caster, enemy)
+        caster.mp -= cost
+        caster.mana_used += cost
+
+        if @cooldown > 0
+          @timer = @cooldown
+        else
+          @effect.call(caster, enemy)
+        end
+      end
+
+      def tick(caster, enemy)
+        return unless active?
+
+        @effect.call(caster, enemy)
+        @timer -= 1
+      end
+
+      def castable_by?(caster)
+        @timer <= 1 && @cost <= caster.mp
+      end
+
+      def active?
+        @timer > 0
+      end
+    end
+
+    SKILLS = [
+      # DRAIN is less efficient than MAGIC MISSILE, and only prolongs the battle
+      Skill.new("DRAIN", 73) { |hero, enemy| enemy.hit(2) && hero.hp += 2 },
+      Skill.new("MAGIC MISSILE", 53) { |_hero, enemy| enemy.hit(4) },
+      Skill.new("SHIELD", 113, 6) { |hero, _enemy| hero.armor = 7 },
+      Skill.new("POISON", 173, 6) { |_hero, enemy| enemy.hit(3) },
+      Skill.new("RECHARGE", 229, 5) { |hero, _enemy| hero.mp += 101 }
+    ].freeze
+
+    class Battle
+      attr_reader :hero, :enemy, :skills
+
+      def initialize(hero, enemy, skills, hard_mode: false)
+        @hero = hero
+        @enemy = enemy
+        @skills = skills
+        @hard_mode = hard_mode
+      end
+
+      def optimal_strategy(minimum = 9999)
+        return minimum if hero.mana_used >= minimum
+
+        save_scum do |save_state, won|
+          minimum =
+            if won
+              [save_state.hero.mana_used, minimum].min
+            else
+              save_state.optimal_strategy(minimum)
+            end
+        end
+
+        minimum
+      end
+
+      def save_scum
+        skills.size.times do |i|
+          state = save_state
+          outcome = state.resolve(state.skills[i])
+
+          yield(state, outcome) unless outcome == false
+        end
+      end
+
+      def resolve(skill)
+        return false unless skill.castable_by?(hero)
+
+        # Hero's turn
+        hero.hp -= 1 if @hard_mode
+        resolve_effects
+        skill.cast(hero, enemy)
+
+        # Enemy's Turn
+        resolve_effects
+        hero.hit(enemy.attack)
+
+        nil
+      rescue Character::Dead
+        enemy.hp <= 0
+      end
+
+      private
+
+      def resolve_effects
+        hero.debuff
+        skills.each { |s| s.tick(hero, enemy) }
+      end
+
+      def save_state
+        Battle.new(hero.clone, enemy.clone, skills.map(&:clone), hard_mode: @hard_mode)
+      end
+    end
+
+    HERO_STATS ||= [50, 0, 500].freeze
+
+    enemy_stats = INPUT.split("\n").map { |i| i.scan(/\d+/).join.to_i }
+    enemy = Character.new(*enemy_stats)
+    hero = Character.new(*HERO_STATS)
+
+    best = Battle.new(hero, enemy, SKILLS).optimal_strategy
+    solve!("Cheapest strategy:", best)
+
+    best = Battle.new(hero, enemy, SKILLS, hard_mode: true).optimal_strategy
+    solve!("Cheapest strategy (hard mode):", best)

data/data/solutions/github/ahorner/2015/23_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2015/23_2.yml

@@ -0,0 +1,55 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    def parse(instruction, line, registers)
+      parsed_instruction = instruction.split
+      instr = parsed_instruction.first
+
+      case instr
+      when "hlf"
+        register = parsed_instruction.last
+        registers[register] /= 2
+        line += 1
+      when "tpl"
+        register = parsed_instruction.last
+        registers[register] *= 3
+        line += 1
+      when "inc"
+        register = parsed_instruction.last
+        registers[register] += 1
+        line += 1
+      when "jmp"
+        jump = parsed_instruction.last
+        line += jump.to_i
+      when "jie"
+        register = parsed_instruction[1].chomp(",")
+        jump = parsed_instruction[2]
+        line += registers[register].even? ? jump.to_i : 1
+      when "jio"
+        register = parsed_instruction[1].chomp(",")
+        jump = parsed_instruction[2]
+        line += (registers[register] == 1) ? jump.to_i : 1
+      end
+
+      line
+    end
+
+    INSTRUCTIONS = INPUT.split("\n")
+
+    def run(registers)
+      line = 0
+      line = parse(INSTRUCTIONS[line], line, registers) while INSTRUCTIONS[line]
+    end
+
+    registers = Hash.new(0)
+    run(registers)
+
+    REGISTER ||= "b".freeze
+    solve!("Register B:", registers[REGISTER])
+
+    registers = Hash.new(0)
+    registers["a"] = 1
+    run(registers)
+
+    solve!("Register B (with A starting at 1):", registers[REGISTER])

data/data/solutions/github/ahorner/2015/24_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2015/24_2.yml

@@ -0,0 +1,36 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    PACKAGES = INPUT.split("\n").map(&:to_i)
+    TOTAL_WEIGHT = PACKAGES.sum
+
+    def target_subsets(array, sum)
+      return [] if array.empty?
+
+      first, *rest = array
+      target = sum - first
+
+      if target == 0
+        [[first]]
+      elsif target < 0
+        target_subsets(rest, sum)
+      else
+        subsets = target_subsets(rest, target).map { |subset| [first, *subset] }
+        target_subsets(rest, sum) + subsets
+      end
+    end
+
+    def quantum_entanglement(combination)
+      combination.inject(:*)
+    end
+
+    def minimal_entanglement(group_weight)
+      sets = target_subsets(PACKAGES.reverse, group_weight)
+
+      min_size = sets.min_by(&:size).size
+      sets.select { |set| set.size == min_size }.map { |set| quantum_entanglement(set) }.min
+    end
+
+    solve!("Optimal QE with good legroom:", minimal_entanglement(TOTAL_WEIGHT / 3))
+    solve!("Optimal QE with good legroom (and a trunk):", minimal_entanglement(TOTAL_WEIGHT / 4))

data/data/solutions/github/ahorner/2015/25_1.yml

@@ -0,0 +1,30 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2015
+  :solution: |-
+    INSTRUCTION_MATCHER = /row (?<row>\d+), column (?<column>\d+)/
+
+    instructions = INSTRUCTION_MATCHER.match(INPUT)
+    row = instructions[:row].to_i
+    column = instructions[:column].to_i
+
+    def generate(num)
+      num * 252_533 % 33_554_393
+    end
+
+    def code_for(row, column)
+      num = 20_151_125
+      r = 1
+      c = 1
+
+      loop do
+        break if r == row && c == column
+
+        r, c = (r == 1) ? [c + 1, 1] : [r - 1, c + 1]
+        num = generate(num)
+      end
+
+      num
+    end
+
+    solve!("The code at #{row}, #{column}:", code_for(row, column))

data/data/solutions/github/ahorner/2016/01_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/01_2.yml

@@ -0,0 +1,54 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Dude
+      DIRECTIONS = %w[N E S W].freeze
+
+      attr_reader :visited
+
+      def initialize
+        @visited = []
+        @facing = "N"
+        @x = 0
+        @y = 0
+      end
+
+      def turn(direction)
+        pos = DIRECTIONS.index(@facing)
+        pos += ((direction == "L") ? -1 : 1)
+        @facing = DIRECTIONS[pos % DIRECTIONS.length]
+      end
+
+      def move(blocks)
+        blocks.times do
+          case @facing
+          when "N" then @y += 1
+          when "E" then @x += 1
+          when "S" then @y -= 1
+          when "W" then @x -= 1
+          end
+          track_position
+        end
+      end
+
+      def distance
+        @x.abs + @y.abs
+      end
+
+      def track_position
+        @visited << [@x, @y]
+      end
+    end
+
+    dude = Dude.new
+
+    INPUT.split(", ").each do |instruction|
+      dude.turn(instruction[0])
+      dude.move(instruction[1..].to_i)
+    end
+
+    solve!("The distance to Easter Bunny HQ:", dude.distance)
+
+    position = dude.visited.detect { |pos| dude.visited.count(pos) > 1 }
+    solve!("The distance to the first place you visited twice is:", position.sum(&:abs))

data/data/solutions/github/ahorner/2016/02_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/02_2.yml

@@ -0,0 +1,56 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Keypad
+      def initialize(layout)
+        @layout = layout
+        @y = layout.index { |row| row.include?("5") }
+        @x = layout[@y].index("5")
+      end
+
+      def move_finger(direction)
+        case direction
+        when "U"
+          @y -= 1 unless @y - 1 < 0 || @layout[@y - 1][@x].nil?
+        when "D"
+          @y += 1 unless @y + 1 >= @layout.length || @layout[@y + 1][@x].nil?
+        when "L"
+          @x -= 1 unless @x - 1 < 0 || @layout[@y][@x - 1].nil?
+        when "R"
+          @x += 1 unless @x + 1 >= @layout[@y].length || @layout[@y][@x + 1].nil?
+        end
+      end
+
+      def current_key
+        @layout[@y][@x]
+      end
+    end
+
+    def code(keypad)
+      INPUT.split("\n").map do |line|
+        line.chars.each { |direction| keypad.move_finger(direction) }
+        keypad.current_key
+      end.join
+    end
+
+    standard_keypad = Keypad.new(
+      [
+        %w[1 2 3],
+        %w[4 5 6],
+        %w[7 8 9]
+      ]
+    )
+
+    solve!("The first keycode is:", code(standard_keypad))
+
+    wonky_keypad = Keypad.new(
+      [
+        [nil, nil, "1", nil, nil],
+        [nil, "2", "3", "4", nil],
+        %w[5 6 7 8 9],
+        [nil, "A", "B", "C", nil],
+        [nil, nil, "D", nil, nil]
+      ]
+    )
+    solve!("The second keycode is:", code(wonky_keypad))

data/data/solutions/github/ahorner/2016/03_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/03_2.yml

@@ -0,0 +1,32 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    LINE_MATCHER = /\A\s*(\d+)\s+(\d+)\s+(\d+)\z/
+
+    def valid?(sides)
+      maximum = sides.max
+      others = sides.dup
+
+      others.delete_at(sides.index(maximum))
+      others.sum > maximum
+    end
+
+    def parse_lines
+      INPUT.split("\n").each do |line|
+        sides = line.match(LINE_MATCHER).captures
+        yield sides.map(&:to_i)
+      end
+    end
+
+    valid_count = 0
+    parse_lines { |sides| valid_count += 1 if valid?(sides) }
+
+    solve!("The number of normal triangles is:", valid_count)
+
+    rows = []
+    parse_lines { |sides| rows << sides }
+    triangles = rows.each_slice(3).flat_map { |items| items.inject(&:zip).map(&:flatten) }
+    valid_count = triangles.count { |triangle| valid?(triangle) }
+
+    solve!("The number of valid vertically-assembled triangles is:", valid_count)

data/data/solutions/github/ahorner/2016/04_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/04_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    MATCHER = /\A(?<code>.*)-(?<sector_id>[0-9]+)\[(?<checksum>.*)\]\z/
+    ALPHABET = ("a".."z").to_a.freeze
+    TARGET_ROOM ||= "northpoleobjectstorage".freeze
+
+    def real?(key, counts)
+      highest = []
+      alphabet = counts.keys.sort
+
+      key.length.times do
+        highest << alphabet.max_by { |i| counts[i] }
+        alphabet -= [highest.last]
+      end
+
+      highest.all? { |c| key.include?(c) }
+    end
+
+    def decrypt(code, shift)
+      code.chars.map do |c|
+        (c == "-") ? " " : ALPHABET[(ALPHABET.index(c) + shift.to_i) % ALPHABET.size]
+      end.join
+    end
+
+    sector_sums = 0
+    room_id = nil
+
+    INPUT.split("\n").each do |line|
+      line = line.match(MATCHER)
+
+      counts = Hash.new(0)
+      line[:code].chars.each { |c| counts[c] += 1 unless c == "-" }
+
+      next unless real?(line[:checksum], counts)
+
+      sector_sums += line[:sector_id].to_i
+      decrypted = decrypt(line[:code], line[:sector_id])
+      room_id = line[:sector_id] if decrypted.delete(" ") == TARGET_ROOM
+    end
+
+    solve!("The sum of the real sector IDs is:", sector_sums)
+    solve!("The sector ID of the North Pole Object Storage is:", room_id)

data/data/solutions/github/ahorner/2016/05_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/05_2.yml

@@ -0,0 +1,33 @@
+---
+- :name: 05.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require "digest"
+
+    def matching_digest(pattern, value = 0)
+      loop do
+        value += 1
+        digest = Digest::MD5.hexdigest "#{INPUT}#{value}"
+        break [digest, value] if digest.start_with?(pattern)
+      end
+    end
+
+    value = 0
+    password = 8.times.map do
+      digest, value = matching_digest("00000", value)
+      digest[5]
+    end
+
+    solve!("The password is:", password.join)
+
+    value = 0
+    password = [nil] * 8
+    loop do
+      digest, value = matching_digest("00000", value)
+      next unless /\A[0-7]\z/.match?(digest[5])
+
+      password[digest[5].to_i] ||= digest[6]
+      break unless password.any?(&:nil?)
+    end
+
+    solve!("The position-specified password is:", password.join)

data/data/solutions/github/ahorner/2016/06_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/06_2.yml

@@ -0,0 +1,18 @@
+---
+- :name: 06.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    counts = []
+
+    INPUT.split("\n").each do |line|
+      line.chars.each_with_index do |char, index|
+        counts[index] ||= Hash.new(0)
+        counts[index][char] += 1
+      end
+    end
+
+    password = counts.map { |count| count.keys.max_by { |c| count[c] } }
+    solve!("The password by most common character is:", password.join)
+
+    password = counts.map { |count| count.keys.min_by { |c| count[c] } }
+    solve!("The password by least common character is:", password.join)

data/data/solutions/github/ahorner/2016/07_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/07_2.yml

@@ -0,0 +1,29 @@
+---
+- :name: 07.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    ABBA_MATCHER = /(.)((?!\1).)\2\1/
+
+    def supports_tls?(supernet, hypernet)
+      supernet.any? { |s| s =~ ABBA_MATCHER } && hypernet.none? { |s| s =~ ABBA_MATCHER }
+    end
+
+    def count_ips
+      INPUT.split("\n").count do |line|
+        components = line.split(/\[|\]/)
+        supernet, hypernet = components.partition.with_index { |_, i| i.even? }
+        yield supernet, hypernet
+      end
+    end
+
+    count = count_ips { |supernet, hypernet| supports_tls?(supernet, hypernet) }
+    solve!("The number of IPs that support TLS:", count)
+
+    ABA_MATCHER = /\A.*([^,])((?!\1)[^,])\1.*~.*\2\1\2.*\z/
+
+    def supports_ssl?(supernet, hypernet)
+      [supernet.join(","), hypernet.join(",")].join("~") =~ ABA_MATCHER
+    end
+
+    count = count_ips { |supernet, hypernet| supports_ssl?(supernet, hypernet) }
+    solve!("The number of IPs that support SSL", count)

data/data/solutions/github/ahorner/2016/08_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/08_2.yml

@@ -0,0 +1,57 @@
+---
+- :name: '08.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Screen
+      attr_reader :pixels
+
+      def initialize(width, height)
+        @pixels = Hash.new(false)
+        @width = width
+        @height = height
+      end
+
+      def rect(width, height)
+        height.times do |y|
+          width.times { |x| @pixels[[y, x]] = true }
+        end
+      end
+
+      def rotate(type, index, shift)
+        size, key =
+          case type
+          when "row" then [@width, ->(i) { [index, i] }]
+          when "column" then [@height, ->(i) { [i, index] }]
+          end
+
+        current = size.times.map { |i| @pixels[key.call(i)] }
+        shifted = current.rotate(-shift)
+        shifted.each_with_index { |value, i| @pixels[key.call(i)] = value }
+      end
+
+      def render
+        @height.times.map do |y|
+          @width.times.map { |x| (@pixels[[y, x]] ? "#" : ".") }.join
+        end.join("\n")
+      end
+    end
+
+    RECT_PATTERN = /rect (?<width>[0-9]+)x(?<height>[0-9]+)/
+    ROTATE_PATTERN = /rotate (?<type>\w*) .=(?<index>[0-9]+) by (?<shift>[0-9]+)/
+
+    SCREEN_DIMENSIONS ||= [50, 6].freeze
+    screen = Screen.new(*SCREEN_DIMENSIONS)
+
+    INPUT.split("\n").each do |line|
+      case line
+      when RECT_PATTERN
+        matches = line.match(RECT_PATTERN)
+        screen.rect(matches[:width].to_i, matches[:height].to_i)
+      when ROTATE_PATTERN
+        matches = line.match(ROTATE_PATTERN)
+        screen.rotate(matches[:type], matches[:index].to_i, matches[:shift].to_i)
+      end
+    end
+
+    solve!("The number of lit pixels is:", screen.pixels.count { |_, v| v })
+    solve!("You can read the screen below:\n\n", screen.render)

data/data/solutions/github/ahorner/2016/09_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ahorner/2016/09_2.yml

@@ -0,0 +1,40 @@
+---
+- :name: '09.rb'
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    def decompressed_length(input, recursive: false)
+      index = 0
+      length = 0
+
+      loop do
+        if input[index] == "("
+          index += 1
+          close_index = input[index..].index(")")
+          metrics = input[index...(index + close_index)]
+
+          gather, repeat = metrics.split("x").map(&:to_i)
+          index += close_index
+
+          sublength =
+            if recursive
+              next_index = (index + 1)
+              decompressed_length(input[next_index...(next_index + gather)], recursive: true)
+            else
+              gather
+            end
+
+          index += gather
+          length += repeat * sublength
+        else
+          length += 1
+        end
+
+        index += 1
+        break if index >= input.length
+      end
+
+      length
+    end
+
+    solve!("The decompressed length is:", decompressed_length(INPUT))
+    solve!("The recursively decompressed length is:", decompressed_length(INPUT, recursive: true))

data/data/solutions/github/ahorner/2016/10_1.yml

@@ -0,0 +1 @@
+--- []