advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2018/01_2.yml

@@ -0,0 +1,15 @@
+---
+- :name: 1b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    require 'set'
+
+    frequency = 0
+    history = Set.new
+
+    p File.readlines("1.txt", chomp: true).map(&:to_i).cycle.find { |df|
+      frequency += df
+      unless history.add?(frequency)
+        break frequency
+      end
+    }

data/data/solutions/github/eregon/2018/02_1.yml

@@ -0,0 +1,16 @@
+---
+- :name: 2a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    counts = { 2=> 0, 3 => 0 }
+    File.foreach("2.txt", chomp: true) { |line|
+      twice = thrice = false
+      line.chars.uniq.each { |c|
+        twice ||= line.count(c) == 2
+        thrice ||= line.count(c) == 3
+      }
+      counts[2] += 1 if twice
+      counts[3] += 1 if thrice
+    }
+
+    p counts[2] * counts[3]

data/data/solutions/github/eregon/2018/02_2.yml

@@ -0,0 +1,11 @@
+---
+- :name: 2b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    boxes = File.readlines("2.txt", chomp: true)
+
+    puts boxes.product(boxes).each { |box1, box2|
+      if box1.chars.zip(box2.chars).count { |c1,c2| c1 != c2 } == 1
+        break box1.chars.zip(box2.chars).select { |c1,c2| c1 == c2 }.map(&:first).join
+      end
+    }

data/data/solutions/github/eregon/2018/03_1.yml

@@ -0,0 +1,19 @@
+---
+- :name: 3a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    claims = File.readlines("3.txt", chomp: true).map { |s|
+      id, x, y, dx, dy = s.split(/\D+/).reject(&:empty?).map(&:to_i)
+      [x...x+dx, y...y+dy]
+    }
+
+    fabric = Hash.new { |h,k| h[k] = Hash.new(0) }
+    claims.each { |xx,yy|
+      yy.each { |y|
+        xx.each { |x|
+          fabric[y][x] += 1
+        }
+      }
+    }
+
+    p fabric.values.sum { |row| row.values.count { |v| v >= 2 } }

data/data/solutions/github/eregon/2018/03_2.yml

@@ -0,0 +1,26 @@
+---
+- :name: 3b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    claims = File.readlines("3.txt", chomp: true).map { |s|
+      id, x, y, dx, dy = s.split(/\D+/).reject(&:empty?).map(&:to_i)
+      [id, x...x+dx, y...y+dy]
+    }
+
+    fabric = Hash.new { |h,k| h[k] = Hash.new(0) }
+
+    claims.each { |id,xx,yy|
+      yy.each { |y|
+        xx.each { |x|
+          fabric[y][x] += 1
+        }
+      }
+    }
+
+    p claims.find { |id,xx,yy|
+      yy.all? { |y|
+        xx.all? { |x|
+          fabric[y][x] == 1
+        }
+      }
+    }[0]

data/data/solutions/github/eregon/2018/04_1.yml

@@ -0,0 +1,46 @@
+---
+- :name: 4a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    require 'time'
+
+    data = File.readlines("4.txt", chomp: true).map { |line|
+      /^\[(?<time>.+)\] (?<action>.+)$/ =~ line
+      time = Time.parse(time)
+      date = time.to_date
+      date = date.next_day if time.hour >= 12
+      [date, time, action]
+    }.group_by { |date,| date }.values.map { |events|
+      events.sort_by { |date, time,|
+        time
+      }.map { |date, time, action|
+        [time, action]
+      }
+    }.map { |events|
+      (t0, start), *events = events
+      /Guard #(\d+) begins shift/ =~ start or raise
+      guard = $1.to_i
+      naps = events.each_slice(2).map { |(t1, asleep), (t2, wake)|
+        raise unless asleep.include? "falls asleep"
+        raise unless wake.include? "wakes up"
+        (t1.min...t2.min)
+      }
+      [guard, naps]
+    }.group_by { |guard,| guard }.transform_values { |naps|
+      naps.map(&:last)
+    }
+
+    most_asleep = data.transform_values { |nights|
+      nights.sum { |night| night.sum { |nap| nap.end - nap.begin } }
+    }.max_by { |guard, sleep_time| sleep_time }.first
+
+    asleep = Hash.new(0)
+    data[most_asleep].each { |night|
+      night.each { |nap|
+        nap.each { |min|
+          asleep[min] += 1
+        }
+      }
+    }
+
+    p most_asleep * asleep.max_by(&:last).first

data/data/solutions/github/eregon/2018/04_2.yml

@@ -0,0 +1,54 @@
+---
+- :name: 4b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    require 'time'
+
+    data = File.readlines("4.txt", chomp: true).map { |line|
+      /^\[(?<time>.+)\] (?<action>.+)$/ =~ line
+      time = Time.parse(time)
+      date = time.to_date
+      date = date.next_day if time.hour >= 12
+      [date, time, action]
+    }.group_by { |date,| date }.values.map { |events|
+      events.sort_by { |date, time,|
+        time
+      }.map { |date, time, action|
+        [time, action]
+      }
+    }.map { |events|
+      (t0, start), *events = events
+      /Guard #(\d+) begins shift/ =~ start or raise
+      guard = $1.to_i
+      naps = events.each_slice(2).map { |(t1, asleep), (t2, wake)|
+        raise unless asleep.include? "falls asleep"
+        raise unless wake.include? "wakes up"
+        (t1.min...t2.min)
+      }
+      [guard, naps]
+    }.group_by { |guard,| guard }.transform_values { |naps|
+      naps.map(&:last)
+    }
+
+    most_asleep = data.transform_values { |nights|
+      nights.sum { |night| night.sum { |nap| nap.end - nap.begin } }
+    }.max_by { |guard, sleep_time| sleep_time }.first
+
+    def sleep_frequency(nights)
+      asleep = Hash.new(0)
+      nights.each { |night|
+        night.each { |nap|
+          nap.each { |min|
+            asleep[min] += 1
+          }
+        }
+      }
+      asleep
+    end
+
+    p most_asleep * sleep_frequency(data[most_asleep]).max_by(&:last).first
+
+    guard, (min, count) = data.transform_values { |nights|
+      sleep_frequency(nights).max_by(&:last)
+    }.max_by { |guard, most_freq_min| most_freq_min&.last || 0 }
+    p guard * min

data/data/solutions/github/eregon/2018/05_1.yml

@@ -0,0 +1,16 @@
+---
+- :name: 5a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    polymer = File.read("5.txt").chomp.chars
+
+    def react?(a, b)
+      a.downcase == b.downcase && a != b
+    end
+
+    while i = polymer.each_cons(2).find_index { |a,b| react?(a,b) }
+      polymer = polymer[0...i] + polymer[i+2..-1]
+      # polymer[i..i+1] = []
+    end
+
+    p polymer.size

data/data/solutions/github/eregon/2018/05_2.yml

@@ -0,0 +1,70 @@
+---
+- :name: 5_linked_list.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    polymer = File.read("5.txt").chomp.chars.freeze
+
+    def react?(a, b)
+      a.downcase == b.downcase && a != b
+    end
+
+    Node = Struct.new(:value, :prev, :next) do
+      def each
+        node = self
+        while node
+          yield node
+          node = node.next
+        end
+      end
+    end
+
+    def react(polymer)
+      polymer = polymer.map { |char| Node.new(char) }
+      polymer.each_cons(2) { |a,b| (b.prev = a).next = b }
+      cur = polymer.first
+
+      while cur and collapse = cur.find { |node| node.next && react?(node.value, node.next.value) }
+        before, after = collapse.prev, collapse.next.next
+        after&.prev = before
+        before&.next = after
+        cur = before || after
+      end
+      return 0 unless cur
+
+      first = cur
+      first = first.prev while first.prev
+      first.count
+    end
+
+    p react(polymer)
+
+    p polymer.map(&:downcase).uniq.sort.map { |type|
+      without = polymer.dup
+      without.delete(type)
+      without.delete(type.upcase)
+      react(without)
+    }.min
+- :name: 5b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    polymer = File.read("5.txt").chomp.chars.freeze
+
+    def react?(a, b)
+      a.downcase == b.downcase && a != b
+    end
+
+    def react(polymer)
+      cur = 0
+      while i = (cur...polymer.size-1).find { |i| react?(polymer[i], polymer[i+1]) }
+        polymer = polymer[0...i] + polymer[i+2..-1]
+        cur = (i-1).clamp(0, polymer.size-1)
+      end
+      polymer
+    end
+
+    p polymer.map(&:downcase).uniq.sort.map { |type|
+      without = polymer.dup
+      without.delete(type)
+      without.delete(type.upcase)
+      react(without).size
+    }.min

data/data/solutions/github/eregon/2018/06_1.yml

@@ -0,0 +1,52 @@
+---
+- :name: 6a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    COORDS = File.readlines("6.txt", chomp: true).map { |line|
+      x, y = line.split(", ").map { |n| Integer(n) }
+      x + y.i
+    }.freeze
+
+    raise unless COORDS.uniq == COORDS
+
+    def distance(a, b)
+      (a.real - b.real).abs + (a.imag - b.imag).abs
+    end
+
+    def compute_areas(range_x, range_y)
+      areas = Hash.new(0)
+      board = range_y.map { |y|
+        range_x.map { |x|
+          at = x + y.i
+          a, b = COORDS.min_by(2) { |coord|
+            distance(coord, at)
+          }
+          if distance(a, at) != distance(b, at)
+            areas[a] += 1
+
+            idx = COORDS.index(a)
+            ch = if idx < 26
+              ("a".ord + idx).chr
+            else
+              ("A".ord + (idx-26)).chr
+            end
+            a == at ? ch.swapcase : ch
+          else
+            "."
+          end
+        }
+      }
+
+      puts board.map(&:join)
+      areas
+    end
+
+    min_x, max_x = COORDS.map(&:real).minmax
+    min_y, max_y = COORDS.map(&:imag).minmax
+
+    areas1 = compute_areas(min_x..max_x, min_y..max_y)
+    areas2 = compute_areas(min_x-1..max_x+1, min_y-1..max_y+1)
+
+    p COORDS.select { |coord| areas1[coord] == areas2[coord] }.map { |coord|
+      areas1[coord]
+    }.max

data/data/solutions/github/eregon/2018/06_2.yml

@@ -0,0 +1,26 @@
+---
+- :name: 6b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    COORDS = File.readlines("6.txt", chomp: true).map { |line|
+      x, y = line.split(", ").map { |n| Integer(n) }
+      x + y.i
+    }.freeze
+
+    def distance(a, b)
+      (a.real - b.real).abs + (a.imag - b.imag).abs
+    end
+
+    def compute_area(range_x, range_y)
+      range_y.sum { |y|
+        range_x.count { |x|
+          at = x + y.i
+          COORDS.sum { |coord| distance(coord, at) } < 10_000
+        }
+      }
+    end
+
+    range_x = COORDS.map(&:real).minmax.reduce(&Range.method(:new))
+    range_y = COORDS.map(&:imag).minmax.reduce(&Range.method(:new))
+
+    p compute_area(range_x, range_y)

data/data/solutions/github/eregon/2018/07_1.yml

@@ -0,0 +1,26 @@
+---
+- :name: 7a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    require "set"
+
+    requirements = Hash.new { |h,k| h[k] = Set.new }
+    File.readlines("7.txt").map { |line|
+      line =~ /Step (.+) must be finished before step (.+) can begin./
+      requirements[$2] << $1
+    }
+
+    all_steps = requirements.map { |k,v| [k, v.to_a] }.flatten.uniq.sort
+
+    done = Set.new
+    remaining = all_steps.to_set
+
+    until remaining.empty?
+      step = remaining.find { |step|
+        requirements[step].subset?(done)
+      }
+      remaining.delete(step)
+      done << step
+    end
+
+    puts done.to_a.join

data/data/solutions/github/eregon/2018/07_2.yml

@@ -0,0 +1,48 @@
+---
+- :name: 7b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    require "set"
+
+    requirements = Hash.new { |h,k| h[k] = Set.new }
+    File.readlines("7.txt").map { |line|
+      line =~ /Step (.+) must be finished before step (.+) can begin./
+      requirements[$2] << $1
+    }
+
+    all_steps = requirements.map { |k,v| [k, v.to_a] }.flatten.uniq.sort
+
+    Worker = Struct.new(:task)
+    Task = Struct.new(:step, :end_time)
+
+    done = Set.new
+    remaining = all_steps.to_set
+    workers = Array.new(5) { Worker.new(nil) }
+    t = 0
+
+    loop do
+      workers.each { |worker|
+        if task = worker.task and task.end_time == t
+          done << task.step
+          worker.task = nil
+        end
+      }
+
+      break if done.size == all_steps.size
+
+      ready = remaining.select { |step|
+        requirements[step].subset?(done)
+      }
+
+      workers.each { |worker|
+        if !worker.task and step = ready.shift
+          duration = 60 + (step.ord - "A".ord + 1)
+          worker.task = Task.new(step, t + duration)
+          remaining.delete(step)
+        end
+      }
+
+      t += 1
+    end
+
+    p t

data/data/solutions/github/eregon/2018/08_1.yml

@@ -0,0 +1,12 @@
+---
+- :name: 8a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    data = File.read("8.txt").split.map(&:to_i)
+    start = sum = 0
+    walk = -> * {
+      children, metadata = data[start...(start += 2)]
+      children.times(&walk)
+      metadata.times { sum += data[start] and start += 1 }
+    }
+    p walk.call && sum

data/data/solutions/github/eregon/2018/08_2.yml

@@ -0,0 +1,28 @@
+---
+- :name: 8b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    data = File.read("8.txt").chomp.split.map { |e| Integer(e) }
+    walk = -> start do
+      children, metadata = data[start...(start += 2)]
+      children_values = children.times.map {
+        (start, _ = walk.call(start))[1]
+      }
+      value = metadata.times.sum {
+        v = data[start]
+        start += 1
+
+        if children > 0
+          if (1..children).include?(v)
+            children_values[v-1]
+          else
+            0
+          end
+        else
+          v
+        end
+      }
+      [start, value]
+    end
+
+    p walk.call(0)[1]

data/data/solutions/github/eregon/2018/09_1.yml

@@ -0,0 +1,63 @@
+---
+- :name: 9.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    Node = Struct.new(:value, :prev, :next) do
+      def each
+        node = self
+        begin
+          yield node
+          node = node.next
+        end until node.equal?(self)
+      end
+
+      def remove
+        prev.next, self.next.prev = self.next, prev
+      end
+
+      Struct.remove_method :to_a
+
+      def inspect
+        value.inspect
+      end
+    end
+
+    def max_score(players, marbles)
+      score = Array.new(players, 0)
+      player = 0
+      value = 0
+      gain = 0
+      initial = Node.new(value)
+      initial.next = initial.prev = initial
+
+      current = initial
+
+      marbles.times do
+        value += 1
+        player = (player + 1) % players
+
+        if value % 23 == 0
+          7.times { current = current.prev }
+          gain = value + current.value
+          score[player] += gain
+          current.remove
+          current = current.next
+        else
+          current = current.next
+          node = Node.new(value, current, current.next)
+          # Interestingly, this does not work:
+          # current.next, current.next.prev = node, node
+          # But this does:
+          current.next.prev, current.next = node, node
+          current = node
+        end
+      end
+
+      score.max
+    end
+
+    p max_score(9, 25)
+    p max_score(10, 1618)
+    p max_score(30, 5807)
+    p max_score(419, 71052)
+    p max_score(419, 7105200)

data/data/solutions/github/eregon/2018/09_2.yml

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

data/data/solutions/github/eregon/2018/10_1.yml

@@ -0,0 +1,63 @@
+---
+- :name: 10a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    MIN_X, MAX_X = -250, 749
+    MIN_Y, MAX_Y = -250, 349
+    RANGE_X = MIN_X..MAX_X
+    RANGE_Y = MIN_Y..MAX_Y
+
+    HEIGHT = MAX_Y - MIN_Y + 1
+    WIDTH = MAX_X - MIN_X + 1
+
+    Star = Struct.new(:position, :velocity) do
+      def advance!
+        self.position += self.velocity
+      end
+    end
+
+    def view(img)
+      unless @mplayer
+        @mplayer = IO.popen('mplayer -really-quiet -noframedrop - 2>/dev/null', 'wb')
+        @mplayer.puts("YUV4MPEG2 W#{WIDTH} H#{HEIGHT} F30:1 Ip A1:1")
+        @color_data = 127.chr * (WIDTH * HEIGHT / 2)
+      end
+      raise unless WIDTH == img[0].size and HEIGHT == img.size
+      @mplayer.write "FRAME\n"
+      img.each { |row|
+        @mplayer.write(row.pack('C*'))
+      }
+      @mplayer.write @color_data
+    end
+
+    stars = File.readlines("10.txt", chomp: true).map { |line|
+      x, y, vx, vy = line.scan(/-?\d+/).map(&:to_i)
+      Star.new(x + y.i, vx + vy.i)
+    }
+
+    def visualize(stars)
+      img = Array.new(HEIGHT) {
+        Array.new(WIDTH, 0)
+      }
+      stars.each { |star|
+        pos = star.position
+        if RANGE_X.include?(pos.real) and RANGE_Y.include?(pos.imag)
+          img[pos.imag-MIN_Y][pos.real-MIN_X] = 255
+        end
+      }
+
+      view(img)
+    end
+
+    visualize(stars)
+
+    20_000.times do |i|
+      p i
+      positions = stars.map(&:position)
+      if (positions.map(&:real).sum(&:abs) / positions.size.to_f) < 300
+        visualize(stars)
+        gets
+      end
+
+      stars.each(&:advance!)
+    end

data/data/solutions/github/eregon/2018/10_2.yml

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

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

@@ -0,0 +1,35 @@
+---
+- :name: 11a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    GRID_SERIAL_NUMBER = 9995
+
+    def power_level(x, y)
+      rack_id = x + 10
+      power = ((rack_id * y) + GRID_SERIAL_NUMBER) * rack_id
+      raise if power < 0
+      power = (power % 1000) / 100
+      power - 5
+    end
+
+    range = (1..300)
+    power = [0, *range].map { |y|
+      [0, *range].map { |x|
+        power_level(x, y)
+      }
+    }
+
+    best = nil
+    best_score = 0
+    range.each_cons(3) { |yy|
+      range.each_cons(3) { |xx|
+        score = yy.sum { |y| xx.sum { |x| power[y][x] } }
+        if score > best_score
+          best = [xx[0], yy[0]]
+          best_score = score
+        end
+      }
+    }
+
+    p best_score
+    puts best.join(',')