advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,75 @@
+---
+- :name: 19.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    ELF_COUNT = INPUT.to_i
+
+    class Elf
+      attr_accessor :gifts, :next, :prev, :number
+
+      def initialize(number)
+        @number = number
+        @gifts = 1
+        @next = nil
+        @prev = nil
+      end
+
+      def take_from(elf)
+        @gifts += elf.gifts
+        elf.gifts = 0
+        elf.prev.next = elf.next
+        elf.next.prev = elf.prev
+      end
+    end
+
+    def elf_ring
+      first_elf = Elf.new(1)
+      current_elf = first_elf
+
+      (ELF_COUNT - 1).times.with_index(2) do |_, number|
+        next_elf = Elf.new(number)
+
+        current_elf.next = next_elf
+        next_elf.prev = current_elf
+
+        current_elf = next_elf
+      end
+
+      current_elf.next = first_elf
+      first_elf.prev = current_elf
+
+      first_elf
+    end
+
+    def take_from_next(start_with)
+      current_elf = start_with
+
+      while current_elf.next != current_elf
+        current_elf.take_from(current_elf.next)
+        current_elf = current_elf.next
+      end
+
+      current_elf
+    end
+
+    def take_from_across(start_with, elf_count)
+      current_elf = start_with
+      target = current_elf
+      (elf_count / 2).times { target = target.next }
+
+      while current_elf.next != current_elf
+        current_elf.take_from(target)
+        target = (elf_count.odd? ? target.next.next : target.next)
+
+        elf_count -= 1
+        current_elf = current_elf.next
+      end
+
+      current_elf
+    end
+
+    winner = take_from_next(elf_ring)
+    solve!("The number of the last elf standing is:", winner.number)
+
+    winner = take_from_across(elf_ring, ELF_COUNT)
+    solve!("The number of the last elf standing (advanced) is:", winner.number)

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

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

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

@@ -0,0 +1,46 @@
+---
+- :name: 20.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    def condense_ranges(ranges)
+      ranges.sort_by(&:first).each_with_object([]) do |range, ips|
+        (ips << range) and next if ips.empty?
+
+        last_range = ips.last
+        last_ip = last_range.end
+
+        if last_ip + 1 < range.begin
+          ips << range
+        else
+          ending_ip = [last_ip, range.end].max
+          ips[-1] = (last_range.begin..ending_ip)
+        end
+      end
+    end
+
+    def valid_ips(blocklist)
+      missing = []
+
+      blocklist.each_with_index do |range, i|
+        next if i == blocklist.length - 1
+
+        lower_ip = range.end
+        upper_ip = blocklist[i + 1].first
+        ((lower_ip + 1)...upper_ip).each { |ip| missing << ip }
+      end
+
+      beginning = (VALID_IPS.begin...blocklist.first.begin).to_a
+      ending = ((blocklist.last.end + 1)..VALID_IPS.end).to_a
+
+      beginning + missing + ending
+    end
+
+    VALID_IPS ||= (0..4_294_967_295)
+    BLOCKLIST = condense_ranges(INPUT.split("\n").map do |line|
+      beginning, ending = line.split("-").map(&:to_i)
+      (beginning..ending)
+    end)
+
+    safelist = valid_ips(BLOCKLIST)
+    solve!("The first valid IP address is:", safelist.first)
+    solve!("The number of valid IP addresses is:", safelist.count)

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

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

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

@@ -0,0 +1,94 @@
+---
+- :name: 21.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    SWAP_POSITION_PATTERN = /swap position (?<x>\d) with position (?<y>\d)/
+    SWAP_LETTER_PATTERN = /swap letter (?<x>\w) with letter (?<y>\w)/
+    ABSOLUTE_ROTATE_PATTERN = /rotate (?<direction>\w+) (?<steps>\d+) step/
+    RELATIVE_ROTATE_PATTERN = /rotate based on position of letter (?<char>\w)/
+    REVERSE_POSITIONS_PATTERN = /reverse positions (?<x>\d) through (?<y>\d)/
+    MOVE_POSITIONS_PATTERN = /move position (?<x>\d) to position (?<y>\d)/
+
+    def act(chars, command)
+      chars = chars.dup
+
+      case command
+      when SWAP_POSITION_PATTERN
+        matches = command.match(SWAP_POSITION_PATTERN)
+        x = matches[:x].to_i
+        y = matches[:y].to_i
+        char = chars[x]
+        chars[x] = chars[y]
+        chars[y] = char
+      when SWAP_LETTER_PATTERN
+        matches = command.match(SWAP_LETTER_PATTERN)
+        x = chars.index(matches[:x])
+        y = chars.index(matches[:y])
+        char = chars[x]
+        chars[x] = chars[y]
+        chars[y] = char
+      when ABSOLUTE_ROTATE_PATTERN
+        matches = command.match(ABSOLUTE_ROTATE_PATTERN)
+        dir = matches[:direction]
+        steps = matches[:steps].to_i
+        chars.rotate!((dir == "left") ? steps : -steps)
+      when RELATIVE_ROTATE_PATTERN
+        matches = command.match(RELATIVE_ROTATE_PATTERN)
+        char = matches[:char]
+        shift = chars.index(char)
+        additional = ((shift >= 4) ? 1 : 0)
+        chars.rotate!(-1 - shift - additional)
+      when REVERSE_POSITIONS_PATTERN
+        matches = command.match(REVERSE_POSITIONS_PATTERN)
+        x = matches[:x].to_i
+        y = matches[:y].to_i
+        tmp = chars[x..y]
+        tmp.reverse.each_with_index do |c, i|
+          chars[x + i] = c
+        end
+      when MOVE_POSITIONS_PATTERN
+        matches = command.match(MOVE_POSITIONS_PATTERN)
+        x = matches[:x].to_i
+        y = matches[:y].to_i
+        char = chars.delete_at(x)
+        chars.insert(y, char)
+      end
+
+      chars
+    end
+
+    def undo(result, command)
+      chars = result.dup
+
+      case command
+      when SWAP_POSITION_PATTERN, SWAP_LETTER_PATTERN, REVERSE_POSITIONS_PATTERN
+        chars = act(chars, command)
+      when ABSOLUTE_ROTATE_PATTERN
+        matches = command.match(ABSOLUTE_ROTATE_PATTERN)
+        dir = matches[:direction]
+        steps = matches[:steps].to_i
+        chars.rotate!((dir == "left") ? -steps : steps)
+      when RELATIVE_ROTATE_PATTERN
+        chars.rotate!(1) while result != act(chars, command)
+      when MOVE_POSITIONS_PATTERN
+        matches = command.match(MOVE_POSITIONS_PATTERN)
+        x = matches[:x].to_i
+        y = matches[:y].to_i
+        char = chars.delete_at(y)
+        chars.insert(x, char)
+      end
+
+      chars
+    end
+
+    SCRAMBLE ||= %w[a b c d e f g h].freeze
+    chars = SCRAMBLE
+    INPUT.split("\n").each { |line| chars = act(chars, line) }
+
+    solve!("Your scrambled password is:", chars.join)
+
+    UNSCRAMBLE ||= %w[f b g d c e a h].freeze
+    chars = UNSCRAMBLE
+    INPUT.split("\n").reverse_each { |line| chars = undo(chars, line) }
+
+    solve!("Your unscrambled password is:", chars.join)

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

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

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

@@ -0,0 +1,120 @@
+---
+- :name: 22.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    # rubocop:disable Layout/LineLength
+    NODE_PATTERN = %r{/dev/grid/node-x(?<x>\d+)-y(?<y>\d+)\s+(?<size>\d+)T\s+(?<used>\d+)T\s+(?<avail>\d+)T\s+(?<percent>\d+)%}
+    # rubocop:enable Layout/LineLength
+
+    class DevNode
+      attr_accessor :size, :used, :avail
+
+      def initialize(size, used, avail)
+        @size = size
+        @used = used
+        @avail = avail
+      end
+
+      def possible_move?(other_node)
+        other_node.size > @used
+      end
+
+      def fits?(other_node)
+        other_node.used <= @avail
+      end
+
+      def take(other_node)
+        @used += other_node.used
+        @avail -= other_node.used
+        other_node.avail += other_node.used
+        other_node.used = 0
+      end
+
+      def empty?
+        @used == 0
+      end
+    end
+
+    class NodePair
+      def initialize(a, b)
+        @a = a
+        @b = b
+      end
+
+      def valid?
+        return false if @a.empty?
+        return false if @b == @a
+
+        @b.fits?(@a)
+      end
+    end
+
+    def adjacent_nodes(nodes, x, y)
+      [
+        [x + 1, y],
+        [x - 1, y],
+        [x, y + 1],
+        [x, y - 1]
+      ].select { |(i, j)| nodes.key?([i, j]) }
+    end
+
+    nodes = INPUT.split("\n")[2..].each_with_object({}) do |line, list|
+      matches = line.match(NODE_PATTERN)
+      list[[matches[:x].to_i, matches[:y].to_i]] = DevNode.new(
+        matches[:size].to_i,
+        matches[:used].to_i,
+        matches[:avail].to_i
+      )
+    end
+
+    viable_pairs = nodes.values.product(nodes.values).count do |(a, b)|
+      !a.empty? && b != a && b.fits?(a)
+    end
+
+    puts "The number of viable pairs is:", viable_pairs, nil
+
+    # Screw solving this problem the "correct" way. I'm so done with pathfinding
+    # challenges this season. The challenge is _clearly_ easier to solve by hand
+    # with some idiotic heuristics, so I'm not going to bother coding anything other
+    # than basic math.
+    #
+    # (.) .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . [.]
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  -  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .
+    #
+    # Thanks for creating the first truly unenjoyable challenge, topaz.
+
+    high_nodes = nodes.select { |_, node| node.size > 400 }
+    wall = high_nodes.min_by { |(x, _y)| x }
+
+    empty_node = nodes.detect { |_, node| node.empty? }
+    x, y = empty_node.first
+
+    steps_to_target = (37 - x).abs + (0 - y).abs
+    additional_steps = 2 * (wall.first[0] - x - 1).abs
+    steps_to_goal = 36 * 5
+    total_steps = steps_to_target + additional_steps + steps_to_goal
+
+    puts "The minimum step count is:", total_steps

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

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

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

@@ -0,0 +1,17 @@
+---
+- :name: 23.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require_relative "shared/assembunny"
+
+    registers = Hash.new(0).tap { |h| h["a"] = 7 }
+    computer = Assembunny.new(registers)
+    computer.run(INSTRUCTIONS)
+
+    solve!("Register 'a' contains:", computer.registers["a"])
+
+    registers = Hash.new(0).tap { |h| h["a"] = 12 }
+    computer = Assembunny.new(registers)
+    computer.run(INSTRUCTIONS)
+
+    solve!("After updating the egg count, register 'a' contains:", computer.registers["a"])

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

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

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

@@ -0,0 +1,138 @@
+---
+- :name: 24.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    class Maze
+      def initialize(nodes)
+        @nodes = nodes
+      end
+
+      def wall?(node)
+        @nodes[node]
+      end
+
+      def adjacent_spots((x, y))
+        [
+          [x + 1, y],
+          [x - 1, y],
+          [x, y + 1],
+          [x, y - 1]
+        ].compact.reject { |spot| wall?(spot) }
+      end
+    end
+
+    # Apologies to http://branch14.org/snippets/a_star_in_ruby.html
+    class PriorityQueue
+      def initialize
+        @list = []
+      end
+
+      def add(priority, item)
+        @list << [priority, @list.length, item]
+        @list.sort!
+      end
+
+      def next
+        @list.shift[2]
+      end
+
+      def empty?
+        @list.empty?
+      end
+    end
+
+    class Pathfinder
+      def initialize(maze)
+        @maze = maze
+      end
+
+      def path(start, target)
+        estimator = proc { |(x, y)| (target[0] - x).abs + (target[1] - y).abs }
+        traverse(start, estimator: estimator) { |spot, path| return path if spot == target }
+      end
+
+      private
+
+      def traverse(start, estimator: proc { 0 })
+        found = {}
+        queue = PriorityQueue.new
+        queue.add(1, [start, [], 0])
+
+        loop do
+          spot, path, steps = queue.next
+          next if found[spot]
+
+          yield spot, path
+
+          found[spot] = true
+          @maze.adjacent_spots(spot).each do |new_spot|
+            next if found[new_spot]
+
+            new_steps = steps + 1
+
+            queue.add(
+              new_steps + estimator.call(new_spot),
+              [new_spot, [*path, new_spot], new_steps]
+            )
+          end
+          break if queue.empty?
+        end
+      end
+    end
+
+    class PathCache
+      def initialize(maze)
+        @cache = {}
+        @maze = maze
+      end
+
+      def fetch(from, to)
+        @cache[[from, to]] ||= Pathfinder.new(@maze).path(from, to)
+      end
+    end
+
+    def minimum_path(maze, start, goals, return_home: false)
+      cache = PathCache.new(maze)
+
+      goals.permutation.map do |goal_order|
+        current = start
+        path = goal_order.flat_map do |goal|
+          segment = cache.fetch(current, goal)
+          current = goal
+
+          segment
+        end
+
+        path += cache.fetch(current, start) if return_home
+
+        path
+      end.min_by(&:length)
+    end
+
+    nodes = {}
+    start = nil
+    goals = []
+
+    INPUT.split("\n").each_with_index do |line, row|
+      line.chars.each_with_index do |char, column|
+        node = [row, column]
+
+        case char
+        when "0"
+          start = node
+        when /\d/
+          goals << node
+        end
+
+        nodes[node] = (char == "#")
+      end
+    end
+
+    maze = Maze.new(nodes)
+    path = minimum_path(maze, start, goals)
+
+    solve!("The minimal path length to hit all goals is:", path.length)
+
+    path = minimum_path(maze, start, goals, return_home: true)
+
+    solve!("The minimal path length to hit all goals and come back home is:", path.length)

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

@@ -0,0 +1,41 @@
+---
+- :name: 25.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2016
+  :solution: |-
+    require_relative "shared/assembunny"
+
+    def sequence(&generator)
+      Enumerator.new do |yielder|
+        n = 0
+        loop do
+          yielder.yield generator.call(n)
+          n += 1
+        end
+      end
+    end
+
+    # There are a handful of false positives if you set this too low.
+    SIGNAL_CUTOFF = 8
+    CLOCK_SIGNAL = sequence { |i| i.even? ? 0 : 1 }.freeze
+
+    def run(start)
+      registers = Hash.new(0).tap { |h| h["a"] = start }
+      computer = Assembunny.new(registers)
+      outputs = []
+
+      computer.run(INSTRUCTIONS) do |output|
+        outputs << output
+        break if outputs != CLOCK_SIGNAL.take(outputs.length)
+        break start if outputs.length == SIGNAL_CUTOFF
+      end
+    end
+
+    start = nil
+    i = 0
+
+    while start.nil?
+      start = run(i)
+      i += 1
+    end
+
+    solve!("The first number that initiates a clock sequence is:", start)

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

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

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

@@ -0,0 +1,18 @@
+---
+- :name: 01.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    SEQUENCE = INPUT.chars.map(&:to_i)
+
+    def sum(sequence, gap = 1)
+      sum = 0
+      sequence.each_with_index do |i, j|
+        comparison = (j + gap) % sequence.length
+        sum += i if i == sequence[comparison]
+      end
+
+      sum
+    end
+
+    solve!("The sum of matching numbers is:", sum(SEQUENCE))
+    solve!("The sum of matching numbers (with a gap) is:", sum(SEQUENCE, SEQUENCE.length / 2))

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

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

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

@@ -0,0 +1,18 @@
+---
+- :name: 02.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    ROWS = INPUT.split("\n").map do |row|
+      row.split.map(&:to_i)
+    end
+
+    checksum = ROWS.sum { |row| row.max - row.min }
+    solve!("The checksum by difference is:", checksum)
+
+    checksum = ROWS.sum do |row|
+      row.detect do |i|
+        divisor = row.detect { |j| i != j && i % j == 0 }
+        break (i / divisor) if divisor
+      end
+    end
+    solve!("The checksum by division is:", checksum)

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

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

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

@@ -0,0 +1,61 @@
+---
+- :name: 03.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    require "set"
+
+    def grid_to(input, &value_for)
+      grid = {[0, 0] => 1}
+      current = {x: 0, y: 0}
+      used = {
+        min: {x: 0, y: 0},
+        max: {x: 0, y: 0}
+      }
+
+      value = 1
+      direction = :x
+      move = 1
+
+      while value <= input
+        current[direction] = current[direction] + move
+
+        if (move < 0 && used[:min][direction] > current[direction]) ||
+            (move > 0 && used[:max][direction] < current[direction])
+          type = (move < 0) ? :min : :max
+          used[type][direction] = current[direction]
+
+          direction, move =
+            case [direction, move]
+            when [:x, 1] then [:y, -1]
+            when [:y, -1] then [:x, -1]
+            when [:x, -1] then [:y, 1]
+            when [:y, 1] then [:x, 1]
+            end
+        end
+
+        value = value_for.call(value, grid, current[:x], current[:y])
+        grid[[current[:x], current[:y]]] = value
+      end
+
+      grid
+    end
+
+    def distance(input)
+      grid_to(input) { |last| last + 1 }.key(input).sum(&:abs)
+    end
+
+    def above(input)
+      grid_to(input) do |_, grid, x, y|
+        grid[[x - 1, y]].to_i +
+          grid[[x + 1, y]].to_i +
+          grid[[x, y - 1]].to_i +
+          grid[[x, y + 1]].to_i +
+          grid[[x - 1, y - 1]].to_i +
+          grid[[x - 1, y + 1]].to_i +
+          grid[[x + 1, y - 1]].to_i +
+          grid[[x + 1, y + 1]].to_i
+      end.values.last
+    end
+
+    solve!("The Manhattan distance from 1 to #{INPUT} is:", distance(INPUT.to_i))
+    solve!("The first number above #{INPUT} is:", above(INPUT.to_i))

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

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

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

@@ -0,0 +1,17 @@
+---
+- :name: 04.rb
+  :url: https://github.com/ahorner/advent-of-code/blob/main/lib/2017
+  :solution: |-
+    PASSWORDS = INPUT.split("\n").map(&:split)
+
+    def valid_count(passwords)
+      passwords.count do |words|
+        words.none? { |word| words.count(word) > 1 }
+      end
+    end
+
+    solve!("Number of valid passwords:", valid_count(PASSWORDS))
+
+    DEANAGRAMIZED_PASSWORDS = PASSWORDS.map { |row| row.map { |word| word.chars.sort.join } }
+
+    solve!("Number of valid passwords (no anagrams):", valid_count(DEANAGRAMIZED_PASSWORDS))

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

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