advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,204 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr10wbf/
+  :body: |-
+    Part 1 went well. Thanks to language I chose (Ruby), it is easy to code the "reverse these N elements" without error. Since I didn't want to deal with the wrap-around, I just always rotate the array so that I'm reversing the **first** N elements, and then rotate the array back when I'm done. This can be done in the various languages that allow assigning an array A1 into a subarray of another array A2, modifying multiple elements of A2 at once. For another example language, Python will do this too with `l[0:5] = reversed(l[0:5])`
+
+    Part 2 was good but less good simply because of confusion about converting to a hash and about interpreting the input. If I had to give myself advice retroactively, it would be to check that an answer is a plausible answer (for the type of answer the problem statement is asking for) before submitting it.
+
+    ```ruby
+    def twist(lengths, n)
+      pos = 0
+      skip_size = 0
+
+      n.times.with_object((0..255).to_a) { |_, l|
+        lengths.each { |len|
+          l.rotate!(pos)
+          l[0, len] = l[0, len].reverse
+          l.rotate!(-pos)
+          pos += len + skip_size
+          skip_size += 1
+        }
+      }
+    end
+
+    input = (ARGV.empty? ? DATA : ARGF).read.chomp
+
+    puts twist(input.split(?,).map(&:to_i), 1).take(2).reduce(:*)
+
+    puts twist(input.bytes + [17, 31, 73, 47, 23], 64).each_slice(16).map { |byte|
+      byte.reduce(0, :^).to_s(16).rjust(2, ?0)
+    }.join
+
+    __END__
+    147,37,249,1,31,2,226,0,161,71,254,243,183,255,30,70
+    ```
+  :replies:
+  - :author: KnorbenKnutsen
+    :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr1bld9/
+    :body: Did the same thing in Python, kept the list in a deque that I rotated `-(current_position + skip_steps) % len(my_deque)` every time. Kinda neat IMO.
+    :replies: []
+  - :author: hpzr24w
+    :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr1f30q/
+    :body: Yes, I like that idea of doing the rotation. Ended up rolling my own C++ `reverse()` rather than being able to use the Standard Library.
+    :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr108bt/
+  :body: |-
+    # irb (Ruby REPL) (41st, 16th)
+
+    The `pbpaste` command must be available in the `$PATH`, and should return the contents in the clipboard (macOS has this command by default).
+
+    ```ruby
+    # Part 1
+    -> n, a { d = (0...n).to_a; r = 0; skip = 0; a.each { |c| d[0...c] = d[0...c].reverse; d = d.rotate(c + skip); r += c + skip; skip += 1; p d.rotate(n - (r % n)) }; r = d.rotate(n - (r % n)); r[0] * r[1] }[256, `pbpaste`.split(',').map(&:to_i)]
+
+    # Part 2
+    -> n, a { d = (0...n).to_a; r = 0; skip = 0; 64.times { a.each { |c| d[0...c] = d[0...c].reverse; d = d.rotate(c + skip); r += c + skip; skip += 1; }; }; r = d.rotate(n - (r % n)); r.each_slice(16).map { |s| "%02x" % s.reduce(&:^) }.join }[256, [*`pbpaste`.strip.bytes, 17, 31, 73, 47, 23]]
+    ```
+  :replies:
+  - :author: Unihedron
+    :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr10yki/
+    :body: Ah, .each_slice! that was the library method I was missing... I've been trying to use `(0...256).group_by{|x|x/16}.map{|x,y|l[x,16].inject &:^}` and it was not giving me the right thing.
+    :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr113ne/
+  :body: |-
+    Ruby; Trigger warning: state approaching unsalvageable, not even I know what's happening here. I spent way too much time debugging because I used the wrong method to chop up the length-16 blocks.
+
+    ```ruby
+    #v=gets.split(?,).map &:to_i
+    v=(gets&.chomp&.chars&.map(&:ord)||[])+[17, 31, 73, 47, 23]
+    #p v - commented out for day 14
+    #v=[3, 4, 1, 5, 17, 31, 73, 47, 23]
+    g=0
+    t=256
+    l=Array.new(t){|x|x}
+    c=0
+    64.times {
+    v.each{|x|l[0,x]=l[0,x].reverse
+    l=l.rotate(x+c)#drop((x+c)%t)+l.take((x+c)%t)
+    g+=x+c
+    c+=1}
+    }
+    #q=Array.new(16){0}
+    #vv=(t-(g%t))%t
+    #vv=(t-((g)%t))%t
+    vv=g%t
+    l=l.rotate(-vv)
+    p l.each_slice(16).map{|x|x.reduce(&:^).to_s(16).rjust(2,?0)}.join
+    #q=(0...t).group_by{|x|x/16}.map{|x,y|l[x,16].inject &:^}
+    #p q,g,l
+    #p q.map{|x|x.to_s(16).rjust(2,?0)}.join
+    #p l,g,l[(t-(g%t))%t]
+    #p l,g,l[(t-(g%t))%t],l[(t-((g-1)%t))%t],l[(t-(g%t))%t]*l[(t-((g-1)%t))%t],c
+    ```
+  :replies: []
+- :author: mrstickman
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr12r55/
+  :body: |-
+    Ruby 406/677: https://pastebin.com/qPtLqvzB
+
+    - I cleaned it up a little after I got the answer in. For example, the whole problem statement at the top was added after I "finished."
+    - Framework.rb is just a tiny unit testing framework.
+    - According to my stats page, this was some of my slowest work (counting only time spent actually working on the problem and not, say, sleeping or having a life outside of this), but I ranked higher than I ever have. This one's gonna be a weed-out problem for the masses.
+  :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr18nn4/
+  :body: |-
+    ruby! this is the first time i've had problems with understanding the task that weren't due to reading the task too quickly. i had to stare at the part 2 task description for around 30 minutes before i could work out what was actually expected
+
+    ```ruby
+    input = File.read("input").chomp.split(",").map(&:to_i)
+
+    def pinch_and_stuff arr, position, length
+      return if length < 2
+      slice = arr.slice(position, length)
+      slice.concat(arr.slice(0, (position + length) % arr.size))
+      slice.reverse!
+
+      length.times do |i|
+        index = (position + i) % arr.size
+        arr[index] =slice[i]
+      end
+    end
+
+    def round list, input, current_position=0, skip_size=0
+      input.each do |l|
+        pinch_and_stuff list, current_position, l
+
+        current_position += l + skip_size
+        current_position = current_position % list.size
+        skip_size += 1
+      end
+
+      [current_position, skip_size]
+    end
+
+    list = (0..255).to_a
+    round list, input
+
+    puts list[0] * list[1]
+
+    ## part2
+    part2_input = File.read("input").chomp.bytes
+    list = (0..255).to_a
+
+    def get_hash input
+      input.concat [17, 31, 73, 47, 23]
+      list = (0..255).to_a
+
+      64.times.inject([0,0]) { |o| round list, input, *o }
+      dense_hash = list.each_slice(16).map{ |sl| sl.reduce(&:^) }
+      dense_hash.map{|c| c.to_s(16).rjust(2,"0")}.join
+    end
+
+    puts get_hash(part2_input)
+    ```
+  :replies: []
+- :author: skarlso
+  :url: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10_solutions/dr202kk/
+  :body: |-
+    I'm actually happy with this _Ruby_ solution.
+
+    Part 1:
+
+    ```ruby
+    lengths = [187,254,0,81,169,219,1,190,19,102,255,56,46,32,2,216]
+    sequence = (0..255).to_a
+
+    current_position = 0
+    skip_size = 0
+    lengths.each do |l|
+      sequence = sequence.rotate(current_position)
+      sequence[0...l] = sequence[0...l].reverse
+      sequence = sequence.rotate(sequence.size - current_position)
+      current_position = (current_position + l + skip_size) % sequence.size
+      skip_size += 1
+    end
+
+    puts "Result of first two numbers: #{sequence[0]*sequence[1]}"
+    ```
+
+    Part 2:
+
+    ```ruby
+    lengths = '187,254,0,81,169,219,1,190,19,102,255,56,46,32,2,216'.bytes
+    lengths += [17,31,73,47,23]
+    sequence = (0..255).to_a
+
+    current_position = 0
+    skip_size = 0
+    64.times {
+      lengths.each do |l|
+        sequence = sequence.rotate(current_position)
+        sequence[0...l] = sequence[0...l].reverse
+        sequence = sequence.rotate(sequence.size - current_position)
+        current_position = (current_position + l + skip_size) % sequence.size
+        skip_size += 1
+      end
+    }
+
+    p sequence.each_slice(16).map { |c| "%02x" % c.reduce(&:^) }.join
+    ```
+  :replies: []

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

@@ -0,0 +1,18 @@
+---
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/7izym2/2017_day_11_solutions/dr2p7w6/
+  :body: |-
+    # Ruby single-statement
+
+    I made a lot of mistake today and didn’t get into the leaderboard, so I challenged myself to solve this without using a statement terminator (newline or `;`).
+
+    ```ruby
+    # Part 1
+    -> a { -> ((x, y)) { x.abs + [0, (y.abs - x.abs) / 2].max }[a.map { |c| { 'ne' => [1, 1], 'nw' => [-1, 1], 'se' => [1, -1], 'sw' => [-1, -1], 's' => [0, -2], 'n' => [0, 2] }[c] }.transpose.map { |v| v.reduce(&:+) }] }[`pbpaste`.strip.split(',')]
+
+    # Part 2
+    -> a { a.map { |c| { 'ne' => [1, 1], 'nw' => [-1, 1], 'se' => [1, -1], 'sw' => [-1, -1], 's' => [0, -2], 'n' => [0, 2] }[c] }.reduce ([[0, 0]]) { |a, (x, y)| a << [a.last[0] + x, a.last[1] + y] } }[`pbpaste`.strip.split(',')].map { |x, y| x.abs + [0, (y.abs - x.abs) / 2].max }.max
+    ```
+
+    I guess I need to learn more about non-square/cube grids.
+  :replies: []

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

@@ -0,0 +1,110 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr4fte4/
+  :body: |-
+    Ruby, silver 17 / gold 29
+
+    I had the wrong answer on part 2 because I used 100.times again, which forced me to wait 1 minute :( This one was an easy incomplete BFS which assumes all groups can be found in under 100 steps.
+
+    ```ruby
+    g=[0]
+    h={}
+    $<.map{|x|a,b=x.split' <-> '
+    h[a.to_i]=b.split(', ').map &:to_i
+    }
+    l=[]
+    c=0 # part 2
+    loop{ # end part 2
+    100.times{s=[]
+    g.map{|x|s+=h[x]}
+    l+=g
+    g=s-l}
+    c+=1 if h.delete_if{|x,y|l.index x} # part 2
+    l=[]
+    break unless h.keys.any?
+    g=[h.keys.first]
+    } # end part 2
+    p l.size # part 1
+    p l.size,c # part 2
+    ```
+  :replies:
+  - :author: Grimnur87
+    :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr4r78n/
+    :body: Yes, I messed about with 10.times, 20.times etc myself until deciding that an until loop would be more foolproof.
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr4uc90/
+      :body: What we need is a graph library like how python has networkx :)
+      :replies: []
+  - :author: el_daniero
+    :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr5frta/
+    :body: |-
+      Line 3: No need to split each line twice, just `scan` it for number-looking things:
+
+      ```ruby
+      a,*b = x.scan(/\d+/).map(&:to_i)
+      ```
+    :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr4ojpx/
+  :body: |-
+    ruby, in some of the least idiomatic ruby possible!
+
+    ```ruby
+    require 'set'
+    input = File.read("input").chomp.lines
+    group_map = input.each_with_object({}) do |i,hsh|
+      key, *group = i.to_enum(:scan, /(\d+)/).map { Regexp.last_match[1] }
+      hsh[key] = group
+    end
+
+    def process_group first_member, map
+      group = Set.new [first_member]
+      to_process = map[first_member].clone
+
+      until to_process.empty? do
+        p = to_process.pop
+
+        p_links = map[p]
+        if p_links.any? {|pl| group.include? pl } and not group.include?(p)
+          group.add p
+          to_process.concat p_links
+        end
+      end
+      group
+    end
+
+    zero_group = process_group "0", group_map
+    puts zero_group.size
+
+    groups = group_map.keys.each_with_object([]) do |k,coll|
+      coll << process_group(k, group_map) unless coll.any? {|g| g.include?(k)}
+    end
+
+    puts groups.size
+    ```
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/7j89tr/2017_day_12_solutions/dr5g0bl/
+  :body: |-
+    # Ruby
+
+    Clean and to the point, if I may say so myself:
+
+    ```ruby
+    require 'set'
+
+    input = File.readlines('../input12.txt').map { |line| line.scan(/\d+/).map(&:to_i) }
+    programs = Hash.new { |h,k| Set[k] }
+
+    input.each { |ids|
+      sets = programs.values_at(*ids)
+      cluster = sets.reduce(Set.new) { |super_set, set| super_set.merge set }
+
+      cluster.each { |id| programs[id] = cluster }
+    }
+
+    p programs[0].size # Part 1
+    p programs.values.uniq.size # Part 2
+    ```
+  :replies: []

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

@@ -0,0 +1,126 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6ftpy/
+  :body: |-
+    After completely failing to get on the leaderboard since my part 2 code ran too slow, it's time to make it faster. It's too inefficient to iterate each possible starting time one by one!
+
+    Instead, for each period, I look at what starting times are forbidden by scanners with that period and combine all that together.
+
+    For example, for my input, the code determines that my part 2 answer must satisfy two conditions:
+
+    - Congruent to 966862 mod 1441440
+    - Congruent to some number in [0, 2, 6, 8, 10, 12, 16, 18, 20, 22, 24, 26, 28, 30, 32] mod 34
+
+    That first bullet point means I only need to iterate through a few values in order to find the answer that eventually works. (Runs in less than a tenth of a second, as opposed to multiple seconds when iterating by 1 each time)
+
+    (It's Ruby)
+
+    ```ruby
+    depths = (ARGV.empty? ? DATA : ARGF).readlines.map { |x|
+      x.scan(/\d+/).map(&:to_i)
+    }.to_h.freeze
+
+    periods = depths.map { |k, v| [k, 2 * (v - 1)] }.to_h.freeze
+
+    puts periods.select { |k, v| k % v == 0 }.keys.map { |k| k * depths[k] }.sum
+
+    # For a given (depth, period) pair,
+    # we can determine a forbidden starting time:
+    # The starting time is NOT congruent to -depth modulo period.
+    # We combine all these forbidden times by period.
+    def forbidden_starts(periods)
+      periods.group_by(&:last).map { |period, depths|
+        [period, depths.map { |depth, _| -depth % period }.sort]
+      }.to_h
+    end
+
+    # Expand smaller periods into larger ones, then remove the smaller ones.
+    # For example, 2 => [1], 8 => [2, 4, 6] would turn into:
+    # 8 => [2, 4, 6, 1, 3, 5, 7]
+    def absorb_periods(forbidden_starts)
+      periods = forbidden_starts.keys.sort
+
+      periods.each_with_index { |p1, i|
+        expand_into = periods[(i + 1)..-1].select { |x| x % p1 == 0 }
+        next if expand_into.empty?
+        forbidden = forbidden_starts.delete(p1)
+        expand_into.each { |p2|
+          forbidden_starts[p2] |= (0...p2).select { |p| forbidden.include?(p % p1) }
+        }
+      }
+
+      forbidden_starts
+    end
+
+    forbidden_starts = absorb_periods(forbidden_starts(periods))
+
+    single_openings, other_periods = forbidden_starts.partition { |p, ds|
+      ds.size == p - 1
+    }
+
+    # For any periods with only one opening, we can combine them into one big period,
+    # and this big period also only has one opening!
+    base, period = single_openings.sort_by(&:first).reverse.reduce([0, 1]) { |(b, p1), (p2, ds)|
+      allowed_d = (0...p2).find { |d| !ds.include?(d) }
+      b += p1 until b % p2 == allowed_d
+      [b, p1.lcm(p2)]
+    }
+
+    puts base.step(by: period).find { |delay|
+      # Now we only need to check all other periods.
+      other_periods.all? { |p, ds| !ds.include?(delay % p) }
+    }
+
+    __END__
+    0: 3
+    (rest of input omitted, you don't need to see that)
+    ```
+  :replies:
+  - :author: sim642
+    :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6lufv/
+    :body: |-
+      Took me a while to think through how you're calculating this, especially not being familiar with Ruby syntax. Here's what I managed deduce:
+
+      1. Each scanner gives us a congruence `depth + start ≢ 0 (mod 2*(range-1))`, where `depth` and `range` are given for every scanner and `start` is the variable we're looking for. Simply put: `start ≢ -depth (mod period)`.
+      2. The congruences are grouped by their period and combined if one's divisor divides the other. This gives a list of remainders for every given modulo (period) that would lead to being caught.
+      3. Find a period that forbids all remainders except one, that one gives a positive congruence (not a negative one like all the ones we've had so far).
+      4. Futhermore, if there are multiple of such, find them all and combine using the Chinese Remainder Theorem, which now can be used since the congruences are not negated. This is where the lowest common multiple comes in and produces a congruence with a large divisor.
+      5. Just try all values for that large congruence against all the rest until a suitable one is found.
+
+      I have to admit, it is pretty clever but from a mathematical point of view, not too general. The speedup only comes in the case where there are periods that forbid all but one value, hopefully multiple such to get a real big congruence at the end. I wonder if this is the case for the AoC inputs because I'm sure in general one could construct a set of depths and ranges that don't do that and maybe always leave two possible values left, etc. The optimization doesn't help in such case as is but I suppose it could be extended to still be smart enough to only consider such two cases separately and continue the reduction recursively or something. This however still sounds like it can be exponential in general if all periods leave multiple possible remainders.
+    :replies:
+    - :author: p_tseng
+      :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6o0a2/
+      :body: |-
+        Yup, you've got it, both what I've done and the weaknesses of it. Although it was true for my input that there was only one period that allowed \> 1 value, I can't speak for everyone else's inputs. So I'm guilty of specialising a bit.
+
+        Prompted by your idea I decided to write the code that would try to keep track of multiple possible values (https://github.com/petertseng/adventofcode-rb-2017/tree/day13\_multi), but you are right that it's exponential because the number of possible solutions we need to decide between is the product of the numbers of values allowed by each period.
+      :replies: []
+    - :author: thomastc
+      :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6nne8/
+      :body: 'Thanks for the summary. This is the direction I was thinking about while my brute force solution was running. It matches my intuition: because we''re looking for something that''s _not_ equal mod something, the CRT is of limited use, and the best we can do is limit the search space a bit.'
+      :replies: []
+    - :author: pak21
+      :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr7jet2/
+      :body: Certainly my input has a very similar set of results (must be congruent to 967380 modulo 1441440, must be one of 15 values modulo 34), even to the detail where the two missing values modulo 34 are 967380 and 967380 + 1441440, thus also giving me a solution of the form n + 2 \* 1441440.
+      :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6bw7a/
+  :body: |-
+    Ruby; A good day! Even though I screwed up by doing `(x+1)%(correct base)` and had to fix the +1 (wrong intuition), I still solved both parts quickly enough to be on top 20 for both.
+
+    ```ruby
+    h=[]
+    $<.map{|x|h<<[x.to_i,x[/\d+$/].to_i]}
+    s=0
+    c=0
+    q=->c{ # part 2
+      h.each{|x,y|(#p s+=x*y if (x%((y-1)*2))==0 # part 1
+      return) if ((x+c)%((y-1)*2))==0} # part 2
+      p s # part 1
+      p c # part 2
+      exit
+    }
+    q[c+=1] while 1
+    ```
+  :replies: []

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

@@ -0,0 +1,86 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7jpelc/2017_day_14_solutions/dr8fdsd/
+  :body: |-
+    Overslept today, non-competing solution. Nice to get to do this in a relaxed manner for once! ^^ Fun!
+
+    Part 1, "day10" is the file from here: https://www.reddit.com/r/adventofcode/comments/7irzg5/2017_day_10\_solutions/dr113ne/ (I didn't change how it has the `"` character at the start)
+
+    ```ruby
+    input=gets.chomp
+    s=0
+    128.times{|x|
+        result = `echo '#{input}-#{x}'|ruby day10`
+        puts result
+        s+=result[1,99].to_i(16).to_s(2).count('1')
+    }
+    puts s
+    ```
+
+    Part 2 uses a straightforward algorithm which I'm quite proud of - for every line, read all the bits, mark where the used bits are and make temporary groups out of them, then when we read the next line, add group counts when we know a group doesn't connect to anything (and is effectively finalized). It's like a state machine!
+
+    (Were I had been rushing, this would had been a DFS and my code would had been vastly different.)
+
+    ```ruby
+    input=gets.chomp
+    s=0
+    last=nil
+    keys=nil
+    @count=0
+
+    def tally
+        @count += 1
+    end
+    128.times{|x|
+        p line=`echo '#{input}-#{x}'|ruby day10`[1,99].to_i(16).to_s(2).rjust(128,?0)
+
+        if !last
+            left = nil
+            last = line.chars.map{|x|
+                case x
+                when '0'
+                    left = nil
+                when '1'
+                    left || left = tally
+                end
+            }
+            keys = [*1..@count]
+        else
+            # [gid1: int, flag1: bool], [gid2, flag2]...
+            zipped = last.zip(line.chars.map(&'1'.method(:==)))
+            map = {}
+            replace = {}
+            left = nil
+            start = @count + 1
+            p last = zipped.map{|up, down|
+                next left = nil if !down
+
+                keys.delete(up)
+
+                if left
+                    if up
+                        if map.has_key? up
+                            replace[left] = map[up]
+                        else
+                            map[up] = left
+                        end
+                    end
+                    left
+                else
+                    next left = map[up] if up && map.has_key?(up)
+
+                    value = tally
+                    map[up] = value if up
+                    left = value
+                end
+            }
+            s += keys.size
+            if replace.any? then last.map!{|x|replace.has_key?(x) ? replace[x] : x} end
+            keys = last.uniq.compact
+        end
+    }
+    p s+keys.size
+    ```
+
+    A complaint I have on today's challenge is that part 2 doesn't have an example test case that aids debugging. (Also, apparently my wrong answer was the right answer for someone else :D ) For a while, I've been getting 1261 instead of the 1242 in the puzzle input and I couldn't figure out why. For example, having "Considering only the first 10 rows of this example, there would be \_\_\_ regions" would already be a huge help in narrowing down the problem.
+  :replies: []

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

@@ -0,0 +1,75 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7jxkiw/2017_day_15_solutions/dr9ystc/
+  :body: |-
+    Ruby; I'm stupid. I wrote `65535`, thought to myself wait am I right? rewrote it to `1<< ... -1`, ran it, oh yeah it's `65536`, then I freaking went to change it back to 65535 because I **totally have that kind of time**. (silver 101 / gold 60)
+
+    anyway... you've gotta be good at manipulating with bits, right? :D
+
+    ```ruby
+    f=16807
+    g=48271
+    h=2147483647
+    j=65535
+    i=0
+    a=gets[/\d+$/].to_i
+    b=gets[/\d+$/].to_i
+    40000000.times{ # part 1
+    5000000.times{ # part 2
+    loop{a=a*f%h # part 1: only keep this
+    break if a%4<1}
+    loop{b=b*g%h # part 1: only keep this
+    break if b%8<1}
+    i+=1 if 0== (a&j)^(b&j)
+    }
+    p i
+    ```
+  :replies:
+  - :author: raevnos
+    :url: https://www.reddit.com/r/adventofcode/comments/7jxkiw/2017_day_15_solutions/dra1z7s/
+    :body: 0xFFFF works too.
+    :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/7jxkiw/2017_day_15_solutions/dra48m4/
+  :body: |-
+    **ruby**
+
+    that postfix until is nice, i didn't even know that was possible...
+
+    ```ruby
+    VALUES = [873,583]
+    FACTORS = [16807,48271]
+    DENUM = 2147483647
+
+    def part_1
+      matches = 0
+      values = VALUES.clone
+
+      40000000.times do
+        values[0] = values[0] * FACTORS[0] % DENUM
+        values[1] = values[1] * FACTORS[1] % DENUM
+
+        matches += 1 if values[0] & 65535 == values[1] & 65535
+      end
+
+      puts matches
+    end
+
+    def part_2
+      matches = 0
+      values = VALUES.clone
+
+      5000000.times do
+        values[0] = values[0] * FACTORS[0] % DENUM
+        values[1] = values[1] * FACTORS[1] % DENUM
+
+        values[0] = values[0] * FACTORS[0] % DENUM until values[0] % 4 == 0
+        values[1] = values[1] * FACTORS[1] % DENUM until values[1] % 8 == 0
+
+        matches += 1 if values[0] & 65535 == values[1] & 65535
+      end
+
+      puts matches
+    end
+    ```
+  :replies: []