advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2016/17.yml

@@ -0,0 +1,114 @@
+---
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/5isvxv/2016_day_17_solutions/dbb5xbi/
+  :body: |-
+    Ruby. I made the search into a generator which yields all the paths in the order they are found. Then I could call `first` and `max` on the same object to get the answers for part 1 and 2 respectively.
+
+    ```ruby
+    require 'digest'
+
+    CODE = 'lpvhkcbi'
+
+    START = [0,0]
+    TARGET = [3,3]
+    DIRECTIONS = {"U" => [0, -1], "D" => [0, 1], "L" => [-1, 0], "R" => [1, 0]}
+
+    paths = Enumerator.new do |yielder|
+      queue = [[0, '', START]] # moves, path, coordinates
+
+      loop do
+        state = queue.shift
+        break unless state
+
+        moves, path, (x,y) = state
+
+        if [x,y] == TARGET
+          yielder << state
+          next
+        end
+
+        doors_open =
+          Digest::MD5.hexdigest(CODE+path)
+          .chars.take(4)
+          .map { |c| c =~ /[b-f]/ }
+
+        directions = DIRECTIONS.select.with_index { |_, i| doors_open[i] }
+
+        directions.each do |direction, (i, j)|
+          new_x, new_y = x + i, y + j
+          next if new_x < 0 || new_x > 3 || new_y < 0 || new_y > 3
+
+          queue << [moves + 1, path + direction, [new_x, new_y]]
+        end
+      end
+    end
+
+    p paths.first
+    p paths.max
+    ```
+  :replies: []
+- :author: yjerem
+  :url: https://www.reddit.com/r/adventofcode/comments/5isvxv/2016_day_17_solutions/dbarvjw/
+  :body: |-
+    Ruby, 13/11!
+
+    ```ruby
+    require 'digest'
+
+    PASSCODE = 'vwbaicqe'
+
+    last_finished = nil
+    found_shortest = false
+    paths = [["", 0, 0]]
+    until paths.empty?
+      next_paths = []
+      paths.each do |dirs, x, y|
+        md5 = Digest::MD5.hexdigest("#{PASSCODE}#{dirs}")
+        "UDLR".chars.select.with_index { |_, i| "bcdef".include? md5[i] }.each do |dir|
+          path = [dirs + dir, x + {?U=>0,?D=>0,?L=>-1,?R=>1}[dir], y + {?U=>-1,?D=>1,?L=>0,?R=>0}[dir]]
+          next if path[1] < 0 or path[1] >= 4 or path[2] < 0 or path[2] >= 4
+          if path[1] == 3 and path[2] == 3
+            if !found_shortest
+              found_shortest = true
+              puts "Shortest: #{path[0]}"
+            end
+            last_finished = path
+          else
+            next_paths << path
+          end
+        end
+      end
+      paths = next_paths
+    end
+
+    puts "Longest: #{last_finished[0].length}"
+    ```
+  :replies:
+  - :author: mperham
+    :url: https://www.reddit.com/r/adventofcode/comments/5isvxv/2016_day_17_solutions/dbbbt1b/
+    :body: |-
+      Recursion will clean up your code alot.
+
+      ```ruby
+      require 'digest/md5'
+
+      input = "vwbaicqe"
+      $open = "bcdef"
+      $sols = []
+
+      def explore(str, x, y, count)
+        return ($sols << str; true) if x == 3 && y == 3
+
+        doors = Digest::MD5.hexdigest(str)[0...4].chars
+
+        explore(str + ?U, x, y-1, count+1) if y > 0 && $open.index(doors[0])
+        explore(str + ?D, x, y+1, count+1) if y < 3 && $open.index(doors[1])
+        explore(str + ?L, x-1, y, count+1) if x > 0 && $open.index(doors[2])
+        explore(str + ?R, x+1, y, count+1) if x < 3 && $open.index(doors[3])
+      end
+
+      explore(input, 0, 0, 0)
+
+      p $sols.sort_by {|x| x.size }.last.size - input.size
+      ```
+    :replies: []

data/data/solutions/reddit/ruby/2016/18.yml

@@ -0,0 +1,129 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/5iyp50/2016_day_18_solutions/dbc4udx/
+  :body: |-
+    My first naive solution takes about 17 seconds to finish part 2. Once again, this is unacceptably slow.
+
+    My first thought was to check whether there were any repeating patterns in the rows generated... NOPE, not in any of my 400000 rows. There goes that idea.
+
+    You know what? Let's make a silly\* solution. We'll:
+
+    - store the input row in blocks of ten, because that evenly divides 100 and in my testing it seemed to work well (20 performed worse! why?)
+    - precompute every block of twelve -\> block of ten transformation
+    - precompute every block of ten -\> safe count
+    - reuse the same two arrays (one for the old row, one for the new row) to avoid allocations
+
+    For each block in the new row, use the corresponding block in the old row and one bit each from the surrounding blocks to look up what the block in the new row will be. Let's go.
+
+    ```ruby
+    # Store rows in blocks of this size.
+    # 1 = trap, 0 = safe.
+    # Within each block, characters on the left are the most significant bits.
+    BLOCK = 10
+
+    # We'll pre-compute every single block of 12 -> 10,
+    # since 4096 entries in a table is easy.
+    RULE = (0...(1 << BLOCK + 2)).map { |i|
+      (0...BLOCK).select { |j|
+        (i >> j) & 1 != (i >> j + 2) & 1
+      }.map { |j| 1 << j }.reduce(0, :|)
+    }.freeze
+
+    SAFE_COUNT = (0...(1 << BLOCK)).map { |i| BLOCK - i.to_s(2).count(?1) }.freeze
+
+    input = ARGV.first || '...^^^^^..^...^...^^^^^^...^.^^^.^.^.^^.^^^.....^.^^^...^^^^^^.....^.^^...^^^^^...^.^^^.^^......^^^^'
+
+    prev_row = input.each_char.each_slice(BLOCK).map { |slice|
+      slice.reduce(0) { |i, c| i << 1 | (c == ?^ ? 1 : 0) }
+    }
+
+    safe = prev_row.map { |block| SAFE_COUNT[block] }.reduce(:+)
+
+    current_row = Array.new(prev_row.size)
+
+    [39, 399960].each { |n|
+      n.times {
+        window = 0
+        current_row.size.times { |i|
+          window = (window << BLOCK | prev_row[i] << 1 | (prev_row[i + 1] || 0) >> BLOCK - 1) & (1 << BLOCK + 2) - 1
+          current_row[i] = RULE[window]
+          safe += SAFE_COUNT[current_row[i]]
+        }
+        prev_row, current_row = [current_row, prev_row]
+      }
+      puts safe
+    }
+    ```
+
+    Yeah, 1.5 seconds!
+
+    \*: Why is this silly? You would think all these ideas are reasonable. But the answer is that you could consider it silly because it's only going halfway. If we're going to store them in blocks of 10, why not [blocks of 100](https://www.reddit.com/r/adventofcode/comments/5iyp50/2016_day_18_solutions/dbc0l6j/)? Yes, the Ruby translation of that code works just fine. Thank the people who did automatic BigNum conversions, etc.
+
+    My answer is always "it's as silly as you'd like it to be".
+
+    ```ruby
+    input = ARGV.first || '...^^^^^..^...^...^^^^^^...^.^^^.^.^.^^.^^^.....^.^^^...^^^^^^.....^.^^...^^^^^...^.^^^.^^......^^^^'
+
+    row = input.each_char.reduce(0) { |i, c| i << 1 | (c == ?^ ? 1 : 0) }
+    mask = 2 ** input.size - 1
+
+    safe = input.size - row.to_s(2).count(?1)
+
+    [39, 399960].each { |n|
+      n.times {
+        row = ((row << 1) ^ (row >> 1)) & mask
+        safe += input.size - row.to_s(2).count(?1)
+      }
+      puts safe
+    }
+    ```
+
+    About half a second. Not as good as the compiled C code, which takes about 7 milliseconds, but it'll do.
+  :replies: []
+- :author: eregontp
+  :url: https://www.reddit.com/r/adventofcode/comments/5iyp50/2016_day_18_solutions/dbcb1ln/
+  :body: |-
+    Ruby one-liner. I find it rather readable for a golfed solution.
+
+    ```ruby
+    f=false;t=0;b=r.bytes.map{|e|e==94};n.times{t+=b.count(f);b=[f,*b,f].each_cons(3).map{|a,_,c|a!=c}};p t
+    ```
+  :replies: []
+- :author: johneffort
+  :url: https://www.reddit.com/r/adventofcode/comments/5iyp50/2016_day_18_solutions/dbcpya7/
+  :body: |-
+    Ruby, quite readable, not very fast, but doable. 30s for part 2
+
+    ```ruby
+    def process(start, row_count)
+      rows = [start]
+      while (rows.length < row_count)
+        puts rows.length if rows.length % 100 == 0
+        old_row = rows.last
+        new_row = [false] * old_row.length
+        new_row.each_with_index do |tile, i|
+          left,center,right = get_tiles(old_row, i)
+           trap = ((left && center && !right) || (center && right && !left) || (left && !center && !right) || (!left && !center && right))
+           new_row[i] = trap
+        end
+        rows << new_row
+      end
+      puts rows.flatten.count{|r| !r}
+    end
+
+    def get_tiles(old_row, i)
+      left = i > 0 ? old_row[i-1] : false
+      center = old_row[i]
+      right = (i < (old_row.length - 1)) ? old_row[i + 1] : false
+      [left,center,right]
+    end
+
+    input =".^^.^.^^^^"
+    values = input.chars.map{|c|c =="^"}
+    process(values, 10)
+
+     input = ".^^^^^.^^.^^^.^...^..^^.^.^..^^^^^^^^^^..^...^^.^..^^^^..^^^^...^.^.^^^^^^^^....^..^^^^^^.^^^.^^^.^^"
+     values = input.chars.map{|c|c =="^"}
+     process(values, 400000)
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2016/19.yml

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

data/data/solutions/reddit/ruby/2016/20.yml

@@ -0,0 +1,82 @@
+---
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/5jbeqo/2016_day_20_solutions/dbfo4nb/
+  :body: |-
+    **Ruby**. Clean as I could and covering any corner cases.
+
+    ```ruby
+    def overlap?(range1, range2)
+      min, max = [range1, range2].minmax_by(&:first)
+      min.cover?(max.first) || min.last + 1 == max.first
+    end
+
+    def merge_overlapping_ranges(*ranges)
+      starts, stops = ranges.map { |range| [range.first, range.last] }.transpose
+      Range.new(starts.min, stops.max)
+    end
+
+    def merge_ranges(ranges)
+      ranges.reduce([]) do |processed, current|
+        overlapping, distinct = processed.partition { |range| overlap?(range, current) }
+        merged = merge_overlapping_ranges(current, *overlapping)
+        [merged, *distinct]
+      end
+    end
+
+    filename = ARGV[0] || 'input/20.txt'
+    input = File.open(filename).each_line.map { |line| Range.new(*line.split('-').map(&:to_i)) }
+
+    blacklist = merge_ranges(input)
+
+    # Part 1
+    p blacklist.min_by(&:first).last + 1
+
+    # Part 2
+    p 2**32 - blacklist.reduce(0) { |count, range| count + range.size }
+    ```
+  :replies:
+  - :author: anonymous_4_custody
+    :url: https://www.reddit.com/r/adventofcode/comments/5jbeqo/2016_day_20_solutions/dbjdm3n/
+    :body: |-
+      > Ruby
+
+      Here's mine. Similar, but I sorted before I merged.
+
+      ```ruby
+      module BlockedIps
+        module_function
+
+        def sort(ranges)
+          ranges.sort { |one,two| one.min <=> two.min }
+        end
+
+        def overlap_upper_bound(ranges)
+          ranges.max_by {|x| x.max }.max
+        end
+
+        def consolidate_overlaps(ranges)
+          range_changed = 0
+          while range_changed != ranges.size
+            range_changed = ranges.size
+            ranges = sort(ranges)
+              .chunk_while { |first,second| first.max + 1 >= second.min }
+              .map { |overlapping_ranges|
+                (overlapping_ranges.first.min..overlap_upper_bound(overlapping_ranges))
+              }
+          end
+          ranges
+        end
+
+        def smallest_allowed(ranges)
+          consolidate_overlaps(ranges).first.max+1
+        end
+
+        def count_all_allowed(ranges)
+          consolidate_overlaps(ranges)
+            .each_cons(2)
+            .inject(0) { |counter,(n1,n2)|( (n1.max + 1)...n2.min).size + counter }
+        end
+
+      end
+      ```
+    :replies: []

data/data/solutions/reddit/ruby/2016/21.yml

@@ -0,0 +1,121 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbge41p/
+  :body: |-
+    Full disclosure: Of course for the leaderboard placement I will brute force the password by trying every permutation of abcdefgh. It makes sense to do that because we have the forward process programmed and "do not have time" to make the reverse process. At least, it would probably take more time to make the reverse process than to just brute force.
+
+    But now that the leaderboard pressure is off, I went ahead and did an implementation that can run the instructions in reverse. Behold:
+
+    ( **Ruby** )
+
+    ```ruby
+    def apply(instructions, input, undo: false)
+      instructions.reduce(input.dup) { |pw, (cmd, *args)|
+        case cmd
+        when :swap_letter
+          # Undo == do
+          pw.tr(args.join, args.join.reverse)
+        when :swap_position
+          # Undo == do
+          i, j = args
+          pw[i], pw[j] = [pw[j], pw[i]]
+          pw
+        when :rotate_right
+          pw.chars.rotate(args[0] * (undo ? 1 : -1)).join
+        when :rotate_left
+          pw.chars.rotate(args[0] * (undo ? -1 : 1)).join
+        when :rotate_based
+          i = pw.index(args[0])
+          if undo
+            # rotate_based needs the most work to undo.
+            # pos shift newpos
+            # 0 1 1
+            # 1 2 3
+            # 2 3 5
+            # 3 4 7
+            # 4 6 2
+            # 5 7 4
+            # 6 8 6
+            # 7 9 0
+            # all odds have a clear pattern, all evens have a clear pattern...
+            # except 0, which we'll just special-case.
+            rot = i / 2 + (i % 2 == 1 || i == 0 ? 1 : 5)
+          else
+            rot = -(i + 1 + (i >= 4 ? 1 : 0))
+          end
+          pw.chars.rotate(rot).join
+        when :reverse_positions
+          # Undo == do
+          c = pw.chars
+          s, e = args
+          c[s..e] = c[s..e].reverse
+          c.join
+        when :move_position
+          from, to = undo ? args.reverse : args
+          c = pw.chars
+          ch = c.delete_at(from)
+          c.insert(to, ch)
+          c.join
+        else raise "Unknown command #{cmd} #{args}"
+        end
+      }
+    end
+
+    instructions = (ARGV.empty? ? DATA : ARGF).readlines.map { |l|
+      words = l.split
+      interesting = words.select { |w| w.size == 1 }.map { |w| w =~ /\d+/ ? w.to_i : w }
+      [words[0..1].join(?_).to_sym] + interesting
+    }
+
+    puts apply(instructions, 'abcdefgh')
+    puts apply(instructions.reverse, 'fbgdceah', undo: true)
+    ```
+
+    As far as I can tell, there is only one unique solution for any given input (please correct if I am wrong).
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbge6w8/
+    :body: |-
+      > As far as I can tell, there is only one unique solution for any given input
+
+      All of the functions _should_ be perfectly reversible. I tried to be quite careful about that.
+    :replies:
+    - :author: daniel-sd
+      :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbges98/
+      :body: |-
+        For size 8 this is true. But for the sample size (5), rotate around letter is not always reversible.
+
+        Take both 'acbde' and 'acdeb' and rotate based on position of b
+
+        ```ruby
+        01234
+        acbde
+        ```
+
+        rotation = 2 + 1 + 0 = 3 result = 'bdeac'
+
+        ```ruby
+        acdeb
+        01234
+        ```
+
+        rotation = 4 + 1 + 1 = 6 result = 'bdeac'
+
+        Unfortunately practicing with the sample input was quite confusing for this one.
+      :replies:
+      - :author: BumpitySnook
+        :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbgf1py/
+        :body: Your puzzle input wasn't abcde, though. Topaz controls the inputs and the scrambling recipe.
+        :replies: []
+      - :author: topaz2078
+        :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbgfoqx/
+        :body: For the second part, you can use the example generator you wrote in part 1. Furthermore, your input is the process, not the string - the string you're working on is the same for everyone.
+        :replies: []
+      - :author: bildzeitung
+        :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbgexsx/
+        :body: That's the gotcha -- size 8 is key to making that rule work. Eric's mapping function is unique over that string length.
+        :replies: []
+      - :author: eregontp
+        :url: https://www.reddit.com/r/adventofcode/comments/5ji29h/2016_day_21_solutions/dbhak5z/
+        :body: 'And indeed, for the example output (decab), there are two valid inputs: abcde and deabc.'
+        :replies: []

data/data/solutions/reddit/ruby/2016/22.yml

@@ -0,0 +1,190 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhw73s/
+  :body: |-
+    Those compatible pairs that we were asked to print out in part 1? [You know something funny about them?](#s "They all involve the empty disk!!!"). So this game devolves into "how can we move the data with only one disk empty at a time?", sort of like those [sliding tile puzzles](https://en.wikipedia.org/wiki/15_puzzle).
+
+    For leaderboard placement: Printed out my grid (preserved in my code as `-m` flag), and solved it by hand (move empty to top, avoid walls, use math to figure out how many more moves are needed to get data out)
+
+    Edit: And let me just confirm that I breathed a huge sigh of relief when I found that my math was correct, because otherwise I anticipated this would have been a long slog of a puzzle. I did not make my above discovery until after having mathed my way onto the leaderboard.
+
+    **Ruby** code that automates what I did by hand.
+
+    Raises an exception if:
+
+    - There is a compatible pair not involving an empty disk
+    - (Edit: newly added this) There is a wall on the top two rows
+
+    since either condition breaks the math.
+
+    ```ruby
+    SHOW_MAP = ARGV.delete('-m')
+
+    Node = Struct.new(:x, :y, :size, :used, :avail, :use_pct)
+
+    nodes = (ARGV.empty? ? DATA : ARGF).each_line.drop(2).map { |l|
+      node = l.chomp.scan(/\d+/).map(&:to_i)
+      raise "Not a df line: #{l}" unless node.size == 6
+      Node.new(*node).freeze
+    }
+
+    HEIGHT = nodes.map(&:y).max + 1
+    WIDTH = nodes.map(&:x).max + 1
+
+    # We could exploit the fact that the nodes come in order,
+    # but let's be safe.
+    GRID = Array.new(HEIGHT) { Array.new(WIDTH) }
+    nodes.each { |n| GRID[n.y][n.x] = n }
+    GRID.each(&:freeze).freeze
+
+    pairs = nodes.permutation(2).select { |a, b|
+      aused = a[:used]
+      aused != 0 && aused <= b[:avail]
+    }
+
+    puts pairs.size
+
+    nonempty_pairs = pairs.select { |a, b| b.used > 0 }
+    unless nonempty_pairs.empty?
+      nonempty_pairs.each { |a, b| puts "Should move #{a} => #{b}" }
+      # We're raising here simply because it will break the below algorithm.
+      # If any input has a pair with non-empty recipient, we should use it.
+      # But the below code can't smartly decide which pairs to use
+      # (in case one recipient could take from multiple senders)
+      raise 'non-empty pairs found, code needs to take them into account'
+    end
+
+    empties = nodes.select { |n| n.used == 0 }
+
+    def assert_no_walls(nodes)
+      largest = nodes.max_by(&:used)
+      too_small = nodes.select { |n| n.size < largest.used }
+      return if too_small.empty?
+      puts too_small
+      raise "#{too_small.size} nodes can't take data of #{largest}"
+    end
+
+    def naive_move_to_top(empty)
+      start = [empty.y, empty.x]
+      queue = [start]
+      dist = {start => 0}
+
+      while (pos = queue.shift)
+        y, x = pos
+        my_size = GRID[y][x].size
+        return [dist[pos], x] if y == 0
+        [
+          ([y - 1, x] if y > 0),
+          ([y + 1, x] if y + 1 < HEIGHT),
+          ([y, x - 1] if x > 0),
+          ([y, x + 1] if x + 1 < WIDTH),
+        ].compact.each { |n|
+          ny, nx = n
+          next if dist.include?(n) || GRID[ny][nx].used > my_size
+          dist[n] = dist[pos] + 1
+          queue << n
+        }
+      end
+    end
+
+    # For the below math to work, there must be no walls in the top two rows.
+    assert_no_walls(GRID[0..1].flatten)
+
+    puts empties.map { |empty|
+      # Naively move the empty spot to y=0. What x does it end up at?
+      steps, x = naive_move_to_top(empty)
+      # Move to (WIDTH - 2, 0), one to the left of the goal.
+      steps += WIDTH - 2 - x
+      # 1 step moves the goal data into (WIDTH - 2, 0), with empty space behind.
+      steps += 1
+      # 4 steps each to move the empty space from behind to in front,
+      # 1 step to move the goal data
+      steps + 5 * (WIDTH - 2)
+    }.min
+
+    puts GRID.map { |row|
+      row.map { |node|
+        wall = empties.none? { |e| node.used <= e.size }
+        wall ? ?# : node.used == 0 ? ?_ : ?.
+      }.join
+    } if SHOW_MAP
+    ```
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhwjaw/
+    :body: |-
+      > They all involve the empty disk.
+
+      Could it be a clue?!
+    :replies: []
+  - :author: pedrosorio
+    :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhwe0d/
+    :body: |-
+      > Those compatible pairs that we were asked to print out in part 1? They all involve the empty disk.
+
+      That's it, from now on in advent of code, if asked about number of things X, I am always going to print the list of things X :P
+    :replies:
+    - :author: topaz2078
+      :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhx3so/
+      :body: That is a _really_ good strategy. Many of the puzzles' part 1 is just a stepping stone to make sure you're on-track for part 2.
+      :replies: []
+  - :author: BumpitySnook
+    :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhwvxz/
+    :body: |-
+      Your solution arrives at 225 steps for my input, as does /u/drysle 's. My solution and hand solution get 224. The website says neither is correct. /u/topaz2078 , help? Input is here: http://dpaste.com/0JHB11A
+
+      Printed it looks like this:
+
+      ```ruby
+      !...............................G
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      .................................
+      ....#############################
+      .................................
+      ...............E.................
+      ```
+    :replies:
+    - :author: topaz2078
+      :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhx0cw/
+      :body: For part two, I get 225, and that's also what the site is expecting.
+      :replies:
+      - :author: BumpitySnook
+        :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhxarn/
+        :body: I swear I entered 225 into the site and got 'Wrong'. Doh. Must have typoed it.
+        :replies:
+        - :author: "[deleted]"
+          :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbiew3r/
+          :body: Did you get the right answer? I counted yours and got 232. Is it right?
+          :replies:
+          - :author: BumpitySnook
+            :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbif5yn/
+            :body: As topaz says, 225 is correct.
+            :replies: []
+  - :author: Quick_Question404
+    :url: https://www.reddit.com/r/adventofcode/comments/5jor9q/2016_day_22_solutions/dbhww4u/
+    :body: I immediately thought of the sliding tile puzzle when seeing this problem, but couldn't think of any way to programatically solve it.
+    :replies: []

data/data/solutions/reddit/ruby/2016/23.yml

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

data/data/solutions/reddit/ruby/2016/24.yml

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

data/data/solutions/reddit/ruby/2016/25.yml

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