advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,45 @@
+---
+- :name: 20_a_regular_map.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    DIRECTIONS = {
+      "N" => [ 0, -1],
+      "S" => [ 0,  1],
+      "E" => [ 1,  0],
+      "W" => [-1,  0],
+    }
+
+    map = Hash.new { |h, k| h[k] = [] }
+    stack = []
+    position = [0, 0]
+    instructions = DATA.read.chomp.chars
+
+    while i = instructions.shift
+      if d = DIRECTIONS[i]
+        n = [position[0] + d[0], position[1] +  d[1]]
+        map[n] << position
+        map[position] << n
+        position = n
+      elsif i == "("
+        stack << position
+      elsif i == ")"
+        stack.pop
+      elsif i == "|"
+        position = stack[-1]
+      end
+    end
+
+    start = [0, 0]
+    queue = [start]
+    distances = { start => 0 }
+
+    while c = queue.shift
+      map[c].each { |n|
+        next if distances[n]
+        distances[n] = distances[c] + 1
+        queue << n
+      }
+    end
+
+    p distances.values.max
+    p distances.values.count { |d| d >= 1000 }

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

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

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

@@ -0,0 +1,25 @@
+---
+- :name: 21_chronal_conversion.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    require "set"
+
+    seen = Set.new
+
+    def f(a)
+      a |= 0x10000
+      b = 14906355
+      while a > 0
+        b = (((b + (a & 0xFF)) & 0xFFFFFF) * 65899) & 0xFFFFFF
+        a >>= 8
+      end
+      b
+    end
+
+    p n = f(0)
+
+    p loop {
+      nn = f(n)
+      break n unless seen.add?(nn)
+      n = nn
+    }

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

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

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

@@ -0,0 +1,85 @@
+---
+- :name: 22_mode_maze.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    require "algorithms"
+
+    DEPTH  = 11394
+    MOUTH  = [0, 0]
+    TARGET = [7, 701]
+
+    @level  = Hash.new { |h, k| h[k] = [] }
+    @index  = Hash.new { |h, k| h[k] = [] }
+    @region = Hash.new { |h, k| h[k] = [] }
+
+    def level(x, y)
+      @level[x][y] ||= (index(x, y) + DEPTH) % 20183
+    end
+
+    def index(x, y)
+      @index[x][y] ||= begin
+        if (x == 0 && y == 0) || (x == TARGET[0] && y == TARGET[1])
+          0
+        elsif x == 0
+          y * 48271
+        elsif y == 0
+          x * 16807
+        else
+          level(x - 1, y) * level(x, y - 1)
+        end
+      end
+    end
+
+    def region(x, y)
+      @region[x][y] ||= level(x, y) % 3
+    end
+
+    p (0..TARGET[1]).sum { |y| (0..TARGET[0]).sum { |x| region(x, y) } }
+
+    NEITHER = 0
+    TORCH = 1
+    CLIMBING_GEAR = 2
+
+    adjacents = -> ((x, y), t) {
+      adj = []
+      adj << [[x - 1, y], t, 1] if x > 0 && t != region(x - 1, y)
+      adj << [[x, y - 1], t, 1] if y > 0 && t != region(x, y - 1)
+      adj << [[x + 1, y], t, 1] if t != region(x + 1, y)
+      adj << [[x, y + 1], t, 1] if t != region(x, y + 1)
+      adj << [[x, y], 3 - region(x, y) - t, 7]
+      adj
+    }
+
+    heuristic = -> ((x, y), t) {
+      (x - TARGET[0]).abs + (y - TARGET[1]).abs + (t == TORCH ? 0 : 7)
+    }
+
+    start  = [MOUTH, TORCH]
+    target = [TARGET, TORCH]
+
+    f = Hash.new(1.0 / 0)
+    g = Hash.new(1.0 / 0)
+
+    f[start] = heuristic[*start]
+    g[start] = 0
+
+    open = Containers::PriorityQueue.new { |a, b| a < b }
+    open.push(start, f[start])
+
+    closed = {}
+
+    while c = open.pop
+      break if c == target
+      closed[c] = true
+
+      adjacents[*c].each { |adj, t, cost|
+        n = [adj, t]
+        next if closed[n]
+        next if (gg = g[c] + cost) >= g[n]
+        g[n] = gg
+        f[n] = gg + heuristic[adj, t]
+        open.push(n, f[n])
+      }
+    end
+
+    p g[target]

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

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

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

@@ -0,0 +1,39 @@
+---
+- :name: 23_experimental_emergency_teleportation.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    require "algorithms"
+
+    nanobots = DATA.each_line.map { |line| line.scan(/-?\d+/).map(&:to_i) }
+
+    def in_range?(a, b)
+      3.times.sum { |i| (a[i] - b[i]).abs } <= a[3]
+    end
+
+    strongest = nanobots.max_by { |n| n[3] }
+
+    p nanobots.count { |n| in_range?(strongest, n) }
+
+    q = Containers::PriorityQueue.new { |a, b| (a <=> b) == -1 }
+
+    nanobots.each { |x, y, z, r|
+      dist  = x.abs + y.abs + z.abs
+      start = [0, dist - r].max
+      _end  = dist + r + 1
+      q.push([start,  1], start)
+      q.push([_end, -1], _end)
+    }
+
+    max   = 0
+    count = 0
+    dist  = 0
+
+    while c = q.pop
+      count += c[1]
+      if count > max
+        max  = count
+        dist = c[0]
+      end
+    end
+
+    p dist

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

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

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

@@ -0,0 +1,83 @@
+---
+- :name: 24_immune_system_simulator_20xx.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    Group = Struct.new(:immune, :units, :hp, :damage, :attack_type, :initiative, :target, :targeted, :weak_to, :immune_to) do
+      def effective_power
+        damage * units
+      end
+
+      def damage_taken(group)
+        if immune_to&.include?(group.attack_type)
+          0
+        elsif weak_to&.include?(group.attack_type)
+          group.effective_power * 2
+        else
+          group.effective_power
+        end
+      end
+
+      def defeated?
+        units <= 0
+      end
+    end
+
+    immune = true
+    base_groups = []
+
+    DATA.each_line { |line|
+      if line["Infection"]
+        immune = false
+      elsif line[/\d+/]
+        units, hp, misc, damage, attack_type, initiative = line.scan(/(\d+) units each with (\d+) hit points (.*)with an attack that does (\d+) (\w+) damage at initiative (\d+)/)[0]
+
+        group = Group.new(immune, units.to_i, hp.to_i, damage.to_i, attack_type, initiative.to_i)
+
+        if misc.size > 0
+          misc = misc[1..-3].split("; ")
+          if w = misc.find { |m| m["weak to "] }
+            group.weak_to = w["weak to ".size..-1].split(", ")
+          end
+          if i = misc.find { |m| m["immune to "] }
+            group.immune_to = i["immune to ".size..-1].split(", ")
+          end
+        end
+
+        base_groups << group
+      end
+    }
+
+    0.step { |boost|
+      groups = base_groups.map(&:dup)
+      groups.select(&:immune).each { |g| g.damage += boost }
+
+      while groups.map(&:immune).uniq.size > 1
+        groups.reject!(&:defeated?)
+        groups.each { |g| g.target = g.targeted = nil }
+
+        total_units_lost = 0
+
+        # target selection
+        groups.sort_by { |g| [-g.effective_power, -g.initiative] }.each { |group|
+          target = groups.select { |g| g.immune != group.immune && !g.targeted && g.damage_taken(group) > 0 }
+                         .max_by { |g| [g.damage_taken(group), g.effective_power, g.initiative] }
+          if target
+            group.target = target
+            target.targeted = true
+          end
+        }
+
+        # attacking
+        groups.sort_by { |g| -g.initiative }.each { |group|
+          next if group.defeated? || !group.target
+          units_lost = group.target.damage_taken(group) / group.target.hp
+          total_units_lost += units_lost
+          group.target.units -= units_lost
+        }
+
+        break if groups.count(&:defeated?) == 0 && total_units_lost == 0
+      end
+
+      p groups.sum(&:units) if boost == 0
+      break p groups.sum(&:units) if groups.all?(&:immune)
+    }

data/data/solutions/github/ZogStriP/2018/25_1.yml

@@ -0,0 +1,41 @@
+---
+- :name: 25_four-dimensional_adventure.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2018
+  :solution: |-
+    # https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+    class DisjointSet
+      def initialize(values)
+        @parent = values.zip(values).to_h
+        @rank = values.map { |v| [v, 0] }.to_h
+      end
+
+      def find(x)
+        x, @parent[x] = @parent[x], @parent[@parent[x]] while @parent[x] != x
+        x
+      end
+
+      def union(x, y)
+        x_root = find(x)
+        y_root = find(y)
+
+        return if x_root == y_root
+
+        x_root, y_root = y_root, x_root if @rank[x_root] < @rank[y_root]
+        @parent[y_root] = x_root
+        @rank[x_root] += 1 if @rank[x_root] == @rank[y_root]
+      end
+
+      def size
+        @parent.keys.count { |k| find(k) == k }
+      end
+    end
+
+    points = DATA.each_line.map { |l| l.split(",").map(&:to_i) }
+
+    ds = DisjointSet.new(points)
+
+    points.combination(2).each { |a, b|
+      ds.union(a, b) if a.zip(b).sum { |x, y| (x - y).abs } <= 3
+    }
+
+    p ds.size

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

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

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

@@ -0,0 +1,8 @@
+---
+- :name: 01_the_tyranny_of_the_rocket_equation.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    input = DATA.read.each_line.map(&:to_i)
+
+    p input.sum { |m| m / 3 - 2 }
+    p input.sum { |m| Enumerator.new { |e| e << m while (m = m / 3 - 2) > 0 }.sum }

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

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

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

@@ -0,0 +1,34 @@
+---
+- :name: 02_1202_program_alarm.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    program = DATA.read.split(",").map(&:to_i)
+
+    def int_code(program, noun, verb)
+      program[1] = noun
+      program[2] = verb
+
+      pc = 0
+
+      loop do
+        case program[pc]
+        when 1
+          program[program[pc + 3]] = program[program[pc + 1]] + program[program[pc + 2]]
+        when 2
+          program[program[pc + 3]] = program[program[pc + 1]] * program[program[pc + 2]]
+        when 99
+          break
+        end
+        pc += 4
+      end
+
+      program[0]
+    end
+
+    p int_code(program.dup, 12, 1)
+
+    99.times { |noun|
+      99.times { |verb|
+        puts 100 * noun + verb if int_code(program.dup, noun, verb) == 19690720
+      }
+    }

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

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

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

@@ -0,0 +1,28 @@
+---
+- :name: 03_crossed_wires.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    require "set"
+
+    wires = [{}, {}]
+
+    DATA.read.each_line.with_index { |line, index|
+      s, x, y = 0, 0, 0
+      line.scan(/(.)(\d+)/).each { |d, t|
+        t.to_i.times {
+          case d
+          when "R" then x += 1
+          when "L" then x -= 1
+          when "U" then y += 1
+          when "D" then y -= 1
+          end
+          s += 1
+          wires[index][[x, y]] ||= s
+        }
+      }
+    }
+
+    intersections = wires[0].keys.to_set & wires[1].keys.to_set
+
+    p intersections.map { |(x, y)| x.abs + y.abs }.min
+    p intersections.map { |p| wires.sum { |s| s[p] }}.min

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

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

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

@@ -0,0 +1,11 @@
+---
+- :name: 04_secure_container.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    passwords = (153517..630395)
+      .map(&:digits)
+      .select { |d| d.each_cons(2).all? { |a, b| a >= b } }
+      .map { |d| d.group_by(&:itself).values.map(&:size) }
+
+    p passwords.count { |p| p.any? { |s| s >= 2 } }
+    p passwords.count { |p| p.include?(2) }

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

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

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

@@ -0,0 +1,53 @@
+---
+- :name: 05_sunny_with_a_chance_of_asteroids.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    @mem = DATA.read.split(",").map(&:to_i)
+
+    def read(address, mode)
+      mode == 1 ? @mem[address] : @mem[@mem[address]]
+    end
+
+    def write(address, value)
+      @mem[@mem[address]] = value
+    end
+
+    def int_code
+      pc = 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, a + b)
+          pc += 4
+        when 2
+          write(pc + 3, a * b)
+          pc += 4
+        when 3
+          write(pc + 1, gets.to_i)
+          pc += 2
+        when 4
+          puts a
+          pc += 2
+        when 5
+          a != 0 ? pc = b : pc += 3
+        when 6
+          a == 0 ? pc = b : pc += 3
+        when 7
+          write(pc + 3, a < b ? 1 : 0)
+          pc += 4
+        when 8
+          write(pc + 3, a == b ? 1 : 0)
+          pc += 4
+        when 99
+          break
+        end
+      end
+    end
+
+    int_code

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

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

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

@@ -0,0 +1,37 @@
+---
+- :name: 06_universal_orbit_map.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    o = Hash.new { |h, k| h[k] = [] }
+    t = Hash.new { |h, k| h[k] = [] }
+
+    DATA.read.split("\n").each { |l|
+      a, b = l.split(")")
+      o[a] << b
+      t[a] << b; t[b] << a
+    }
+
+    d = { "COM" => 0 }
+    q = ["COM"]
+
+    while c = q.pop
+      o[c]&.each { |n|
+        q << n
+        d[n] = d[c] + 1
+      }
+    end
+
+    p d.values.sum
+
+    d = { "YOU" => 0 }
+    q = ["YOU"]
+
+    while c = q.pop
+      t[c]&.each { |n|
+        next if d[n]
+        q << n
+        d[n] = d[c] + 1
+      }
+    end
+
+    p d["SAN"] - 2

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

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

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

@@ -0,0 +1,77 @@
+---
+- :name: 07_amplification_circuit.rb
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    program = DATA.read.split(",").map(&:to_i)
+
+    class IntCode
+
+      def initialize(mem, input: [])
+        @pc = 0
+        @mem = mem.dup
+        @input = input
+      end
+
+      def read(address, mode)
+        mode == 1 ? @mem[address] : @mem[@mem[address]]
+      end
+
+      def write(address, value)
+        @mem[@mem[address]] = value
+      end
+
+      def run(input = nil)
+        @input.push(input) if input
+
+        loop do
+          mode, opcode = @mem[@pc].divmod(100)
+          m = mode.digits
+          a = read(@pc + 1, m[0]) rescue nil
+          b = read(@pc + 2, m[1]) rescue nil
+
+          case opcode
+          when 1
+            write(@pc + 3, a + b)
+            @pc += 4
+          when 2
+            write(@pc + 3, a * b)
+            @pc += 4
+          when 3
+            write(@pc + 1, @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, a < b ? 1 : 0)
+            @pc += 4
+          when 8
+            write(@pc + 3, a == b ? 1 : 0)
+            @pc += 4
+          when 99
+            return
+          end
+        end
+      end
+
+    end
+
+    p [*0..4].permutation.map { |settings|
+      settings.reduce(0) { |signal, setting|
+        IntCode.new(program, input: [setting]).run(signal)
+      }
+    }.max
+
+    p [*5..9].permutation.map { |settings|
+      vms = settings.map { |s| IntCode.new(program, input: [s]) }
+      signal = 0
+      while signal
+        result = signal
+        vms.each { |vm| signal = vm.run(signal) }
+      end
+      result
+    }.max

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

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

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

@@ -0,0 +1,13 @@
+---
+- :name: '08_space_image_format.rb'
+  :url: https://github.com/ZogStriP/adventofcode-old/blob/master/2019
+  :solution: |-
+    layers = DATA.read.strip.chars.each_slice(25 * 6).to_a
+
+    layer = layers.min_by { |l| l.count(?0) }
+    p layer.count(?1) * layer.count(?2)
+
+    layers
+      .transpose
+      .map { |l| l.find { |p| p != ?2 } }
+      .each_slice(25) { |r| puts r.join.tr("01", " █") }

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

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