advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,74 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    ranges = {}
+
+    fields = input.scan(/([\w\s]*:.+)\n/).flatten
+
+    fields.each_with_index do |field|
+      key = field.match(/(.*):/).captures[0]
+
+      range_set = field.split(" or ").map do |range|
+        range = range.scan(/\d+-\d+/)[0]
+        Range.new(*range.split("-").map(&:to_i))
+      end
+
+      ranges[key] = range_set
+    end
+
+    nearby = input.match(/nearby tickets:\n([\d,\n]+)\n\n/).captures.first
+    nearby_tickets = nearby.split("\n").map do |ticket|
+      ticket.split(?,).map(&:to_i)
+    end
+
+    invalid_values = nearby_tickets.flatten.select do |value|
+      ranges.values.flatten.none? { |range| range.cover?(value) }
+    end
+
+    puts invalid_values.sum
+
+    # Part 2
+
+    valid_tickets = nearby_tickets.select do |nums|
+      nums.all? { |value|
+        ranges.values.flatten.any? { |range| range.cover?(value) }
+      }
+    end
+
+    columns = valid_tickets.transpose
+
+    keys_per_col = columns.map do |col|
+      ranges.keys.select { |key|
+        col.all? { |value|
+          ranges[key].any? { |range| range.cover?(value) }
+        }
+      }
+    end
+
+    # Map each key to a column index
+    key_to_col = {}
+
+    # Luckily this greedy approach works
+    while keys_per_col.any?(&:any?)
+      keys_per_col.each_with_index do |col, idx|
+        next if col.empty? || col.size > 1
+
+        key = col.first
+        key_to_col[key] = idx
+
+        keys_per_col.each do |col|
+          col.delete(key)
+        end
+      end
+    end
+
+    your_ticket = input.match(/your ticket:\n(\S+)/).captures.first
+      .split(",").map(&:to_i)
+
+    puts ranges.keys
+      .select { |key| key.include?("departure") }
+      .map { |key| your_ticket[key_to_col[key]] }
+      .inject(:*)

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

@@ -0,0 +1,74 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    ranges = {}
+
+    fields = input.scan(/([\w\s]*:.+)\n/).flatten
+
+    fields.each_with_index do |field|
+      key = field.match(/(.*):/).captures[0]
+
+      range_set = field.split(" or ").map do |range|
+        range = range.scan(/\d+-\d+/)[0]
+        Range.new(*range.split("-").map(&:to_i))
+      end
+
+      ranges[key] = range_set
+    end
+
+    nearby = input.match(/nearby tickets:\n([\d,\n]+)\n\n/).captures.first
+    nearby_tickets = nearby.split("\n").map do |ticket|
+      ticket.split(?,).map(&:to_i)
+    end
+
+    invalid_values = nearby_tickets.flatten.select do |value|
+      ranges.values.flatten.none? { |range| range.cover?(value) }
+    end
+
+    puts invalid_values.sum
+
+    # Part 2
+
+    valid_tickets = nearby_tickets.select do |nums|
+      nums.all? { |value|
+        ranges.values.flatten.any? { |range| range.cover?(value) }
+      }
+    end
+
+    columns = valid_tickets.transpose
+
+    keys_per_col = columns.map do |col|
+      ranges.keys.select { |key|
+        col.all? { |value|
+          ranges[key].any? { |range| range.cover?(value) }
+        }
+      }
+    end
+
+    # Map each key to a column index
+    key_to_col = {}
+
+    # Luckily this greedy approach works
+    while keys_per_col.any?(&:any?)
+      keys_per_col.each_with_index do |col, idx|
+        next if col.empty? || col.size > 1
+
+        key = col.first
+        key_to_col[key] = idx
+
+        keys_per_col.each do |col|
+          col.delete(key)
+        end
+      end
+    end
+
+    your_ticket = input.match(/your ticket:\n(\S+)/).captures.first
+      .split(",").map(&:to_i)
+
+    puts ranges.keys
+      .select { |key| key.include?("departure") }
+      .map { |key| your_ticket[key_to_col[key]] }
+      .inject(:*)

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

@@ -0,0 +1,75 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-17
+  :solution: |-
+    slice = input.split("\n").map { |a| a.split("") }
+
+    slices = [slice]
+
+    def neighbours(x, y, z, slices)
+      diff = [-1, 0, 1]
+
+      diff.product(diff, diff)
+        .reject { |d| d == [0,0,0] }
+        .map { |dx, dy, dz| [x + dx, y + dy, z + dz] }
+        .select {|x,y,z|
+          (0..slices.size-1).cover?(z) &&
+            (0..slices[z].size-1).cover?(y) &&
+            (0..slices[z].size-1).cover?(x)
+        }
+    end
+
+    def row(size)
+      Array.new(size, ?.)
+    end
+
+    def slice(size)
+      Array.new(size) { row(size) }
+    end
+
+    6.times do |i|
+      size = slices[0].size + 2
+
+      slices.each do |slice|
+        slice.each do |row|
+          row.unshift ?.
+          row << ?.
+        end
+
+        slice.unshift row(size)
+        slice << row(size)
+      end
+
+      slices.unshift slice(size)
+      slices << slice(size)
+
+      new_slices = slices.map { |slice| slice.map(&:dup) }
+
+      slices.each_with_index do |slice, z|
+        slice.each_with_index do |row, y|
+          row.each_with_index do |cell, x|
+            count = neighbours(x, y, z, slices)
+              .map { |x1, y1, z1| slices[z1][y1][x1] }
+              .count { |c1| c1 == ?# }
+
+            if cell == ?#
+              if !(count == 2 || count == 3)
+                new_slices[z][y][x] = ?.
+              end
+            elsif count == 3
+              new_slices[z][y][x] = ?#
+            end
+          end
+        end
+      end
+
+      slices = new_slices
+
+      #puts "Cycle #{i + 1}"
+      #slices.each_with_index do |slice, idx|
+      #  puts -slice.size / 2 + 1 + idx
+      #  puts slice.map(&:join).join("\n")
+      #end
+    end
+
+    puts slices.flatten.count { |c| c == ?# }

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

@@ -0,0 +1,91 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-17
+  :solution: |-
+    slice = input.split("\n").map { |a| a.split("") }
+
+    size = slice.length
+
+    cubes = [[slice]]
+
+    def neighbours(x, y, z, w, cubes)
+      diff = [-1, 0, 1]
+
+      diff.product(diff, diff, diff)
+        .reject { |d| d == [0, 0, 0, 0] }
+        .map { |dx, dy, dz, dw| [x + dx ,y + dy, z + dz, w + dw] }
+        .select {|x,y,z,w|
+          (0..cubes.size-1).cover?(w) &&
+            (0..cubes[w].size-1).cover?(z) &&
+            (0..cubes[w][z].size-1).cover?(y) &&
+            (0..cubes[w][z].size-1).cover?(x)
+        }
+    end
+
+    def row(size)
+      Array.new(size, ?.)
+    end
+
+    def slice(size)
+      Array.new(size) { row(size) }
+    end
+
+    def cube(size)
+      Array.new(size - 2) { slice(size) }
+    end
+
+    6.times do |i|
+      size += 2
+
+      cubes.each do |cube|
+        cube.each do |slice|
+          slice.each do |row|
+            row.unshift ?.
+            row << ?.
+          end
+
+          slice.unshift row(size)
+          slice << row(size)
+        end
+
+        cube.unshift slice(size)
+        cube << slice(size)
+      end
+
+      cubes.unshift cube(size)
+      cubes << cube(size)
+
+      new_cubes = cubes.map { |slice| slice.map { |s| s.map(&:dup) } }
+
+      cubes.each_with_index do |cube, w|
+        cube.each_with_index do |slice, z|
+          slice.each_with_index do |row, y|
+            row.each_with_index do |cell, x|
+              count = neighbours(x, y, z, w, cubes)
+                .map { |x1, y1, z1, w1| cubes[w1][z1][y1][x1] }
+                .count { |c1| c1 == ?# }
+
+              if cell == ?#
+                if !(count == 2 || count == 3)
+                  new_cubes[w][z][y][x] = ?.
+                end
+              elsif count == 3
+                new_cubes[w][z][y][x] = ?#
+              end
+            end
+          end
+        end
+      end
+
+      cubes = new_cubes
+
+      #puts "Cycle #{i + 1}"
+      #cubes.each_with_index do |cube, w|
+      #  cube.each_with_index do |slice, z|
+      #    puts [-cube.size / 2 + 1 + z, -cubes.size / 2 + 1 + w].inspect
+      #    puts slice.map(&:join).join("\n")
+      #  end
+      #end
+    end
+
+    puts cubes.flatten.count { |c| c == ?# }

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

@@ -0,0 +1,44 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-18
+  :solution: |-
+    lines = input.split("\n")
+
+    sum = 0
+
+    def sum(exp)
+      result = exp.shift.to_i
+
+      exp.each_slice(2) do |op, num|
+        result = result.send(op, num.to_i)
+      end
+
+      result
+    end
+
+    lines.each do |line|
+      tokens = line.gsub(/\s/, '').chars
+
+      stack = []
+
+      tokens.each do |token|
+        if token =~ /[\d\*\+\(]+/
+          stack << token
+        else # ?(
+          exp = []
+
+          while stack.last != ?(
+            exp << stack.pop
+          end
+          stack.pop # ?(
+
+          result = sum(exp.reverse)
+
+          stack << result
+        end
+      end
+
+      sum += sum(stack)
+    end
+
+    puts sum

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

@@ -0,0 +1,44 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-18
+  :solution: |-
+    lines = input.split("\n")
+
+    sum = 0
+
+    lines.each do |line|
+      tokens = line.gsub(/\s/, '').chars
+
+      stack = []
+
+      tokens.each do |token|
+        if token =~ /\d/
+          stack << token.to_i
+        elsif token =~ /[\+\*\(]+/
+          stack << token
+        else # ?(
+          exp = []
+
+          while stack.last != ?(
+            exp << stack.pop
+          end
+          stack.pop # ?(
+
+          result = eval(exp.join)
+
+          stack << result
+        end
+
+        while stack.last.is_a?(Integer) && stack[-2] == ?+
+          num1 = stack.pop
+          stack.pop # ?+
+          num2 = stack.pop
+
+          stack << num1 + num2
+        end
+      end
+
+      sum += eval(stack.reverse.join)
+    end
+
+    puts sum

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

@@ -0,0 +1,28 @@
+---
+- :name: day-19-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-19
+  :solution: |-
+    rules, msgs = input.split("\n\n")
+
+    rule_map = {}
+
+    rules.split("\n").each do |rule|
+      key, rule = rule.split(": ")
+
+      rule.gsub!(?", "")
+      rule.gsub!(/(\d+)/, '[\1]')
+      rule = "(#{rule})" if rule.include? ?|
+
+      rule_map[key] = rule
+    end
+
+    while rule_map[?0] =~ /\d/
+      zero = rule_map[?0]
+      rule = zero.scan(/\d+/)[0]
+      zero.gsub!(/\[#{rule}\]/, rule_map[rule])
+    end
+
+    rule_map[?0].gsub!(/\s/, '')
+    regex = Regexp.new("^#{rule_map[?0]}$")
+
+    puts msgs.split("\n").count { |msg| regex.match(msg) }

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

@@ -0,0 +1,32 @@
+---
+- :name: day-19-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-19
+  :solution: |-
+    rules, msgs = input.split("\n\n")
+
+    rule_map = {}
+
+    rules.split("\n").each do |rule|
+      key, rule = rule.split(": ")
+
+      rule.gsub!(?", "")
+      rule.gsub!(/(\d+)/, '[\1]')
+      rule = "(#{rule})" if rule.include? ?|
+
+      rule_map[key] = rule
+    end
+
+    rule_map["8"] = "([42]+)"
+    # https://ruby-doc.org/core-2.7.1/Regexp.html#class-Regexp-label-Subexpression+Calls
+    rule_map["11"] = "(?<recursive>[42]\\g<recursive>?[31])"
+
+    while rule_map[?0] =~ /\d/
+      zero = rule_map[?0]
+      rule = zero.scan(/\d+/)[0]
+      zero.gsub!(/\[#{rule}\]/, rule_map[rule])
+    end
+
+    rule_map[?0].gsub!(/\s/, '')
+    regex = Regexp.new("^#{rule_map[?0]}$")
+
+    puts msgs.split("\n").count { |msg| regex.match(msg) }

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

@@ -0,0 +1,186 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-20
+  :solution: |-
+    input     = File.read(file_path)
+
+    def rotate(tile)
+      tile.transpose.map(&:reverse)
+    end
+
+    def flip(tile)
+      tile.map(&:reverse)
+    end
+
+    def print(tile)
+      tile.map(&:join).join("\n")
+    end
+
+    # N, E, S, W
+    def borders(tile)
+      [
+        tile.first,
+        tile.transpose.last,
+        tile.last,
+        tile.transpose.first
+      ]
+    end
+
+    tiles = {}
+
+    input.split("\n\n").each do |tile|
+      id, tile = tile.match(/Tile (\d+):\n([\s\S]+)/).captures
+
+      id = id.to_i
+      tile = tile.split("\n").map(&:chars)
+
+      tiles[id] = tile
+    end
+
+    neighbours = Hash.new { |h, k| h[k] = [] }
+
+    tiles.keys.combination(2) do |tile1, tile2|
+      tile1_borders = borders(tiles[tile1])
+      tile2_borders = borders(tiles[tile2]) + borders(tiles[tile2]).map(&:reverse)
+
+      tile1_borders.each.with_index do |border1, idx|
+        tile2_borders.each.with_index do |border2, idx2|
+          if border1 == border2
+            neighbours[tile1] << tile2
+            neighbours[tile2] << tile1
+          end
+        end
+      end
+    end
+
+    corners = neighbours.keys.select { |tile_id| neighbours[tile_id].count == 2 }
+
+    puts corners.inject(&:*)
+
+    # Part 2
+
+    size = (tiles.size)**(0.5)
+    image = Array.new(size) { Array.new(size, nil) }
+    image_ids = Array.new(size) { Array.new(size, nil) }
+
+    corner_id = corners.first
+    tile = tiles[corner_id]
+
+    # Smallest index of matching borders
+    border_idx = borders(tile).map.with_index { |border, idx|
+      borders = neighbours[corner_id].flat_map { |id| borders(tiles[id]) }
+      borders += borders.map(&:reverse)
+
+      idx if borders.include?(border)
+    }.compact.min
+
+    # 1 == East
+    rotations = 1 - border_idx
+    rotations.times do
+      tile = rotate(tile)
+    end
+
+    image[0][0] = tile
+    image_ids[0][0] = corner_id
+
+    #
+    # For the first row (y == 0), match tiles on left and right borders (east and
+    # west).
+    # For all other row, match tiles on top and bottom borders (north and south).
+    #
+    (0..size-1).each do |y|
+      (0..size-1).each do |x|
+        next if y == 0 && x == 0 # corner_id piece already placed
+
+        # West neighbour if top row, else north neighbour
+        if y == 0
+          previous = image[y][x-1]
+          previous_id = image_ids[y][x-1]
+        else
+          previous = image[y-1][x]
+          previous_id = image_ids[y-1][x]
+        end
+
+        # East if top row, else south
+        if y == 0
+          border = borders(previous)[1]
+        else
+          border = borders(previous)[2]
+        end
+
+        tile_id = neighbours[previous_id].find do |id|
+          tile = tiles[id]
+          borders(tile).include?(border) ||
+            borders(tile).map(&:reverse).include?(border)
+        end
+
+        tile = tiles[tile_id]
+
+        # West if top row, else north
+        if y == 0
+          tile_dir = 3
+        else
+          tile_dir = 0
+        end
+
+        rotations = 0
+        while borders(tile)[tile_dir] != border
+          tile = rotate(tile)
+          rotations += 1
+          tile = flip(tile) if rotations == 4
+        end
+
+        image[y][x] = tile
+        image_ids[y][x] = tile_id
+      end
+    end
+
+    # Shave borders
+    image = image.map do |tiles_row|
+      tiles_row.map do |tile|
+        tile[1..-2].map { |row| row[1..-2] }
+      end
+    end
+
+    # Connect tiles
+    image = image.flat_map do |tiles_row|
+      tiles_row[0].zip(*tiles_row[1..-1]).map(&:flatten).map(&:join)
+    end
+
+    monster = [
+      "                  # ",
+      "#    ##    ##    ###",
+      " #  #  #  #  #  #   "
+    ]
+
+    monster_length = monster.first.size
+
+    monster_regexp = monster.map { |row|
+      Regexp.new(row.gsub(" ", "."))
+    }
+
+    rotations = 0
+    monsters = 0
+
+    while monsters == 0
+      (0..(image.size - 3)).each do |y|
+        ((monster_length - 1)..(image.first.length)).each do |x|
+          match = monster_regexp.each_with_index.all? { |regexp, idx|
+            image[y + idx][x - monster_length, monster_length] =~ regexp
+          }
+
+          monsters += 1 if match
+          x += 1
+        end
+      end
+
+      rotations += 1
+      image_chars = image.map(&:chars)
+
+      image_chars = rotate(image_chars)
+      image_chars = flip(image_chars) if rotations == 4
+      image = image_chars.map(&:join)
+    end
+
+    monster_chars = monster.join.chars.count { |char| char == ?# }
+    puts image.join.chars.count { |char| char == ?# } - (monsters * monster_chars)