advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,250 @@
+---
+- :author: jafuentest
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2x6w5g/
+  :body: |-
+    Filtering down the patterns really helped, specially on part 2, ex:
+
+    `relevant_patterns = patterns.select { |e| target.include?(e) }`
+
+    [Part 1](https://raw.githubusercontent.com/jafuentest/advent-of-code/refs/heads/main/2024/solution-19-1.rb), [Part 2](https://raw.githubusercontent.com/jafuentest/advent-of-code/refs/heads/main/2024/solution-19-2.rb)
+  :replies:
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m4qoaf6/
+    :body: Very impressed with your solution. Had you used it for some other problem before?
+    :replies:
+    - :author: jafuentest
+      :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m5rgbud/
+      :body: Thanks! Filtering usually works to reduce execution time when complexity is quadratic or worse
+      :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2widl9/
+  :body: |-
+    ```ruby
+    input = File.read('input19.txt').split("\n\n")
+    prefixes = input[0].strip.split(', ')
+    designs = input[1].split("\n")
+
+    $num_ways = { '' => 1 }
+    def count_possible(prefixes, design)
+      return $num_ways[design] if $num_ways.include?(design)
+
+      $num_ways[design] = prefixes.sum do |prefix|
+        design.start_with?(prefix) ? count_possible(prefixes, design[prefix.length..]) : 0
+      end
+
+      $num_ways[design]
+    end
+
+    # populate $num_ways memo
+    part2 = designs.map { |design| count_possible(prefixes, design) }.sum
+    puts designs.map { |design| $num_ways[design].zero? ? 0 : 1 }.sum
+    puts part2
+    ```
+
+    After writing separate functions for part 1 and part 2 I realized only part 2 is needed to solve both parts. This can probably go faster but the code is already so minimal I don't really see where improvements can be found
+  :replies:
+  - :author: eggselent_folk
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2wtil3/
+    :body: "I was stuck because my implementation was trying to seek through the design string back-and-forth, instead of using each towel as the start of the search. I realized the problem is I did not consider the uniqueness of some of the possible arrangements. Just realized this after reading your solution.\n\nNice and well-written. \U0001F44D"
+    :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2uyv5y/
+  :body: |-
+    [day19 git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day19/day19.rb)
+
+    part 1/part 2 both use the same dfs function to solve it, with a slight variable change.
+
+    Really easy today ngl. Basically a dfs with memoization is very viable here in that since you can consider your patterns nodes. all you have to do is identify whatever substrings is possible from your current string window (two pointer window, which always has a limit, that is the longest pattern in your collection of patterns). And you just repeat until you read the end of the string.
+
+    Then you drop in your memoization to optimize because you will be encountering repeated patterns of words and indexes.
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sv7i7/
+  :body: |-
+    golfed both parts: 143 bytes.
+
+    start\_with? would be significantly faster but the regex match saves 6 bytes
+
+    It also hits that `0` evaluates to a truthy value in ruby. otherwise the final print could've saved the extra `>0` block
+
+    ```ruby
+    t,i=$<.read.split("\n\n").map{_1.split(/\n|, /)}
+    m,f={},->(q){m[q]||=q==""?1:t.sum{q=~/^#{_1}/?f[q[_1.size..]]:0}}
+    p i.count{f[_1]>0},i.sum(&f)
+    ```
+  :replies: []
+- :author: Mon_Ouie
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s3zyk/
+  :body: |-
+    Nothing special about the recursive search for part 2, but part 1 was solved using the cute `Regexp.union` method.
+
+    ```ruby
+    a, b = DATA.read.split("\n\n")
+    available_patterns = a.split(", ")
+
+    desired_patterns = b.split("\n").map { |x| x.strip }
+
+    def possible?(pattern, available_patterns)
+      pattern =~ /^#{Regexp.union(*available_patterns)}+$/
+    end
+
+    CACHE = {}
+
+    def count_patterns(x, patterns)
+      if old = CACHE[x]
+        old
+      elsif x == ""
+        1
+      else
+        CACHE[x] = patterns.select { |p|
+          x.start_with?(p)
+        }.map { |p| count_patterns(x[p.size..-1], patterns) }.sum
+      end
+    end
+
+    p desired_patterns.count { |x| possible?(x, available_patterns) }
+    p desired_patterns.map { |x| count_patterns(x, available_patterns) }.sum
+
+    __END__
+    [My input here]
+    ```
+  :replies:
+  - :author: whyrememberpassword
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sa7kd/
+    :body: |-
+      yeah this (along with the equivalent python version) doesn't work on my input. here's a minimized test case that breaks your solution
+
+      ```ruby
+      b, bb, bbu, bg, bgg, bggw, br, brw, bu, bur, burw, gg, ggu, ggw, ggwg, ggwgwbrw, gr, grw, gu, guu, guw, gw, gwb, gwg, gwr, r, rb, rbu, rgw, ru, rub, rubg, ruw, rw, rwr, rww, rwww, u, ub, ubb, ubg, ugg, ugr, ur, uru, urw, urwr, uu, uuw, uuwu, uuwur, uw, uwg, uwu, w, wb, wbr, wg, wgu, wguu, wgw, wr, wrb, wrg, wru, wu, wub, wug, wurubggw, ww, wwu, www
+
+      ugguwugrwrgwruwguuwurubggwgwbrwwwubburwrburg
+      ```
+    :replies: []
+  - :author: globalreset
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sbkg8/
+    :body: Nice, that is cute!
+    :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2tfq1q/
+  :body: |-
+    ```ruby
+    t, p = File.read("input.txt").split("\n\n")
+
+    @cache = {}
+    @towels = t.scan(/([wubgr]+)/).flatten
+    designs = p.split("\n")
+
+    def count(design) =
+        @cache[design] ||= @towels.filter{ design.start_with?(_1)}.sum { |t| t == design ? 1 : count(design[t.size..]) }
+
+    counts = designs.map{count _1}
+    p counts.count{_1 > 0 }, counts.sum
+    ```
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sc76v/
+  :body: |-
+    I'm scared for tomorrow. Part 1, I started off with a simple "select all the patterns that work for the start of the current design, then check if any recursions on the substring after that pattern get us to the end of string". Part 2 was just change the .any? on that second part to .sum and adding memoization so we could complete in reasonable time. I later went back and adjusted my part 1 to use a regex trick that I learned here so hopefully I'll remember it for next time.
+
+    ```ruby
+    def part_1
+      pattern = /^#{Regexp.union(*data[0].split(", "))}+$/
+      data[2..].count { |design| design =~ pattern }
+    end
+
+    def count_paths(design, pattern, cache)
+      return 1 if design.empty?
+
+      cache[design] ||=
+        pattern.select { |p| design.start_with?(p) }
+               .sum { |p| count_paths(design[p.length..], pattern, cache) }
+    end
+
+    def part_2
+      pattern = data[0].split(", ")
+      cache = {}
+      data[2..].sum { |design| count_paths(design, pattern, cache) }
+    end
+    ```
+  :replies:
+  - :author: riffraff
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sdi3m/
+    :body: ah I love part 1!
+    :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sco2c/
+  :body: |-
+    basic recursion and memoization. For some reason the Memoist library has decided not to work at the top level anymore, which I'm sure it did at some time, so I need to define a useless class but eh, it works and solve each part in 1s (could do both together, but I usually don't)
+
+    ```ruby
+    class C
+      extend Memoist
+      memoize def solve_easy_design(towels, design)
+        towels.sum do |towel|
+          if design == towel
+            1
+          elsif design.start_with?(towel)
+            solve_easy_design(towels, design[towel.size..])
+          else
+            0
+          end
+        end
+      end
+    end
+
+    def solve_easy(input)
+      towels, designs = input
+      c=C.new
+      solutions = designs.map do |design|
+        sol = c.solve_easy_design(towels, design)
+      end
+      solutions.select(&:positive?).size
+    end
+
+    def solve_hard(input)
+      towels, designs = input
+      c=C.new
+      solutions = designs.map do |design|
+        sol = c.solve_easy_design(towels, design)
+      end
+      solutions.sum
+    end
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sxxpi/
+  :body: |-
+    Straight forward today, I did a recursive solution which finds matches for the start of the string, then chomps off the ones that match from the string and trys again. Part 1, short circuit to return true if it finds any valid combo. Part 2, remove ths short circuit return logic so that we check each path, but add a cache to speed it up.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/19](https://github.com/careyi3/aoc_2024/tree/master/solutions/19)
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s6hju/
+  :body: |-
+    665/869
+
+    For part 1, a simple recursive function did the trick:
+
+    ```ruby
+        def can_make?(towel, patterns)
+          return true if towel.empty?
+
+          pats = patterns.select { |pat| towel.start_with?(pat) }
+          pats.any? { |pat| can_make?(towel[pat.size..], patterns) }
+        end
+    ```
+
+    For part 2, adding memoization was necessary. Without it, the code will probably never finish. As seen here, the code completes in about 0.7 seconds.
+
+    ```ruby
+        def variations(towel, patterns, memo = {})
+          return 1 if towel.empty?
+          return memo[towel] if memo.key?(towel)
+
+          pats = patterns.select { |pat| towel.start_with?(pat) }
+          memo[towel] = pats.sum { |pat| variations(towel[pat.size..], patterns, memo) }
+        end
+    ```
+
+    full solution including I/O [here](https://github.com/jstanley0/advent-2024/commit/f4eeacde267ee4ac8fe1ab4cd8336b20d9e8dca1)
+  :replies: []

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

@@ -0,0 +1,113 @@
+---
+- :author: eggselent_folk
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32h60h/
+  :body: |-
+    Part 1
+
+    1. Using Dijkstra to first calculate the one and only path. [Code](https://topaz.github.io/paste/#XQAAAQCSCgAAAAAAAAAxm8rOIKvf+s1X+3/ql1GvzcY8rsOBAxCz+TAXgKsPEu51khhgDYTz4Llygtm1vimuA/IDTRWggRLpes53OkLP1HeqVGACgl0l26fPxNUsDt9hlpWQ1yeSi8FvpqSw1VK5fug/l6bgl48NS/GIzyYIOJzm8gDIXpI1QKqhfY0uK83Qwt4odKyRthkWpy9l8Hh9wq/eO+BrurbMRgvNLqxbcWW9xoBxxsYgnyVFjek6GUu8EqHH2Nc05/pKHlGQ8vKv3q7dCIm+8M72Gz/LFfPnjroJJtuHAEcgytypULcWbQcuyqtk/ymqRlyovykD/FvYKcy10V/3hNTJV/caQN45Hc/CXCmGePAHtnkivA8ILK2bL87acOx2bMZKZlDwTvZ4FkD41GUDt/SDbMPSFMTBeZC5bhZshWCSxCL7qaBPRDxjTfqace+7QdeEUQnwSCh/ePpMkq3/i1SCYys4dQ8smkjOT1hLIzfAzOJE4wYR5EM/jK9efAQJhXSG5FllWjPEfHmDeR7Xyduvf6ggXSQnkJN1cvgzseFGOUnyYvWC5/kBqP3uJiz+qspgLh/oMDPe9ESWuup+gD2XAA4MFIH0ChZcKD2kUddYzJ1s/T25i76HqHOrpQhorH0ioxhWtVpLwprtGbziNTGxC8+l9fJNBFSXIEvRPjmHeTTyhB25yqExvXedeVZVdv9WWDCjAm80Kc6LoHVHWO7DRLmUtimlqJ1WdVz3fIKf2CGDVgCZAqpF5lviIgigQylvQMDylUZPoF3Jf3jZfxKOdQozDfTqQFhd3NKFNtRYUvPNIHHKqbK8e2l7GJkT51BQkvBTvE26msWIpZe5VxbLLU1+Gvlwxgq+PBMRsMnlN21oaLWDvTwisieIqrPQ/v1OF+MNMeorQzcpWouWF71KEg65etZT7pXQKry0quKBywgzESFsaIGfjcBsCu7fTxQaq9aDbQRybxHuMW12cskMYF4pzM27CiQDQsHTUOev1KC7IJemw6yeXUG3q+ohS/yskSx/YiV3V1dC6MEMekjt3FHZeb35DT0LGwAK7sy5clNDjk08AWtZP/UjHKaYfb4FN2KeP7X3P9fYsNgylD5bwfwb/GhSDjLMp2xRfxzRzWTBuCo3z+1XGWQcHq9Xg8UdK47VFqPqIwr87/x9)
+    2. Get the length of the path.
+    3. Then, remove walls one by one while recalculating the shortest length of the path. This runs very slowly.
+    4. Filter out potential cheats based on the amount that can be saved (100).
+
+    Part 2
+
+    [Code](https://topaz.github.io/paste/#XQAAAQBXAQAAAAAAAAA5GUqKNoFH6SKufxdCrLeXzl/r7oI8pLzRkk/8AoN8YnvSd31COCWMyZcSjsBDPIkRMvGZwuxEW9fg/fLEewfbjWRugkJ/XpRB3W0CvdMcmNF7D92Ew8uKsGoYZ3qq0WMw7uEy5FkbhhOWRGef2kVYMUqO5M/CP5PKxX2dHEC9zU7O5TWImcIZqeOFyENXAiyTovXlsZxvt5ACNLGKu9+cm4Vliq31TWnqG6I/lipcO3xWRpMwUoBLLV1/fX3I66vGdpG82Gqz0FFEwLjolZj+70QerIP//j5VGQ==)
+
+    I tried a similar approach to Part 1, but it was really slow. Then I realized there’s no need to keep running Dijkstra since there’s only one path. Instead, we can just use the path we already have: the savings come from how many grid cells along the path we can skip minus how many we pass by 'cheating' through the wall.
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32dmpd/
+  :body: |-
+    [Day 20 git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day20/day20.rb)
+
+    Part 1 was okay, I solved it using a single bfs search, and then iterate through all the "#" and did some math to calculate, since you know that a "#" has to connect two "." so you just calculate off those two "."
+
+    Part 2, I brute forced with it bfs for each node along the path. Took about 30s. I did try to optimize with caching, but whatever it is I was trying to cache wasn't working. Another idea came along, which could probably work, but it's a bit too much work to redo, something to with shifting the nodes calculated after the 20th iteration, since im traversing along the known path.
+
+    Edit: implemented manhattan distance instead. Learned something today.
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m31r0rz/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQBSBQAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8fKlEL/CNiVvHcK3eo2f1wG2uFy9c4gJqYPLUFmRQObk0r1ctDG23Tm34gRt6y0eQyY1K3b+i262JFsBcUTwua3DLm6KSkqYEXQeJcnMzX2GiPxLyHJWGSpd1fxuDnJy73MlIlL5A6O9r7sUJc74tEcDpuOSFvnIDUAJroBJOl4///H6DVYUL4ZAWQeDifCTkpGd48wf1XWh8OaloKZi3EBui3TYbf2XczZyUTJ0gCrwy+Vh0acUQfuSoTFGJySKo455BdcpopJKl1y3juBmP7oTORtH9I+4Yc9FW6x16Zu2xxSRUQlgzbf1x9qA59hab7ZSSFhgnpgKR6yEueMsduCcaTE1MrEBvThUWafam677wcu+jaQ0J84QspD7caKAlferv+Cj6YKtb/tS78hON9X62Q3+NBEhKbWgkmSs1PcSSmSWgs42iMkoOr9LXiNfqHCdow+xffrKvSWd3WUHN5tOBn2/PX1R+2MMcMD4wUHU+1P6f5hal6aCciijFQ0qntvI31170SCUg5hBWTqE6dsM1/zVWkIBB/gbB70aKBu3Qy2Agvif5WFB9bkR0kjjnpR6QbiR4KCh90LFncnJON33o5rLoSRAJoAX7OxByKGSgzusOC1JU9xhRYzPFiLQHTI4k/ZRdX6QWrS/VNyt489cJmMbQ6EZXS2aSNxDtXZ0Pm1aQYcpSQwVxg9KYOECireQAH48ATQOjXOAcdn2yBJMFPtw0yGLODKhKxBj/RCss1ZFRDrLxOdeuQTyEAlkxA3LEvUBMmyXOIiv09YUM/5OhmCMOYedljBc2+9RK4+e/rLITQNz/vHkIsQ==)
+
+    I really don't think today's problem description was very good. Part 1 was clear but I just didn't read carefully. Part 2 sure felt a bit underspecified
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2yun6p/
+  :body: |-
+    ```ruby
+    start, target, map = nil, nil, Set.new
+
+    File.readlines("input.txt").each_with_index do |l, y|
+        l.chars.each.with_index do |c, x|
+          p = Complex(x,y)
+          map << p unless c == ?#
+          start = p if c == ?S
+          target = p if c == ?E
+        end
+    end
+
+    DIRS = [1+0i, 0-1i, -1+0i, 0+1i]
+    @dist = {}
+
+    @dist[target] = 0
+    queue = [target]
+    visited = Set.new
+
+    until queue.empty?
+        node = queue.pop
+        visited << node
+        DIRS.map{ node + _1 }
+            .filter{ map.include?(_1) && !visited.include?(_1)}
+            .each{ |pos| @dist[pos] = @dist[node] + 1; queue << pos }
+    end
+
+    def manhattan(a, b) = (a.real-b.real).abs + (a.imag-b.imag).abs
+
+    def count(cheatsize) =
+        @dist.keys.combination(2)
+             .filter{ |a,b| manhattan(a,b) <= cheatsize }
+             .count{ |a,b| @dist[b] - @dist[a] >= manhattan(a,b) + 100 }
+
+    puts count(2), count(20)
+    ```
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2ycfqu/
+  :body: |-
+    Advent of the Grid! Quick bfs to get the shortest path. It wasn't immediately obvious to me that there was only one path through, so I wasted time trying to tweak my bfs at first. My find\_path function returns a hash of all the points on the grid and their step counts. For part 1, I went to every point and checked if 1 or 2 steps in any direction would let me short circuit the path. For part 2, this was slow, but worked just changing it to 20 steps in any direction. I cut part 2 down from 7 seconds to 4 by instead testing every point in the grid with every later point to see if it was less than the cheat distance away from the first point. This technique slowed down part 1 quite a bit. I'm curious if anyone found faster solutions.
+
+    ```ruby
+      maxCheat = 20
+      stepCnt = find_path()
+      points = stepCnt.keys.to_set
+      stepCnt.to_a.sum { |pos1, step1|
+        points.delete(pos1).count { |pos2|
+          cheat = (pos2[0] - pos1[0]).abs + (pos2[1] - pos1[1]).abs
+          next if cheat > maxCheat
+          stepCnt[pos2] - (step1 + cheat) >= 100
+        }
+      }
+    ```
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/20/solution.rb)
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zkao9/
+  :body: |-
+    Not too bad today, I was surprised that my lazy solution for part 2 worked in a reasonable time. I made a mistake at the start and assumed that there was a third move needed to get you back onto the track and was overcomplicating it, but turned out not to be an issue anyway. Solution is to run dijkstra, then with the known set of visited paths, for each one, see if it is N steps away (through walls) from another visited point on the path who's distance from the start is longer. For part 1 N = 2, for part 2, N = 20. I use a dump 40x40 grid in the second part centered on the point of interst and then calculate all the points that have a manhatten distance of 20 or less as candidates.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/20](https://github.com/careyi3/aoc_2024/tree/master/solutions/20)
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zvmsc/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day20.rb)"
+  :replies: []
+- :author: masterarms
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2z9o0z/
+  :body: |-
+    For part1 the brute force solution (doing a BFS for every possible cheat pair from the start and the end) correctly finished before I wrote the faster solution for both parts. But it was clear that part2 would take ages.
+
+    In the end the result takes 11s for both parts on my machine: [code](https://github.com/mpcjanssen/aoc-python/blob/master/2024/20/solution.rb)
+  :replies: []

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

@@ -0,0 +1,21 @@
+---
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m3c99gh/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day21.rb)"
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m38oozv/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day21/day21.rb)
+
+    Struggled hard on this one. Recognized that it was dp problem, but I had issue figuring out what I needed to memoize. I also made a mistake of selecting individual sub sequence by "weighing" them based on the number of movements required, and selecting only one of them. That was a mistake. Weighing them is fine, but all the substrings of the same weight must be accounted for as well, and that took some snooping around here to figure out.
+  :replies: []
+- :author: NullT3rminated
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m33nqyg/
+  :body: |-
+    [Language: Ruby 710/223]
+
+    My recursive solution set me up well for part 2, I just needed to add memoization. I was surprised I did this well, I guess it was just a hard problem
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDFBwAAAAAAAAA5GUqKNoFH6SMqVwa6yG0l+GbarPLmcoOjU+diH4oGkfzoDs8nu4dmVhYVKW+v9/4pixeespRGd6tcsbqkK0tqdtAW/cV8BKHGZ9ajYRn8DgzVUnHgSukF3AdnaQnWWKCJKKH+cmVm95d1TYhAIps7zoHJ5mpoXbZMt5uQduTy6Mc6oYaHReNVmjNqu+TkcXq+iZyiX8BhxEA4vROa6BWHYlmrFArJAzQr6BY6Cl6Ioef+7RoyT5RoZ6SYv07wKdWjBDoIp3UAKTfMsMDXDhg39gjpG9cdUSQtsdPixyDZesvSup6AXItKVqXjbN5mNSly9aHOcHuVch4Um6AcXyNIICWmykuWNChhwA9WNJDDO/oappe6XRV/p1SA009C9Ilemweo8cGfxYi/Cmu41EKpweCYd3jFDSSzFgkBYS/d9E1mnGA/hQ6P4jzi/1MaDSxwbhzcY/+Zo0c4Q+Owru9pDh1bIpgqLCNdfSMSbFm/32CEsQHAkBv9PEIfZf9eoY05y9UYQBTMgELl2oNa6olqo6Acpl/bO1PJeHr6C+OImz+ixk5wVSa4ln7n2bPxz1p1oEQ1pMVxKkwA8977pWbi0oU7shVh5rEGm1wuQqqe0wsVQLFdPV/2jpj9uFwnksgEmk+XHZUnuiT5rSSl92iMtpeGJqcCMcgp2ocB9P5E/PqS7ZuJjStqol0QThavnZ4BZdotJwpFwS/wGWnm5yad2sdIgZWKJCJ71hxHEuiE/TjDvq296vu14IWJe6S+0zQZ4S3/7ztwQpro9+CUpMwujlZX1tAk+2TaBsylsdfUPhVM/h5MDrAYRxp2KJK/B8V/c0M07aTk+hqyJhGq1/gr7Fsdz9LPhLPPwgpOdGPef3tivFUxMnwSAuh2nHIhKoaIzedIArFm9k/rLku+6uvCBo0AnTslwXKKdaScJjYPtn3FMedUCf9twY3IHPZ4fNCy+hRWIg/eL7HvJdMi2JPyZch2O64Ca7zwww7bq22SbUuA6bLk1+B/mFaq4LzuCzT6bs0bUAWDa66ezI8RDsLSGvza+74yofmLu7WcBPKLv/+aQ58O)
+  :replies: []

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

@@ -0,0 +1,146 @@
+---
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3dig7t/
+  :body: |-
+    Really overcomplicated this on my first attempt and wrote something that took 20s. Significantly refactored and this runs in about 1s which is just fine by me for AoC purposes.
+
+    ```ruby
+    require 'set'
+
+    seeds = File.readlines('input22.txt', chomp: true).map(&:to_i)
+    sales = Hash.new(0)
+    secret_sum = 0
+
+    def next_secret(secret)
+      secret = (secret ^ (secret << 6)) & 0xFFFFFF
+      secret = (secret ^ (secret >> 5)) & 0xFFFFFF
+      (secret ^ (secret << 11)) & 0xFFFFFF
+    end
+
+    seeds.each do |seed|
+      seen = Set.new
+      diffs = 0
+
+      4.times do
+        old_price = seed % 10
+        seed = next_secret(seed)
+        new_price = seed % 10
+        # adjust range from (-9, 9) to (0, 18)
+        diffs = (diffs << 5) + (new_price - old_price + 9)
+      end
+
+      seen << diffs
+      sales[diffs] += seed % 10
+
+      1996.times do
+        old_price = seed % 10
+        seed = next_secret(seed)
+        new_price = seed % 10
+
+        # take lowest 15 bits
+        diffs = ((diffs & 0x7FFF) << 5) + (new_price - old_price + 9)
+        sales[diffs] += new_price unless seen.include?(diffs)
+        seen << diffs
+      end
+      secret_sum += seed
+    end
+
+    puts secret_sum
+    puts sales.values.max
+    ```
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3c9pg4/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day22.rb)"
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a99nb/
+  :body: |-
+    Busy weekend, didn't get day 21 done yet, but happy this one wasn't too bad. For part 2 I generated a hash of all sequences I encountered and stored the values found. Then I summed the matching sequences across each start number, the largest value in the end was the correct answer. Fairly slow, but not optimised at all, can deffinately make it faster. Runs in about 5 seconds for me.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/22](https://github.com/careyi3/aoc_2024/tree/master/solutions/22)
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a2wy5/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day22/day22.rb)
+
+    straight forward solution for part 1, just plugging into the formula
+
+    Part 2, I used an inner set to mark sequences I already seen for a number, and it gets processed into a frequency table, which accumulates the price, then it's a simple sort, and pick the last one. There was one mistake I made, and it was that I choose the maximal value a particular sequence is worth for a number, cuz I figure that is the best way to min max, but it turns out the monkey only picks a sequence the first time it appears.
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m38ylua/
+  :body: |-
+    (1352/1270)
+
+    [[GitHub]](https://github.com/Sharparam/advent-of-code/blob/main/src/2024/22/solve.rb)
+
+    Completes both parts in around 43 seconds on my machine, pure brute force. With how easy today was it makes me shiver in fear for the coming two final days before day 25…
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39lq9x/
+  :body: |-
+    ```ruby
+    input = File.readlines("input.txt").map(&:to_i)
+
+    def nextnum(n)
+       n = (n << 6 ^ n) & 0xFFFFFF
+       n = (n >> 5 ^ n) & 0xFFFFFF
+           (n << 11 ^ n) & 0xFFFFFF
+    end
+
+    def rand(n, times) = (times.times { n = nextnum(n) }; n)
+
+    def prices(n)
+        price, diff,last = [], [], 0
+
+        2000.times do
+            price << v = n % 10
+            diff << v - last
+            last = v
+            n = nextnum(n)
+        end
+        res = {}
+        diff[1..].each_cons(4).with_index.each do |seq, ix|
+            res[seq] ||= price[ix+4]
+        end
+        res.default_proc = proc {0}
+        res
+    end
+
+    p input.sum{ rand(_1, 2000) }
+
+    maps = input.map{ prices(_1) }
+    seqs = maps.map(&:keys).inject(&:concat).uniq
+
+    p seqs.map{ |s| maps.sum{ _1[s] }}.max
+    ```
+  :replies: []
+- :author: birblett
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m390b32/
+  :body: |-
+    ```ruby
+    puts (seq = {}) && File.read("in.txt").split(/\n/).map(&:to_i).sum { |cu, h = {}, last4 = 1048575|
+      2000.times {
+        i = ((i = ((i = (cu << 6 ^ cu) & 16777215) >> 5 ^ i) & 16777215) << 11 ^ i) & 16777215
+        key = (key = (price = i % 10) - cu % 10) < 0 ? 16 | key.abs : key
+        last4 = ((last4 << 5) + key) & 1048575
+        cu = _1 < 3 || h[last4] ? i : (seq[last4] = seq.fetch(last4, 0) + price) && (h[last4] = i)
+      } && cu
+    }, seq.max_by { _2 }[1]
+    ```
+
+    just use the last 4 prices as a key to sum up the results of each individual sequence. used some funky bitwise stuff during key generation to save the overhead of passing entire arrays around as keys. runs in about ~1s on my machine (using truffleruby).
+  :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39a4gv/
+  :body: |-
+    [LANGUAGE: Go]
+
+    Implementing in both languages in order to get more familiar with Go.
+
+    Simple iteration over all possible sequences in the sets of sequences and find the one with the best score. Memoization is pretty important here.
+
+    [Ruby](https://github.com/phene/advent-of-code/blob/main/2024/22/22.rb) in 49s and [Go](https://github.com/phene/advent-of-code/blob/main/2024/22/22.go) in 11s.
+  :replies: []