advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2017/04.yml

@@ -0,0 +1,51 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7hf5xb/2017_day_4_solutions/dqqj92m/
+  :body: |-
+    Ruby, #8 silver #4 gold (run with -x)
+
+    ```ruby
+    To ensure security, a valid passphrase must contain no duplicate words.
+
+    For added security, yet another system policy has been put in place. Now, a valid passphrase must contain no two words that are anagrams of each other - that is, a passphrase is invalid if any words letters can be rearranged to form any other word in the passphrase.
+
+    For example:
+
+    abcde fghij is a valid passphrase.
+    abcde xyz ecdab is not valid - the letters from the third word can be rearranged to form the first word.
+    a ab abc abd abf abj is a valid passphrase, because all letters need to be used when forming another word.
+    iiii oiii ooii oooi oooo is valid.
+    oiii ioii iioi iiio is not valid - any of these words can be rearranged to form any other word.
+
+    #!ruby
+    p $<.count{|x|v=x.split
+    v=v.map!{|x|x.chars.sort*''} # this line added for part 2
+    v.uniq==v}
+    ```
+
+    PS: I now keep a [log series detailing my adventofcode adventure](https://github.com/Unihedro/workout/blob/master/adventofcode2017/entry1.md). If you're interested feel free to read it as I write more, if I do!
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/7hf5xb/2017_day_4_solutions/dqqnfky/
+    :body: Fun log series! It's always enlightening to see some stream-of-consciousness gut-reaction to the puzzles so I can try to improve them for next year.
+    :replies: []
+- :author: Frizkie
+  :url: https://www.reddit.com/r/adventofcode/comments/7hf5xb/2017_day_4_solutions/dqqo3ae/
+  :body: |-
+    Never code golfed before, but I gave it a try:
+
+    ```ruby
+    #!/usr/bin/ruby
+    # part 1
+    p File.read('data.txt').split("\n").count{|p|a=p.split;a==a.uniq}
+    # part 2
+    p File.read('data.txt').split("\n").count{|p|a=p.split.map{|w|w.chars.sort};a==a.uniq}
+    ```
+  :replies:
+  - :author: jschulenklopper
+    :url: https://www.reddit.com/r/adventofcode/comments/7hf5xb/2017_day_4_solutions/dqqr184/
+    :body: |-
+      You can trim some characters using `readlines()`. No need for a `split()` anymore:
+
+      `p File.readlines('data.txt').count{|p|a=p.split;a==a.uniq}`
+    :replies: []

data/data/solutions/reddit/ruby/2017/05.yml

@@ -0,0 +1,185 @@
+---
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqshwef/
+  :body: |-
+    in ruby, this felt simultaneously wayy too easy and waayy too dirty of a solution. i feel like i'm missing some really elegant iteration trick, but everyone in this thread seems to have the same approach
+
+    ```ruby
+    def jump &blk
+        input = File.read("input").lines.map(&:to_i)
+
+        index = 0
+        steps = 0
+
+        while index < input.size
+            to_move = input[index]
+            input[index] += blk ? blk.call(to_move) : 1
+            index += to_move
+
+            steps += 1
+        end
+
+        steps
+    end
+
+    puts jump
+    puts jump {|f| f >= 3 ? -1 : 1}
+    ```
+  :replies:
+  - :author: jschulenklopper
+    :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqsj6pi/
+    :body: |-
+      Here's the iteration trick that I used. (Also, your code would not catch if the index would run out at the other end, so below 0.)
+
+      ```ruby
+      offsets = readlines.map { |offset| offset.to_i }
+      index, count = 0, 0
+      while offset = offsets[index] do # Here's the crux
+        offsets[index] += (offsets[index] >= 3 ? -1 : 1)
+        index += offset
+        count += 1
+      end
+      puts count
+      ```
+
+      The 'trick' is twofold: it gets the `offset` immediately while testing the `while` condition (which will save a line). This value will be `nil` (and thus `false`) for index values outside the range of offset instructions.
+
+      What I like in your solution is that you're passing the proper increment function as a block to `jump()`. Kudos to you.
+    :replies: []
+  - :author: gettalong
+    :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqt8aci/
+    :body: |-
+      Here is my 2-line quick and dirty solution for use in IRB:
+
+      ```ruby
+      arr = File.readlines('/tmp/input5').map(&:chomp).map(&:to_i)
+      old_i = 0; i = 0; count = 0; while 0 <= i && i < arr.length do old_i = i; i += arr[i]; arr[old_i] >= 3 ? arr[old_i] -=1 : arr[old_i] += 1; count += 1; end; count
+      ```
+    :replies: []
+- :author: OneEyedGammer
+  :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqshytd/
+  :body: |-
+    My god, I spent almost 10 minutes trying to figure out why my code wasn't working on part 2. Turns out it doesn't want an absolute value.
+
+    Here is my garbage code in ruby:
+
+    ```ruby
+        def count_steps filename
+            count = 0
+            contents = []
+            File.open(filename, "r") do |f|
+                f.each_line do |line|
+                    contents.push(line.to_i)
+                end
+            end
+            index = 0
+            steps = 0
+            while true
+                temp = contents[index]
+                contents[index] = contents[index] + 1
+                # temp >= 3 ? contents[index] -= 1 : contents[index] += 1 replace the above line with this for part 2
+                index += temp
+                count += 1
+                break if index >= contents.length || index < 0
+            end
+            return count
+        end
+    ```
+  :replies:
+  - :author: gbeier
+    :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqu1ghw/
+    :body: I made the exact same mistake. I think "offset" tripped that in my brain.
+    :replies:
+    - :author: OneEyedGammer
+      :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dquvrb8/
+      :body: I don't think we're wrong for thinking that way. From what I've seen from programming challenges it would read that way. Oh well, it didn't take long to long to notice what was wrong.
+      :replies: []
+- :author: andreesgor
+  :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqti5pu/
+  :body: |-
+    Ruby:
+
+    ```ruby
+    arr = input.lines.map(&:to_i).to_a
+
+    part=2
+    steps, current = 0, 0
+    while current < arr.length
+      cache = current
+      current += arr[current]
+
+      if part == 1
+        arr[cache] += 1
+      elsif part == 2
+        if arr[cache] < 3
+          arr[cache] += 1
+        else
+          arr[cache] -= 1
+        end
+      end
+
+      steps += 1
+    end
+
+    puts "Steps: #{steps}"
+    ```
+  :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqsdne6/
+  :body: |-
+    Ruby. Huge disappointment! I was running my day4 code instead of my day5 code. I couldn't even count what day it is anymore :)
+
+    Solved in a minute, took 7 minutes to realize I was not running it properly.
+
+    ```ruby
+    h=$<.map &:to_i
+    s=0
+    g=j=0
+    (g+=1
+    v=h[j=s]
+    v<0 ? (s+=v) : (
+    s+=v
+    )
+    h[j]+=1 # part1
+    h[j]+=(j >= 3 ? -1 : 1) #part2
+    )while s>=0 && h[s]
+    p g
+    ```
+
+    PS: I've been keeping a [small blog over on github detailing my Aoc adventure so far.](https://github.com/Unihedro/workout/blob/master/adventofcode2017/entry1.md) there will be a short break before I "blog" about day6+ again though
+  :replies:
+  - :author: jschulenklopper
+    :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqshm9c/
+    :body: |-
+      Another solution in Ruby. A bit more characters, a bit less magic :-)
+
+      ```ruby
+      offsets = readlines.map { |offset| offset.to_i }
+      index, count = 0, 0
+      while offset = offsets[index] do
+        offsets[index] += (offsets[index] >= 3 ? -1 : 1) # Or just `+1` for part 1.
+        index += offset
+        count += 1
+      end
+      puts count
+      ```
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqshxts/
+      :body: |-
+        Respect! Really tidy code - I wrote mine in a rush :/. Some notes (not sure if it'll be helpful but in case it expands your knowledge):
+
+        1. `.to_i` ignores whitespace characters both in front and back, as well as any invalid characters after the leading number: `"99 red balloons".to_i #=> 99`, `" 100 ".to_i #=> 100` so .strip or .chomp right before extracting the integer is usually redundant
+        2. `map!` is a destructive operation which (attempts to) change the original Enumerable as well, it doesn't do much in this case so it can be `map` instead.
+      :replies:
+      - :author: jschulenklopper
+        :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqsizom/
+        :body: Ha, those were indeed two minor improvements that I made later (updated in the post as well). Looks just like a recent discovery that `.split(" ")` would split on spaces _and_ tabs... just as the default `.split` without argument :-)
+        :replies:
+        - :author: Unihedron
+          :url: https://www.reddit.com/r/adventofcode/comments/7hngbn/2017_day_5_solutions/dqsjhqj/
+          :body: |-
+            Hello, yes, .split uses $; by default, if $; is nil then it uses whitespace. This means newline characters are also included. As such $\<.read.split will give you all non-space character sequences when the parameter is not specified. The use of this global variable is very similar to how perl implements input parsing.
+
+            However, if $; is specified then .split won't be acting on whitespaces.
+          :replies: []

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

@@ -0,0 +1,222 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqu8dku/
+  :body: |-
+    Ruby; I tried guessing what it wanted me to do (fill towards the start and loop back, instead of filling after the index of the unit) and I guessed wrong. :P
+
+    ```ruby
+    p (s=gets.split.map &:to_i)
+    m=s.size
+    h={}
+    i=0
+    (h[s.to_s]=1 # part 1
+    h[s.to_s]=(i+=1) # part 2
+    v=s.max
+    i=s.index(v)
+    s[i]=0
+    v>=m && (s.map!{|x|x+v/m}
+    v-=v/m*m)
+    j=p
+    (i..i+v).map{|x|x==i ? j=1 : x>=m ? s[x-m]+=1 : s[x]+=1 }
+    #s[v]+=1 if j
+    p s
+    i+=1 # part 1
+    )while !h[s.to_s]
+    p i
+    p i-h[s.to_s]
+    ```
+  :replies:
+  - :author: nakilon
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqua8h9/
+    :body: Excuse me, where is the loop?
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqub2k2/
+      :body: The loop starts at previous counter with the same state to the current counter. `p i` prints the solution for part 1, while `h[s.to_s]` to `i` is the loop, so the size is `p i-h[s.to_s]`
+      :replies:
+      - :author: nakilon
+        :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dquelrk/
+        :body: Oops, didn't see the markdown code block had scrollbar...
+        :replies: []
+  - :author: jschulenklopper
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dquidyd/
+    :body: |-
+      My solution in Ruby, also using string representation of memory banks as key in a hash, and the cycle count of when that configuration has been seen is stored as value.
+
+      ```ruby
+      config = gets.split.map(&:to_i)
+      cycles = 0
+      memory = {}
+
+      until memory.has_key?(config.to_s)
+        # Store cycle count with string representation of memory banks.
+        memory[config.to_s] = cycles
+
+        # Find bank with most blocks.
+        index = config.index(config.max)
+        blocks = config[index]
+
+        # Redistribute the blocks from index bank.
+        config[index] = 0
+        blocks.times do |i|
+          config[(index + i + 1) % config.length] += 1
+        end
+
+        cycles += 1
+      end
+
+      puts cycles # Part 1
+      puts cycles - memory[config.to_s] # Part 2, cycle count minus when cycle started.
+      ```
+    :replies: []
+- :author: nakilon
+  :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqu8dry/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    a = gets.split.map &:to_i
+    s = {a.dup => 0}
+    m = 0
+    loop do
+      m += 1
+      i = a.index a.max
+      n = a[i]
+      a[i] = 0
+      n.times do
+        i = (i + 1) % a.size
+        a[i] += 1
+      end
+      break p m - s[a] if s[a]
+      s[a.dup] = m
+    end
+    ```
+
+    122nd place with around 8 minutes, damn. How one can solve in 2 minutes if I've spent 4 minutes to read the task?! ..(
+
+    **UPD: golfed to 125 chars for lulz**
+
+    ```ruby
+    a=gets.split.map &:to_i
+    s,m={},0
+    until s[a]
+    s[a]=m+=1
+    a[i=a.index(a.max)]-=x=a[i]
+    x.times{a[i=(i+1)%a.size]+=1}end
+    p m-s[a]+1
+    ```
+  :replies:
+  - :author: Unihedron
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqudd9e/
+    :body: ~~$/=' ';a=$\<.map &:to\_i to get rid of another char.~~ (\<- I couldn't get it to put a tab character here) `until ... end` can be replaced with modifier syntax `()until ...` to get rid of 2 chars (including whitespace). Also, it doesn't really matter that `m` is initialized to zero for part 2 (end+k - start+k == end-start) so you can delete `,m ,0` and replace the two `m` references with the global variable `$.` which is the "lines read" counter (because we don't use `gets` again)
+    :replies:
+    - :author: nakilon
+      :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dquek6v/
+      :body: |-
+        There is some problem with input taken from site -- maybe that some gaps consist of two whitespace characters instead of one so `a` gets parsed incorrectly for me.
+
+        The rest works fine. Thanks! -4 chars
+      :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqw138x/
+  :body: |-
+    **Ruby REPL** (irb) solution. The `pbpaste` command must be available in the `$PATH`, and should return the contents in the clipboard (macOS has this command by default).
+
+    Part 1 (31st rank)
+
+    ```ruby
+    nx = -> x { max = x.max; m = x.index(max); n = x.dup; n[m] = 0; (m + 1...m + 1 + max).map { |i| i % x.length }.each { |i| n[i] += 1 }; n }
+    -> a { seen = { }; c = 0; while !seen[a]; c += 1; seen[a] = true; a = nx[a]; end; c }[`pbpaste`.split.map(&:to_i)]
+    ```
+
+    Part 2 (38th rank)
+
+    ```ruby
+    nx = -> x { max = x.max; m = x.index(max); n = x.dup; n[m] = 0; (m + 1...m + 1 + max).map { |i| i % x.length }.each { |i| n[i] += 1 }; n }
+    -> a { seen = { }; c = 0; while !seen[a]; c += 1; seen[a] = c; a = nx[a]; end; c - seen[a] + 1 }[`pbpaste`.split.map(&:to_i)]
+    ```
+  :replies: []
+- :author: doromin
+  :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqudcpy/
+  :body: |-
+    **Ruby** simply using mem-string(join) instead of array of mem-arrays as comparison made it fast enough.
+
+    ```ruby
+
+        data = input.split("\t").strip.map(&:to_i)
+        results = []
+
+        while !results.include?(data.join)
+          results << data.join
+          max = data.max
+          i = data.index(max)
+          data[i] = 0
+          max.times do
+            i = (i + 1) % data.size
+            data[i] += 1
+          end
+        end
+        puts 'part1 -------', results.count, '----------'
+
+        initial_data = data.clone
+        cycles = 0
+
+        loop do
+          break if data == initial_data
+          max = data.max
+          i = data.index(max)
+          data[i] = 0
+          max.times do
+            i = (i + 1) % data.size
+            data[i] += 1
+          end
+          cycles += 1
+        end
+        puts 'part2 -------', cycles, '----------'
+
+    ```
+  :replies:
+  - :author: jschulenklopper
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqui874/
+    :body: |-
+      Question: would your `data.join` not be fallible for cases in which the string representation of two different arrays is equal? As in: `[1,11,0,22,2].join == [11,1,0,2,22].join` which is `true`, but the arrays clearly aren't.
+
+      I think you got lucky that this case didn't appear with your input :-) A `data.join(",")` would prevent this from occurring.
+    :replies: []
+- :author: disclosure5
+  :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqui8ho/
+  :body: |-
+    Rather than paste another boring Ruby solution, this is the sort of workload where jruby shines. Have a benchmark. Even though this horrible test included the significant warm up time, which is about six seconds on this machine.
+
+    ```ruby
+    $ time ./six.rb
+    ... 0m24.399s
+    $ time jruby ./six.rb
+    ... 0m14.844s
+    ```
+  :replies:
+  - :author: maxerickson
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqumy44/
+    :body: |-
+      Looks like checking whether the current arrangement has already occurred is really costly there. My solution is similar to the Python solutions posted already, uses sets to check for the repeat (my computer is ancient):
+
+      ```ruby
+      time python six.py
+      user 0m0.258s
+      ```
+    :replies:
+    - :author: nakilon
+      :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqv10ll/
+      :body: I suppose he's putting arrangements to Array, not Hash. That costs him a lot but he's free of collision unlike of your solution.
+      :replies: []
+  - :author: nakilon
+    :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqv0wdf/
+    :body: |-
+      I've got 0.090s and 0.170s
+
+      Is my MRI broken?
+    :replies:
+    - :author: disclosure5
+      :url: https://www.reddit.com/r/adventofcode/comments/7hvtoq/2017_day_6_solutions/dqv90m8/
+      :body: I'm going to guess your solution is a lot more performant!
+      :replies: []

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

@@ -0,0 +1,173 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7i44pg/2017_day_7_solutions/dqw1an1/
+  :body: |-
+    Ruby; kinda late, had to rewrite a lot. I assumed the puzzle was "validate heights" (and a wrong one was provided), not "ensure balancing", based on the highlighted text. Even after I rewrote my code, it showed 2 wrong sectors, which worried me hugely. It took a long time for me to realize that I should manually dig through the input for the disc to change. Fun riddle!
+
+    Also I think we're reaching the point where forfeiting readability for speed is starting to become a liability.
+
+    ```ruby
+    h={}
+    o=[]
+    $<.map{|x|x=~/^(\S+) \((\d+)\) ?([^>]+> )?/
+    #p $1, $'
+    l=($3 ? ($'.split(', ').map(&:to_sym)) : [])
+    h[$1.to_sym]=[$2.to_i,l]
+    o+=l
+    }
+    q={}
+
+    # part 1 only
+    p h.delete_if{|x,y|!y.any? || o.index(x)}
+
+    # part 2 here
+    h.delete_if{|x,y|a,b=y
+    #p b
+     h[x]=q[x]=[a,b,a+b.sum{|x|h[x] ? h[x][0] : q[x][2]}] if b.all?{|x|!h[x] || (!h[x].any?)}}while h.any?
+    #p h.reject!{|x,y|y[0]!=y[2]&&y[2]!=0}
+     q.map{|x,y|a,b,c=y
+    t=b.map{|x|q[x][2]}
+    (p x,a,b,c,t,q[x]) if t.uniq.count>1
+    }
+    ```
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/7i44pg/2017_day_7_solutions/dqw1kdy/
+    :body: |-
+      > Also I think we're reaching the point where forfeiting readability for speed is starting to become a liability.
+
+      **_yes_**
+    :replies: []
+  - :author: LeCrushinator
+    :url: https://www.reddit.com/r/adventofcode/comments/7i44pg/2017_day_7_solutions/dqxs2mv/
+    :body: This looks similar to when I let my 4 year old pretend they're typing something on the keyboard. I've been programming for years and this still looks like greek to me.
+    :replies: []
+- :author: arachnist
+  :url: https://www.reddit.com/r/adventofcode/comments/7i44pg/2017_day_7_solutions/dqw96y5/
+  :body: |-
+    Went through my pry and zsh history, and cleaned up the ruby solution i came up with in the morning
+
+    ```ruby
+    class Node
+      attr_accessor :name, :weight, :children
+
+      def initialize(name, weight, children = [])
+        @name = name
+        @weight = weight
+        @children = children
+      end
+
+      def branch_weight
+        @children.map do |c|
+          c.branch_weight
+        end.reduce(@weight, :+)
+      end
+
+      def common_children_weight
+        value_counter = Hash.new(0)
+        values = @children.map do |c|
+          c.branch_weight
+        end
+
+        values.each do |v|
+          value_counter[v] += 1
+        end
+
+        values.select do |v|
+          v if v != value_counter.key(1)
+        end[0]
+      end
+
+      def outlier
+        o = nil
+        @children.each do |c|
+          o = c if c.branch_weight != self.common_children_weight
+        end
+        o
+      end
+    end
+
+    def construct_tree(b_root)
+      if (ch = Branches[b_root]).nil?
+        children = []
+      else
+        children = ch.map do |c|
+          construct_tree(c)
+        end
+      end
+
+      Node.new(b_root, Weights[b_root], children)
+    end
+
+    def find_final_outlier(root)
+      outlier = root.clone
+      previous = nil
+      while not (outlier = outlier.outlier).nil?
+        previous = outlier.clone
+      end
+      previous
+    end
+
+    Branches = {}
+    Weights = {}
+    children = []
+    all = []
+    file = ARGV[0] || "input.txt"
+
+    open(file).each_line do |line|
+      a = line.gsub(/,/, "").split
+      Weights.merge!({ a[0] => Integer(a[1].gsub(/[()]/, "")) })
+      all << a[0]
+      if not a[3].nil?
+        Branches.merge!({ a[0] => a[3..a.count] })
+        children += a[3..a.count]
+      end
+    end
+
+    Root = construct_tree((all - children)[0])
+    puts Root.name
+    puts find_final_outlier(Root).weight + (Root.common_children_weight - Root.outlier.branch_weight)
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/7i44pg/2017_day_7_solutions/dqw10dq/
+  :body: |-
+    **Ruby REPL** (irb) solution. The `pbpaste` command must be available in the `$PATH`, and should return the contents in the clipboard (macOS has this command by default).
+
+    Part 1 (47th rank):
+
+    ```ruby
+    -> x { s = {}; p = {}; x.scan(/(\w+).*?->\s*(.+)/).each { |a, b| b.strip.split(', ').each{|n|p[n]=a}; s[a]=1 }; s.keys.select{|z|!p[z]} }[`pbpaste`]
+    ```
+
+    Part 2 (71st rank):
+
+    ```ruby
+    s = {}; p = {}; c = {}; `pbpaste`.scan(/(\w+) \((\d+)\)(?: -> )?(.*)/).each { |a, w, b| b.length > 0 && b.strip.split(', ').each{|n|p[n]=a; (c[a]||=[]) << n}; s[a]=w.to_i }
+    wei = -> n { s[n] + (c[n] || []).map(&wei).reduce(0, &:+) }
+
+    # s['name'] -> Weight of the program
+    # p['name'] -> Name of the program’s parent (or nil)
+    # c['name'] -> List of the program’s children
+    # wei['name'] -> Weight of the program, including all its children.
+
+    # Use this to find the nodes with unbalanced child weight
+    c.select { |n, ch| ch.map(&wei).uniq.length > 1 }
+
+    # The final answer can be found by manually inspecting weights in the REPL. Here’s mine:
+    # 2.4.1 :085 > wei['nieyygi']
+    # => 11781
+    # 2.4.1 :086 > wei['mxgpbvf']
+    # => 1117
+    # 2.4.1 :087 > wei['cfqdsb']
+    # => 1117
+    # 2.4.1 :088 > wei['yfejqb']
+    # => 1117
+    # 2.4.1 :089 > wei['ptshtrn']
+    # => 1122
+    # 2.4.1 :090 > s['ptshtrn']
+    # => 526
+    # 2.4.1 :091 > 526 - (1117 - 1122)
+    # => 521
+    ```
+  :replies: []