advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/ZogStriP/2019/18_2.yml

@@ -0,0 +1,102 @@
+---
+- :name: 18_many-worlds_interpretation.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    require_relative "priority_queue"
+
+    input = DATA.read.split("\n")
+
+    @map = input.join
+    @height = input.size
+    @width = input[0].size
+
+    @keys = {}
+    @gates = {}
+    @start = nil
+    @sources = []
+
+    input.each.with_index { |r, y|
+      r.bytes.each.with_index { |c, x|
+        p = y * @width + x
+        if 65 <= c && c <= 90
+          @gates[p] = 1 << (c - 65)
+        elsif 97 <= c && c <= 122
+          @keys[p] = 1 << (c - 97)
+          @sources << p
+        elsif c == 64
+          @start = p
+          @sources << p
+        end
+      }
+    }
+
+    @all_keys = (1 << @keys.size) - 1
+
+    @bfs = {}
+
+    def bfs(from)
+      @bfs[from] ||= begin
+        d = { from => 0 }
+        q = [from]
+        p = {}
+
+        while c = q.shift
+          [c - @width, c + @width, c - 1, c + 1]
+            .select { |n| !d[n] && @map[n] != ?# }
+            .each { |n| d[n] = d[c] + 1; p[n] = c; q << n }
+        end
+
+        @sources.select { |s| d[s] }.map { |s|
+          k = @keys[s].to_i
+          g = 0
+          n = s
+
+          while n = p[n]
+            k |= @keys[n]  if @keys[n]
+            g |= @gates[n] if @gates[n]
+          end
+
+          [k, g, s, d[s]]
+        }
+      end
+    end
+
+    def dijkstra(froms)
+      score = Hash.new(1.0 / 0)
+      open = PriorityQueue.new
+      closed = {}
+
+      start = [froms, 0]
+      score[start] = 0
+      open.push(start, 0)
+
+      while c = open.pop
+        return score[c] if c[1] == @all_keys
+
+        closed[c] = true
+
+        c[0].each.with_index { |r, i|
+          bfs(r).each { |keys, gates, position, steps|
+            next if c[1] & keys  == keys
+            next if c[1] & gates != gates
+            cc = c[0].dup
+            cc[i] = position
+            n = [cc, c[1] | keys]
+            next if closed[n]
+            next if (s = score[c] + steps) >= score[n]
+            open.push(n, score[n] = s)
+          }
+        }
+      end
+    end
+
+    p dijkstra([@start])
+
+    @bfs = {}
+
+    [@start, @start + 1, @start - 1, @start + @width, @start - @width].each { |p| @map[p] = ?# }
+
+    starts = [@start - 1 - @width, @start - 1 + @width, @start + 1 - @width, @start + 1 + @width ]
+    starts.each { |p| @sources << p }
+
+    p dijkstra(starts)

data/data/solutions/github/ZogStriP/2019/19_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/19_2.yml

@@ -0,0 +1,86 @@
+---
+- :name: 19_tractor_beam.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    PROGRAM = DATA.read.split(?,).map(&:to_i).freeze
+
+    class IntCode
+
+      def initialize(mem, input = [])
+        @pc = 0
+        @base = 0
+        @input = input
+        @mem = mem.map.with_index { |m, i| [i, m] }.to_h
+        @mem.default = 0
+      end
+
+      def read(address, mode)
+        case mode.to_i
+        when 0 then @mem[@mem[address]]
+        when 1 then @mem[address]
+        when 2 then @mem[@mem[address] + @base]
+        end
+      end
+
+      def write(address, mode, value)
+        case mode.to_i
+        when 0 then @mem[@mem[address]] = value
+        when 2 then @mem[@mem[address] + @base] = value
+        end
+      end
+
+      def run
+        loop do
+          mode, opcode = @mem[@pc].divmod(100)
+          m = mode.digits
+          a = read(@pc + 1, m[0])
+          b = read(@pc + 2, m[1])
+
+          case opcode
+          when 1
+            write(@pc + 3, m[2], a + b)
+            @pc += 4
+          when 2
+            write(@pc + 3, m[2], a * b)
+            @pc += 4
+          when 3
+            write(@pc + 1, m[0], @input.shift)
+            @pc += 2
+          when 4
+            @pc += 2
+            return a
+          when 5
+            a != 0 ? @pc = b : @pc += 3
+          when 6
+            a == 0 ? @pc = b : @pc += 3
+          when 7
+            write(@pc + 3, m[2], a < b ? 1 : 0)
+            @pc += 4
+          when 8
+            write(@pc + 3, m[2], a == b ? 1 : 0)
+            @pc += 4
+          when 9
+            @base += a
+            @pc += 2
+          when 99
+            return
+          else
+            throw "Unknown opcode: #{opcode}"
+          end
+        end
+      end
+
+    end
+
+    def in_beam?(x, y)
+      IntCode.new(PROGRAM, [x, y]).run == 1
+    end
+
+    p (0..49).sum { |y| (0..49).count { |x| in_beam?(x, y) }}
+
+    x = 0
+
+    p 1000.step { |y|
+      x = (x..).find { |xx| in_beam?(xx, y) }
+      break x * 10000 + y - 99 if in_beam?(x + 99, y - 99)
+    }

data/data/solutions/github/ZogStriP/2019/20_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/20_2.yml

@@ -0,0 +1,90 @@
+---
+- :name: 20_donut_maze.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    require_relative "priority_queue"
+
+    @donut = DATA.read.split("\n")
+    @height = @donut.size
+    @width = @donut.map(&:size).max
+
+    AA_ZZ = /[A-Z]{2}/
+    N = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+
+    @portals = {}
+    @levels = {}
+    @wraps = {}
+
+    (2..@height - 2).each { |y|
+      (2..@width - 2).each { |x|
+        next if @donut[y][x] != ?.
+        @portals[[x, y]] = @donut[y][x - 2, 2] if @donut[y][x - 2, 2][AA_ZZ]
+        @portals[[x, y]] = @donut[y][x + 1, 2] if @donut[y][x + 1, 2][AA_ZZ]
+        @portals[[x, y]] = @donut[y - 2][x] + @donut[y - 1][x] if (@donut[y - 2][x].to_s + @donut[y - 1][x])[AA_ZZ]
+        @portals[[x, y]] = @donut[y + 1][x] + @donut[y + 2][x] if (@donut[y + 1][x] + @donut[y + 2][x].to_s)[AA_ZZ]
+      }
+    }
+
+    @max_depth = @portals.size - 2
+
+    @portals.each { |k, _| @levels[k] = k[0] == 2 || k[1] == 2 || k[0] == @width - 3 || k[1] == @height - 3 ? -1 : 1 }
+
+    @portals.group_by(&:last).each { |_, v|
+      w = v.map(&:first)
+      @wraps[w[0]] = w[1]
+      @wraps[w[1]] = w[0]
+    }
+
+    @_bfs = {}
+
+    def bfs(start)
+      @_bfs[start] ||= begin
+        d = { start => 0 }
+        q = [start]
+
+        while c = q.shift
+          N.map { |n| [c[0] + n[0], c[1] + n[1]] }
+           .select { |n| !d[n] && @donut[n[1]][n[0]] == ?. }
+           .each { |n| q << n; d[n] = d[c] + 1 }
+        end
+
+        @portals.select { |k, _| d[k] && d[k] > 0 }.map { |k, _| [k, d[k]] }
+      end
+    end
+
+    def dijkstra(from, to, deep = 0)
+      score = Hash.new(1.0 / 0)
+      open = PriorityQueue.new
+      closed = {}
+
+      start = [from, 0]
+      score[start] = 0
+      open.push(start, 0)
+
+      while c = open.pop
+        position, depth = c
+
+        return score[c] if position == to && depth == 0
+
+        closed[c] = true
+
+        bfs(position).each { |p, steps|
+          d = depth
+          if @wraps[p]
+            d += @levels[p] * deep
+            p = @wraps[p]
+            steps += 1
+          end
+          next if d < 0 || d > @max_depth
+          n = [p, d]
+          next if closed[n]
+          next if (s = score[c] + steps) >= score[n]
+          open.push(n, score[n] = s)
+        }
+      end
+    end
+
+    src = @portals.key("AA")
+    dst = @portals.key("ZZ")
+
+    p dijkstra(src, dst), dijkstra(src, dst, 1)

data/data/solutions/github/ZogStriP/2019/21_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/21_2.yml

@@ -0,0 +1,104 @@
+---
+- :name: 21_springdroid_adventure.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    PROGRAM = DATA.read.split(?,).map(&:to_i).freeze
+
+    class IntCode
+
+      def initialize(mem)
+        @pc = 0
+        @base = 0
+        @mem = mem.map.with_index { |m, i| [i, m] }.to_h
+        @mem.default = 0
+      end
+
+      def read(address, mode)
+        case mode.to_i
+        when 0 then @mem[@mem[address]]
+        when 1 then @mem[address]
+        when 2 then @mem[@mem[address] + @base]
+        end
+      end
+
+      def write(address, mode, value)
+        case mode.to_i
+        when 0 then @mem[@mem[address]] = value
+        when 2 then @mem[@mem[address] + @base] = value
+        end
+      end
+
+      def run(input)
+        loop do
+          mode, opcode = @mem[@pc].divmod(100)
+          m = mode.digits
+          a = read(@pc + 1, m[0])
+          b = read(@pc + 2, m[1])
+
+          case opcode
+          when 1
+            write(@pc + 3, m[2], a + b)
+            @pc += 4
+          when 2
+            write(@pc + 3, m[2], a * b)
+            @pc += 4
+          when 3
+            write(@pc + 1, m[0], input.shift)
+            @pc += 2
+          when 4
+            @pc += 2
+            return a if a > 255
+          when 5
+            a != 0 ? @pc = b : @pc += 3
+          when 6
+            a == 0 ? @pc = b : @pc += 3
+          when 7
+            write(@pc + 3, m[2], a < b ? 1 : 0)
+            @pc += 4
+          when 8
+            write(@pc + 3, m[2], a == b ? 1 : 0)
+            @pc += 4
+          when 9
+            @base += a
+            @pc += 2
+          when 99
+            return
+          else
+            throw "Unknown opcode: #{opcode}"
+          end
+        end
+      end
+
+    end
+
+    # ..............
+    # ..@...........
+    # ###ABCD#######
+
+    # !A || (!C && D)
+    walk = <<~SCRIPT
+    NOT C J
+    AND D J
+    NOT A T
+    OR T J
+    WALK
+    SCRIPT
+
+    p IntCode.new(PROGRAM).run(walk.bytes << 10)
+
+    # ..............
+    # ..@...........
+    # ###ABCDEFGHIJ.
+
+    # D && !(A && B && (C OR !H))
+    run = <<~SCRIPT
+    NOT H J
+    OR C J
+    AND A J
+    AND B J
+    NOT J J
+    AND D J
+    RUN
+    SCRIPT
+
+    p IntCode.new(PROGRAM).run(run.bytes << 10)

data/data/solutions/github/ZogStriP/2019/22_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/22_2.yml

@@ -0,0 +1,76 @@
+---
+- :name: 22_slam_shuffle.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    SHUFFLES = DATA.read.split("\n")
+
+    p = 2019
+    n = 10007
+
+    SHUFFLES.each { |s|
+      case s
+      when /deal with increment (\d+)/
+        p = ( p * $1.to_i) % n
+      when /cut (-?\d+)/
+        p = ( p - $1.to_i) % n
+      when /deal into new stack/
+        p = (-p - 1) % n
+      end
+    }
+
+    p p
+
+    # part 2 is totally stolen from https://www.reddit.com/r/adventofcode/comments/ee0rqi/2019_day_22_solutions/
+
+    p = 2020
+    n = 119315717514047
+    r = 101741582076661
+
+    # f(x) = ax + b
+    # g(x) = cx + d
+
+    # g(f(x))
+    #   = c(f(x)) + d
+    #   = c(ax + b) + d
+    #   = cax + cb + d
+
+    a = 1
+    b = 0
+
+    SHUFFLES.each { |s|
+      case s
+      when /deal with increment (\d+)/
+        c = $1.to_i
+        d = 0
+      when /cut (-?\d+)/
+        c = 1
+        d = -$1.to_i
+      when /deal into new stack/
+        c = -1
+        d = -1
+      end
+      a = (c * a) % n
+      b = (c * b + d) % n
+    }
+
+    # instead of doing
+
+    # c, d = a, b
+    # a, b = 1, 0
+    #
+    # r.times {
+    #   a = (c * a) % n
+    #   b = (c * b + d) % n
+    # }
+
+    # we compute
+
+    # a = (a ** r) % n
+    # b = ... + a ** 2 * b + a * b + b = b * (a ** (r - 1) + a ** (r) + ... + a + 1) = b * (a ** r - 1) / (a - 1)
+
+    inv = -> (a, b) { a.pow(b - 2, b) }
+
+    aa = a.pow(r, n)
+    bb = (b * (aa - 1) * inv[a - 1, n]) % n
+
+    p ((p - bb) * inv[aa, n]) % n

data/data/solutions/github/ZogStriP/2019/23_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/23_2.yml

@@ -0,0 +1,100 @@
+---
+- :name: 23_category_six.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    PROGRAM = DATA.read.split(?,).map(&:to_i).freeze
+
+    class IntCode
+
+      def initialize(mem, input)
+        @pc = 0
+        @base = 0
+        @input = input
+        @mem = mem.map.with_index { |m, i| [i, m] }.to_h
+        @mem.default = 0
+      end
+
+      def read(address, mode)
+        case mode.to_i
+        when 0 then @mem[@mem[address]]
+        when 1 then @mem[address]
+        when 2 then @mem[@mem[address] + @base]
+        end
+      end
+
+      def write(address, mode, value)
+        case mode.to_i
+        when 0 then @mem[@mem[address]] = value
+        when 2 then @mem[@mem[address] + @base] = value
+        end
+      end
+
+      def run(input = [])
+        @input.concat(input) if input.size > 0
+
+        loop do
+          mode, opcode = @mem[@pc].divmod(100)
+          m = mode.digits
+          a = read(@pc + 1, m[0])
+          b = read(@pc + 2, m[1])
+
+          case opcode
+          when 1
+            write(@pc + 3, m[2], a + b)
+            @pc += 4
+          when 2
+            write(@pc + 3, m[2], a * b)
+            @pc += 4
+          when 3
+            return if @input.size == 0
+            write(@pc + 1, m[0], @input.shift)
+            @pc += 2
+          when 4
+            @pc += 2
+            return a
+          when 5
+            a != 0 ? @pc = b : @pc += 3
+          when 6
+            a == 0 ? @pc = b : @pc += 3
+          when 7
+            write(@pc + 3, m[2], a < b ? 1 : 0)
+            @pc += 4
+          when 8
+            write(@pc + 3, m[2], a == b ? 1 : 0)
+            @pc += 4
+          when 9
+            @base += a
+            @pc += 2
+          when 99
+            return
+          else
+            throw "Unknown opcode: #{opcode}"
+          end
+        end
+      end
+
+    end
+
+    NICS = 50.times.map { |i| IntCode.new(PROGRAM, [i]) }
+    queues = Hash.new { |h, k| h[k] = [] }
+
+    first = last = nil
+
+    loop {
+      states = NICS.map.with_index { |nic, i|
+        x, y = queues[i].shift, queues[i].shift
+        next :idle unless a = nic.run(x.nil? ? [-1] : [x, y])
+        queues[a] << nic.run << nic.run
+        :running
+      }
+
+      if states.count(:idle) == 50
+        break if queues[255].size == 0
+        first ||= queues[255][1]
+        queues[0] = queues[255].last(2)
+        queues[255].clear
+        last = queues[0][1]
+      end
+    }
+
+    p first, last

data/data/solutions/github/ZogStriP/2019/24_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/ZogStriP/2019/24_2.yml

@@ -0,0 +1,75 @@
+---
+- :name: 24_planet_of_discord.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    input = DATA.read.delete("\n").freeze
+    grid = input.tr(".#", "01").reverse.to_i(2)
+    seen = {}
+
+    until seen[grid]
+      seen[grid] = true
+      g = 0
+
+      25.times { |i|
+        c = 0
+        c += (grid >> (i - 5)) & 1 if i >= 5
+        c += (grid >> (i + 5)) & 1 if i < 20
+        c += (grid >> (i - 1)) & 1 if i % 5 != 0
+        c += (grid >> (i + 1)) & 1 if i % 5 != 4
+        g |= 1 << i if c == 1 || (c == 2 && ((grid >> i) & 1) == 0)
+      }
+
+      grid = g
+    end
+
+    p grid
+
+    NEIGHBORS = [
+      [[7, -1], [1, 0], [5, 0], [11, -1]],
+      [[7, -1], [2, 0], [6, 0], [0, 0]],
+      [[7, -1], [3, 0], [7, 0], [1, 0]],
+      [[7, -1], [4, 0], [8, 0], [2, 0]],
+      [[7, -1], [13, -1], [9, 0], [3, 0]],
+      [[0, 0], [6, 0], [10, 0], [11, -1]],
+      [[1, 0], [7, 0], [11, 0], [5, 0]],
+      [[2, 0], [8, 0], [0, 1], [1, 1], [2, 1], [3, 1], [4, 1], [6, 0]],
+      [[3, 0], [9, 0], [13, 0], [7, 0]],
+      [[4, 0], [13, -1], [14, 0], [8, 0]],
+      [[5, 0], [11, 0], [15, 0], [11, -1]],
+      [[6, 0], [0, 1], [5, 1], [10, 1], [15, 1], [20, 1], [16, 0], [10, 0]],
+      [], # center
+      [[8, 0], [14, 0], [18, 0], [4, 1], [9, 1], [14, 1], [19, 1], [24, 1]],
+      [[9, 0], [13, -1], [19, 0], [13, 0]],
+      [[10, 0], [16, 0], [20, 0], [11, -1]],
+      [[11, 0], [17, 0], [21, 0], [15, 0]],
+      [[20, 1], [21, 1], [22, 1], [23, 1], [24, 1], [18, 0], [22, 0], [16, 0]],
+      [[13, 0], [19, 0], [23, 0], [17, 0]],
+      [[14, 0], [13, -1], [24, 0], [18, 0]],
+      [[15, 0], [21, 0], [17, -1], [11, -1]],
+      [[16, 0], [22, 0], [17, -1], [20, 0]],
+      [[17, 0], [23, 0], [17, -1], [21, 0]],
+      [[18, 0], [24, 0], [17, -1], [22, 0]],
+      [[19, 0], [13, -1], [17, -1], [23, 0]],
+    ]
+
+    def evolve(grids)
+      g = Hash.new { |h, k| h[k] = ?. * 25 }
+
+      min, max = grids.keys.minmax
+
+      Range.new(min - 1, max + 1).each { |k|
+        25.times { |i|
+          c = NEIGHBORS[i].count { |n, l| grids[k + l][n] == ?# }
+          g[k][i] = ?# if c == 1 || (c == 2 && grids[k][i] == ?.)
+        }
+      }
+
+      g
+    end
+
+    grids = Hash.new { |h, k| h[k] = ?. * 25 }
+    grids[0] = input
+
+    200.times { grids = evolve(grids) }
+
+    p grids.values.sum { |g| g.count(?#) }