advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,33 @@
+---
+- :name: day-07-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-07
+  :solution: |-
+    input     = File.read(file_path)
+
+    parent_bag = Hash.new { |hash, key| hash[key] = Array.new }
+
+    input.split("\n").each do |line|
+      parent, contain = line.match(/(\w+ \w+) bags contain (.*)\./)[1..2]
+
+      children = contain.split(",")
+        .map { |child| child.match(/(\w+ \w+) bag/)[1] }
+        .compact
+
+      children.each do |child|
+        parent_bag[child] << parent
+      end
+    end
+
+    bag_colours = Set.new
+    queue = ["shiny gold"]
+
+    while queue.any?
+      child = queue.shift
+
+      parent_bag[child].each do |parent|
+        bag_colours.add(parent)
+        queue << parent
+      end
+    end
+
+    puts bag_colours.size

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

@@ -0,0 +1,34 @@
+---
+- :name: day-07-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-07
+  :solution: |-
+    children_bags = {}
+
+    input.split("\n").each do |line|
+      parent, contain = line.match(/(\w+ \w+) bags contain (.*)\./)[1..2]
+
+      children = contain.split(",")
+        .reject { |child| child.include?("no other") }
+        .map { |child|
+          [
+            child.match(/\d+/)[0].to_i,
+            child.match(/(\w+ \w+) bag/)[1]
+          ]
+        }
+
+      children_bags[parent] = children
+    end
+
+    sum = 0
+    queue = [["shiny gold", 1]]
+
+    while queue.any?
+      parent, parent_count = queue.shift
+
+      children_bags[parent].each do |child_count, child|
+        sum += child_count * parent_count
+        queue << [child, child_count * parent_count]
+      end
+    end
+
+    puts sum

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

@@ -0,0 +1,32 @@
+---
+- :name: day-08-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-08
+  :solution: |-
+    input     = File.read(file_path)
+
+    ops = input.split("\n")
+
+    i = 0
+    acc = 0
+    executed = Set.new
+
+    while true
+      if executed.include?(i)
+        puts acc
+        exit
+      end
+
+      executed.add(i)
+
+      op, arg = ops[i].split
+      arg = arg.to_i
+
+      case op
+      when "acc"
+        acc += arg
+      when "jmp"
+        i += arg - 1
+      end
+
+      i += 1
+    end

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

@@ -0,0 +1,53 @@
+---
+- :name: day-08-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-08
+  :solution: |-
+    input     = File.read(file_path)
+
+    def run(ops)
+      i = 0
+      acc = 0
+      executed = Set.new
+
+      while i < ops.size
+        return nil if executed.include?(i)
+        executed.add(i)
+
+        op, arg = ops[i].split
+        arg = arg.to_i
+
+        case op
+        when "acc"
+          acc += arg
+        when "jmp"
+          i += arg - 1
+        end
+
+        i += 1
+      end
+
+      acc
+    end
+
+    ops = input.split("\n")
+
+    ops.size.times do |i|
+      fixed_ops = ops.map(&:clone)
+
+      instr = fixed_ops[i]
+
+      if instr =~ /jmp/
+        instr.gsub!("jmp", "nop")
+      elsif instr =~ /nop/
+        instr.gsub!("nop", "jmp")
+      else
+        next
+      end
+
+      acc = run(fixed_ops)
+
+      if acc
+        puts acc
+        exit
+      end
+    end

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

@@ -0,0 +1,35 @@
+---
+- :name: day-09-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-09
+  :solution: |-
+    input     = File.read(file_path)
+
+    step = 25
+
+    data = input.split("\n").map(&:to_i)
+
+    invalid, _ = data.find.with_index do |sum, i|
+      next if i < step
+
+      data[i - step, step]
+        .combination(2).none? { |pair| pair.sum == sum }
+    end
+
+    puts invalid
+
+    data.size.times do |i|
+      j = i + 1
+
+      while true
+        range = data[i..j]
+        sum = range.sum
+
+        if sum == invalid
+          puts range.minmax.sum
+          exit
+        end
+
+        break if sum > invalid
+        j += 1
+      end
+    end

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

@@ -0,0 +1,35 @@
+---
+- :name: day-09-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-09
+  :solution: |-
+    input     = File.read(file_path)
+
+    step = 25
+
+    data = input.split("\n").map(&:to_i)
+
+    invalid, _ = data.find.with_index do |sum, i|
+      next if i < step
+
+      data[i - step, step]
+        .combination(2).none? { |pair| pair.sum == sum }
+    end
+
+    puts invalid
+
+    data.size.times do |i|
+      j = i + 1
+
+      while true
+        range = data[i..j]
+        sum = range.sum
+
+        if sum == invalid
+          puts range.minmax.sum
+          exit
+        end
+
+        break if sum > invalid
+        j += 1
+      end
+    end

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

@@ -0,0 +1,31 @@
+---
+- :name: day-10-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-10
+  :solution: |-
+    input     = File.read(file_path)
+
+    adapters = input.split("\n").map(&:to_i).sort
+
+    adapters.unshift(0)
+    adapters << adapters.last + 3
+
+    diffs = Hash.new(0)
+
+    adapters.each_cons(2) do |a, b|
+      diff = b - a
+      diffs[diff] += 1
+    end
+
+    puts diffs[1] * diffs[3]
+
+
+    pos = Hash.new(0)
+    pos[0] = 1
+
+    adapters.each do |a|
+      3.times do |i|
+        pos[a] += pos[a - i - 1]
+      end
+    end
+
+    puts pos.values.max

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

@@ -0,0 +1,31 @@
+---
+- :name: day-10-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-10
+  :solution: |-
+    input     = File.read(file_path)
+
+    adapters = input.split("\n").map(&:to_i).sort
+
+    adapters.unshift(0)
+    adapters << adapters.last + 3
+
+    diffs = Hash.new(0)
+
+    adapters.each_cons(2) do |a, b|
+      diff = b - a
+      diffs[diff] += 1
+    end
+
+    puts diffs[1] * diffs[3]
+
+
+    pos = Hash.new(0)
+    pos[0] = 1
+
+    adapters.each do |a|
+      3.times do |i|
+        pos[a] += pos[a - i - 1]
+      end
+    end
+
+    puts pos.values.max

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

@@ -0,0 +1,43 @@
+---
+- :name: day-11-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-11
+  :solution: |-
+    grid = input.split("\n").map(&:chars)
+
+    def neighbours(x, y, grid)
+      [x - 1, x, x + 1].product([y - 1, y, y + 1])
+        .reject { |x1, y1| x1 == x && y1 == y }
+        .select { |x1, y1|
+          (0..grid.size-1).cover?(y1) && (0..grid[0].size-1).cover?(x1)
+        }
+    end
+
+    while true
+      new_grid = grid.map(&:dup)
+
+      grid.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          next if cell == ?.
+
+          occupied = neighbours(x, y, grid)
+            .count { |x, y| grid[y][x] == ?# }
+
+          case cell
+          when ?L
+            new_grid[y][x] = ?# if occupied.zero?
+          when ?#
+            new_grid[y][x] = ?L if occupied >= 4
+          end
+        end
+      end
+
+      #puts new_grid.map(&:join).join("\n")
+      #puts
+
+      if new_grid == grid
+        puts new_grid.flatten.count { |c| c == ?# }
+        exit
+      end
+
+      grid = new_grid.map(&:dup)
+    end

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

@@ -0,0 +1,54 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-11
+  :solution: |-
+    grid = input.split("\n").map(&:chars)
+
+    def visible(x, y, grid)
+      [-1, 0, 1].product([-1, 0, 1])
+        .reject { |dx, dy| dx == 0 && dy == 0 }
+        .map { |dx, dy|
+          x1 = x + dx
+          y1 = y + dy
+
+          while grid.dig(y1, x1) == ?.
+            x1 += dx
+            y1 += dy
+          end
+
+          [x1, y1]
+        }
+        .select { |x, y|
+          (0..grid.size-1).cover?(y) && (0..grid[0].size-1).cover?(x)
+        }
+    end
+
+    while true
+      new_grid = grid.map(&:dup)
+
+      grid.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          next if cell == ?.
+
+          visible_count = visible(x, y, grid)
+            .count { |x, y| grid[y][x] == ?# }
+
+          case cell
+          when ?L
+            new_grid[y][x] = ?# if visible_count == 0
+          when ?#
+            new_grid[y][x] = ?L if visible_count >= 5
+          end
+        end
+      end
+
+      #puts new_grid.map(&:join).join("\n")
+      #puts
+
+      if new_grid == grid
+        puts new_grid.flatten.count { |c| c == ?# }
+        exit
+      end
+
+      grid = new_grid.map(&:dup)
+    end

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

@@ -0,0 +1,41 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-12
+  :solution: |-
+    lines = input.split("\n")
+
+    x, y = 0, 0
+    facing = [1, 0]
+
+    def turn(dir, deg)
+      turns = deg / 90
+      dirs = [[0, -1], [-1, 0], [0, 1], [1, 0]]
+      idx = dirs.index(dir) + turns
+      dirs[idx % 4]
+    end
+
+    lines.each do |cmd|
+      action, val = cmd.match(/(\w)(\d+)/).captures
+
+      val = val.to_i
+
+      case action
+      when ?N
+        y -= val
+      when ?E
+        x += val
+      when ?S
+        y += val
+      when ?W
+        x -= val
+      when ?L
+        facing = turn(facing, val)
+      when ?R
+        facing = turn(facing, -val)
+      when ?F
+        x += val * facing[0]
+        y += val * facing[1]
+      end
+    end
+
+    puts [x, y].map(&:abs).sum

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

@@ -0,0 +1,40 @@
+---
+- :name: day-12-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-12
+  :solution: |-
+    x, y = 0, 0
+    x1, y1 = [10, -1]
+
+    def rotate(x, y, deg)
+      {
+        90 => [-y, x],
+        270 => [y, -x],
+        180 => [-x, -y],
+      }[(deg + 360) % 360]
+    end
+
+    input.split("\n").each do |cmd|
+      action, val = cmd.match(/(\w)(\d+)/).captures
+
+      val = val.to_i
+
+      case action
+      when ?N
+        y1 -= val
+      when ?E
+        x1 += val
+      when ?S
+        y1 += val
+      when ?W
+        x1 -= val
+      when ?L
+        x1, y1 = rotate(x1, y1, -val)
+      when ?R
+        x1, y1 = rotate(x1, y1, val)
+      when ?F
+        x += val * x1
+        y += val * y1
+      end
+    end
+
+    puts [x, y].map(&:abs).sum

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

@@ -0,0 +1,17 @@
+---
+- :name: day-13-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-13
+  :solution: |-
+    earliest, buses = input.split("\n")
+
+    earliest = earliest.to_i
+    buses = buses.split(",").reject { |id| id == ?x }.map(&:to_i)
+
+    depart, id = buses.map { |id|
+      [
+        (earliest.to_f / id).ceil * id,
+        id
+      ]
+    }.min
+
+    puts (depart - earliest) * id

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

@@ -0,0 +1,58 @@
+---
+- :name: day-13-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-13
+  :solution: |-
+    buses = input.split("\n").last.split(?,)
+
+    ids = buses
+      .map.with_index { |id, idx| [id.to_i, idx] }
+      .reject { |id, _| id.zero? }
+      .sort.reverse
+
+    id, idx = ids.first
+
+    # Solve for the first bus, and time step for the next valid timestamp
+    t = id - idx
+    step = id
+
+    # Solve for each additional bus
+    ids.each do |id, idx|
+      while true
+        break if (t + idx) % id == 0
+        t += step
+      end
+
+      # Find next time step for this subset of buses by locating the next timestamp
+      # OR simply `step *= id` if you know you are dealing only with prime numbers
+      t2 = t
+      subset = ids[0..(ids.index([id, idx]))]
+      while true
+        t2 += step
+        break if subset.all? { |id, i| (t2 + i) % id  == 0 }
+      end
+
+      step = t2 - t
+    end
+
+    puts t
+
+    exit
+
+    # Solution below is too slow for non-example input
+    ids = buses
+      .map.with_index { |id, idx| [id.to_i, idx] }
+      .reject { |id, _| id.zero? }
+      .sort
+
+    step = ids.last[0]
+    adj = ids.last[1]
+
+    t = step - adj
+
+    while true
+      break if ids.all? { |id, i| (t + i) % id  == 0 }
+
+      t += step
+    end
+
+    puts t

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

@@ -0,0 +1,31 @@
+---
+- :name: day-14-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-14
+  :solution: |-
+    lines = input.split("\n")
+
+    mem  = {}
+    mask = nil
+
+    lines.each do |line|
+      if line.include?("mask")
+        mask = line.match(/= (.*)/).captures.first
+      else
+        idx, val = line.match(/\[(\d+)\] = (\d+)/).captures
+
+        idx = idx.to_i
+        val = val.to_i.to_s(2)
+
+        result = mask.reverse.chars.zip(val.reverse.chars).map do |m, v|
+          if m != ?X
+            m
+          else
+            v || 0
+          end
+        end
+
+        mem[idx] = result.reverse.join.to_i(2)
+      end
+    end
+
+    puts mem.values.sum

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

@@ -0,0 +1,44 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-14
+  :solution: |-
+    lines = input.split("\n")
+
+    mem  = {}
+    mask = nil
+
+    lines.each do |line|
+      if line.include?("mask")
+        mask = line.match(/= (.*)/).captures.first
+      else
+        idx, val = line.match(/\[(\d+)\] = (\d+)/).captures
+
+        idx = idx.to_i.to_s(2)
+        val = val.to_i
+
+        result = mask.reverse.chars.zip(idx.reverse.chars).map do |m, i|
+          if m == ?1
+            1
+          elsif m == ?X
+            'X'
+          else
+            i || 0
+          end
+        end
+
+        addresses = result.count { |c| c == ?X }
+
+        (2**addresses).times do |i|
+          address = result.join
+          bin = i.to_s(2).rjust(addresses, '0')
+
+          bin.chars.each do |j|
+            address.sub!(?X, j)
+          end
+
+          mem[address.reverse.to_i(2)] = val
+        end
+      end
+    end
+
+    puts mem.values.sum

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

@@ -0,0 +1,32 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    nums = input.split(",").map(&:to_i)
+
+    spoken = Hash.new { |h, k| h[k] = Array.new }
+
+    nums.each.with_index do |i, idx|
+      spoken[i] << idx
+    end
+
+    idx = nums.count
+    last = nums.last
+
+    while idx < 30000000
+      if spoken[last].count > 1
+        last = spoken[last].last(2).inject(:-).abs
+      else
+        last = 0
+      end
+
+      spoken[last] << idx
+
+      idx += 1
+
+      puts last if idx == 2020
+    end
+
+    puts last

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

@@ -0,0 +1,32 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2020/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    nums = input.split(",").map(&:to_i)
+
+    spoken = Hash.new { |h, k| h[k] = Array.new }
+
+    nums.each.with_index do |i, idx|
+      spoken[i] << idx
+    end
+
+    idx = nums.count
+    last = nums.last
+
+    while idx < 30000000
+      if spoken[last].count > 1
+        last = spoken[last].last(2).inject(:-).abs
+      else
+        last = 0
+      end
+
+      spoken[last] << idx
+
+      idx += 1
+
+      puts last if idx == 2020
+    end
+
+    puts last