advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,77 @@
+---
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/hocnwwo/
+  :body: |-
+    I found this to be a great way to learn and improve recursive functions. I still have a ways to go, but I got there. Barely!
+
+    [Ruby @ github](https://github.com/ttilberg/advent-of-code-2021-rb/blob/main/2021/12/2.rb)
+  :replies: []
+- :author: JRX71
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/ho92eff/
+  :body: "[Ruby](https://gist.github.com/JX71/3d92a1833fcc26ad96e779213d2e6de8) attempt to be readable (part 2 only)"
+  :replies: []
+- :author: SnooConfections2453
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/ho93rd3/
+  :body: 'My solution in 50 lines of ruby: https://github.com/ciscou/aoc/blob/master/2021/12.rb'
+  :replies: []
+- :author: AMusingMule
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/hoa347u/
+  :body: |-
+    # [Ruby](https://gist.github.com/kaine119/8bec5cbe2d97868da16a84744e5b7e38)
+
+    Simple recursive DFS solution. I kinda cheesed part 2 by running it once per lowercase node to allow one duplication of said node; it takes a solid 1s longer to run than part 1. It's not very efficient because of all the duplicate paths, but I couldn't think of anything else.
+  :replies:
+  - :author: ignurant
+    :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/hocnsge/
+    :body: |-
+      Thanks for sharing. I was having a hard time figuring out how to resolve completed routes in the recursive function. I’m not fluent with building up recursive stuff, but I figured it was something like what you had (building up another argument for completed routes). I tried something similar to that, but ended up having an issue where only one route per top level iteration was returning. I couldn’t figure out the “return completed and this route” at the exit clause, and then also return the completed routes at the bottom. Getting closer!
+
+      Anyway, here was my solution where I mapped in order to resolve that problem, and then had to write a recursive “untangle the mess function” haha: https://github.com/ttilberg/advent-of-code-2021-rb/blob/main/2021/12/2.rb
+    :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/ho7pzfq/
+  :body: |-
+    Ruby 1099/850
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDVBAAAAAAAAAA5GUqKNoFH6SMqoVC09YWR20g6Fjy4njtAfnTDe/6u+Gn6Hao+wfKaqM0wJb78UXSXizCPo0tcdH0rfhLBF6BTkXIFTL6rf7HEcSdt5ZfjquN7hRg1AhqdG//1XW/PovXWc9z7V6w0l8vDPMoWsQzxkK7SDwijpdVfBFBPsvpjfiY2EUF+A3TmE8Pr1J3s3tkCjFbOuNKZ+Clq7D1gkhjTKsfTzUAuJ93MJOwEufcbRVFsz8l3LyL7Citin18CKKZiaqxWbKMTiUiQW+rNncoMojomjGzddZ2upJCmH7xGyf5eXEOv1/xl116tJ1mWxPDzqNAlOAVx3rR4tkskw6EKaGzeIdcy1a9sdgBSqaeIVC5dTWGPW7BzcQf0/mpZUK1/TVeLqNgTK+CEX6ulmeTFQeabAiBHRs4Zr7tOWU2DuYzmPDOPHFKmt8Pkoeobpn8naMoOpO94k2fSPOefcwuTsWdAfrtuvxVgx7ZsuRLeqrNq7Dd1rTVXOmyKLk5mKX20tjcnzlRPwGzXz7Uej5XTgVe5cPzllibf5EZ9/++jv6k=)
+  :replies: []
+- :author: MuumiJumala
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/ho7rg14/
+  :body: |-
+    Recursive Ruby solution (296/458):
+
+    ```ruby
+    cavemap = Hash.new{|h,k|h[k]=[]}
+    input = File.open('input.txt').read.split.each do |line|
+        a, b = line.split('-')
+        cavemap[a] << b
+        cavemap[b] << a
+    end
+
+    def small?(cave) = cave.match?(/^[a-z]+/)
+
+    def countpaths(graph, doubled, visited, from, to)
+        return 1 if from == to
+        if visited.include?(from)
+            return 0 if doubled || from == 'start'
+            doubled = true
+        end
+        graph[from].sum do |dest|
+            countpaths(graph, doubled, small?(from) ? visited + [from] : visited, dest, to)
+        end
+    end
+
+    # Part 1
+    puts countpaths(cavemap, true, [], 'start', 'end')
+
+    # Part 2
+    puts countpaths(cavemap, false, [], 'start', 'end')
+    ```
+  :replies: []
+- :author: dhruvasagar
+  :url: https://www.reddit.com/r/adventofcode/comments/rehj2r/2021_day_12_solutions/ho8030p/
+  :body: |-
+    Nice and easy
+
+    [Ruby](https://github.com/dhruvasagar/comp/blob/master/adventofcode/2021/day12/day12.rb)
+  :replies: []

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

@@ -0,0 +1,260 @@
+---
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hohjrdx/
+  :body: |-
+    **Ruby** : _Unofficial_ 5:07/7:04, which would have been good for 49th and 21st on the leaderboard
+
+    Here's a [recording](https://youtu.be/5S-EO_7IyxM) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec13.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    I wasn't able to do this one live, but I timed myself when I did it. This would have been my best performance by FAR! Major bummer.
+
+    My biggest time loss was from accidentally deleting a line from my stub file.
+  :replies: []
+- :author: blackbunbun
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hogogq8/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    points, folds = File.read('input.txt').split("\n\n")
+
+    points = points.lines.map {|coords| coords.split(',').map(&:to_i) }
+    folds = folds.lines.map {|fold| fold.match(/(x|y)=(\d+)$/).captures }
+
+    max_x = points.collect(&:first).max
+    max_y = points.collect(&:last).max
+
+    grid = []
+    (max_y + 1).times { grid << Array.new(max_x + 1, 0) }
+
+    points.each {|x,y| grid[y][x] = 1 }
+
+    def fold(grid, dir, index)
+      m = dir == 'x' ? grid.map {|row| row[...index] } : grid[...index]
+      n = dir == 'x' ? grid.map {|row| row[index...].reverse } : grid[index...].reverse
+      m.zip(n).map {|m_row,n_row| m_row.zip(n_row).map(&:max) }
+    end
+
+    dir, index = folds.shift
+    grid = fold(grid, dir, index.to_i)
+
+    puts "Part 1: #{grid.map(&:sum).sum}"
+
+    folds.each do |dir,index|
+      grid = fold(grid, dir, index.to_i)
+    end
+
+    puts "Part 2:"
+    grid.each {|row| row.each {|col| print col == 1 ? '#' : ' ' }; print "\n" }
+    ```
+  :replies: []
+- :author: tom_collier2002
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hoe3xs1/
+  :body: |-
+    [Ruby solution using complex numbers](https://github.com/tcollier/aoc_solutions/blob/main/2021/13/main.rb)
+
+    Using ruby's built-in `Complex#conjugate` I was able to write a clean folding method
+
+    ```ruby
+    def fold(dots, axis)
+      dots.map do |dot|
+        if axis.real.between?(1, dot.real)
+          2 * axis - dot.conjugate
+        elsif axis.imag.between?(1, dot.imag)
+          2 * axis + dot.conjugate
+        else
+          dot
+        end
+      end.to_set
+    end
+    ```
+
+    Lots of people were struggling reading the output for part 2 when printing with `#` and `.` characters, so I wrote [my own OCR](https://github.com/tcollier/aoc_solutions/blob/main/2021/13/ocr.rb). Granted I made up a few of the characters (`M` and `W` ain't looking too hot), so I can't guarantee it'll work for every input.
+  :replies:
+  - :author: tom_collier2002
+    :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hoe6461/
+    :body: |-
+      The complex conjugate reflects the point around the real axis (`a + bi` become `a - bi`). The folding `axis` in my code is either purely real or purely imaginary (`a + 0i` or `0 + bi`) and `2 * axis` is effectively the far end of the paper that will be folded over.
+
+      When folding in the `y` direction (`elsif axis.imag.between?(1, dot.imag)`) the real part of `axis` is `0`, so the real result of the expression is simply the real part of `dot`. The imaginary part of the expression is the difference between `2 * axis` (i.e. the opposite edge of the paper) and the imaginary part of `dot` (which is a negative number after taking `Complex#conjugate`). In short we keep the real part of `dot` and find the distance between the far edge of the paper and the `dot` along the imaginary axis.
+
+      The math for folding in the `x` direction (`axis.real.between?(1, dot.real)`) is similar. However, we need to reflect the dot around the _imaginary_ axis. To accomplish this we can rotate the complex conjugate `π` radians. Multiply a complex number by `i` rotates the number by `π/2` radians, we need to do that twice (`i * i`), which is the same as multiplying by `-1`.
+    :replies: []
+  - :author: tom_collier2002
+    :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hoe7evc/
+    :body: |-
+      I wrote the OCR code after initially printing out the result using `#` and `.` characters. It felt like reading a Captcha (Is that a `U` or a `V`?! I sweat I'm not a bot!). A few coworkers also posted their part 2 results in a similar format, which gave me examples of roughly half the alphabet to "train" my OCR code with. About half of the remaining letters were pretty easy to guess at (though they could still be wrong).
+
+      Finally, since we only have a 4 "pixel" width, characters like `M` and `W` didn't have enough width for all the required detail. Also, vertically symmetric characters like `I`, `T` and `Y` would look better using an odd pixel width so I either had to leave a column unused or make the character asymmetrical around the vertical axis.
+
+      Edit: the OCR fails on the sample input as the `O` character has a width of 5 pixels :(
+    :replies: []
+- :author: kejadlen
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hociv59/
+  :body: |-
+    Ruby:
+
+    ```ruby
+    dots, folds = ARGF.read.split("\n\n")
+
+    dots = dots.scan(/(\d+),(\d+)/).map { _1.map(&:to_i) }
+    folds = folds.scan(/(x|y)=(\d+)/).map { [_1, _2.to_i] }
+
+    dirs = { ?x => 0, ?y => 1 }
+    folds.each do |dir, axis|
+      index = dirs.fetch(dir)
+      dots.select { _1[index] > axis }.each do |dot|
+        dot[index] = axis - (dot[index] - axis)
+      end
+      dots.uniq!
+      # p dots.size or exit
+    end
+
+    xx = Range.new(*dots.map(&:first).minmax)
+    yy = Range.new(*dots.map(&:last).minmax)
+    puts yy.map {|y| xx.map {|x| dots.include?([x,y]) ? "█" : " " }.join }.join("\n")
+    ```
+  :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hodvyvn/
+  :body: |-
+    **Ruby** :
+
+    This one went well, which I'm glad for because I found the previous two more difficult.
+
+    ```ruby
+    dots, directions = File.read('input.txt').split("\n\n").map{|section| section.split("\n")}
+
+    dots.map! {|dot| dot.split(',').map(&:to_i)}
+
+    directions.each do |direction|
+      axis, amp = direction[/[xy]=\d+/].split('=')
+      amp = amp.to_i
+
+      p "Folding #{axis} at #{amp}"
+
+      # Create the crease line
+      dots.reject{|x, y| (axis == 'x' ? x : y) == amp }
+
+      # Separate the top/left from the bottom/right
+      a, b = dots.partition{|x, y| (axis == 'x' ? x : y) < amp}
+
+      b.map! do |x, y|
+        case axis
+        when 'x'
+          [x + 2 * (amp - x), y]
+        when 'y'
+          [x, y + 2 * (amp - y)]
+        end
+      end
+
+      dots = (a + b).uniq
+    end
+
+    x_max = dots.max_by{|x, y| x }[0]
+    y_max = dots.max_by{|x, y| y }[0]
+
+    (0..y_max).each do |y|
+      (0..x_max).each do |x|
+        print dots.include?([x, y]) ? '■' : ' '
+      end
+      print $/
+    end
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hocf83u/
+  :body: |-
+    Ruby, 46 / 10
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBHAwAAAAAAAAARiAbIwVXFxjAHV4imsypiJuz6/+IEIy7rTsLLfhuNEAxYhyw4F82R76RPshGKTUBSf3YjhjC5Tj9WAOFYiECgvZsopP2yESwt9zJV4XNHRB4n2IcJbCTlae5DqLuAk1IWj/RgAHLIJ0Spk9CbJgiYqtCZgU+Kqg/CuWfJnHx60tK7ZArfEfg+msG5yU2hRFdY8oC7ySROoA9Sj5kzpeQID4UelObSGbw++oCaDTQDhoV4F+2XWJFHbCluVLCocjzrZdcSd0ak8VQitgnyEMi37hO2PxgSkgePCoE2vFq33N2JdkWrLxwKOusx/PP/vh72/maSYE0ARZ+vShuWMm0EbVv9wOIYTrBRanh2QtaYGfijUhE3A4byVx202dAW9L5WdC2zyWPik8cxjENqqlYApYyk1Wuz9JHWj6878nSRu6c25w820eLFfng90zJehpp2irrXzvU4GS0UQvAxaNZD/vy/HK9n3yMOiXnjuERSlMQbUQ0eIM7BCbCjUP/H3RPd)
+
+    - Parsing is done using `String#scan(regex)`. GitHub Copilot helped me write part of the input parsing code. (And helped me avoid typing mistakes when dealing with nested for loops.)
+    - I spent quite some time writing the `plot[]` function while working on part 1. Glad to see it came really handy in part 2.
+  :replies: []
+- :author: dhruvasagar
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hociz5m/
+  :body: Yay! [Ruby](https://github.com/dhruvasagar/comp/blob/master/adventofcode/2021/day13/day13.rb)
+  :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hocka3h/
+  :body: |-
+    ### Ruby
+
+    I give you the power of `Hash#transform_keys!` (which will automatically deduplicate any points that overlap!)
+
+    ```ruby
+    fold = ->(v, along) { v <= along ? v : 2 * along - v }
+
+    case dim
+    when ?x; dot.transform_keys! { |x, y| [fold[x, along], y].freeze }
+    when ?y; dot.transform_keys! { |x, y| [x, fold[y, along]].freeze }
+    ```
+
+    Full code at https://github.com/petertseng/adventofcode-rb-2021/blob/master/13_transparent_origami.rb
+
+    There's a weird story about why my part 1 rank is much higher than my part 2 rank. For part 1, I just transformed with `(x - along).abs`, which gives you the correct number of points, but mangles the coordinates too much for them to show up in part 2. So for part 2 I had to slow down a bit and determine the right equation for actually transforming.
+
+    ### Haskell
+
+    In a similar vein, I give you the power of `Set.map`.
+
+    ```ruby
+    foldAlong :: Set Point -> (Point -> Point) -> Set Point
+    foldAlong = flip Set.map
+
+    let foldedPoints = scanl foldAlong (Set.fromList (map point points)) (map fold folds)
+    ```
+
+    Full code at https://github.com/petertseng/adventofcode-hs-2021/blob/master/bin/13_transparent_origami.hs
+  :replies:
+  - :author: Sharparam
+    :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hocn7yo/
+    :body: |-
+      TIL about `Hash.transform_keys`.
+
+      I was using a hash at first in my Ruby solution then rewrote to use a `Set`: https://github.com/Sharparam/advent-of-code/blob/main/2021/13/solve.rb
+
+      (The commit history for that file shows a bit of how it changed since initial solve.)
+    :replies: []
+- :author: scarfaceDeb
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hocqo2l/
+  :body: |-
+    **Ruby**
+
+    I decided to go with the matrix because it was easier to work with. But I can see a way to do it with just simple math.
+
+    https://github.com/scarfacedeb/advent-of-code/blob/master/2021/day13/run.rb#L3-L80
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rf7onx/2021_day_13_solutions/hoctwgk/
+  :body: |-
+    **Ruby**
+
+    I only realized _after_ solving the problem that there's no need to initialize a 1500x1500 array and loop through it for every fold, just saving a list of the # marked coordinates is good enough. (This version runs in 6 ms compared with 5 seconds for my first version)
+
+    Note: A human is required to parse the output file into an 8-letter string
+
+    ```ruby
+    data = open("input").read.split("\n\n")
+    marked = data[0].split("\n").map{_1.split(",").map(&:to_i)}
+    folds = data[1].split("\n").map{_1.gsub("fold along ", "").split("=")}
+
+    folds.each_with_index do |fold, i|
+      axis, loc = fold
+      if axis == "x"
+        marked = marked.map{_1.first > loc.to_i ? [2 * loc.to_i - _1.first, _1.last] : _1}.uniq
+      else
+        marked = marked.map{_1.last > loc.to_i ? [_1.first, 2 * loc.to_i - _1.last] : _1}.uniq
+      end
+      puts "Part 1: #{marked.count}" if i == 0
+    end
+    output = File.open("output", "w")
+    [*0..marked.map(&:last).max].each do |y|
+      [*0..marked.map(&:first).max].each do |x|
+        output << (marked.include?([x, y]) ? "#" : " ")
+      end
+      output << "\n"
+    end
+    ```
+  :replies: []

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

@@ -0,0 +1,199 @@
+---
+- :author: Jomy10
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hy8o0n7/
+  :body: |-
+    ## Ruby
+
+    Had a lot of fun with this one!
+
+    [Ruby solution](https://github.com/Jomy10/Advent-Of-Code-2021/blob/master/day14/main.rb)
+
+    [Script for calculating both parts](https://github.com/Jomy10/Advent-Of-Code-2021/blob/master/day14/main.sh)
+  :replies: []
+- :author: tom_collier2002
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hoky675/
+  :body: |-
+    [Ruby solution](https://github.com/tcollier/aoc_solutions/blob/main/2021/14/main.rb) optimized (~8ms to print both parts) by precomputing 41,000 values
+
+    The number 41k comes from the number of iterations (40) plus one (to add in the base case) times the number of possible 2 character pairings (there are 10 distinct characters in my rules, resulting in 100 possible pairings) times the number of characters.
+
+    I allocate a 41k element array for integers (each representing the count of a given character for a number of steps and a starting pair of 2 characters). To help visualize how this array is structured, imaging an input that only has the characters `A` and `B` in the template/rules. The array values are in the bottom `count` row in the comment below. The top three rows map the given array index to the step number, pair, and specific character that is counted.
+
+    ```ruby
+    # ╓───────────────────────────────╥─────────────────────────────
+    # step: ║ 0 ║ 1 ...
+    # ╟───────┬───────┬───────┬───────╫───────┬───────┬───────┬─────
+    # pair: ║ AA │ AB │ BA │ BB ║ AA │ AB │ BA │ ...
+    # ╟───┬───┼───┬───┼───┬───┼───┬───╫───┬───┼───┬───┼───┬───┼───┬─
+    # character: ║ A │ B │ A │ B │ A │ B │ A │ B ║ A │ B │ A │ B │ A │ B │ ...
+    # ╠═══╪═══╪═══╪═══╪═══╪═══╪═══╪═══╬═══╪═══╪═══╪═══╪═══╪═══╪═══╪═
+    # count: ║ 2 │ 0 │ 1 │ 1 │ 1 │ 1 │ 0 │ 2 ║ 3 │ 0 │ 2 │ 1 │ 2 │ 1 │ ...
+    # ╙───┴───┴───┴───┴───┴───┴───┴───╨───┴───┴───┴───┴───┴───┴───┴─
+    ```
+
+    Filling in the array for step 0 is straightforward (each value is the count of times the corresponding character appears in the pair).
+
+    Filling in the array for step 1+ requires applying the rules once for each pair, splitting the now 3-character string into 2 pairs (the inserted character will appear in both pairs), adding the per-character counts for these 2 pairs from step - 1, then subtracting 1 from inserted characters count (as it was counted twice, once for each pair)
+
+    Once this array is filled in, it can be used to compute the value of any template. Generate a set of pairs from the template (similar to has we split the 3-character string into 2 pairs above we'll get _N - 1_ pairs, where _N_ is the length of the template). Sum up the per-character counts for each pair for the given number of steps (10 for part 1, 40 for part 2) and subtract 1 from each character count that was used for 2 pairs (i.e. every character in the template except for the first and the last).
+
+    With these counts, it's trivial to find the difference between the highest and lowest character counts.
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hokk7yj/
+  :body: |-
+    A little late to the party, but when I read today's part 1 I just _knew_ what was comming in part 2. I'm usually not too quick at spotting a fast solution for these kinda problems, but I'm pleased that this one struck me pretty quickly. It's this year's least aesthetically pleasing code so far, though.
+
+    # Ruby
+
+    ```ruby
+    f = File.open('../input/14.txt')
+    template = f.gets.chomp
+    insertion_rules = f.read.scan(/(..)(?: -> )(.)/).to_h
+
+    pairs = template.chars.each_cons(2).tally
+    pairs.default = 0
+
+    40.times do
+      next_pairs = {}
+      next_pairs.default = 0
+
+      pairs.each { |(a,b),tally|
+        i = insertion_rules[a+b]
+
+        next_pairs[[a,i]] += tally
+        next_pairs[[i,b]] += tally
+      }
+      pairs = next_pairs
+    end
+
+    totals = {}
+    totals.default = 0
+    pairs.each { |(a,b),tally| totals[a] += tally }
+    totals[template.chars.last] += 1
+
+    min,max = totals.values.minmax
+    puts max - min
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hoh5uwe/
+  :body: |-
+    Ruby, 45 / 60
+
+    [paste](https://topaz.github.io/paste/#XQAAAQByAwAAAAAAAAARiAbIwVXFxjAHVuSY6fgD5zCgKkZ/UXunA8B1izlqB3srX05rXADItUakgqB1w+YzQuhYXk5VHW2jIG6VXmV0b+BVv3hVC4gLI07hiAzlV5OxGCLWOW7+oqVnSqkUKnfSgLBM4R5KiS9X5+WHy6vEnnt+zCkKwd9rXiRUDGvohge68kEVi80Txeb9Ie1Bd2nxubyjj6cWGQxaT90QzqUx+LXsUuUUVFM1M0699qLMFczHe+nHmd399ZIRYpbM4Vqmty+NO008S+j/mIQ72G8bDzCrfP2FTonUQwpOZe6kuJiMPV+VQN0Pu6r3SrcIqJKlI1n5ffP+uBej7Tl94Q/GghUPBMYGT944dNhzfCMXVBVa3O7qxuWqx64Zl4Da9DPGelrIVP8EHZRdGN7iKhvfHfLXpMbz3y4cOgUe856el2DeiEmx2ZzvymWYmvSU7I4LDEc8cG7DFBC2ogjx09MOmvoDh0S+u8YLTlGv2XwVZEJOVsmGa8TnXDFurDxdV+amskaMOE8GnXxC39nSuBD/spqFTA==)
+
+    `each_cons(2)` helps quite a lot in solving this.
+  :replies: []
+- :author: mxBug
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hohnxwl/
+  :body: "[ruby but OOPy](https://topaz.github.io/paste/#XQAAAQAWBAAAAAAAAAA0m4poOBCMftdkRQiciXYGFBdLcr8czW9TZUkh6Ogb11apudi2OZNyqfLGru4I+laPGJe60A1OZ+sy5KmHgPZo3L2nOHKh4zJrxOfv4igKmXz4gkuPfTPs/CmNtvCUbrYio0YiHj7G8qoywgl/zc+Kw4khjnTUe6SEHFCmNmp/R6MOtkRguw9rAScmnMqk7iSFwSr0D9ywr3M3Dhp6XInreVSl6Q2od3zq1Q3iCLPXbKY5mikOYvdUvp3QPA8YGMxy3jIFTf+Li1spvwRWj9pCEHYfzs1Y52bUzm32mL1VQXXXSmKGUbToGXRlEcByeDYdz3J5GeT+r9Npd+8ItLs/XVo68N8IQkT1mcUZN9RXfphWV/C00K4oyNkReR2+zflDyMT1FW1AvoxtlxJHlSpt9n+EaCQzWU/8s9rciVDkkMqOQXcKVN/nvs/sYnS/iVrUL1UL4WDN1EtItA6UNeNr1SuDn2XT1Tv20kq0jPLSE+5HP184vFic7FVjYyNVIXAuVCWeuhJOdi64f4YjxIKJecOtm7P2LG79zwqjswgFXAOlaEP6/5fGdgssK7M0+j/lPv98nzYA)"
+  :replies: []
+- :author: '442401'
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hohtwll/
+  :body: |-
+    [**Ruby**](https://topaz.github.io/paste/#XQAAAQDHAwAAAAAAAAA4G8nPaRVx/o1ZZYKycGL0SspRCXDQTQUVmHvXfVLEqraSWb0elNeZvnSclxpoFwVtzGktWmOe/XRTtEUmBAOBYzfSLnqEuShWc7DJrSu/wnPgm5XHzf4ctTUjOJhE1iC3FndYgzu3V2InBzTUhniHJP7rQreNtZQB5QWeHZ31bmzByLve13RoeaZt5XSmXhW9Pb/IE1pIlwmTIrQQSKCY0BgD+vhhAtmITSlv3PocxzxYS2LC55RCSGutN6OXlsCCDP/kZ3pIP79XYyqfnmZMgXD7W/6TXztLcx3Dup5qlr8zQxhIJ7C/D1n4o6rQSEDUS5wuY30dvfirzIjzf4pMjifsLJYeaZAyulqxCJBaIZYWP/YFfdWM4JlBKlN+RWgDJYVHvMAyMKsQ34L2HMk8vdB5U9yeFaHJwuCs9qNhumZ1SkclHblRBmB0kFBdWx/Sj/0k5+tGMKPE4+z195Mhn/p1RV9ZJt6wRcFJPo552hzd8IywsjWu+3E1iasGYKOfqHFo3mcjGyTS9IjHisWwqxbTivh6ii//tZt3Pg==)
+
+    Wasted far too much time assuming that each pair only occurs once in the input polymer.
+
+    Thanks to /u/Divritenis for the [hint](https://www.reddit.com/r/adventofcode/comments/rg23lu/2021_day_14_part_2_awk_spoilers_part_2_working/hohm0kb/).
+  :replies: []
+- :author: weiss_i_net
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hoikmis/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    input = ARGF.each_line.map(&:strip).to_a
+
+    pairs = Hash.new(0)
+    input[0].chars.each_cons(2){|a,b| pairs[[a, b]] += 1}
+    rules = input[2..].map{_1.split(' -> ').map(&:chars).flatten}
+
+    40.times do
+      new_pairs = pairs.clone
+      rules.each do |a, b, n|
+        new_pairs[[a, n]] += pairs[[a, b]]
+        new_pairs[[n, b]] += pairs[[a, b]]
+        new_pairs[[a, b]] -= pairs[[a, b]]
+      end
+      pairs = new_pairs
+    end
+
+    count = Hash.new(0)
+    count[input[0][-1]] = 1
+    pairs.each{|k, v| count[k[0]] += v}
+
+    puts count.values.minmax.reduce(&:-).abs
+    ```
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hohjjhw/
+  :body: |-
+    **Ruby** : 4:25/18:50, 63/293
+
+    Here's a [recording](https://youtu.be/ZmUvza2G0Og) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec14.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    First one I was able to do live in a while, and I was able to make the leaderboard for Part 1!
+
+    I felt pretty good about Part 2, but then I reused a variable name from Part 1 and so everything was broken for a while and I got pretty mixed up trying to fix that. Oh well.
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hojriug/
+  :body: |-
+    Ruby
+
+    [https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day14/main.rb](https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day14/main.rb)
+
+    Benchmark 1: ruby main.rb data.txt
+
+     Time (mean ± σ): 225.7 ms ± 32.5 ms [User: 230.3 ms, System: 54.4 ms]
+
+     Range (min … max): 151.7 ms … 291.2 ms 13 runs
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/rfzq6f/2021_day_14_solutions/hohc55j/
+  :body: |-
+    ### Ruby
+
+    ```ruby
+    @data = DATA.each_line.map(&:chomp)
+
+    template = nil
+    instructions = {}
+
+    @data.each do |line|
+      next if line == ''
+
+      if template.nil?
+        template ||= line.strip.chars
+      else
+        two, third = line.split(' -> ').map(&:strip)
+        first, second = two.split('')
+        instructions[[first, second]] = third
+      end
+    end
+
+    def ans(c, tm)
+      t = Hash.new(0)
+      c.each { t[_1.first] += _2 }
+      t[tm[-1]] += 1
+      p t.values.max - t.values.min
+    end
+
+    counts = Hash.new(0)
+    template.each_cons(2) { counts[[_1, _2]] += 1 }
+    40.times.each do |i|
+      old = counts.dup
+      counts = Hash.new(0)
+      old.each do |(a, b), v|
+        found = instructions[[a, b]]
+        counts[[a, found]] += v
+        counts[[found, b]] += v
+      end
+      ans(counts, template) if i + 1 == 10 || i + 1 == 40
+    end
+
+    __END__
+    ```
+  :replies: []