advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,65 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-14
+  :solution: |-
+    # output_chemical => [inputs, output_qty]
+    produce = {}
+
+    input.split("\n").each do |reaction|
+      inputs, out = reaction.split("=>").map(&:strip)
+
+      # chem => qty
+      inputs = Hash[
+        *inputs.split(",")
+          .map { |from| from.strip.split(" ").reverse }
+          .flatten
+      ]
+
+      inputs.transform_values! { |qty| qty.to_i }
+
+      out_qty, out_chem = out.split(" ")
+
+      produce[out_chem] = [inputs, out_qty.to_i]
+    end
+
+    # Binary search the output fuel
+
+    min = 0
+    max = 1e12.to_i
+
+    while max - min > 1
+      guess = min + (max - min) / 2
+
+      required = Hash.new(0)
+      required["FUEL"] = guess
+
+      while required.any? { |chem, qty| chem != "ORE" && qty > 0 }
+        required.entries.each do |chem, qty_required|
+          next if chem == "ORE"
+
+          inputs, to_qty = produce[chem]
+
+          multiples = (qty_required.to_f / to_qty).ceil
+
+          inputs.each do |in_chem, in_qty|
+            required[in_chem] += in_qty.to_i * multiples
+          end
+
+          required[chem] -= multiples * to_qty
+        end
+
+        required.each do |chem, qty|
+          required.delete(chem) if qty == 0
+        end
+      end
+
+      ore_needed = required["ORE"]
+
+      if ore_needed >= 1e12
+        max = guess
+      else
+        min = guess
+      end
+    end
+
+    puts min

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

@@ -0,0 +1,198 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    codes = Hash.new(0)
+
+    input.split(",").each_with_index do |code, i|
+      codes[i] = code.to_i
+    end
+
+    x = y = 0
+    step = 1
+
+    map = { [x,y] => false }
+    visited = {}
+
+    reverse_move = {
+      1 => 2,
+      2 => 1,
+      3 => 4,
+      4 => 3
+    }
+
+    # Starting movement commands inputs - depth-first
+    stack = reverse_move.keys
+
+    found = nil
+    manual_mode = false
+
+    relative_base = 0
+    i = 0
+    out = nil
+    inp = nil
+
+    loop do
+      opcode = codes[i] % 100
+
+      modes = (codes[i] / 100).digits
+      3.times { modes << 0 }
+
+      refs = modes.map.with_index do |m, idx|
+        address = i + idx + 1
+
+        if m == 1
+          address
+        elsif m == 2
+          relative_base + codes[address]
+        else
+          codes[address]
+        end
+      end
+
+      case opcode
+      when 1
+        op = :+
+      when 2
+        op = :*
+      when 3
+        inp = stack.pop
+
+        if manual_mode
+          # wasd
+          char = STDIN.getch
+          case char
+          when 'w'
+            inp = 1
+          when 'a'
+            inp = 3
+          when 's'
+            inp = 2
+          when 'd'
+            inp = 4
+          else
+            exit
+          end
+        end
+
+        codes[refs[0]] = inp
+      when 4
+        out = codes[refs[0]]
+      when 5
+        if codes[refs[0]] != 0
+          i = codes[refs[1]]
+          next
+        end
+      when 6
+        if codes[refs[0]] == 0
+          i = codes[refs[1]]
+          next
+        end
+      when 7
+        if codes[refs[0]] < codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 8
+        if codes[refs[0]] == codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 9
+        relative_base += codes[refs[0]]
+      when 99
+        break
+      end
+
+      codes[refs[2]] = codes[refs[0]].send(op, codes[refs[1]]) if op
+
+      if [1, 2, 7, 8].include?(opcode)
+        i += 4
+      elsif [5, 6].include?(opcode)
+        i += 3
+      else
+        i += 2
+      end
+
+      if out
+        if out == 0
+          y1 = y
+          x1 = x
+
+          case inp
+          when 1
+            y1 = y - 1
+          when 2
+            y1 = y + 1
+          when 3
+            x1 = x - 1
+          when 4
+            x1 = x + 1
+          end
+
+          map[[x1, y1]] = true
+        else
+          case inp
+          when 1
+            y -= 1
+          when 2
+            y += 1
+          when 3
+            x -= 1
+          when 4
+            x += 1
+          end
+
+          found = [x, y] if out == 2
+
+          # Depth-first search
+          if !visited[[x,y]]
+            # Backtrack
+            reverse_direction = reverse_move[inp]
+            stack << reverse_direction
+
+            movements = reverse_move.keys
+            movements.delete reverse_direction
+
+            stack.concat(movements)
+
+            visited[[x, y]] = step
+            step += 1
+            map[[x, y]] = false
+          else
+            step -= 1
+          end
+        end
+
+        if manual_mode || stack.empty? || visited.length % 20 == 0
+          puts "\e[H\e[2J"
+
+          Range.new(*map.keys.map(&:last).minmax).each do |y2|
+            Range.new(*map.keys.map(&:first).minmax).each do |x2|
+              if map[[x2, y2]]
+                print "#"
+              elsif x2 == x && y2 == y
+                print "D"
+              elsif x2 == 0 && y2 == 0
+                print "S"
+              elsif found && found[0] == x2 && found[1] == y2
+                print "O"
+              elsif visited[[x2, y2]]
+                print "."
+              else
+                print " "
+              end
+            end
+            print "\n"
+          end
+        end
+
+        out = nil
+      end
+    end
+
+    puts visited[found]

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

@@ -0,0 +1,216 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-15
+  :solution: |-
+    input     = File.read(file_path)
+
+    codes = Hash.new(0)
+
+    input.split(",").each_with_index do |code, i|
+      codes[i] = code.to_i
+    end
+
+    x = y = 0
+    step = 1
+
+    map = { [x,y] => false }
+    visited = {}
+
+    reverse_move = {
+      1 => 2,
+      2 => 1,
+      3 => 4,
+      4 => 3
+    }
+
+    # Starting movement commands inputs - depth-first
+    stack = reverse_move.keys
+
+    found = nil
+    manual_mode = false
+
+    relative_base = 0
+    i = 0
+    out = nil
+    inp = nil
+
+    loop do
+      opcode = codes[i] % 100
+
+      modes = (codes[i] / 100).digits
+      3.times { modes << 0 }
+
+      refs = modes.map.with_index do |m, idx|
+        address = i + idx + 1
+
+        if m == 1
+          address
+        elsif m == 2
+          relative_base + codes[address]
+        else
+          codes[address]
+        end
+      end
+
+      case opcode
+      when 1
+        op = :+
+      when 2
+        op = :*
+      when 3
+        inp = stack.pop
+
+        if manual_mode
+          # wasd
+          char = STDIN.getch
+          case char
+          when 'w'
+            inp = 1
+          when 'a'
+            inp = 3
+          when 's'
+            inp = 2
+          when 'd'
+            inp = 4
+          else
+            exit
+          end
+        end
+
+        codes[refs[0]] = inp
+      when 4
+        out = codes[refs[0]]
+      when 5
+        if codes[refs[0]] != 0
+          i = codes[refs[1]]
+          next
+        end
+      when 6
+        if codes[refs[0]] == 0
+          i = codes[refs[1]]
+          next
+        end
+      when 7
+        if codes[refs[0]] < codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 8
+        if codes[refs[0]] == codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 9
+        relative_base += codes[refs[0]]
+      when 99
+        break
+      end
+
+      codes[refs[2]] = codes[refs[0]].send(op, codes[refs[1]]) if op
+
+      if [1, 2, 7, 8].include?(opcode)
+        i += 4
+      elsif [5, 6].include?(opcode)
+        i += 3
+      else
+        i += 2
+      end
+
+      if out
+        if out == 0
+          y1 = y
+          x1 = x
+
+          case inp
+          when 1
+            y1 = y - 1
+          when 2
+            y1 = y + 1
+          when 3
+            x1 = x - 1
+          when 4
+            x1 = x + 1
+          end
+
+          map[[x1, y1]] = true
+        else
+          case inp
+          when 1
+            y -= 1
+          when 2
+            y += 1
+          when 3
+            x -= 1
+          when 4
+            x += 1
+          end
+
+          found = [x, y] if out == 2
+
+          # Depth-first search
+          if !visited[[x,y]]
+            # Backtrack
+            reverse_direction = reverse_move[inp]
+            stack << reverse_direction
+
+            movements = reverse_move.keys
+            movements.delete reverse_direction
+
+            stack.concat(movements)
+
+            visited[[x, y]] = step
+            step += 1
+            map[[x, y]] = false
+          else
+            step -= 1
+          end
+        end
+
+        if manual_mode || stack.empty? || visited.length % 20 == 0
+          puts "\e[H\e[2J"
+
+          Range.new(*map.keys.map(&:last).minmax).each do |y2|
+            Range.new(*map.keys.map(&:first).minmax).each do |x2|
+              if map[[x2, y2]]
+                print "#"
+              elsif x2 == x && y2 == y
+                print "D"
+              elsif x2 == 0 && y2 == 0
+                print "S"
+              elsif found && found[0] == x2 && found[1] == y2
+                print "O"
+              elsif visited[[x2, y2]]
+                print "."
+              else
+                print " "
+              end
+            end
+            print "\n"
+          end
+        end
+
+        out = nil
+      end
+    end
+
+
+    visited = {}
+    stack = [found << 0]
+
+    while stack.any?
+      x, y, step = stack.pop
+
+      visited[[x,y]] = step
+
+      neighbours = [[x+1, y], [x-1, y], [x, y-1], [x, y+1]]
+
+      neighbours.select! do |location|
+        map[location] == false && !visited[location]
+      end
+
+      neighbours.each { |n| stack << (n << step + 1) }
+    end
+
+    puts visited.values.max

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

@@ -0,0 +1,49 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-16
+  :solution: |-
+    base = [0, 1, 0, -1]
+
+    digits = input.to_i.digits.reverse
+
+    100.times do |time|
+      result = []
+
+      digits.length.times do |i|
+        sum = 0
+
+        # 5 x slower solution - but simplier
+        # digits.length.times do |idx|
+        #   sum += digits[idx] * base[(idx + 1) / (i + 1) % base.length]
+        # end
+
+        # This observation is very important for part 2 :)
+        last_relevant_digit = digits.length - 1
+
+        if ((i + 1) * 3) > digits.length
+          last_relevant_digit = [
+            (i + 1) * 2 - 1,
+            last_relevant_digit
+          ].min
+        end
+
+        digits[i..last_relevant_digit].each_slice(i + 1)
+          .with_index do |slice, idx|
+
+          total = slice.inject(:+)
+
+          case idx % 4
+          when 0 # 1
+            sum += total
+          when 2 # -1
+            sum -= total
+          end
+        end
+
+        result << sum.abs % 10
+      end
+
+      digits = result
+    end
+
+    puts digits[0, 8].join

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

@@ -0,0 +1,27 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-16
+  :solution: |-
+    digits = input.chars.map(&:to_i) * 10000
+
+    offset = digits[0, 7].join.to_i
+
+    digits = digits[offset..]
+
+    100.times do |time|
+      result = []
+
+      # Bottom half digits is a triangular matrix.
+      # From the offset, we are certainly in the bottom half.
+      sum = digits.inject(:+)
+
+      digits.length.times do |i|
+        result << sum.abs % 10
+
+        sum -= digits[i]
+      end
+
+      digits = result
+    end
+
+    puts digits[0, 8].join

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

@@ -0,0 +1,109 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2019/day-17
+  :solution: |-
+    codes = Hash.new(0)
+
+    input.split(",").each_with_index do |code, i|
+      codes[i] = code.to_i
+    end
+
+    relative_base = 0
+    inp = 1
+
+    i = 0
+
+    out = []
+
+    loop do
+      opcode = codes[i] % 100
+
+      modes = (codes[i] / 100).digits
+      3.times { modes << 0 }
+
+      refs = modes.map.with_index do |m, idx|
+        address = i + idx + 1
+
+        if m == 1
+          address
+        elsif m == 2
+          relative_base + codes[address]
+        else
+          codes[address]
+        end
+      end
+
+      case opcode
+      when 1
+        op = :+
+      when 2
+        op = :*
+      when 3
+        codes[refs[0]] = inp
+      when 4
+        out << codes[refs[0]]
+      when 5
+        if codes[refs[0]] != 0
+          i = codes[refs[1]]
+          next
+        end
+      when 6
+        if codes[refs[0]] == 0
+          i = codes[refs[1]]
+          next
+        end
+      when 7
+        if codes[refs[0]] < codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 8
+        if codes[refs[0]] == codes[refs[1]]
+          codes[refs[2]] = 1
+        else
+          codes[refs[2]] = 0
+        end
+      when 9
+        relative_base += codes[refs[0]]
+      when 99
+        break
+      end
+
+      codes[refs[2]] = codes[refs[0]].send(op, codes[refs[1]]) if op
+
+      if [1, 2, 7, 8].include?(opcode)
+        i += 4
+      elsif [5, 6].include?(opcode)
+        i += 3
+      else
+        i += 2
+      end
+    end
+
+    map = out.map(&:chr).join
+
+    puts map
+
+    grid = map.split("\n").map { |row| row.split('') }
+
+    rows = grid.size
+    cols = grid[0].size
+
+    sum = 0
+
+    grid.each_with_index do |row, y|
+      row.each_with_index do |cell, x|
+        next unless cell == ?#
+
+        adjacent = [[x, y - 1], [x, y + 1], [x - 1, y], [x + 1, y]]
+          .select { |x, _| (0..cols-1).cover?(x) }
+          .select { |_, y| (0..rows-1).cover?(y) }
+
+        next if adjacent.size != 4
+
+        sum += x * y if adjacent.all? { |x, y| grid[y][x] == ?# }
+      end
+    end
+
+    puts sum