advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,66 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-11
+  :solution: |-
+    input     = File.read(file_path)
+
+    def find_neighbours(grid, x ,y)
+      width = grid[0].length
+      height = grid.length
+
+      neighbours = [x - 1, x, x + 1].product([y - 1, y, y + 1])
+
+      neighbours.select do |x1, y1|
+        x1 >= 0 && x1 < width &&
+        y1 >= 0 && y1 < height &&
+        (x1 != x || y1 != y)
+      end
+    end
+
+    grid = input.split("\n").map(&:chars).map { |row| row.map(&:to_i) }
+
+    steps = 0
+
+    while true do
+      grid.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          grid[y][x] += 1
+        end
+      end
+
+      flashed = Set.new
+
+      queue = []
+
+      queue.concat(
+        (0..grid[0].length - 1).to_a.product((0..grid.length - 1).to_a)
+      )
+
+      while queue.any? do
+        x, y = queue.shift
+
+        next if flashed.include?([x, y])
+
+        cell = grid[y][x]
+
+        if cell > 9
+          flashed.add([x, y])
+
+          find_neighbours(grid, x, y).each do |x1, y1|
+            grid[y1][x1] += 1
+            queue << [x1, y1]
+          end
+        end
+      end
+
+      flashed.each do |x, y|
+        grid[y][x] = 0
+      end
+
+      steps += 1
+
+      if grid.flatten.all?(&:zero?)
+        puts steps
+        exit
+      end
+    end

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

@@ -0,0 +1,34 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-12
+  :solution: |-
+    caves = Hash.new { |h, k| h[k] = [] }
+
+    input.split("\n").each do |line|
+      from, to = line.split("-")
+
+      from_cave = caves[from]
+      to_cave = caves[to]
+
+      from_cave << to unless "start" == to || "end" == from
+      to_cave << from unless "start" == from || "end" == to
+    end
+
+    count = 0
+    queue = [["start"]]
+
+    while queue.any?
+      path = queue.shift
+
+      caves[path.last].each do |neighbour|
+        next if neighbour.upcase != neighbour && path.include?(neighbour)
+
+        count += 1 if neighbour == "end"
+
+        new_path = path + [neighbour]
+
+        queue << new_path
+      end
+    end
+
+    puts count

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

@@ -0,0 +1,38 @@
+---
+- :name: day-12-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-12
+  :solution: |-
+    caves = Hash.new { |h, k| h[k] = [] }
+
+    input.split("\n").each do |line|
+      from, to = line.split("-")
+
+      from_cave = caves[from]
+      to_cave = caves[to]
+
+      from_cave << to unless "start" == to || "end" == from
+      to_cave << from unless "start" == from || "end" == to
+    end
+
+    Path = Struct.new(:second_visit, :path)
+
+    count = 0
+    queue = [Path.new(false, ["start"])]
+
+    while queue.any?
+      path = queue.shift
+
+      caves[path.path.last].each do |neighbour|
+        second_visit = neighbour.downcase == neighbour && path.path.include?(neighbour)
+
+        next if second_visit && path.second_visit
+
+        visited_twice = path.second_visit || second_visit
+        new_path = Path.new(visited_twice, path.path + [neighbour])
+
+        count += 1 if neighbour == "end"
+        queue << new_path
+      end
+    end
+
+    puts count

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

@@ -0,0 +1,57 @@
+---
+- :name: day-13-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-13
+  :solution: |-
+    coords = []
+    folds = []
+
+    input.split("\n").each do |line|
+      next if line.empty?
+
+      if line.match?(/fold/)
+        folds << line.scan(/(y|x)=(\d+)/).flatten
+      else
+        coords << line.split(",").map(&:to_i)
+      end
+    end
+
+    height = coords.map(&:last).max + 1
+    width = coords.map(&:first).max + 1
+
+    grid = Array.new(height) { Array.new(width, ".") }
+
+    coords.each do |x, y|
+      grid[y][x] = "#"
+    end
+
+    folds.each_with_index do |(axis, pos), idx|
+      pos = pos.to_i
+
+      grid = grid.transpose if axis == "x"
+
+      # Fold downwards and account for uneven folds
+      #
+      grid = grid[0...pos].reverse.zip(grid[pos+1..]).map do |row_one, row_two|
+        if row_one.nil? || row_two.nil?
+          row_one || row_two
+        else
+          row_one.zip(row_two).map do |cell_one, cell_two|
+            if cell_one == "#" || cell_two == "#"
+              "#"
+            else
+              "."
+            end
+          end
+        end
+      end
+
+      # Reverse the image as we should be folding upwards
+      #
+      grid = grid.reverse
+
+      grid = grid.transpose if axis == "x"
+
+      puts grid.flatten.count { |cell| cell == "#" } if idx == 0
+    end
+
+    puts grid.map(&:join).join("\n")

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

@@ -0,0 +1,57 @@
+---
+- :name: day-13-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-13
+  :solution: |-
+    coords = []
+    folds = []
+
+    input.split("\n").each do |line|
+      next if line.empty?
+
+      if line.match?(/fold/)
+        folds << line.scan(/(y|x)=(\d+)/).flatten
+      else
+        coords << line.split(",").map(&:to_i)
+      end
+    end
+
+    height = coords.map(&:last).max + 1
+    width = coords.map(&:first).max + 1
+
+    grid = Array.new(height) { Array.new(width, ".") }
+
+    coords.each do |x, y|
+      grid[y][x] = "#"
+    end
+
+    folds.each_with_index do |(axis, pos), idx|
+      pos = pos.to_i
+
+      grid = grid.transpose if axis == "x"
+
+      # Fold downwards and account for uneven folds
+      #
+      grid = grid[0...pos].reverse.zip(grid[pos+1..]).map do |row_one, row_two|
+        if row_one.nil? || row_two.nil?
+          row_one || row_two
+        else
+          row_one.zip(row_two).map do |cell_one, cell_two|
+            if cell_one == "#" || cell_two == "#"
+              "#"
+            else
+              "."
+            end
+          end
+        end
+      end
+
+      # Reverse the image as we should be folding upwards
+      #
+      grid = grid.reverse
+
+      grid = grid.transpose if axis == "x"
+
+      puts grid.flatten.count { |cell| cell == "#" } if idx == 0
+    end
+
+    puts grid.map(&:join).join("\n")

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

@@ -0,0 +1,31 @@
+---
+- :name: day-14-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-14
+  :solution: |-
+    polymer, insertion_rules = input.split("\n\n")
+
+    rules = {}
+
+    insertion_rules.split("\n").map do |rule|
+      from, insert = rule.split(" -> ")
+
+      rules[from] = insert
+    end
+
+    10.times do
+      new_polymer = polymer.chars.each_cons(2).map do |pair|
+        pair = pair.join
+
+        if rules[pair]
+          pair[0] + rules[pair]
+        else
+          pair[0]
+        end
+      end
+
+      new_polymer << polymer.chars.last
+
+      polymer = new_polymer.join
+    end
+
+    puts polymer.chars.tally.values.minmax.inject(&:-).abs

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

@@ -0,0 +1,42 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-14
+  :solution: |-
+    polymer, insertion_rules = input.split("\n\n")
+
+    rules = {}
+
+    insertion_rules.split("\n").map do |rule|
+      from, insert = rule.split(" -> ")
+
+      rules[from] = from.chars.zip([insert]).flatten.compact.each_cons(2).to_a
+    end
+
+    element_count = Hash.new { |h, k| h[k] = 0 }
+
+    polymer.chars.each do |e|
+      element_count[e] += 1
+    end
+
+    pairs = polymer.chars.each_cons(2).tally
+
+    40.times do
+      new_pairs = Hash.new { |h, k| h[k] = 0 }
+
+      pairs.each do |pair, count|
+        if rules[pair.join]
+          new_element = rules[pair.join].first[1]
+          element_count[new_element] += count
+
+          rules[pair.join].each do |new_pair|
+            new_pairs[new_pair] += count
+          end
+        else
+          new_pairs[pair] += count
+        end
+      end
+
+      pairs = new_pairs
+    end
+
+    puts element_count.values.minmax.inject(&:-).abs

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

@@ -0,0 +1,58 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    def find_neighbours(grid, x ,y)
+      width = grid[0].length
+      height = grid.length
+
+      neighbours = [
+        [x - 1, y],
+        [x + 1, y],
+        [x, y + 1],
+        [x, y - 1]
+      ]
+
+      neighbours.select do |x1, y1|
+        x1 >= 0 && x1 < width &&
+        y1 >= 0 && y1 < height
+      end
+    end
+
+    grid = input.split("\n").map(&:chars).map { |row| row.map(&:to_i) }
+
+    queue = [[0, 0]]
+    visited = queue.to_set
+
+    risks = {
+      [0, 0] => 0
+    }
+
+    while queue.any?
+      x, y = queue.shift
+
+      current_risk = risks[[x, y]]
+
+      find_neighbours(grid, x, y).each do |x1, y1|
+        coord = [x1, y1]
+        risk = grid[y1][x1]
+
+        new_risk = current_risk + risk
+
+        next if risks[coord] && risks[coord] < new_risk
+
+        risks[coord] = new_risk
+
+        next if visited.include?(coord)
+
+        queue << coord
+        visited.add(coord)
+      end
+    end
+
+    width = grid[0].length
+    height = grid.length
+
+    puts risks[[height - 1, width - 1]]

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

@@ -0,0 +1,72 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    def find_neighbours(grid, x ,y)
+      width = grid[0].length
+      height = grid.length
+
+      neighbours = [
+        [x - 1, y],
+        [x + 1, y],
+        [x, y + 1],
+        [x, y - 1]
+      ]
+
+      neighbours.select do |x1, y1|
+        x1 >= 0 && x1 < width &&
+        y1 >= 0 && y1 < height
+      end
+    end
+
+    grid = input.split("\n").map(&:chars).map { |row| row.map(&:to_i) }
+
+    width = grid[0].length
+    height = grid.length
+
+    new_grid = Array.new(height * 5) { Array.new(width * 5) }
+
+    grid.each_with_index do |row, y|
+      row.each_with_index do |cell, x|
+        5.times do |y1|
+          5.times do |x1|
+            new_grid[y + y1 * height][x + x1 * width] =
+              (grid[y][x] + x1 + y1 - 1) % 9 + 1
+          end
+        end
+      end
+    end
+
+    grid = new_grid
+
+    queue = [[0, 0, 0]]
+    visited = queue.to_set
+
+    risks = {
+      [0, 0] => 0
+    }
+
+    while queue.any?
+      queue.sort_by!(&:last)
+      x, y, current_risk = queue.shift
+
+      find_neighbours(grid, x, y)
+        .reject { |x1, y1| visited.include?([x1, y1]) }
+        .each { |x1, y1|
+          coord = [x1, y1]
+
+          new_risk = current_risk + grid[y1][x1]
+
+          risks[coord] = new_risk
+
+          queue << [x1, y1, new_risk]
+          visited.add(coord)
+        }
+    end
+
+    width = grid[0].length
+    height = grid.length
+
+    puts risks[[height - 1, width - 1]]

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

@@ -0,0 +1,40 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-16
+  :solution: |-
+    packet = input.hex.to_s(2)
+      .rjust(input.strip.size * 4, "0")
+      .chars.map(&:to_i)
+
+    def read_packet(packet)
+      version = packet.shift(3).join.to_i(2)
+      type = packet.shift(3).join.to_i(2)
+
+      subpackets = []
+
+      case type
+      when 4
+        while packet.shift(5)[0] != 0
+        end
+      else
+        if packet.shift == 0
+          subpacket_length = packet.shift(15).join.to_i(2)
+
+          subpacket = packet.shift(subpacket_length)
+
+          while subpacket.length > 0
+            version += read_packet(subpacket)
+          end
+        else
+          num_subpackets = packet.shift(11).join.to_i(2)
+
+          num_subpackets.times do
+            version += read_packet(packet)
+          end
+        end
+      end
+
+      version
+    end
+
+    puts read_packet(packet)

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

@@ -0,0 +1,62 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-16
+  :solution: |-
+    packet = input.hex.to_s(2)
+      .rjust(input.strip.size * 4, "0")
+      .chars.map(&:to_i)
+
+    def read_packet(packet)
+      version = packet.shift(3).join.to_i(2)
+      type = packet.shift(3).join.to_i(2)
+
+      if type == 4 # Literal
+        bits = []
+
+        while true
+          group = packet.shift(5)
+          bits << group[1..]
+
+          break if group[0] == 0
+        end
+
+        return bits.flatten.join.to_i(2)
+      end
+
+      literals = []
+
+      if packet.shift == 0
+        subpacket_length = packet.shift(15).join.to_i(2)
+
+        subpacket = packet.shift(subpacket_length)
+
+        while subpacket.length > 0
+          literals << read_packet(subpacket)
+        end
+      else
+        num_subpackets = packet.shift(11).join.to_i(2)
+
+        num_subpackets.times do
+          literals << read_packet(packet)
+        end
+      end
+
+      case type
+      when 0 # Sum
+        literals.sum
+      when 1 # Product
+        literals.inject(:*)
+      when 2 # Min
+        literals.min
+      when 3 # Max
+        literals.max
+      when 5 # Greater than
+        literals.inject(:>) ? 1 : 0
+      when 6 # Less than
+        literals.inject(:<) ? 1 : 0
+      when 7 # Equal
+        literals.inject(:==) ? 1 : 0
+      end
+    end
+
+    puts read_packet(packet)

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

@@ -0,0 +1,38 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-17
+  :solution: |-
+    x1, x2, y1, y2 = input.scan(/x=([-\d]*)..([-\d]*), y=([-\d]*)..([-\d]*)/)
+      .flatten.map(&:to_i)
+
+    max_v = nil
+
+    (y1..500).each do |yv|
+      vel = yv
+      current = yv
+      step = 1
+
+      while true
+        if (y1..y2).cover?(current)
+          max_v = yv
+          break
+        end
+
+        vel -= 1
+        current += vel
+        step += 1
+
+        break if current < y1
+      end
+    end
+
+    vel = max_v
+
+    max_y = 0
+
+    while vel > 0
+      max_y += vel
+      vel -= 1
+    end
+
+    puts max_y

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

@@ -0,0 +1,89 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2021/day-17
+  :solution: |-
+    x1, x2, y1, y2 = input.scan(/x=([-\d]*)..([-\d]*), y=([-\d]*)..([-\d]*)/)
+      .flatten.map(&:to_i)
+
+    # Viable Xs (ignoring Y)
+    #
+    xs = []
+
+    (1..x2).each do |xv|
+      vel = xv
+      current = xv
+      step = 1
+
+      min_step = nil
+      max_step = nil
+
+      while true
+        if (x1..x2).cover?(current)
+          min_step = step if min_step.nil?
+          max_step = step
+          max_step = nil if vel == 0
+        end
+
+        vel -= 1
+        current += vel
+        step += 1
+
+        break if current > x2 || vel < 0
+      end
+
+      xs << [min_step..max_step, xv] if min_step
+    end
+
+    x_map = Hash.new { |h, k| h[k] = [] }
+
+    xs.each do |step_range, xv|
+      x_map[step_range] << xv
+    end
+
+    # Viable Ys (ignoring X)
+    #
+    ys = []
+
+    (y1..500).each do |yv|
+      vel = yv
+      current = yv
+      step = 1
+
+      min_step = nil
+      max_step = nil
+
+      while true
+        if (y1..y2).cover?(current)
+          min_step = step if min_step.nil?
+          may_step = step
+          may_step = nil if vel == 0
+        end
+
+        vel -= 1
+        current += vel
+        step += 1
+
+        break if current < y1
+      end
+
+      ys << [min_step..may_step, yv] if min_step
+    end
+
+    y_map = Hash.new { |h, k| h[k] = [] }
+
+    ys.each do |step_range, yv|
+      y_map[step_range] << yv
+    end
+
+
+    combinations = []
+
+    y_map.each do |y_step_range, ys|
+      x_map.each do |x_step_range, xs|
+        y_step_range.each do |y|
+          combinations += ys.product(xs) if x_step_range.cover?(y)
+        end
+      end
+    end
+
+    puts combinations.uniq.count