advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2020/18_1.yml

@@ -0,0 +1,13 @@
+---
+- :name: 18a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    using Module.new {
+      refine(defined?(Fixnum) ? Fixnum : Integer) do
+        alias_method :-, :*
+      end
+    }
+
+    p File.readlines('18.txt', chomp: true).sum { |line|
+      eval(line.gsub('*', '-'))
+    }

data/data/solutions/github/eregon/2020/18_2.yml

@@ -0,0 +1,13 @@
+---
+- :name: 18b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    using Module.new {
+      refine(defined?(Fixnum) ? Fixnum : Integer) do
+        alias_method :**, :+
+      end
+    }
+
+    p File.readlines('18.txt', chomp: true).sum { |line|
+      eval(line.gsub('+', '**'))
+    }

data/data/solutions/github/eregon/2020/19_1.yml

@@ -0,0 +1,19 @@
+---
+- :name: 19a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    rules, messages = File.read('19.txt').split("\n\n")
+    rules = rules.lines.to_h { |line| line.chomp.split(': ', 2).then { [Integer(_1), _2] } }
+    regexps = Hash.new { |h, n|
+      rule = rules.fetch(n)
+      h[rule] = if /^"(?<c>.)"$/ =~ rule
+        /#{Regexp.escape c}/
+      else
+        Regexp.union rule.split(' | ').map { |subrule|
+          Regexp.new subrule.split.map { |part| regexps[Integer(part)] }.join
+        }
+      end
+    }
+
+    valid = /\A#{regexps[0]}\z/
+    p messages.lines.map(&:chomp).grep(valid).size

data/data/solutions/github/eregon/2020/19_2.yml

@@ -0,0 +1,55 @@
+---
+- :name: 19b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    rules, messages = File.read('19.txt').split("\n\n")
+    rules = rules.lines.to_h { |line| line.chomp.split(': ', 2).then { [Integer(_1), _2] } }
+    can_expand = false
+    regexps = Hash.new { |h, n|
+      raise "Must not expand #{n} yet" if !can_expand and (n == 8 or n == 11)
+      rule = rules.fetch(n)
+      h[rule] = if /^"(?<c>.)"$/ =~ rule
+        /#{Regexp.escape c}/
+      else
+        Regexp.union rule.split(' | ').map { |subrule|
+          Regexp.new subrule.split.map { |part| regexps[Integer(part)] }.join
+        }
+      end
+    }
+
+    # 8: 42 | 42 8
+    regexps[8] = /#{regexps[42]}+/
+    # 11: 42 31 | 42 11 31
+    regexps[11] = /(?<eleven>#{regexps[42]}(?:\g<eleven>)?#{regexps[31]})/
+
+    can_expand = true
+    valid = /\A#{regexps[0]}\z/
+    p messages.lines.map(&:chomp).grep(valid).size
+- :name: 19b_generic.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    rules, messages = File.read('19.txt').split("\n\n")
+    rules = rules.lines.to_h { |line| line.chomp.split(': ', 2).then { [Integer(_1), _2] } }
+    rules[8] = '42 | 42 8'
+    rules[11] = '42 31 | 42 11 31'
+
+    regexps = Hash.new { |h, n|
+      rule = rules.fetch(n)
+      h[rule] = if /^"(?<c>.)"$/ =~ rule
+        /#{Regexp.escape c}/
+      else
+        /(?<g#{n}>#{rule.split(' | ').map { |subrule|
+          subrule.split.map { |part|
+            part = Integer(part)
+            if part == n
+              "(?:\\g<g#{n}>)"
+            else
+              regexps[part]
+            end
+          }.join
+        }.join('|')})/
+      end
+    }
+
+    valid = /\A#{regexps[0]}\z/
+    p messages.lines.map(&:chomp).grep(valid).size

data/data/solutions/github/eregon/2020/20_1.yml

@@ -0,0 +1,37 @@
+---
+- :name: 20a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    tiles = File.read('20.txt').split("\n\n").to_h { |chunk|
+      chunk.lines.then { |id,*lines|
+        [Integer(id[/\d+/]), lines.map { |line| line.chomp.tr('#.', '10').chars }]
+      }
+    }
+
+    def normalize(border)
+      a = Integer(border.join, 2)
+      b = Integer(border.join.reverse, 2)
+      [a, b].min
+    end
+
+    borders = tiles.to_h { |id, tile|
+      [
+        id,
+        [
+          normalize(tile[0]),
+          normalize(tile[-1]),
+          normalize(tile.map { _1[0] }),
+          normalize(tile.map { _1[-1] }),
+        ]
+      ]
+    }
+
+    corners = tiles.select { |id, tile|
+      borders[id].count { |border|
+        borders.none? { |other_id, other_borders|
+          id != other_id and other_borders.include?(border)
+        }
+      } == 2
+    }
+
+    p corners.keys.reduce(:*)

data/data/solutions/github/eregon/2020/20_2.yml

@@ -0,0 +1,196 @@
+---
+- :name: 20b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    class Tile
+      attr_reader :id, :rows, :borders, :normalized_borders, :neighbors
+      def initialize(id, rows)
+        @id = id
+        @rows = rows
+        @borders = [rows[0], rows.map { _1[-1] }, rows[-1], rows.map { _1[0] }]
+        @normalized_borders = @borders.map { normalize(_1) }
+        @neighbors = Array.new(4)
+      end
+
+      def attach(bi, other, oi)
+        raise unless @normalized_borders[bi] == other.normalized_borders[oi]
+        if other.neighbors[oi] != self && !other.neighbors.all?(&:nil?)
+          raise "#{other} already has neighbors: #{other.neighbors}[#{oi}]; #{self} #{neighbors}[#{bi}]"
+        end
+
+        until (bi-oi).abs == 2
+          other.rotate_right
+          oi = (oi + 1) % 4
+        end
+        raise unless (bi-oi).abs == 2
+
+        unless @borders[bi] == other.borders[oi]
+          raise unless @borders[bi] == other.borders[oi].reverse
+          if oi.even?
+            other.flip_horizontally
+          else
+            other.flip_vertically
+          end
+        end
+        raise unless @borders[bi] == other.borders[oi]
+
+        @neighbors[bi] = other
+      end
+
+      def rotate_right
+        replace Tile.new(@id, rows.rotate_right)
+      end
+
+      def flip_horizontally
+        replace Tile.new(@id, rows.flip_horizontally)
+      end
+
+      def flip_vertically
+        replace Tile.new(@id, rows.flip_vertically)
+      end
+
+      def replace(other)
+        raise @neighbors.to_s if $check and !@neighbors.all?(&:nil?)
+        @rows = other.rows
+        @borders = other.borders
+        @normalized_borders = other.normalized_borders
+      end
+
+      def normalize(border)
+        a = Integer(border.join, 2)
+        b = Integer(border.join.reverse, 2)
+        [a, b].min
+      end
+
+      def to_s
+        "#{@id}"
+      end
+      alias inspect to_s
+    end
+
+    tiles = File.read('20.txt').split("\n\n").map { |chunk|
+      chunk.lines.then { |id,*lines|
+        Tile.new(Integer(id[/\d+/]), lines.map { |line| line.chomp.tr('#.', '10').chars })
+      }
+    }
+
+    SIDE = Integer.sqrt(tiles.size)
+
+    corresponding_tiles = tiles.flat_map(&:normalized_borders).tally.values.tally
+    unless corresponding_tiles == { 1 => SIDE * 4, 2 => (tiles.size - SIDE) * 4 / 2 }
+      raise corresponding_tiles.to_s
+    end
+
+    $check = true
+
+    visited = {}
+    todo = [tiles.first]
+    while current = todo.shift
+      visited[current] = true
+      current.normalized_borders.each_with_index { |border, bi|
+        other = tiles.find { |other| other != current and other.normalized_borders.include?(border) }
+        if other
+          oi = other.normalized_borders.index(border)
+          current.attach(bi, other, oi)
+          todo << other unless visited.include?(other)
+        end
+      }
+    end
+
+    $check = false
+
+    top_left = tiles.find { |tile|
+      tile.normalized_borders.values_at(0, 3).all? { |border|
+        tiles.none? { |other_tile|
+          tile != other_tile and other_tile.normalized_borders.include?(border)
+        }
+      }
+    }
+
+    board = SIDE.times.map { |y|
+      first_in_row = top_left
+      y.times { first_in_row = first_in_row.neighbors[2] }
+      SIDE.times.map { |x|
+        tile = first_in_row
+        x.times { tile = tile.neighbors[1] }
+        tile
+      }
+    }
+
+    def board.to_s
+      out = +''
+      self.each { |row|
+        in_row = row.map { |tile|
+          Matrix2D.new(tile.rows[1...-1].map { _1[1...-1] }).map { |cell,|
+            cell.tr('10', '#.')
+          }.rows.map(&:join)
+        }
+        out << in_row.transpose.map { _1.join('') }.join("\n") << "\n"
+      }
+      out
+    end
+
+    SEA_MONSTER = <<MONSTER
+                      #
+    #    ##    ##    ###
+     #  #  #  #  #  #
+    MONSTER
+
+    SEA_MONSTER_MARKS = SEA_MONSTER.lines.map { |line|
+      line.chomp.chars.map.with_index.select { |c,i| c == '#' }.map(&:last)
+    }
+
+    MONSTER_REGEXPS = SEA_MONSTER.lines.map(&:chomp).map.with_index { |line, i|
+      /#{'\G' if i != 1}#{line.tr(' ', '.')}/
+    }
+
+    def matches?(str)
+      if start1 = MONSTER_REGEXPS[1] =~ str
+        line_length = str.lines.first.size
+        start0 = start1 - line_length
+        start2 = start1 + line_length
+        if str.match(MONSTER_REGEXPS[0], start0) and str.match(MONSTER_REGEXPS[2], start2)
+          start0
+        end
+      end
+    end
+
+    def search(board)
+      tiles = board.flatten(1)
+
+      order = [:rotate_right] * 4 +
+        [:flip_vertically] +
+        [:rotate_right] * 4 +
+        [:flip_horizontally] +
+        [:rotate_right] * 4
+
+      order.each { |transformation|
+        str = board.to_s
+        line_length = str.lines.first.size
+        if matches?(str)
+          monsters = 0
+          while start = matches?(str)
+            SEA_MONSTER_MARKS.each_with_index { |cols, line|
+              cols.each { |col|
+                offset = start + line * line_length + col
+                raise unless str[offset] == '#'
+                str[offset] = 'O'
+              }
+            }
+            monsters += 1
+          end
+
+          p monsters
+          return str
+        else
+          tiles.each(&transformation)
+          board.replace board.then(&transformation)
+        end
+      }
+    end
+
+    puts str = search(board)
+    p str.count('#')

data/data/solutions/github/eregon/2020/21_1.yml

@@ -0,0 +1,15 @@
+---
+- :name: 21a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    foods = File.readlines('21.txt', chomp: true).map { |line|
+      line.split(' (contains ', 2).then { [_1.split.map(&:to_sym), _2.chomp(')').split(', ').map(&:to_sym)] }
+    }
+
+    per_allergen = Hash.new { |h,k| h[k] = [] }
+    foods.each { |ingredients, allergens|
+      allergens.each { |allergen| per_allergen[allergen] << ingredients }
+    }
+    per_allergen = per_allergen.transform_values { _1.reduce(:&) }
+    all_ingredients = foods.map(&:first).reduce(:+)
+    p (all_ingredients - per_allergen.values.reduce(:|)).size

data/data/solutions/github/eregon/2020/21_2.yml

@@ -0,0 +1,25 @@
+---
+- :name: 21b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    foods = File.readlines('21.txt', chomp: true).map { |line|
+      line.split(' (contains ', 2).then { [_1.split.map(&:to_sym), _2.chomp(')').split(', ').map(&:to_sym)] }
+    }
+
+    per_allergen = Hash.new { |h,k| h[k] = [] }
+    foods.each { |ingredients, allergens|
+      allergens.each { |allergen| per_allergen[allergen] << ingredients }
+    }
+    per_allergen = per_allergen.transform_values { _1.reduce(:&) }
+
+    known = {}
+    until per_allergen.empty?
+      per_allergen.select { |allergen, ingredients|
+        ingredients.size == 1
+      }.each { |allergen, (ingredient, *)|
+        known[ingredient] = allergen
+        per_allergen.delete(allergen)
+        per_allergen.each_value { _1.delete(ingredient) }
+      }
+    end
+    puts known.sort_by(&:last).map(&:first).join(',')

data/data/solutions/github/eregon/2020/22_1.yml

@@ -0,0 +1,18 @@
+---
+- :name: 22a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    p1, p2 = decks = File.read('22.txt').strip.split("\n\n").map { |chunk|
+      chunk.lines.then { |player, *cards| cards.map { Integer(_1) } }
+    }
+
+    until decks.any?(&:empty?)
+      a, b = decks.map(&:shift)
+      if a > b
+        p1 << a << b
+      else
+        p2 << b << a
+      end
+    end
+
+    p decks.reject(&:empty?)[0].reverse.map.with_index(1) { |card, i| card * i }.sum

data/data/solutions/github/eregon/2020/22_2.yml

@@ -0,0 +1,42 @@
+---
+- :name: 22b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    decks = File.read('22.txt').strip.split("\n\n").map { |chunk|
+      chunk.lines.then { |player, *cards| cards.map { |c| Integer(c) } }
+    }
+
+    def play_game(decks)
+      p1, p2 = decks
+      seen = {}
+
+      until decks.any?(&:empty?)
+        if seen[decks]
+          return [1, decks]
+        else
+          seen[decks.map(&:dup)] = true
+        end
+
+        a, b = decks.map(&:shift)
+
+        if p1.size >= a and p2.size >= b
+          if play_game([p1.take(a), p2.take(b)])[0] == 1
+            p1 << a << b
+          else
+            p2 << b << a
+          end
+        else
+          if a > b
+            p1 << a << b
+          else
+            p2 << b << a
+          end
+        end
+      end
+
+      winner = p1.empty? ? 2 : 1
+      [winner, decks]
+    end
+
+    winner, decks = play_game(decks)
+    p decks.reject(&:empty?)[0].reverse.map.with_index(1) { |card, i| card * i }.sum

data/data/solutions/github/eregon/2020/23_1.yml

@@ -0,0 +1,87 @@
+---
+- :name: 23a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    class Node
+      attr_reader :value
+      attr_accessor :prev, :next
+
+      def initialize(value)
+        @value = value
+      end
+
+      def remove
+        @prev.next, @next.prev = @next, @prev
+        @prev, @next = nil, nil
+        self
+      end
+
+      def insert_after(node)
+        @prev, @next = node, node.next
+        @prev.next, @next.prev = self, self
+        self
+      end
+
+      def to_s
+        value.to_s
+      end
+      alias_method :inspect, :to_s
+    end
+
+    class CyclicLinkedList
+      attr_reader :current
+      include Enumerable
+
+      def initialize(values)
+        @nodes = values.map { |v| Node.new(v) }
+        (@nodes.each_cons(2).to_a + [[@nodes.last, @nodes.first]]).each { |a,b|
+          a.next, b.prev = b, a
+        }
+
+        @current = @nodes.first
+      end
+
+      def advance!
+        @current = @current.next
+      end
+
+      def each
+        node = @current
+        begin
+          yield node
+          node = node.next
+        end while node != @current
+        self
+      end
+
+      def to_s
+        ary = to_a
+        ary[0] = "(#{ary[0]})"
+        ary.join(' ')
+      end
+      alias_method :inspect, :to_s
+    end
+
+    values = File.read('23.txt').strip.chars.map { |i| Integer(i) }
+
+    min, max = values.minmax
+    list = CyclicLinkedList.new(values)
+
+    100.times do
+      pick = 3.times.map { list.current.next.remove }
+
+      destination = list.current.value
+      begin
+        destination = destination == min ? max : destination - 1
+      end while pick.any? { |node| node.value == destination }
+
+      insert = list.find { |node| node.value == destination }
+      pick.each { |node|
+        insert = node.insert_after(insert)
+      }
+
+      list.advance!
+    end
+
+    list.advance! until list.current.value == 1
+    puts list.drop(1).join

data/data/solutions/github/eregon/2020/23_2.yml

@@ -0,0 +1,91 @@
+---
+- :name: 23b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    class Node
+      attr_reader :value
+      attr_accessor :prev, :next
+
+      def initialize(value)
+        @value = value
+      end
+
+      def remove
+        @prev.next, @next.prev = @next, @prev
+        @prev, @next = nil, nil
+        self
+      end
+
+      def insert_after(node)
+        @prev, @next = node, node.next
+        @prev.next, @next.prev = self, self
+        self
+      end
+
+      def to_s
+        value.to_s
+      end
+      alias_method :inspect, :to_s
+    end
+
+    class CyclicLinkedList
+      attr_reader :current
+      include Enumerable
+
+      def initialize(values)
+        @nodes = values.map { |v| Node.new(v) }
+        (@nodes.each_cons(2).to_a + [[@nodes.last, @nodes.first]]).each { |a,b|
+          a.next, b.prev = b, a
+        }
+
+        @current = @nodes.first
+      end
+
+      def advance!
+        @current = @current.next
+      end
+
+      def each
+        node = @current
+        begin
+          yield node
+          node = node.next
+        end while node != @current
+        self
+      end
+
+      def to_s
+        ary = to_a
+        ary[0] = "(#{ary[0]})"
+        ary.join(' ')
+      end
+      alias_method :inspect, :to_s
+    end
+
+    values = File.read('23.txt').strip.chars.map { |i| Integer(i) }
+    values += (values.max+1..1_000_000).to_a
+
+    min, max = values.minmax
+    list = CyclicLinkedList.new(values)
+
+    nodes = Array.new(1_000_001)
+    list.each { |node| nodes[node.value] = node }
+    nodes.freeze
+
+    10_000_000.times do
+      pick = 3.times.map { list.current.next.remove }
+
+      destination = list.current.value
+      begin
+        destination = destination == min ? max : destination - 1
+      end while pick.any? { |node| node.value == destination }
+
+      insert = nodes[destination]
+      pick.each { |node|
+        insert = node.insert_after(insert)
+      }
+
+      list.advance!
+    end
+
+    p [nodes[1].next, nodes[1].next.next].map(&:value).reduce(:*)

data/data/solutions/github/eregon/2020/24_1.yml

@@ -0,0 +1,34 @@
+---
+- :name: 24a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    moves = File.readlines('24.txt', chomp: true).map { |line| line.scan(/e|se|sw|w|nw|ne/).map(&:to_sym) }
+
+    #  NW NE
+    # W  O  E
+    #  SW SE
+    # --> 1
+    # \
+    #  v
+    #   1
+
+    WHITE, BLACK = false, true
+
+    tiles = Hash.new(WHITE)
+
+    DIRS = {
+      e:  0i + 1,
+      se: 1i,
+      sw: 1i - 1,
+      w:  0i - 1,
+      nw: -1i,
+      ne: -1i + 1,
+    }.freeze
+
+    moves.each { |move|
+      pos = 0 + 0i
+      move.each { |step| pos += DIRS[step] }
+      tiles[pos] = !tiles[pos]
+    }
+
+    p tiles.values.count(BLACK)