advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,51 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-18
+  :solution: |-
+    rows = input.split("\n")
+
+    grid = Array.new(rows.size) { Array.new(rows.first.size) }
+
+    rows.each.with_index do |row, y|
+      row.chars.each.with_index do |cell, x|
+        grid[y][x] = cell
+      end
+    end
+
+    def neighbours(x1, y1, grid)
+      [x1 - 1, x1, x1 + 1].product([y1 - 1, y1, y1 + 1])
+        .reject { |x, y| x == x1 && y == y1 }
+        .reject { |x, y| x < 0 || y < 0 || x >= grid[0].size || y >= grid.size }
+        .map { |x, y| grid[y][x] }
+    end
+
+    10.times do
+      new_grid = Array.new(rows.size) { Array.new(rows.first.size) }
+
+      grid.each.with_index do |row, y|
+        row.each.with_index do |cell, x|
+          adjacent = neighbours(x, y, grid)
+
+          trees = adjacent.count { |c| c == "|" }
+          lumber = adjacent.count { |c| c == "#" }
+
+          case cell
+          when "."
+            cell = "|" if trees >= 3
+          when "|"
+            cell = "#" if lumber >= 3
+          when "#"
+            cell = "." if lumber == 0 || trees == 0
+          end
+
+          new_grid[y][x] = cell
+        end
+      end
+
+      grid = new_grid
+    end
+
+    trees = grid.flatten.count { |c| c == "|" }
+    lumber = grid.flatten.count { |c| c == "#" }
+
+    puts trees * lumber

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

@@ -0,0 +1,79 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-18
+  :solution: |-
+    rows = input.split("\n")
+
+    grid = Array.new(rows.size) { Array.new(rows.first.size) }
+
+    rows.each.with_index do |row, y|
+      row.chars.each.with_index do |cell, x|
+        grid[y][x] = cell
+      end
+    end
+
+    def neighbours(x1, y1, grid)
+      [x1 - 1, x1, x1 + 1].product([y1 - 1, y1, y1 + 1])
+        .reject { |x, y| x == x1 && y == y1 }
+        .reject { |x, y| x < 0 || y < 0 || x >= grid[0].size || y >= grid.size }
+        .map { |x, y| grid[y][x] }
+    end
+
+    i = 0
+
+    visited = Hash.new { |h, k| h[k] = Array.new }
+
+    visited[grid] << i
+
+    loop do
+      i += 1
+
+      new_grid = Array.new(rows.size) { Array.new(rows.first.size) }
+
+      grid.each.with_index do |row, y|
+        row.each.with_index do |cell, x|
+          adjacent = neighbours(x, y, grid)
+
+          trees = adjacent.count { |c| c == "|" }
+          lumber = adjacent.count { |c| c == "#" }
+
+          case cell
+          when "."
+            cell = "|" if trees >= 3
+          when "|"
+            cell = "#" if lumber >= 3
+          when "#"
+            cell = "." if lumber == 0 || trees == 0
+          end
+
+          new_grid[y][x] = cell
+        end
+      end
+
+      visited[new_grid] << i
+
+      # two full loops
+      if visited[new_grid].size == 3
+        grids = visited.entries.select { |_grid, iter| iter.size > 1 }
+
+        iters = grids.map(&:last).map(&:first)
+
+        loop_size = iters.count
+        start_iter = iters.min
+
+        target = 1000000000
+
+        target_iter = (target - start_iter) % loop_size + start_iter
+
+        final_grid = grids.find { |(_grid, iter)| iter.include?(target_iter) }.first
+
+        trees = final_grid.flatten.count { |c| c == "|" }
+        lumber = final_grid.flatten.count { |c| c == "#" }
+
+        puts trees * lumber
+
+        exit
+      end
+
+      grid = new_grid
+    end

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

@@ -0,0 +1,66 @@
+---
+- :name: day-19-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-19
+  :solution: |-
+    input     = File.read(file_path)
+
+    def operation(reg, op, a, b, c)
+      case op
+      when 'addr'
+        reg[c] = reg[a] + reg[b]
+      when 'addi'
+        reg[c] = reg[a] + b
+      when 'mulr'
+        reg[c] = reg[a] * reg[b]
+      when 'muli'
+        reg[c] = reg[a] * b
+      when 'banr'
+        reg[c] = reg[a] & reg[b]
+      when 'bani'
+        reg[c] = reg[a] & b
+      when 'boor'
+        reg[c] = reg[a] | reg[b]
+      when 'bori'
+        reg[c] = reg[a] | b
+      when 'setr'
+        reg[c] = reg[a]
+      when 'seti'
+        reg[c] = a
+      when 'gtir'
+        reg[c] = a > reg[b] ? 1 : 0
+      when 'gtri'
+        reg[c] = reg[a] > b ? 1 : 0
+      when 'gtrr'
+        reg[c] = reg[a] > reg[b] ? 1 : 0
+      when 'eqir'
+        reg[c] = a == reg[b] ? 1 : 0
+      when 'eqri'
+        reg[c] = reg[a] == b ? 1 : 0
+      when 'eqrr'
+        reg[c] = reg[a] == reg[b] ? 1 : 0
+      end
+
+      reg
+    end
+
+    reg = [0, 0, 0, 0, 0, 0]
+
+    instructions = input.split("\n")
+
+    pointer = instructions.shift.scan(/\d+/)[0].to_i
+
+    instructions = instructions.map do |instruction|
+      op, *val = instruction.split(" ")
+      a, b, c = val.map(&:to_i)
+
+      [op, a, b, c]
+    end
+
+    while reg[pointer] >= 0 && reg[pointer] < instructions.size
+      op, a, b, c = instructions[reg[pointer]]
+
+      reg = operation(reg, op, a, b, c)
+      reg[pointer] += 1
+    end
+
+    puts reg[0]

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

@@ -0,0 +1,73 @@
+---
+- :name: day-19-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-19
+  :solution: |-
+    input     = File.read(file_path)
+
+    def operation(reg, op, a, b, c)
+      case op
+      when 'addr'
+        reg[c] = reg[a] + reg[b]
+      when 'addi'
+        reg[c] = reg[a] + b
+      when 'mulr'
+        reg[c] = reg[a] * reg[b]
+      when 'muli'
+        reg[c] = reg[a] * b
+      when 'banr'
+        reg[c] = reg[a] & reg[b]
+      when 'bani'
+        reg[c] = reg[a] & b
+      when 'boor'
+        reg[c] = reg[a] | reg[b]
+      when 'bori'
+        reg[c] = reg[a] | b
+      when 'setr'
+        reg[c] = reg[a]
+      when 'seti'
+        reg[c] = a
+      when 'gtir'
+        reg[c] = a > reg[b] ? 1 : 0
+      when 'gtri'
+        reg[c] = reg[a] > b ? 1 : 0
+      when 'gtrr'
+        reg[c] = reg[a] > reg[b] ? 1 : 0
+      when 'eqir'
+        reg[c] = a == reg[b] ? 1 : 0
+      when 'eqri'
+        reg[c] = reg[a] == b ? 1 : 0
+      when 'eqrr'
+        reg[c] = reg[a] == reg[b] ? 1 : 0
+      end
+
+      reg
+    end
+
+    reg = [1, 0, 0, 0, 0, 0]
+
+    instructions = input.split("\n")
+
+    pointer = instructions.shift.scan(/\d+/)[0].to_i
+
+    instructions = instructions.map do |instruction|
+      op, *val = instruction.split(" ")
+      a, b, c = val.map(&:to_i)
+
+      [op, a, b, c]
+    end
+
+    while reg[pointer] >= 0 && reg[pointer] < instructions.size
+      if reg[pointer] == 3
+        # Identify the loop and optimise: sum of all factors of reg[2]
+        reg[0] = (1..reg[2]).select { |i| reg[2] % i == 0 }.inject(:+)
+
+        reg[pointer] = 10
+      else
+        op, a, b, c = instructions[reg[pointer]]
+
+        reg = operation(reg, op, a, b, c)
+        reg[pointer] += 1
+      end
+    end
+
+    puts reg[0]

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

@@ -0,0 +1,55 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-20
+  :solution: |-
+    file_path = File.expand_path("../day-20-input.txt", __FILE__)
+    input = File.read(file_path)
+
+    path = input[1..-2]
+
+    def longest(path)
+      path_lengths = [0]
+
+      idx = 0
+
+      while idx < path.length
+        case path[idx]
+        when ?(
+          length = branch_length(path[idx..-1])
+
+          branch = path[idx + 1, length - 1]
+
+          path_lengths[-1] += longest(branch)
+
+          idx += length
+        when ?|
+          path_lengths << 0
+        else
+          path_lengths[-1] += 1
+        end
+
+        idx += 1
+      end
+
+      if path_lengths.any?(&:zero?)
+        0
+      else
+        path_lengths.max
+      end
+    end
+
+    def branch_length(branch)
+      depth = 1
+      idx = 0
+
+      while depth > 0
+        idx += 1
+
+        depth -= 1 if branch[idx] == ?)
+        depth += 1 if branch[idx] == ?(
+      end
+
+      idx
+    end
+
+    puts longest(path)

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

@@ -0,0 +1,70 @@
+---
+- :name: day-20-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-20
+  :solution: |-
+    input = File.read(file_path)
+
+    path = input[1..-2]
+
+    def visit(path, x0 = 0, y0 = 0, visited = {}, start = 1)
+      x = x0
+      y = y0
+
+      doors = start
+      visited[[x, y]] = doors - 1
+
+      idx = 0
+
+      while idx < path.length
+        case path[idx]
+        when ?(
+          length = branch_length(path[idx..-1])
+
+          branch = path[idx + 1, length - 1]
+
+          visit(branch, x, y, visited, doors)
+
+          idx += length
+        when ?|
+          x, y, doors = x0, y0, start
+        else
+          case path[idx]
+          when ?N
+            y -= 1
+          when ?W
+            x -= 1
+          when ?E
+            x += 1
+          when ?S
+            y += 1
+          end
+
+          visited[[x, y]] = [visited[[x, y]], doors].compact.min
+
+          doors += 1
+        end
+
+        idx += 1
+      end
+
+      visited
+    end
+
+    def branch_length(path)
+      depth = 1
+      idx = 0
+
+      while depth > 0
+        idx += 1
+
+        depth -= 1 if path[idx] == ?)
+        depth += 1 if path[idx] == ?(
+      end
+
+      idx
+    end
+
+    visited_rooms = visit(path)
+
+    puts visited_rooms.values.count { |doors| doors >= 1000 } # Part 2
+    puts visited_rooms.values.max # Part 1

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

@@ -0,0 +1,68 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-21
+  :solution: |-
+    def operation(reg, op, a, b, c)
+      case op
+      when 'addr'
+        reg[c] = reg[a] + reg[b]
+      when 'addi'
+        reg[c] = reg[a] + b
+      when 'mulr'
+        reg[c] = reg[a] * reg[b]
+      when 'muli'
+        reg[c] = reg[a] * b
+      when 'banr'
+        reg[c] = reg[a] & reg[b]
+      when 'bani'
+        reg[c] = reg[a] & b
+      when 'boor'
+        reg[c] = reg[a] | reg[b]
+      when 'bori'
+        reg[c] = reg[a] | b
+      when 'setr'
+        reg[c] = reg[a]
+      when 'seti'
+        reg[c] = a
+      when 'gtir'
+        reg[c] = a > reg[b] ? 1 : 0
+      when 'gtri'
+        reg[c] = reg[a] > b ? 1 : 0
+      when 'gtrr'
+        reg[c] = reg[a] > reg[b] ? 1 : 0
+      when 'eqir'
+        reg[c] = a == reg[b] ? 1 : 0
+      when 'eqri'
+        reg[c] = reg[a] == b ? 1 : 0
+      when 'eqrr'
+        reg[c] = reg[a] == reg[b] ? 1 : 0
+      end
+
+      reg
+    end
+
+    reg = [0, 0, 0, 0, 0, 0]
+
+    instructions = input.split("\n")
+
+    pointer = instructions.shift.scan(/\d+/)[0].to_i
+
+    instructions = instructions.map do |instruction|
+      op, *val = instruction.split(" ")
+      a, b, c = val.map(&:to_i)
+
+      [op, a, b, c]
+    end
+
+    while reg[pointer] >= 0 && reg[pointer] < instructions.size
+      # Instruction 28 exits when reg[5] == reg[0]
+      if reg[pointer] == 28
+        puts reg[5]
+        exit
+      end
+
+      op, a, b, c = instructions[reg[pointer]]
+
+      reg = operation(reg, op, a, b, c)
+      reg[pointer] += 1
+    end

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

@@ -0,0 +1,43 @@
+---
+- :name: day-21-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-21
+  :solution: |-
+    input = File.read(file_path)
+
+    # Reverse engineer and optimise - a = reg[4], b = reg[5]
+    def activation_system(input)
+      b = input
+
+      a = b | 65536
+      b = 13159625
+
+      while a > 0
+        b += a & 255
+        b &= 16777215
+
+        b *= 65899
+        b &= 16777215
+
+        a /= 256
+      end
+
+      b
+    end
+
+    # It should halt before an infinite loop, identity when that is
+    visited = Set.new
+
+    input = 0
+
+    loop do
+      visited.add(input)
+
+      output = activation_system(input)
+
+      if visited.include?(output)
+        puts input
+        exit
+      end
+
+      input = output
+    end

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

@@ -0,0 +1,40 @@
+---
+- :name: day-22-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-22
+  :solution: |-
+    depth, target = input.split("\n")
+
+    depth = depth.scan(/\d+/)[0].to_i
+    xt, yt = target.scan(/\d+/).map(&:to_i)
+
+    length = yt + 1
+    width = xt + 1
+
+    map = Array.new(length) { Array.new(width) }
+
+    map[0][0] = 0
+    map[yt][xt] = 0
+
+    length.times do |y|
+      map[y][0] = (y * 48271 + depth) % 20183
+    end
+
+    width.times do |x|
+      map[0][x] = (x * 16807 + depth) % 20183
+    end
+
+    length.times do |y|
+      next if y == 0
+      width.times do |x|
+        next if x == 0 || x == xt && y == yt
+        map[y][x] = ((map[y-1][x] * map[y][x-1]) + depth) % 20183
+      end
+    end
+
+    length.times do |y|
+      width.times do |x|
+        map[y][x] %= 3
+      end
+    end
+
+    puts map.flatten.inject(:+)

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

@@ -0,0 +1,90 @@
+---
+- :name: day-22-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-22
+  :solution: |-
+    depth, target = input.split("\n")
+
+    depth = depth.scan(/\d+/)[0].to_i
+    xt, yt = target.scan(/\d+/).map(&:to_i)
+
+    length = yt + 1 + 15
+    width = xt + 1 + 15
+
+    map = Array.new(length) { Array.new(width) }
+
+    map[0][0] = 0
+    map[yt][xt] = 0
+
+    length.times do |y|
+      map[y][0] = (y * 48271 + depth) % 20183
+    end
+
+    width.times do |x|
+      map[0][x] = (x * 16807 + depth) % 20183
+    end
+
+    length.times do |y|
+      next if y == 0
+      width.times do |x|
+        next if x == 0 || x == xt && y == yt
+        map[y][x] = ((map[y-1][x] * map[y][x-1]) + depth) % 20183
+      end
+    end
+
+    length.times do |y|
+      width.times do |x|
+        map[y][x] =
+          case map[y][x] % 3
+          when 0
+            ?.
+          when 1
+            ?=
+          when 2
+            ?|
+          end
+      end
+    end
+
+    # BFS with a priority queue
+
+    equipment = {
+      ?. => [:climb, :torch],
+      ?= => [:climb, nil],
+      ?| => [:torch, nil]
+    }
+
+    visited = {}
+    queue = [[0, 0, :torch, 0]]
+
+    while queue.any?
+      queue.sort_by!(&:last)
+
+      x, y, equip, time = queue.shift
+
+      if x == xt && y == yt && equip == :torch
+        puts time
+        exit
+      end
+
+      adjacents = [[x, y - 1], [x - 1, y], [x + 1, y], [x, y + 1]]
+        .reject { |x, y| x < 0 || y < 0 }
+        .select { |x, y| x < width && y < length }
+
+      adjacents.each do |x0, y0|
+        tools = equipment[map[y0][x0]] & equipment[map[y][x]]
+
+        t = time + 1
+        e = equip
+
+        if !tools.include?(equip)
+          e = tools.first
+          t += 7
+        end
+
+        if !visited[[x0, y0, e]] || visited[[x0, y0, e]] > t
+          visited[[x0, y0, e]] = t
+
+          queue << [x0, y0, e, t]
+        end
+      end
+    end

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

@@ -0,0 +1,36 @@
+---
+- :name: day-23-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2018/day-23
+  :solution: |-
+    bots = input.split("\n")
+
+    class Bot
+      attr_reader :x, :y, :z, :r
+
+      def initialize(x, y, z, r)
+        @x = x
+        @y = y
+        @z = z
+        @r = r
+      end
+
+      def distance(other)
+        (other.x - x).abs +
+        (other.y - y).abs +
+        (other.z - z).abs
+      end
+
+      def within_range?(other)
+        distance(other) <= r
+      end
+    end
+
+    bots.map! do |bot|
+      x, y, z, r = bot.scan(/-*\d+/).map(&:to_i)
+
+      Bot.new(x, y, z, r)
+    end
+
+    puts bots.map { |bot|
+      bots.count { |other| bot.within_range?(other) }
+    }.max