advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/gchan/2022/08_2.yml

@@ -0,0 +1,59 @@
+---
+- :name: day-08-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-08
+  :solution: |-
+    grid = input.each_line.map { |line| line.strip.chars.map(&:to_i) }
+
+    width = grid.first.length
+    length = grid.length
+
+    trees = Hash.new { |hash, key| hash[key] = [] }
+
+    grid.each_with_index do |row, y|
+      next if y == 0 || y == length - 1
+      row.each_with_index do |height, x|
+        next if x == 0 || x == width - 1
+
+        # up
+        dist = y
+        (0..y-1).reverse_each.with_index do |y1, idx|
+          if grid[y1][x] >= height
+            dist = idx + 1
+            break
+          end
+        end
+        trees[[y, x]] << dist
+
+        # left
+        dist = x
+        (0..x-1).reverse_each do |x1|
+          if grid[y][x1] >= height
+            dist = x - x1
+            break
+          end
+        end
+        trees[[y, x]] << dist
+
+        # down
+        dist = length - 1 - y
+        (y+1..length-1).each do |y1|
+          if grid[y1][x] >= height
+            dist = y1 - y
+            break
+          end
+        end
+        trees[[y, x]] << dist
+
+        # right
+        dist = width - 1 - x
+        (x+1..width-1).each do |x1|
+          if grid[y][x1] >= height
+            dist = x1 - x
+            break
+          end
+        end
+        trees[[y, x]] << dist
+      end
+    end
+
+    puts trees.values.map { |dist| dist.inject(&:*) }.max

data/data/solutions/github/gchan/2022/09_1.yml

@@ -0,0 +1,43 @@
+---
+- :name: day-09-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-09
+  :solution: |-
+    input     = File.read(file_path)
+
+    hx = hy = 0
+    tx = ty = 0
+
+    visited = [[tx, ty]].to_set
+
+    input.each_line do |line|
+      dir, v = line.split
+      v = v.to_i
+
+      v.times do
+        case dir
+        when "R"
+          hx += 1
+        when "L"
+          hx -= 1
+        when "U"
+          hy += 1
+        when "D"
+          hy -= 1
+        end
+
+        # neighbour check
+        next if (hx - tx).abs <= 1 && (hy - ty).abs <= 1
+
+        if hy != ty
+          ty += (hy - ty).positive? ? 1 : -1
+        end
+
+        if hx != tx
+          tx += (hx - tx).positive? ? 1 : -1
+        end
+
+        visited << [tx, ty]
+      end
+    end
+
+    puts visited.count

data/data/solutions/github/gchan/2022/09_2.yml

@@ -0,0 +1,46 @@
+---
+- :name: day-09-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-09
+  :solution: |-
+    input     = File.read(file_path)
+
+    # Head knot is at index 0
+    knots = Array.new(10) { [0, 0] }
+
+    visited = [knots[-1].clone].to_set
+
+    input.each_line do |line|
+      dir, v = line.split
+      v = v.to_i
+
+      head = knots[0]
+      v.times do
+        case dir
+        when "R"
+          head[0] += 1
+        when "L"
+          head[0] -= 1
+        when "U"
+          head[1] += 1
+        when "D"
+          head[1] -= 1
+        end
+
+        knots.each_cons(2) do |head, tail|
+          # neighbour check
+          next if (head[0] - tail[0]).abs <= 1 && (head[1] - tail[1]).abs <= 1
+
+          if head[1] != tail[1]
+            tail[1] += (head[1] - tail[1]).positive? ? 1 : -1
+          end
+
+          if head[0] != tail[0]
+            tail[0] += (head[0] - tail[0]).positive? ? 1 : -1
+          end
+        end
+
+        visited << knots[-1].clone
+      end
+    end
+
+    puts visited.count

data/data/solutions/github/gchan/2022/10_1.yml

@@ -0,0 +1,40 @@
+---
+- :name: day-10-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-10
+  :solution: |-
+    class Cpu
+      attr_reader :x, :cycle, :signal_sum
+
+      def initialize
+        @x = 1
+        @cycle = 0
+        @signal_sum = 0
+      end
+
+      def tick
+        @cycle += 1
+
+        if (cycle - 20) % 40 == 0
+          @signal_sum += cycle * x
+        end
+      end
+
+      def add(i)
+        @x += i
+      end
+    end
+
+    cpu = Cpu.new
+
+    input.each_line do |line|
+      case line.strip.split
+      in ["addx", add]
+        cpu.tick
+        cpu.tick
+        cpu.add(add.to_i)
+      in ["noop"]
+        cpu.tick
+      end
+    end
+
+    puts cpu.signal_sum

data/data/solutions/github/gchan/2022/10_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: day-10-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-10
+  :solution: |-
+    class Cpu
+      attr_reader :x, :cycle
+
+      def initialize
+        @x = 1
+        @cycle = 0
+      end
+
+      def tick
+        @cycle += 1
+
+        draw
+      end
+
+      def add(i)
+        @x += i
+      end
+
+      private
+
+      def draw
+        print lit_pixel? ? "#" : "."
+
+        puts if cycle % 40 == 0
+      end
+
+      def lit_pixel?
+        pixel = cycle % 40
+
+        pixel >= x && pixel < x + 3
+      end
+    end
+
+    cpu = Cpu.new
+
+    input.each_line do |line|
+      case line.strip.split
+      in ["addx", add]
+        cpu.tick
+        cpu.tick
+        cpu.add(add.to_i)
+      in ["noop"]
+        cpu.tick
+      end
+    end

data/data/solutions/github/gchan/2022/11_1.yml

@@ -0,0 +1,53 @@
+---
+- :name: day-11-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-11
+  :solution: |-
+    Monkey = Struct.new(:items, :op, :op_val, :test, :t_true, :t_false, :inspected) do
+      def initialize(*)
+        super
+        self.inspected = 0
+      end
+    end
+
+    monkeys = []
+
+    input.each_line.each_slice(7) do |lines|
+      _, items, op_str, test, t_true, t_false = lines.map(&:strip)
+
+      items = items.scan(/\d+/).map(&:to_i)
+      op = op_str.scan(/\*|\+/).first
+      op_val = op_str.scan(/\d+/).first
+
+      # handle old * old
+      if op_val.nil?
+        op = "**"
+        op_val = 2
+      else
+        op_val = op_val.to_i
+      end
+
+      test = test.scan(/\d+/).first.to_i
+      t_true = t_true.scan(/\d+/).first.to_i
+      t_false = t_false.scan(/\d+/).first.to_i
+
+      monkeys << Monkey.new(items, op, op_val, test, t_true, t_false)
+    end
+
+    20.times do
+      monkeys.each do |monkey|
+        monkey.items.each do |item|
+          monkey.inspected += 1
+          worry = item.send(monkey.op, monkey.op_val) / 3
+
+          if worry % monkey.test == 0
+            monkeys[monkey.t_true].items << worry
+          else
+            monkeys[monkey.t_false].items << worry
+          end
+        end
+
+        monkey.items = []
+      end
+    end
+
+    pp monkeys.map(&:inspected).sort.last(2).inject(&:*)

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

@@ -0,0 +1,58 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-11
+  :solution: |-
+    Monkey = Struct.new(:items, :op, :op_val, :test, :t_true, :t_false, :inspected) do
+      def initialize(*)
+        super
+        self.inspected = 0
+      end
+    end
+
+    monkeys = []
+
+    input.each_line.each_slice(7) do |lines|
+      _, items, op_str, test, t_true, t_false = lines.map(&:strip)
+
+      items = items.scan(/\d+/).map(&:to_i)
+      op = op_str.scan(/\*|\+/).first
+      op_val = op_str.scan(/\d+/).first
+
+      # handle old * old
+      if op_val.nil?
+        op = "**"
+        op_val = 2
+      else
+        op_val = op_val.to_i
+      end
+
+      test = test.scan(/\d+/).first.to_i
+      t_true = t_true.scan(/\d+/).first.to_i
+      t_false = t_false.scan(/\d+/).first.to_i
+
+      monkeys << Monkey.new(items, op, op_val, test, t_true, t_false)
+    end
+
+    # https://en.wikipedia.org/wiki/Least_common_multiple
+    # Note the numbers are all primes
+    divisor = monkeys.map(&:test).inject(&:*)
+
+    10_000.times do |i|
+      monkeys.each do |monkey|
+        monkey.items.each do |item|
+          monkey.inspected += 1
+
+          worry = item.send(monkey.op, monkey.op_val) % divisor
+
+          if worry % monkey.test == 0
+            monkeys[monkey.t_true].items << worry
+          else
+            monkeys[monkey.t_false].items << worry
+          end
+        end
+
+        monkey.items = []
+      end
+    end
+
+    pp monkeys.map(&:inspected).sort.last(2).inject(&:*)

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

@@ -0,0 +1,42 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-12
+  :solution: |-
+    grid = input.split("\n").map(&:chars)
+
+    y = grid.find_index { |row| row.include?("S") }
+    x = grid[y].find_index { |cell| cell == "S" }
+
+    visited = {}
+
+    queue = [[x, y, 0, ?a]]
+
+    def neighbours(x, y)
+      [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]].select do |x, y|
+        x >= 0 && y >= 0
+      end
+    end
+
+    while queue.any?
+      x, y, d, h = queue.shift
+
+      neighbours(x, y).each do |x1, y1|
+        h1 = grid[y1]&.[](x1)
+
+        next unless h1
+        next if h1 > h.next
+
+        d1 = d + 1
+
+        if h1 == 'E'
+          puts d1
+          exit
+        elsif !visited[[x1, y1]]
+          queue << [x1, y1, d1, h1]
+          visited[[x1, y1]] = d1
+        else
+          d2 = visited[[x1, y1]]
+          visited[[x1, y1]] = [d1, d2].min
+        end
+      end
+    end

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

@@ -0,0 +1,42 @@
+---
+- :name: day-12-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-12
+  :solution: |-
+    grid = input.split("\n").map(&:chars)
+
+    y = grid.find_index { |row| row.include?("E") }
+    x = grid[y].find_index { |cell| cell == "E" }
+
+    visited = {}
+
+    queue = [[x, y, 0, ?z]]
+
+    def neighbours(x, y)
+      [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]].select do |x, y|
+        x >= 0 && y >= 0
+      end
+    end
+
+    while queue.any?
+      x, y, d, h = queue.shift
+
+      neighbours(x, y).each do |x1, y1|
+        h1 = grid[y1]&.[](x1)
+
+        next unless h1
+        next if h1.next < h
+
+        d1 = d + 1
+
+        if h1 == 'a'
+          puts d1
+          exit
+        elsif !visited[[x1, y1]]
+          queue << [x1, y1, d1, h1]
+          visited[[x1, y1]] = d1
+        else
+          d2 = visited[[x1, y1]]
+          visited[[x1, y1]] = [d1, d2].min
+        end
+      end
+    end

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

@@ -0,0 +1,42 @@
+---
+- :name: day-13-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-13
+  :solution: |-
+    input     = File.read(file_path)
+
+    def compare(l1, l2)
+      return 0 if l1 == l2
+
+      l1.each_with_index do |i1, idx|
+        i2 = l2[idx]
+
+        return 1 if i2.nil?
+
+        next if i1 == i2
+
+        if i1.is_a?(Integer) && i2.is_a?(Integer)
+          return i1 <=> i2
+        else
+          i1 = [i1] if i1.is_a?(Integer)
+          i2 = [i2] if i2.is_a?(Integer)
+
+          next if i1 == i2
+          return compare(i1, i2)
+        end
+      end
+
+      -1
+    end
+
+    sum = 0
+
+    input.split("\n\n").each_with_index do |pair, idx|
+      p1, p2 = pair.split("\n")
+
+      p1 = JSON.parse(p1)
+      p2 = JSON.parse(p2)
+
+      sum += idx + 1 if compare(p1, p2) <= 0
+    end
+
+    puts sum

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

@@ -0,0 +1,41 @@
+---
+- :name: day-13-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-13
+  :solution: |-
+    input     = File.read(file_path)
+
+    def compare(l1, l2)
+      return 0 if l1 == l2
+
+      l1.each_with_index do |i1, idx|
+        i2 = l2[idx]
+
+        return 1 if i2.nil?
+
+        next if i1 == i2
+
+        if i1.is_a?(Integer) && i2.is_a?(Integer)
+          return i1 <=> i2
+        else
+          i1 = [i1] if i1.is_a?(Integer)
+          i2 = [i2] if i2.is_a?(Integer)
+
+          next if i1 == i2
+          return compare(i1, i2)
+        end
+      end
+
+      -1
+    end
+
+    lists = input.scan(/\[.*/).map { |l| JSON.parse(l) }
+
+    d1 = [[2]]
+    d2 = [[6]]
+
+    lists << d1
+    lists << d2
+
+    lists.sort! { |l1, l2| compare(l1, l2) }
+
+    puts (lists.index(d1) + 1 ) * (lists.index(d2) + 1)

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

@@ -0,0 +1,57 @@
+---
+- :name: day-14-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-14
+  :solution: |-
+    paths = input.split("\n").map do |path|
+      path.split(" -> ").map { |point| point.split(",").map(&:to_i) }
+    end
+
+    min_x, max_x = paths.map { |path| path.map(&:first) }.flatten.minmax
+    max_y = paths.map { |path| path.map(&:last) }.flatten.max
+
+    width = max_x - min_x + 1
+    grid = Array.new(max_y + 1) { Array.new(width, ".") }
+
+    paths.each do |path|
+      path.each_cons(2) do |(x, y), (x1, y1)|
+        y1, y = y, y1 if y > y1
+        x1, x = x, x1 if x > x1
+
+        (y..y1).each do |y2|
+          (x..x1).each do |x2|
+            grid[y2][x2 - min_x] = "#"
+          end
+        end
+      end
+    end
+
+    # puts grid.map(&:join).join("\n")
+
+    pour_x = 500 - min_x
+
+    1_000.times do |i|
+      x = pour_x
+      y = 0
+
+      while true
+        if grid[y + 1][x] == ?.
+          y += 1
+        elsif grid[y + 1][x - 1] == ?.
+          y += 1
+          x -= 1
+        elsif grid[y + 1][x + 1] == ?.
+          y += 1
+          x += 1
+        else
+          break
+        end
+
+        if y == max_y
+          # puts grid.map(&:join).join("\n")
+          puts i
+          exit
+        end
+      end
+
+      grid[y][x] = "o"
+    end

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

@@ -0,0 +1,69 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-14
+  :solution: |-
+    paths = input.split("\n").map do |path|
+      path.split(" -> ").map { |point| point.split(",").map(&:to_i) }
+    end
+
+    min_x, max_x = paths.map { |path| path.map(&:first) }.flatten.minmax
+    max_y = paths.map { |path| path.map(&:last) }.flatten.max
+
+    width = max_x - min_x + 1
+    grid = Array.new(max_y + 1) { Array.new(width, ".") }
+
+    paths.each do |path|
+      path.each_cons(2) do |(x, y), (x1, y1)|
+        y1, y = y, y1 if y > y1
+        x1, x = x, x1 if x > x1
+
+        (y..y1).each do |y2|
+          (x..x1).each do |x2|
+            grid[y2][x2 - min_x] = "#"
+          end
+        end
+      end
+    end
+
+    max_y += 1
+    grid << Array.new(width, ".")
+
+    grid = grid.transpose
+
+    #puts grid.map(&:join).join("\n")
+
+    pour_x = 500 - min_x
+
+    100_000.times do |i|
+      x = pour_x
+      y = 0
+
+      while true
+        if grid[x][y+1] == ?.
+          y += 1
+        elsif grid[x - 1][y + 1] == ?.
+          y += 1
+          x -= 1
+        elsif grid[x + 1][y + 1] == ?.
+          y += 1
+          x += 1
+        else
+          break
+        end
+
+        if x == 0
+          grid.unshift(Array.new(max_y + 1, "."))
+          pour_x += 1
+          x += 1
+        elsif x + 1 >= grid.length
+          grid << Array.new(max_y + 1, ".")
+        end
+      end
+
+      if x == pour_x && y == 0
+        puts i + 1
+        exit
+      end
+
+      grid[x][y] = "o"
+    end

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

@@ -0,0 +1,47 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    sensors = {}
+    beacons = Set.new
+
+    input.strip.each_line do |sensor|
+      sensor, beacon = sensor.split(":")
+
+      x, y = sensor.scan(/\d+/).map(&:to_i)
+      bx, by = beacon.scan(/-?\d+/).map(&:to_i)
+
+      dist = (x - bx).abs + (y - by).abs
+
+      sensors[[x,y]] = dist
+      beacons << [bx, by]
+    end
+
+    row = 2_000_000
+
+    max_x = [sensors.keys.map(&:first).max, beacons.map(&:first).max].max
+
+    max_dist = sensors.values.max
+
+    count = 0
+
+    # Could be quicker by building ranges for each sensor, count
+    # the length and subtract any beacons and sensors on the row.
+    #
+    (-max_dist..max_x+max_dist).each do |x|
+      print ?. if x % 100_000 == 0
+
+      next if beacons.include?([x, row]) || sensors[[x, row]]
+
+      sensors.each do |(sx, sy), dist|
+        if (x - sx).abs + (row - sy).abs <= dist
+          count += 1
+          break
+        end
+      end
+    end
+
+    puts
+    puts count