advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2019/11_1.yml

@@ -0,0 +1,113 @@
+---
+- :name: 11a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    input = File.read('11.txt')
+    code = input.chomp.split(',').map { |e| Integer(e) }.freeze
+
+    def interpreter(memory, input, output)
+      memory = memory.dup
+      def memory.[](i)
+        raise if i < 0
+        super(i) || 0
+      end
+      ip = 0
+      mode = 0
+      relative_base = 0
+
+      get_mode = -> i {
+        mode / (10 ** (i-1)) % 10
+      }
+
+      read = -> i {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v]
+        when 1 # immediate
+          v
+        when 2 # relative
+          memory[relative_base + v]
+        else
+          raise "Unknown read mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      write = -> i, result {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v] = result
+        when 2 # relative
+          memory[relative_base + v] = result
+        else
+          raise "Unknown write mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      while true
+        instruction = memory[ip]
+        mode, opcode = instruction.divmod(100)
+        case opcode
+        when 1 # add
+          write[3, read[1] + read[2]]
+          ip += 4
+        when 2 # multiply
+          write[3, read[1] * read[2]]
+          ip += 4
+        when 3 # input
+          write[1, input.call]
+          ip += 2
+        when 4 # output
+          output.call(read[1])
+          ip += 2
+        when 5 # jump-if-true
+          ip = read[1] != 0 ? read[2] : ip + 3
+        when 6 # jump-if-false
+          ip = read[1] == 0 ? read[2] : ip + 3
+        when 7 # less than
+          write[3, read[1] < read[2] ? 1 : 0]
+          ip += 4
+        when 8 # equals
+          write[3, read[1] == read[2] ? 1 : 0]
+          ip += 4
+        when 9 # relative base offset
+          relative_base += read[1]
+          ip += 2
+        when 99
+          break
+        else
+          raise "Unknown opcode: #{opcode} at #{ip} (#{instruction})"
+        end
+      end
+    end
+
+    BLACK = 0
+    WHITE = 1
+    DIRS = [-1i, 1, 1i, -1]
+
+    pos = 0 + 0i
+    dir = DIRS[0]
+    panels = Hash.new(BLACK)
+
+    f = Fiber.new do
+      interpreter(code, -> { panels[pos] }, -> r { Fiber.yield(r) })
+      nil
+    end
+
+    while color = f.resume
+      panels[pos] = color
+
+      direction = f.resume
+      case direction
+      when 0 # left
+        dir = DIRS[(DIRS.index(dir) - 1) % DIRS.size]
+      when 1 # right
+        dir = DIRS[(DIRS.index(dir) + 1) % DIRS.size]
+      else
+        raise direction
+      end
+      pos += dir
+    end
+
+    p panels.size

data/data/solutions/github/eregon/2019/11_2.yml

@@ -0,0 +1,119 @@
+---
+- :name: 11b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    input = File.read('11.txt')
+    code = input.chomp.split(',').map { |e| Integer(e) }.freeze
+
+    def interpreter(memory, input, output)
+      memory = memory.dup
+      def memory.[](i)
+        raise if i < 0
+        super(i) || 0
+      end
+      ip = 0
+      mode = 0
+      relative_base = 0
+
+      get_mode = -> i {
+        mode / (10 ** (i-1)) % 10
+      }
+
+      read = -> i {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v]
+        when 1 # immediate
+          v
+        when 2 # relative
+          memory[relative_base + v]
+        else
+          raise "Unknown read mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      write = -> i, result {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v] = result
+        when 2 # relative
+          memory[relative_base + v] = result
+        else
+          raise "Unknown write mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      while true
+        instruction = memory[ip]
+        mode, opcode = instruction.divmod(100)
+        case opcode
+        when 1 # add
+          write[3, read[1] + read[2]]
+          ip += 4
+        when 2 # multiply
+          write[3, read[1] * read[2]]
+          ip += 4
+        when 3 # input
+          write[1, input.call]
+          ip += 2
+        when 4 # output
+          output.call(read[1])
+          ip += 2
+        when 5 # jump-if-true
+          ip = read[1] != 0 ? read[2] : ip + 3
+        when 6 # jump-if-false
+          ip = read[1] == 0 ? read[2] : ip + 3
+        when 7 # less than
+          write[3, read[1] < read[2] ? 1 : 0]
+          ip += 4
+        when 8 # equals
+          write[3, read[1] == read[2] ? 1 : 0]
+          ip += 4
+        when 9 # relative base offset
+          relative_base += read[1]
+          ip += 2
+        when 99
+          break
+        else
+          raise "Unknown opcode: #{opcode} at #{ip} (#{instruction})"
+        end
+      end
+    end
+
+    BLACK = 0
+    WHITE = 1
+    DIRS = [-1i, 1, 1i, -1]
+
+    pos = 0 + 0i
+    dir = DIRS[0]
+    panels = Hash.new(BLACK)
+    panels[pos] = WHITE
+
+    f = Fiber.new do
+      interpreter(code, -> { panels[pos] }, -> r { Fiber.yield(r) })
+      nil
+    end
+
+    while color = f.resume
+      panels[pos] = color
+
+      direction = f.resume
+      case direction
+      when 0 # left
+        dir = DIRS[(DIRS.index(dir) - 1) % DIRS.size]
+      when 1 # right
+        dir = DIRS[(DIRS.index(dir) + 1) % DIRS.size]
+      else
+        raise direction
+      end
+      pos += dir
+    end
+
+    Range.new(*panels.keys.map(&:imag).minmax).each { |y|
+      Range.new(*panels.keys.map(&:real).minmax).each { |x|
+        print(panels[x + y.i] == WHITE ? '#' : ' ')
+      }
+      puts
+    }

data/data/solutions/github/eregon/2019/12_1.yml

@@ -0,0 +1,34 @@
+---
+- :name: 12a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    require 'matrix'
+
+    Moon = Struct.new(:name, :pos, :vel) do
+      def energy
+        pos.to_a.sum(&:abs) * vel.to_a.sum(&:abs)
+      end
+    end
+
+    input = File.readlines('12.txt')
+    names = %i[Io Europa Ganymede Callisto]
+    dimensions = 3
+
+    moons = input.zip(names).map { |line, name|
+      pos = Vector[*line.scan(/-?\d+/).map(&:to_i)]
+      Moon.new(name[0], pos, Vector.zero(dimensions))
+    }
+
+    1000.times do |step|
+      moons.combination(2) { |a,b|
+        dimensions.times { |dim|
+          cmp = a.pos[dim] <=> b.pos[dim]
+          a.vel[dim] -= cmp
+          b.vel[dim] += cmp
+        }
+      }
+
+      moons.each { |moon| moon.pos += moon.vel }
+    end
+
+    p moons.sum(&:energy)

data/data/solutions/github/eregon/2019/12_2.yml

@@ -0,0 +1,136 @@
+---
+- :name: 12b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    require 'matrix'
+
+    Moon = Struct.new(:name, :pos, :vel) do
+      def energy
+        pos.to_a.sum(&:abs) * vel.to_a.sum(&:abs)
+      end
+    end
+
+    input = File.readlines('12.txt')
+    names = %i[Io Europa Ganymede Callisto]
+    dimensions = 3
+
+    moons = input.zip(names).map { |line, name|
+      pos = Vector[*line.scan(/-?\d+/).map(&:to_i)]
+      Moon.new(name[0], pos, Vector.zero(dimensions))
+    }
+
+    ORIGINALS = Marshal.load(Marshal.dump(moons))
+
+    def simulate(dim)
+      moons = Marshal.load(Marshal.dump(ORIGINALS))
+      steps = 0
+      begin
+        moons.combination(2) { |a,b|
+          cmp = a.pos[dim] <=> b.pos[dim]
+          a.vel[dim] -= cmp
+          b.vel[dim] += cmp
+        }
+
+        moons.each { |moon| moon.pos += moon.vel }
+
+        steps += 1
+      end until moons == ORIGINALS
+
+      steps
+    end
+
+    p dimensions.times.map { |dim| simulate(dim) }.reduce(:lcm)
+- :name: 12b_eval.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    require 'matrix'
+
+    Moon = Struct.new(:name, :pos, :vel) do
+      def energy
+        pos.to_a.sum(&:abs) * vel.to_a.sum(&:abs)
+      end
+    end
+
+    input = File.readlines('12.txt')
+    names = %i[Io Europa Ganymede Callisto]
+    dimensions = 3
+
+    moons = input.zip(names).map { |line, name|
+      pos = Vector[*line.scan(/-?\d+/).map(&:to_i)]
+      Moon.new(name[0], pos, Vector.zero(dimensions))
+    }
+
+    ORIGINALS = Marshal.load(Marshal.dump(moons))
+    INDICIES = ORIGINALS.each_index.to_a.freeze
+
+    eval <<RUBY
+    def simulate(dim)
+      orig_positions = ORIGINALS.map { |moon| moon.pos[dim] }.freeze
+      orig_velocities = ORIGINALS.map { |moon| moon.vel[dim] }.freeze
+      positions = orig_positions.dup
+      velocities = orig_velocities.dup
+
+      steps = 0
+      begin
+        #{INDICIES.combination(2).map { |a,b|
+          "cmp = positions[#{a}] <=> positions[#{b}]
+          velocities[#{a}] -= cmp
+          velocities[#{b}] += cmp"
+        }.join("\n")}
+
+        #{INDICIES.map { |i| "positions[#{i}] += velocities[#{i}]" }.join("\n")}
+
+        steps += 1
+      end until positions == orig_positions and velocities == orig_velocities
+
+      steps
+    end
+    RUBY
+
+    p dimensions.times.map { |dim| simulate(dim) }.reduce(:lcm)
+- :name: 12b_opt.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    require 'matrix'
+
+    Moon = Struct.new(:name, :pos, :vel) do
+      def energy
+        pos.to_a.sum(&:abs) * vel.to_a.sum(&:abs)
+      end
+    end
+
+    input = File.readlines('12.txt')
+    names = %i[Io Europa Ganymede Callisto]
+    dimensions = 3
+
+    moons = input.zip(names).map { |line, name|
+      pos = Vector[*line.scan(/-?\d+/).map(&:to_i)]
+      Moon.new(name[0], pos, Vector.zero(dimensions))
+    }
+
+    ORIGINALS = Marshal.load(Marshal.dump(moons))
+    INDICIES = ORIGINALS.each_index.to_a.freeze
+
+    def simulate(dim)
+      orig_positions = ORIGINALS.map { |moon| moon.pos[dim] }.freeze
+      orig_velocities = ORIGINALS.map { |moon| moon.vel[dim] }.freeze
+      positions = orig_positions.dup
+      velocities = orig_velocities.dup
+
+      steps = 0
+      begin
+        INDICIES.combination(2) { |a,b|
+          cmp = positions[a] <=> positions[b]
+          velocities[a] -= cmp
+          velocities[b] += cmp
+        }
+
+        velocities.each_with_index { |v,i| positions[i] += v }
+
+        steps += 1
+      end until positions == orig_positions and velocities == orig_velocities
+
+      steps
+    end
+
+    p dimensions.times.map { |dim| simulate(dim) }.reduce(:lcm)

data/data/solutions/github/eregon/2019/13_1.yml

@@ -0,0 +1,99 @@
+---
+- :name: 13a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2019
+  :solution: |-
+    input = File.read('13.txt')
+    code = input.chomp.split(',').map { |e| Integer(e) }.freeze
+
+    def interpreter(memory, input, output)
+      memory = memory.dup
+      def memory.[](i)
+        raise if i < 0
+        super(i) || 0
+      end
+      ip = 0
+      mode = 0
+      relative_base = 0
+
+      get_mode = -> i {
+        mode / (10 ** (i-1)) % 10
+      }
+
+      read = -> i {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v]
+        when 1 # immediate
+          v
+        when 2 # relative
+          memory[relative_base + v]
+        else
+          raise "Unknown read mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      write = -> i, result {
+        v = memory[ip + i]
+        case m = get_mode[i]
+        when 0 # position
+          memory[v] = result
+        when 2 # relative
+          memory[relative_base + v] = result
+        else
+          raise "Unknown write mode #{m} (#{mode} #{i})"
+        end
+      }
+
+      while true
+        instruction = memory[ip]
+        mode, opcode = instruction.divmod(100)
+        case opcode
+        when 1 # add
+          write[3, read[1] + read[2]]
+          ip += 4
+        when 2 # multiply
+          write[3, read[1] * read[2]]
+          ip += 4
+        when 3 # input
+          write[1, input.call]
+          ip += 2
+        when 4 # output
+          output.call(read[1])
+          ip += 2
+        when 5 # jump-if-true
+          ip = read[1] != 0 ? read[2] : ip + 3
+        when 6 # jump-if-false
+          ip = read[1] == 0 ? read[2] : ip + 3
+        when 7 # less than
+          write[3, read[1] < read[2] ? 1 : 0]
+          ip += 4
+        when 8 # equals
+          write[3, read[1] == read[2] ? 1 : 0]
+          ip += 4
+        when 9 # relative base offset
+          relative_base += read[1]
+          ip += 2
+        when 99
+          break
+        else
+          raise "Unknown opcode: #{opcode} at #{ip} (#{instruction})"
+        end
+      end
+    end
+
+    TYPES = [' ', '#', '+', '_', '*']
+    tiles = Hash.new(TYPES[0])
+
+    f = Fiber.new do
+      interpreter(code, -> { raise }, -> r { Fiber.yield(r) })
+      nil
+    end
+
+    while x = f.resume
+      y = f.resume
+      id = f.resume
+      tiles[x + y.i] = TYPES[id]
+    end
+
+    p tiles.values.count('+')