advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,186 @@
+---
+- :name: day-20-part-2.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)

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

@@ -0,0 +1,49 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-21
+  :solution: |-
+    input     = File.read(file_path)
+
+    foods = input.split("\n")
+
+    all_allergens = {}
+    all_ingredients = []
+
+    foods.each do |food|
+      ingredients, allergens = food.match(/(.+)\(contains (.+)\)/).captures
+
+      ingredients = ingredients.split
+      allergens = allergens.split(/[\s,]+/)
+
+      allergens.each do |allergen|
+        if all_allergens[allergen]
+          all_allergens[allergen] = all_allergens[allergen] & ingredients
+        else
+          all_allergens[allergen] = ingredients
+        end
+      end
+
+      all_ingredients.concat(ingredients)
+    end
+
+    all_allergens.values.flatten.uniq.each do |allergen|
+      all_ingredients.delete(allergen)
+    end
+
+    puts all_ingredients.size
+
+    # Greedy works again
+    while all_allergens.values.map(&:size).any? { |allergen| allergen > 1 }
+      all_allergens.each do |allergen, possible|
+        next if possible.size > 1
+
+        all_allergens.each do |other_allergen, other_possible|
+          next if allergen == other_allergen
+          other_possible.delete(possible.first)
+        end
+      end
+    end
+
+    puts all_allergens.keys.sort
+      .flat_map { |allergen| all_allergens[allergen] }
+      .join(?,)

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

@@ -0,0 +1,49 @@
+---
+- :name: day-21-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-21
+  :solution: |-
+    input     = File.read(file_path)
+
+    foods = input.split("\n")
+
+    all_allergens = {}
+    all_ingredients = []
+
+    foods.each do |food|
+      ingredients, allergens = food.match(/(.+)\(contains (.+)\)/).captures
+
+      ingredients = ingredients.split
+      allergens = allergens.split(/[\s,]+/)
+
+      allergens.each do |allergen|
+        if all_allergens[allergen]
+          all_allergens[allergen] = all_allergens[allergen] & ingredients
+        else
+          all_allergens[allergen] = ingredients
+        end
+      end
+
+      all_ingredients.concat(ingredients)
+    end
+
+    all_allergens.values.flatten.uniq.each do |allergen|
+      all_ingredients.delete(allergen)
+    end
+
+    puts all_ingredients.size
+
+    # Greedy works again
+    while all_allergens.values.map(&:size).any? { |allergen| allergen > 1 }
+      all_allergens.each do |allergen, possible|
+        next if possible.size > 1
+
+        all_allergens.each do |other_allergen, other_possible|
+          next if allergen == other_allergen
+          other_possible.delete(possible.first)
+        end
+      end
+    end
+
+    puts all_allergens.keys.sort
+      .flat_map { |allergen| all_allergens[allergen] }
+      .join(?,)

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

@@ -0,0 +1,23 @@
+---
+- :name: day-22-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-22
+  :solution: |-
+    one = input.match(/1:\s((\d+\s)+)/).captures.first.split.map(&:to_i)
+    two = input.match(/2:\s((\d+\s)+)/).captures.first.split.map(&:to_i)
+
+    while one.any? && two.any?
+      o = one.shift
+      t = two.shift
+
+      if o > t
+        one << o
+        one << t
+      else
+        two << t
+        two << o
+      end
+    end
+
+    winner = one.any? ? one : two
+
+    puts winner.reverse.map.with_index { |num, idx| num * (idx + 1) }.sum

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

@@ -0,0 +1,41 @@
+---
+- :name: day-22-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-22
+  :solution: |-
+    input     = File.read(file_path)
+
+    one = input.match(/1:\s((\d+\s)+)/).captures.first.split.map(&:to_i)
+    two = input.match(/2:\s((\d+\s)+)/).captures.first.split.map(&:to_i)
+
+    def game(one, two, decks)
+      while one.any? && two.any?
+        return [true, one] if decks.include? [one, two]
+        decks.add [one, two]
+
+        o = one.shift
+        t = two.shift
+
+        if o <= one.size && t <= two.size
+          one_wins , _, _ = game(one[0, o], two[0, t], decks)
+        else
+          one_wins = o > t
+        end
+
+        if one_wins
+          one << o
+          one << t
+        else
+          two << t
+          two << o
+        end
+      end
+
+      winner = one.any? ? one : two
+      [one.any?, winner]
+    end
+
+    decks = Set.new
+
+    _, winner = game(one, two, decks)
+
+    puts winner.reverse.map.with_index { |num, idx| num * (idx + 1) }.sum

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

@@ -0,0 +1,33 @@
+---
+- :name: day-23-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-23
+  :solution: |-
+    input     = File.read(file_path)
+
+    cups = input.strip.chars.map(&:to_i)
+
+    current = cups.first
+
+    cups = cups.rotate(1)
+
+    100.times do
+      slice = cups.take(3)
+      cups = cups.drop(3)
+
+      dest = current
+      while
+        dest = (dest - 2) % cups.size + 1
+        break unless slice.include?(dest)
+      end
+
+      idx = cups.index(dest)
+      cups = cups.rotate(idx + 1)
+
+      cups = slice + cups
+
+      current_index = (cups.index(current) + 1) % cups.size
+      current = cups[current_index]
+      cups = cups.rotate(current_index + 1)
+    end
+
+    puts cups.rotate(cups.index(1) + 1).join[0..-2]

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

@@ -0,0 +1,66 @@
+---
+- :name: day-23-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-23
+  :solution: |-
+    class Node
+      attr_reader :num, :next
+
+      def initialize(num)
+        @num = num
+      end
+
+      def next=(node)
+        @next = node
+      end
+    end
+
+    cups = {}
+
+    ints = input.strip.chars.map(&:to_i)
+
+    num = ints.shift
+    curr = prev = Node.new(num)
+    cups[num] = curr
+
+    ints.each do |num|
+      node = Node.new(num)
+
+      prev.next = node
+      prev = node
+      cups[num] = node
+    end
+
+    (cups.size+1..1_000_000).each do |num|
+      node = Node.new(num)
+
+      prev.next = node
+      prev = node
+      cups[num] = node
+    end
+
+    prev.next = curr
+
+    10_000_000.times do
+      start = curr.next
+      last = curr.next.next.next
+
+      curr.next = last.next
+
+      nums = [start.num, start.next.num, last.num]
+
+      dest_num = curr.num
+      while
+        dest_num = (dest_num - 2) % cups.size + 1
+        break unless nums.include?(dest_num)
+      end
+
+      dest = cups[dest_num]
+
+      last.next = dest.next
+      dest.next = start
+
+      curr = curr.next
+    end
+
+    one = cups[1]
+    puts one.next.num * one.next.next.num

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

@@ -0,0 +1,84 @@
+---
+- :name: day-24-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-24
+  :solution: |-
+    input     = File.read(file_path)
+
+    lines = input.split("\n").map(&:chars)
+
+    ins = lines.map do |chars|
+      dirs = []
+
+      while chars.any?
+        dir = chars.shift
+        dir += chars.shift if dir == ?s || dir == ?n
+        dirs << dir
+      end
+
+      dirs
+    end
+
+    map = {}
+    ins.each do |inst|
+      x, y  = 0,0
+
+      inst.each do |i|
+        case i
+        when ?e
+          x += 1
+        when ?w
+          x -= 1
+        when 'se'
+          y += 1
+        when 'sw'
+          x -= 1
+          y += 1
+        when 'ne'
+          x += 1
+          y -= 1
+        when 'nw'
+          y -= 1
+        else
+          raise 'e'
+        end
+      end
+
+      map[[x,y]] = !map[[x,y]]
+    end
+
+    puts map.values.count { |black| black }
+
+    # Part 2
+    #
+    def neighbours(x, y)
+      [[x-1, y], [x+1, y], [x, y+1], [x, y-1], [x-1, y+1], [x+1, y-1]]
+    end
+
+    100.times do
+      map.keys.each do |loc|
+        next unless map[loc]
+        neighbours(*loc).each do |loc2|
+          map[loc2] = false unless map[loc2]
+        end
+      end
+
+      updates = {}
+
+      map.each do |loc, black|
+        count = neighbours(*loc).count { |loc2| map[loc2] }
+
+        if black
+          if count == 0 || count > 2
+            updates[loc] = false
+          end
+        elsif count == 2
+          updates[loc] = true
+        end
+      end
+
+      updates.each do |loc, black|
+        map[loc] = black
+      end
+    end
+
+    puts map.values.count { |black| black }

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

@@ -0,0 +1,84 @@
+---
+- :name: day-24-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-24
+  :solution: |-
+    input     = File.read(file_path)
+
+    lines = input.split("\n").map(&:chars)
+
+    ins = lines.map do |chars|
+      dirs = []
+
+      while chars.any?
+        dir = chars.shift
+        dir += chars.shift if dir == ?s || dir == ?n
+        dirs << dir
+      end
+
+      dirs
+    end
+
+    map = {}
+    ins.each do |inst|
+      x, y  = 0,0
+
+      inst.each do |i|
+        case i
+        when ?e
+          x += 1
+        when ?w
+          x -= 1
+        when 'se'
+          y += 1
+        when 'sw'
+          x -= 1
+          y += 1
+        when 'ne'
+          x += 1
+          y -= 1
+        when 'nw'
+          y -= 1
+        else
+          raise 'e'
+        end
+      end
+
+      map[[x,y]] = !map[[x,y]]
+    end
+
+    puts map.values.count { |black| black }
+
+    # Part 2
+    #
+    def neighbours(x, y)
+      [[x-1, y], [x+1, y], [x, y+1], [x, y-1], [x-1, y+1], [x+1, y-1]]
+    end
+
+    100.times do
+      map.keys.each do |loc|
+        next unless map[loc]
+        neighbours(*loc).each do |loc2|
+          map[loc2] = false unless map[loc2]
+        end
+      end
+
+      updates = {}
+
+      map.each do |loc, black|
+        count = neighbours(*loc).count { |loc2| map[loc2] }
+
+        if black
+          if count == 0 || count > 2
+            updates[loc] = false
+          end
+        elsif count == 2
+          updates[loc] = true
+        end
+      end
+
+      updates.each do |loc, black|
+        map[loc] = black
+      end
+    end
+
+    puts map.values.count { |black| black }

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

@@ -0,0 +1,30 @@
+---
+- :name: day-25-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-25
+  :solution: |-
+    card, door = input.split("\n").map(&:to_i)
+
+    def transform(value: 1, subject:, frequency: 1)
+      frequency.times do
+        value *= subject
+        value %= 20201227
+      end
+      value
+    end
+
+    def identify_loop(subject)
+      size = 0
+      value = 1
+      while value != subject
+        value = transform(value: value, subject: 7)
+        size += 1
+      end
+
+      size
+    end
+
+    loop1 = identify_loop(card)
+    loop2 = identify_loop(door)
+
+    puts transform(subject: door, frequency: loop1)
+    puts transform(subject: card, frequency: loop2)

data/data/solutions/github/gchan/2021/01_1.yml

@@ -0,0 +1,7 @@
+---
+- :name: day-01-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-01
+  :solution: |-
+    depths = input.split("\n").map(&:to_i)
+
+    puts depths.each_cons(2).count { |a, b| b > a }

data/data/solutions/github/gchan/2021/01_2.yml

@@ -0,0 +1,9 @@
+---
+- :name: day-01-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-01
+  :solution: |-
+    depths = input.split("\n").map(&:to_i)
+
+    puts depths.each_cons(4).count do |a, b, c, d|
+      (b + c + d) > (a + b + c)
+    end

data/data/solutions/github/gchan/2021/02_1.yml

@@ -0,0 +1,25 @@
+---
+- :name: day-02-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-02
+  :solution: |-
+    cmds = input.split("\n")
+
+    depth = 0
+    horizontal = 0
+
+    cmds.each do |cmd|
+      dir, num = cmd.split
+
+      num = num.to_i
+
+      case dir
+      when "forward"
+        horizontal += num
+      when "up"
+        depth -= num
+      when "down"
+        depth += num
+      end
+    end
+
+    puts depth * horizontal