advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2018/06.yml

@@ -0,0 +1,220 @@
+---
+- :author: daybreaker
+  :url: https://www.reddit.com/r/adventofcode/comments/a3kr4r/2018_day_6_solutions/eb74i3j/
+  :body: |-
+    While we wait for the bug fix, here's my theoretically working part 1 and 2 in completely non-optimized horrible ruby
+
+    Part 1 basically loops through each point and stores the "ID" (array index position) of the closest Coordinate. If a coordinate already exists there (a shared coordinate) it nils it out basically (I planned to put an 'x', but it wound up being nil somehow. Code magic? ¯\_(ツ)\_/¯). Then you flatten a 2D array of IDs, count how many times they each show up, and delete any that have infinite bounds (same x coord as the left or right edge, or same y coord as the top or bottom edge).
+
+    Ignore the set of nil indexed (shared) coordinates, and the largest count with an index will be the answer. CoordList[index]
+
+    Part 2 does the same initial loop through every single possible x,y coord in our 2D space, and marks it off if the manhattan sum of every point is under 10000. Then you just count how many of those there are.
+
+    * * *
+
+    ```ruby
+    points = File.readlines('day6.txt').map { |line| line.strip.split(', ').map(&:to_i) }
+
+    x0 = 0
+    y0 = 0
+    xmax = points.collect { |x| x[0] }.max
+    ymax = points.collect { |x| x[1] }.max
+
+    def manhattan(pt1, pt2)
+      (pt1[0] - pt2[0]).abs + (pt1[1] - pt2[1]).abs
+    end
+
+    def find_closest(points, xxx, yyy)
+      closest_for_point = points.each_with_index
+                                .map { |point, index| [index, manhattan([xxx, yyy], point)] }
+                                .sort_by { |_xxxx, yyyy| yyyy }.first(2)
+      closest_for_point.first[1] == closest_for_point.last[1] ? false : closest_for_point.first
+    end
+
+    distances = []
+
+    (x0..xmax).each do |x|
+      (y0..ymax).each do |y|
+        distances[x] ||= []
+        closest = find_closest(points, x, y)
+        closest ? distances[x][y] = closest[0] : 'x'
+      end
+    end
+
+    def infinite?(distances, points, id, xmax, ymax)
+      return if id.nil?
+
+      x, y = points[id]
+      [distances[0][y], distances[x][0], distances[0][ymax], distances[xmax][0]].include?(id)
+    end
+
+    results = distances.clone.flatten
+                       .group_by(&:itself).transform_values(&:count)
+                       .delete_if { |id, _count| infinite?(distances, points, id, xmax, ymax) }
+
+    puts results.sort_by { |_x, y| y }.inspect # Take highest non-nil-index count
+
+    #-------PART 2--------
+
+    def sum_closest(points, xxx, yyy)
+      points.inject(0) { |sum, point| sum + manhattan(point, [xxx, yyy]) } < 10_000
+    end
+
+    answers = []
+
+    (x0..xmax).each do |x|
+      (y0..ymax).each do |y|
+        answers << [x, y] if sum_closest(points, x, y)
+      end
+    end
+
+    puts answers.count
+    ```
+  :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/a3kr4r/2018_day_6_solutions/eb765k8/
+  :body: |-
+    Ruby
+
+    ```ruby
+    p a=$<.map{|x|x.split(/\D+/).map{|x|x.to_i}}
+    h=Hash.new 0
+    u=[]
+    j=0
+    (0..ll=a.max_by{|x,y|x}.first).each{|b|
+    (0..lp=a.max_by{|x,y|y}.last).each{|c|
+    j+=1if a.sum{|x,y|(x-b).abs+(y-c).abs}<10000
+    next
+    e=d.min_by{|x,y|y}
+    (h[e[0]]+=1
+
+    u|=[e[0]] if b==0 || c==0 || c==lp || b==ll
+    #print (65+a.index(e[0])).chr
+    )if ddd=d.count{|x,y|y==e[1]}==1
+    #print ?. if !ddd
+    }
+    #print "\n"
+    }
+    p j
+    ```
+  :replies: []
+- :author: charismotron
+  :url: https://www.reddit.com/r/adventofcode/comments/a3kr4r/2018_day_6_solutions/eb74hkg/
+  :body: |-
+    _Ruby_
+
+    ```ruby
+    require 'set'
+
+    def manhattan(pt1, pt2)
+      (pt1[0] - pt2[0]).abs + (pt1[1] - pt2[1]).abs
+    end
+
+    def find_closest(points, x, y)
+      distances = []
+      points.each_with_index do |pt, idx|
+        distances << [manhattan([x, y], pt), idx]
+      end
+      distances.sort!
+
+      return -1 if distances[0][0] == distances[1][0] # same distance counts to no one
+      distances[0][1]
+    end
+
+    def largest_non_infinite_region(points)
+      max_x = points.max_by { |p| p[0] }
+      max_y = points.max_by { |p| p[1] }
+
+      grid = {}
+      pt_idx_counts = {}
+
+      (0..max_x[0]).each do |x|
+        (0..max_y[1]).each do |y|
+          pt_idx = find_closest(points, x, y)
+          grid[[x, y]] = pt_idx
+          pt_idx_counts[pt_idx] ||= 0
+          pt_idx_counts[pt_idx] += 1
+        end
+      end
+
+      find_infinite_indexes(grid, max_x[0], max_y[1]).each do |inf_idx|
+        pt_idx_counts.delete(inf_idx)
+      end
+
+      pt_idx_counts.max_by { |idx, count| count }[1]
+    end
+
+    def find_infinite_indexes(grid, max_x, max_y)
+      infinite_indexes = Set.new
+      grid.each_pair do |pt, idx|
+        if pt[0] == 0 || pt[1] == 0 || pt[0] == max_x || pt[1] == max_y
+          infinite_indexes << idx
+        end
+      end
+      infinite_indexes
+    end
+
+    def largest_region_with_closest_distances(points, max_distance)
+      max_x = points.max_by { |p| p[0] }
+      max_y = points.max_by { |p| p[1] }
+
+      grid_of_distance_sums = {}
+      (0..max_x[0]).each do |x|
+        (0..max_y[1]).each do |y|
+          d_sums = points.sum(0) { |pt| manhattan(pt, [x, y]) }
+          grid_of_distance_sums[[x, y]] = d_sums
+        end
+      end
+      grid_of_distance_sums.select { |pt, distance| distance < max_distance }.length
+    end
+
+    if __FILE__ == $0
+      puts "Part 1"
+      input = File.readlines('input.txt').map { |ln| ln.split(', ').map(&:to_i) }
+      output = largest_non_infinite_region(input)
+      p output
+
+      puts "Part 2"
+      output = largest_region_with_closest_distances(input, 10_000)
+      p output
+    end
+    ```
+  :replies: []
+- :author: Frizkie
+  :url: https://www.reddit.com/r/adventofcode/comments/a3kr4r/2018_day_6_solutions/eb9fmta/
+  :body: |-
+    Ruby
+
+    ```ruby
+    data = File.read('data.txt').chomp.split("\n").map.with_index do |d, i|
+      [i, d.match(/(\d+), (\d+)/)[1..2].map(&:to_i)]
+    end
+    ```
+
+    **Part 1:**
+
+    ```ruby
+    grid = Array.new(1000) { Array.new(1000) }
+    1000.times do |i|
+      1000.times do |j|
+        dists = data.map { |id, coords| [id, (coords[0] - i).abs + (coords[1] - j).abs] }
+        closest = dists.min_by { |_, dist| dist }
+        grid[j][i] = closest[0] if dists.map{ |d| d[1] }.count(closest[1]) == 1
+      end
+    end
+
+    infinites = [grid[0], grid[999], grid.map { |r| r[0] }, grid.map { |r| r[999] }].flatten.compact
+
+    flat = grid.flatten.compact.reject { |e| infinites.include? e }
+    freq = flat.inject(Hash.new(0)) { |h, v| h[v] += 1; h }
+    puts flat.count(flat.max_by { |v| freq[v] })
+    ```
+
+    **Part 2:**
+
+    ```ruby
+    grid = Array.new(1000) { Array.new(1000) }
+    1000.times { |i| 1000.times { |j| grid[i][j] = data.map { |_, coords| (coords[0] - i).abs + (coords[1] - j).abs }.sum } }
+    puts grid.flatten.count { |e| e < 10000 }
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2018/07.yml

@@ -0,0 +1,380 @@
+---
+- :author: Frizkie
+  :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/eb9xtuf/
+  :body: |-
+    Ruby
+
+    This one was tough for me, I figured out it was topological sort pretty quickly, but figuring out how to tweak the algorithm to grab the right nodes was tough. I ended up using a priority queue to sort the `to_visit` set and that fixed my problem.
+
+    Part 2 initially seemed absurdly difficult, but implementing a second-by-second work loop didn't actually take much effort.
+
+    Always nice when you're so excited about the right answer you throw your hands up in the air!
+
+    ```ruby
+    require 'pqueue'
+
+    data = File.read('data.txt').chomp.split("\n").map{ |d| d.match(/Step ([A-Z])[a-z]+([A-Z])/)[1..2] }
+
+    class Node
+      attr_accessor :val, :children
+
+      def initialize(val)
+        @val = val
+        @children = []
+      end
+    end
+
+    nodes = []
+    data.each do |before, after|
+      added = nodes.map(&:val)
+      nodes << Node.new(before) unless added.include? before
+      nodes << Node.new(after) unless added.include? after
+
+      before = nodes.find { |n| n.val == before }
+      after = nodes.find { |n| n.val == after }
+
+      before.children << after unless before.children.include? after
+    end
+    ```
+
+    **Part 1:**
+
+    ```ruby
+    list = []
+    roots = nodes.reject { |n| nodes.any? { |n2| n2.children.include? n } }.sort_by(&:val)
+    s = PQueue.new(roots) { |a, b| a.val < b.val }
+    p s.to_a.map(&:val).join
+
+    until s.empty?
+      n = s.pop
+      list << n
+
+      n.children.sort_by(&:val).each do |c|
+        n.children.delete(c)
+        s << c unless nodes.any? { |n2| n2.children.include? c }
+      end
+    end
+
+    p list.map(&:val).join
+    ```
+
+    **Part 2:**
+
+    ```ruby
+    current_seconds = 0
+    base_seconds = 60
+
+    workers = { # value structure: [working_node, second_total_when_finished]
+      1 => nil,
+      2 => nil,
+      3 => nil,
+      4 => nil,
+      5 => nil
+    }
+
+    until nodes.empty?
+      # check for finished jobs
+      workers.reject { |_, job| job.nil? }.each do |id, job|
+        if job[1] == current_seconds
+          workers[id] = nil
+          nodes.delete(job[0])
+        end
+      end
+
+      # get new jobs
+      workers.select { |_, job| job.nil? }.each do |id, _|
+        work_node = nodes.find { |n| nodes.none? { |n2| n2.children.include? n } && !workers.values.compact.map { |w| w[0] }.include?(n) }
+        break unless work_node
+
+        finish_time = current_seconds + work_node.val.ord - 64 + base_seconds
+        workers[id] = [work_node, finish_time]
+      end
+
+      current_seconds += 1
+    end
+
+    puts current_seconds - 1
+    ```
+  :replies:
+  - :author: aoc_throwaway
+    :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebbg934/
+    :body: |-
+      check out my part 1 ruby solution:
+
+      ```ruby
+      h = {}
+      File.readlines('input.txt').each do |l|
+        i, j = l[36], l[5]
+        h[i] ||= []
+        h[j] ||= []
+        h[i] << j
+      end
+
+      f = ''
+      until h.empty?
+        e = h.select {|k,v| v.empty?}.keys.sort[0]
+        h.delete(e)
+        h.each {|k,v| v.delete(e)}
+        f += e
+      end
+      puts f
+      ```
+
+      --kss
+    :replies: []
+  - :author: Larkenx
+    :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebc0qie/
+    :body: here’s my part 1 ruby solution as well, after learning ruby for a couple hours https://github.com/Larkenx/AdventOfCode2018/blob/master/7/parta.rb
+    :replies:
+    - :author: craigontour
+      :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebkkqqn/
+      :body: Which site did you use to learn Ruby so fast?
+      :replies:
+      - :author: Larkenx
+        :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebl4ws1/
+        :body: Pretty much the Ruby docs exclusively. I had just learned Perl 6 and Lua, which are quite similar in ways
+        :replies: []
+- :author: Dee_Jiensai
+  :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/eba5rfj/
+  :body: |-
+    ruby 2.5.1
+
+    That was nice. Now i have to go look up what a topological sort is.
+
+    ```ruby
+    require 'pp'
+
+    input = File.read('input7').lines.map!{|l| l.match(/Step\ (?<do_this>[A-Z]+{1})\ must\ be\ finished\ before\ step\ (?<before_that>[A-Z]+{1})\ can\ begin.*$/).named_captures.transform_keys(&:to_sym)}
+
+    all = input.map(&:values).flatten.uniq
+
+    def to_i(letter)
+      letter.bytes[0] - 64
+    end
+
+    data = {}
+    all.each do |letter|
+      data[letter] = {before: [], dauer: 60 + to_i(letter)}
+      input.each do |item|
+        if item[:before_that] == letter
+          data[letter][:before].push item[:do_this]
+        end
+      end
+    end
+
+    def find_next(data,done)
+      res = []
+      data.each_pair do |letter, hash|
+        unless done.include? letter
+          i=0
+          if hash[:before]
+            hash[:before].each do |item|
+              i+=1 unless done.include? item
+            end
+          end
+          res.push [letter,i]
+        end
+      end
+      res.sort{|a,b| a[1] <=> b[1]}
+      res.select{|x| x[1] == 0}.map(&:first).sort
+    end
+
+    done = []
+    order = []
+    while true
+      res = find_next(data,done)
+      done.push res[0]
+      order.push res[0]
+      break if res.length == 0
+    end
+
+    #output solution part 1
+    pp order.flatten.join
+
+    # The file output is just for fun.
+    File.open('output7', 'w') do |f|
+      f.write "Time 1 2 3 4 5 done in Progress"
+      f.write "\n"
+    end
+
+    done = []
+    in_progress = []
+    order = []
+    time = 0
+    workers = [nil,nil,nil,nil,nil]
+    res = []
+
+    while done.length < all.length
+      for count in 0..4
+        if workers[count] and workers[count][1] == time
+          done.push workers[count][0]
+          in_progress.delete(workers[count][0])
+          workers[count] = nil
+        end
+      end
+      unless workers.include?(nil)
+      else
+        if res.empty?
+          res = find_next(data,done)
+          res -= in_progress
+        end
+        while workers.include?(nil) and not res.empty?
+          for count in 0..4
+            break if res.empty?
+            if workers[count] == nil
+              letter = res.slice!(0)
+              workers[count] = [letter, data[letter][:dauer] + time]
+              order.push(letter)
+              in_progress.push(letter)
+            end
+          end
+        end
+      end
+      time += 1
+
+      a = "#{sprintf('%5s',time)}"
+      (0..4).each do |c|
+        a += "#{workers[c].nil? ? ' idle ' : " " + workers[c][0] + " "}"
+      end
+      a += " #{ done.join}"
+      a += " #{ in_progress.join}"
+      pp a
+      File.open('output7', 'a') do |f|
+        f.write a
+        f.write "\n"
+      end
+    end
+    ```
+  :replies:
+  - :author: aoc_throwaway
+    :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebbhb9y/
+    :body: |-
+      check out my part 1 ruby solution:
+
+      ```ruby
+      h = {}
+      File.readlines('input.txt').each do |l|
+        i, j = l[36], l[5]
+        h[i] ||= []
+        h[j] ||= []
+        h[i] << j
+      end
+
+      f = ''
+      until h.empty?
+        e = h.select {|k,v| v.empty?}.keys.sort[0]
+        h.delete(e)
+        h.each {|k,v| v.delete(e)}
+        f += e
+      end
+      puts f
+      ```
+    :replies: []
+- :author: aoc_throwaway
+  :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebazkui/
+  :body: |-
+    Short Ruby solution for part 1, takes \<1ms to run (usually around 0.3ms):
+
+    ```ruby
+        h = {}
+        File.readlines('input.txt').each do |l|
+          i, j = l[36], l[5]
+          h[i] ||= []
+          h[j] ||= []
+          h[i] << j
+        end
+
+        f = ''
+        until h.empty?
+          e = h.select {|k,v| v.empty?}.keys.sort[0]
+          h.delete(e)
+          h.each {|k,v| v.delete(e)}
+          f += e
+        end
+        puts f
+    ```
+
+    -kss
+  :replies:
+  - :author: wzkx
+    :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebchy1a/
+    :body: |-
+      Very good solution! I translated it into Python to see if it looks the same there.
+
+      ```ruby
+      h = {}
+      for l in open('07.dat','rt').readlines():
+        i, j = l[36], l[5]
+        if i not in h: h[i] = []
+        if j not in h: h[j] = []
+        h[i].append( j )
+
+      r = ''
+      while len(h):
+        e = sorted( k for k,v in h.items() if len(v)==0 )[0]
+        del h[e]
+        for k in h:
+          if e in h[k]: h[k].remove(e)
+        # could be one line too: for k in h: e not in h[k] or h[k].remove(e)
+        r += e
+      print( r )
+      ```
+    :replies:
+    - :author: aoc_throwaway
+      :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebfgin4/
+      :body: Nice! Probably faster in python too. Ruby is slow.
+      :replies: []
+- :author: morfi717
+  :url: https://www.reddit.com/r/adventofcode/comments/a3wmnl/2018_day_7_solutions/ebcrskf/
+  :body: |-
+    Ruby (0.08s)
+
+    ```ruby
+    F = File.read("#{ __dir__ }/data/day7.txt")
+                .scan(/Step (\w+) must.+? step (\w+) can/)
+
+    Timer = {t: -1}
+    Workers = Array.new(5) { [nil, 0] }
+
+    V = F.group_by(&:first).map{|k, v| [k, v.map(&:last).sort] }.to_h
+    V.to_a.transpose.map(&:flatten).reverse.reduce(:-).uniq.sort.each{ |λ|
+        V[λ] = []
+    }
+
+    def P1(stack)
+        Timer[:t] += 1
+
+        Workers.select(&:first).each{ |ω|
+            ω[1] -= 1
+
+            if(ω.last == 0)
+                stack.append(ω.first)
+                V.delete(ω.first)
+                ω[0] = nil
+            end
+        }
+
+        if V.any?
+            Ξ = Workers.reject(&:first)
+
+            V.to_a.transpose
+                .map(&:flatten)
+                .append(Workers.map(&:first))
+                .reduce(:-)
+                .sort
+                .take(Ξ.size)
+                .each_with_index.each{ |letter, idx|
+                    Ξ[idx][0] = letter
+                    Ξ[idx][1] = letter.ord - 64 + 60
+                }
+
+            P1(stack)
+        end
+
+        stack
+    end
+
+    puts "Ans1: %s" % P1([]).join
+    puts "Ans2: %s" % Timer[:t]
+    ```
+  :replies: []