advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,185 @@
+---
+- :author: KeyboardFire
+  :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/eci5rgz/
+  :body: |-
+    ruby, 10/58:
+
+    ```ruby
+    cons = []
+    File.readlines('f').map do |line|
+        x,y,z,w = line.split(',').map(&:to_i)
+        joined = []
+        cons.each.with_index do |a,i|
+            if a.map{|xx,yy,zz,ww| (x-xx).abs + (y-yy).abs + (z-zz).abs + (w-ww).abs <= 3}.any?
+                a.push [x,y,z,w]
+                joined.push i
+            end
+        end
+        if joined.empty?
+            cons.push [[x,y,z,w]]
+        else
+            newcons = joined.sort.reverse.flat_map{|i|cons.delete_at i}
+            cons.push newcons + [[x,y,z,w]]
+        end
+    end
+    p cons.size
+    ```
+
+    simple algorithm that makes a single pass over the input array, joining constellations as it goes.
+
+    i'm a little disappointed by the last non-puzzle (unless it's always like this? i haven't done aoc before). the difference of 48 was due to the time it took me to copy/paste a solution for day 23 part 2, which i feel like was not the spirit of the event...
+
+    well, i really shouldn't be complaining, because i had tons of fun doing the puzzles, which i'm sure consumed lots of free time to make. thanks so much /u/topaz2078 for all the work it took to organize this! :)
+  :replies:
+  - :author: Porky623
+    :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/eci69yp/
+    :body: I feel for you, last year I missed exactly one star and I didn't want to copy paste a solution so I just went to sleep and got the last two stars the next day. This year, though, I was prepared, as you will be next year should you decide to participate again!
+    :replies: []
+  - :author: dan_144
+    :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/eci6pf9/
+    :body: Day 23 Part 2 was the only solution that took me over 24 hours as well. I finished it up this afternoon in anticipation of Part 2 since I'd been forewarned that it required all 49 other stars.
+    :replies: []
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/ecicggk/
+    :body: |-
+      Hi. Well done on AoC. I'm new to it too, but only managed handful of stars. I have learned lots, but far more still to learn.
+
+      I've been using Ruby for some and so was interested in your solution and use of map, which I still have to fully grasp. To understand how your codes works, I 'puts' joined after cons loop and cons at end of File line read.
+
+      Is cons.push same as cons \<\<?
+
+      Also, in
+
+      cons.push newscons + [[x,y,z,w]]
+
+      is the + [x,y,z,ew]] superfluous?
+    :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/eci7dju/
+  :body: |-
+    I admit I took a cheap shot on this problem. I already had Union-Find written for last year's day 14, so I just imported it and most of my time was spent reminding myself how I was supposed to use it.
+
+    Ruby:
+
+    ```ruby
+    require_relative 'lib/union_find'
+
+    input = (ARGV.empty? ? DATA : ARGF).each_line.map { |l| l.scan(/-?\d+/).map(&:to_i) }
+
+    uf = UnionFind.new(input)
+
+    input.combination(2) { |a, b|
+      uf.union(a, b) if a.zip(b).sum { |x, y| (x - y).abs } <= 3
+    }
+
+    puts input.count { |a| uf.find(a) == a }
+
+    __END__
+    0,6,-4,7
+    5,4,0,-8
+    0,1,1,-2
+    omitted
+    ```
+
+    Here's the contents of union\_find:
+
+    ```ruby
+    class UnionFind
+      def initialize(things)
+        @parent = things.map { |x| [x, x] }.to_h
+        @rank = things.map { |x| [x, 0] }.to_h
+      end
+
+      def union(x, y)
+        xp = find(x)
+        yp = find(y)
+
+        return if xp == yp
+
+        if @rank[xp] < @rank[yp]
+          @parent[xp] = yp
+        elsif @rank[xp] > @rank[yp]
+          @parent[yp] = xp
+        else
+          @parent[yp] = xp
+          @rank[xp] += 1
+        end
+      end
+
+      def find(x)
+        @parent[x] = find(@parent[x]) if @parent[x] != x
+        @parent[x]
+      end
+    end
+    ```
+
+    Thanks for a great month!
+  :replies:
+  - :author: koordinate
+    :url: https://www.reddit.com/r/adventofcode/comments/a9c61w/2018_day_25_solutions/edwqqtn/
+    :body: |-
+      Thank you. For kicks, here is a Swift translation of your code:
+
+      ```ruby
+      class UnionFind {
+          var parent: [Int]
+          var rank: [Int]
+
+          init(n: Int) {
+              parent = Array(repeating: 0, count: n)
+              rank = Array(repeating: 0, count: n)
+              for i in 0..<n {
+                  parent[i] = i
+                  rank[i] = 0
+              }
+          }
+
+          func union(_ x: Int, _ y: Int) {
+              let (px, py) = (find(x), find(y))
+
+              if px == py {
+                  return
+              }
+
+              if rank[px] < rank[py] {
+                  parent[px] = py
+              } else if rank[px] > rank[py] {
+                  parent[py] = px
+              } else {
+                  parent[py] = px
+                  rank[px] += 1
+              }
+          }
+
+          func find(_ x: Int) -> Int {
+              if parent[x] != x {
+                  parent[x] = find(parent[x])
+              }
+              return parent[x]
+          }
+
+          func rootCount() -> Int {
+              let n = parent.count
+              return (0..<n).filter({ find($0) == $0 }).count
+          }
+      }
+
+      var points = [[Int]]()
+      while let line = readLine() {
+          points.append(line.split(whereSeparator: { !"-0123456789".contains($0) }).compactMap({ Int($0) }))
+      }
+
+      let uf = UnionFind(n: points.count)
+
+      for (i, p) in points.enumerated() {
+          for (j, q) in points.enumerated() {
+              let d = Int(abs(p[0] - q[0])) + Int(abs(p[1] - q[1])) + Int(abs(p[2] - q[2])) + Int(abs(p[3] - q[3]))
+              if i != j, d <= 3 {
+                  uf.union(i, j)
+              }
+          }
+      }
+
+      print(uf.rootCount())
+      ```
+    :replies: []

data/data/solutions/reddit/ruby/2019/01.yml

@@ -0,0 +1,185 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f9i4ujc/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_01
+  :replies: []
+- :author: ECTXGK
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f9etbve/
+  :body: |-
+    Ruby
+
+    ```ruby
+    def total_fuel_for_module(module_fuel)
+      current_fuel_needed = (module_fuel / 3).floor - 2
+      return 0 if current_fuel_needed <= 0
+      current_fuel_needed + total_fuel_for_module(current_fuel_needed)
+    end
+
+    x = input.reduce(0) do |total_fuel, single_module_fuel|
+      total_fuel + total_fuel_for_module(single_module_fuel)
+    end
+
+    puts x
+    ```
+  :replies:
+  - :author: nakilon
+    :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f9f31db/
+    :body: |-
+      ```ruby
+      ruby -rmll/core_ext -e 'p `pbpaste`.split.sum{ |s| MLL::nest_while_list[s.to_i, ->_{_/3-2}, ->_{_>0}].to_a.most.rest.sum }'
+      ```
+    :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98due7/
+  :body: |-
+    I had wrong answer
+
+    ​ ​ ​ ​ Forgot to check negative
+
+    ​ ​ ​ ​ ​ ​ ​ ​ Please wait 20 secs
+
+    ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ - "Wrong answer", a poem by Uni
+
+    `ruby 1.rb input` 23/105
+
+    ```ruby
+    # part 1
+    p $<.map{|x|a=(x.to_i/3)-2}.sum
+    # part 2
+    p $<.map{|x|a=(x.to_i/3)-2
+    s=a
+    while a > 0
+    a=a/3-2
+    s+=a if a>0 # <- left this out...
+    end
+    s }.sum
+    ```
+
+    * * *
+
+    With [reception for my poem](https://i.imgur.com/BJPi4gP.png) being better than expected (I had no expectations) I guess I will write more on the next days :P
+  :replies:
+  - :author: tslater2006
+    :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98uztc/
+    :body: Upvoted for the poem :)
+    :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98e7ds/
+  :body: |-
+    Ruby 24/148
+
+    ```ruby
+    f=->m{n=m/3-2;n<0?0:n+f[n]}
+    p $<.sum{|l|f[l.to_i]}
+    ```
+  :replies:
+  - :author: Unihedron
+    :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98f6fz/
+    :body: |-
+      Very compact I approve
+
+      If you're golfing, I'm p. sure I can beat you with `-p`
+    :replies:
+    - :author: BluFoot
+      :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98gvi5/
+      :body: I've never used `-p` before, can you show me an example? I can't figure it out..
+      :replies:
+      - :author: Unihedron
+        :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f98ke18/
+        :body: |-
+          [-p demo](https://tio.run/##KypNqvz/XyXeViVeryi1LLWoOPX//4zUnJx8rvL8opwUrsSkZBBO4fqXX1CSmZ9X/F@3AAA "Ruby – Try It Online")
+
+          `ruby -p input`
+
+          ```ruby
+          $_=$_.reverse
+          ```
+
+          On second thoughts, I take that back, ultimately you have to print a sum which is not per-line, so it probably doesn't save much
+        :replies: []
+- :author: jamie_ca
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f9dns88/
+  :body: |-
+    Firstly, a unified solution in ruby:
+
+    ```ruby
+    def fuel(mass, recurse: false)
+      return 0 if mass < 7
+      f_mass = mass / 3 - 2
+      f_mass += fuel(f_mass, recurse: recurse) if recurse
+      f_mass
+    end
+
+    puts input.map { |m| fuel(m) }.sum
+    puts input.map { |m| fuel(m, true) }.sum
+    ```
+
+    And for bonus points (taking Fuel as one syllable):
+
+    ```ruby
+    First, for the input
+    Parse the lines as integers.
+    Store in an array.
+
+    Define a method
+    Fuel, taking as input mass
+    And a recurse flag.
+
+    For masses less than
+    Seven, return a zero
+    And call it a day.
+
+    Fuel mass is then
+    Two less than one third the mass.
+    Make sure to round down.
+
+    Check the recurse flag.
+    If set, call Fuel with fuel mass,
+    Setting still the flag.
+
+    The recursed result
+    Is then added to fuel mass,
+    Which then is returned.
+
+    Our problems' answers:
+    Sum Fuel for all input, and
+    The same, with recurse.
+    ```
+  :replies: []
+- :author: ShinobuLove
+  :url: https://www.reddit.com/r/adventofcode/comments/e4axxe/2019_day_1_solutions/f9b9r1k/
+  :body: |-
+    Where are my Ruby-bros at?
+
+    ```ruby
+    input = File.open("input.txt").map(&:to_i)
+    # input = File.open("bigboyinput").map(&:to_i)
+
+    def calculate_fuel value
+      value / 3 - 2
+    end
+
+    def recursive_fuel fuel, sum=0
+      return sum if fuel <= 0
+      recursive_fuel(calculate_fuel(fuel), sum + fuel)
+    end
+
+    # Part 1
+    # Answer 3365459
+    list = input.map do |mass|
+      calculate_fuel mass
+    end
+    puts "Part 1: #{ list.sum }"
+
+    # Part 2
+    # Answer 5045301
+    final_fuel_sum = list.sum do |fuel|
+      recursive_fuel fuel
+    end
+
+    puts "Part 2: #{ final_fuel_sum }"
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2019/02.yml

@@ -0,0 +1,285 @@
+---
+- :author: pwhyz
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9ia8ek/
+  :body: |-
+    # Ruby Golfed
+
+    ```ruby
+    def exec_op v
+      { 1 => method(define_method(:a) {|x,y,z,m| m[z] = m[x] + m[y]}),
+        2 => method(define_method(:a) {|x,y,z,m| m[z] = m[x] * m[y]})
+      }[v] || method(define_method(:empty) {|a,b,c,d| nil })
+    end
+
+    def run_program i
+      i.each_slice(4).to_a.map {|p| exec_op(p[0]).call(p[1], p[2], p[3], i)}
+    end
+    ```
+
+    Part 2 was done tweaking input other than with an algorithm.
+
+    Full code at [paste](https://topaz.github.io/paste/#XQAAAQBrAgAAAAAAAAAyGUj/Tve38MzRtZbm3r89bULIsmWYplfgMPs86+76gdev4zrFsCgRGPloppeyn2vkDgnVs1tL4aCNpxNV+Ek2X7ciU/gt7UN550xVUvCcR4Qkv7PIzvyJEYPreWCavBQkbQyvKIgs77AtEnIYz9fCdBzwU1juv6ExDoe/y+Vmeba3UmCzVjjLn9vplrjNswDNH2MdTVu4YfsvT0qZ4PaDlFiyX7LfonVUKXWjpx92l2SeG8fJi+vJTARXv8CDKClDHPuduRsPXSfkW9UV69SZp8tyRHgDVl4zPHiP3REFUeSqGYBiF74yyXpLcoEgwe1GMA+D+90LpkWV1bVFLKLiCGpvz1akP4rt7nB9TrmdJloD/l5ea1d96X8sEIZ3oZ3mPmU7/185jgA=)
+  :replies: []
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9i4v23/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_02
+  :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9fd7tb/
+  :body: |-
+    ​ ​ ​ ​​ ​ ​ ​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ Code
+
+    ​ ​ ​ ​ ​ ​​ ​ ​ ​ ​ ​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ Has bug in it
+
+    ​ ​ ​ ​ ​ ​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ Can't find the problem
+
+    ​ ​ ​ ​​ ​ ​ ​ Debug with the given test cases
+
+    ​​ ​ ​ ​​ ​ ​ ​ ​ ​ ​​ ​ ​ ​ Oh it's something dumb
+
+    ​​ ​ ​ ​​ ​ ​ ​ ​ ​ ​​ ​ ​ ​ Fixed instantly though
+
+    ​ ​ ​ ​​ ​ ​ ​ ​ ​ ​ ​​ ​ ​ ​ Fell out from top 100s
+
+    ​ ​ ​ ​​ ​ ​ ​ ​ ​ ​ ​​ ​ ​ ​ Still gonna write poem
+
+    - "Attempted to draw a house", a poem by Uni
+
+    `ruby 2.rb input` 247/128
+
+    ```ruby
+    a= $<.read.chomp.split(?,).map &:to_i
+
+    #a#=[2,4,4,5,99,0]
+    # begin part 2
+    b=a*1
+
+    want = 19690720
+    (0..99).each{|noun|
+    (0..99).each{|verb|
+    # end part 2
+    a=b*1
+    a[1]=noun # 12
+    a[2]=verb # 2
+    ps = 0
+    until a[ps]==99
+    case a[ps]
+    when 1
+    # bug: a[ps+3]= instead of a[a[ps+3]]
+    a[a[ps+3]]=a[a[ps+1]]+a[a[ps+2]]
+    when 2
+    a[a[ps+3]]=a[a[ps+1]]*a[a[ps+2]]
+    when 99
+    break
+    end
+    ps += 4
+    end
+    # part 1
+    p a[0]
+    # part 2
+    (p [noun,verb]
+    exit)if a[0] == want
+    }}
+    ```
+
+    * * *
+
+    [It looked better in monospace](https://i.imgur.com/zcjuPI2.png). Also I want to tackle every poem type: Day 1 has been haiku, day 2 is shaped poems, will there really be enough types of poems for me to write?!
+  :replies:
+  - :author: tslater2006
+    :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9fe4pf/
+    :body: |-
+      Here's a few different types, should be able to find enough I think?
+
+      [Types of poems](https://www.writersdigest.com/whats-new/list-of-50-poetic-forms-for-poets)
+    :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9h25cv/
+  :body: |-
+    Ruby 2.7.0-dev (hehe)
+
+    https://github.com/ni3t/advent-2019/blob/master/2_1202_program\_alarm.rb
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9f9uu3/
+  :body: |-
+    Ruby, #55/#150
+
+    ```ruby
+    lines = $<.read.split("\n")
+
+    (0..99).each do |x|
+      (0..99).each do |y|
+        codes = lines[0].split(',').map(&:to_i)
+        codes[1] = x
+        codes[2] = y
+
+        idx = 0
+        loop do
+          e = true
+          a, b, c, d = codes[idx..idx+3]
+          case a
+          when 1
+            codes[d] = codes[b] + codes[c]
+          when 2
+            codes[d] = codes[b] * codes[c]
+          when 99
+            if codes[0] == 19690720
+              p codes
+              p x, y
+              p 100 * x + y
+              exit
+            end
+            e = false
+          else
+            raise '??'
+          end
+          break unless e
+          idx += 4
+        end
+      end
+    end
+    ```
+  :replies:
+  - :author: BluFoot
+    :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9fc1f6/
+    :body: |-
+      Golfed it up /u/Unihedron
+
+      ```ruby
+      g=$<.read.split(?,).map &:to_i
+      0.upto(99){|x|0.upto(99){|y|h=g.dup
+      h[1,2]=x,y
+      h.each_slice(4){|a,b,c,d|a==99?(p 100*x+y if h[0]==19690720;break):h[d]=a==1?h[b]+h[c]:h[b]*h[c]}}}
+      ```
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9fcq9j/
+      :body: |-
+        `$<.read.split(?,)` -\> `$/=?,;$<`
+
+        `0.upto(99)` -\> `100.times`
+
+        `h=g.dup` -\> `h=g*1`
+
+        the huge line I don't want to check for now lol. Still working on my poem
+      :replies:
+      - :author: BluFoot
+        :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9gb3xt/
+        :body: I thank you for your teachings, that first one is ridiculous
+        :replies:
+        - :author: Unihedron
+          :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9irna3/
+          :body: |-
+            Some more:
+
+            `p 100*x+y if h[0]==19690720` -\> `h[0]==19690720&&p(100*x+y)` cuts off one char (syntactic sugar is not always shorter!)
+
+            and an advanced but dirty trick: move the `.map &:to_i` from line 1 to line 2, i.e. `h=g.map &:to_i`; since `.map` creates a new array, why duplicate with an operation if we can delay an operation and use it to exploit its new-ness nature? (because it's suboptimal. but hey, code golf!) 2 chars saved?! now, if you followed my advice as before, this wouldn't work because if `g=$<`, `.map` consumes the entire thing and subsequent attempts to `.map` it would fail because `STDIN` reads forwards; so we should make it read everything in at once and reuse that value, so `g=*$<` with spread operator to force it into an array! 2 chars saved 1 char used profit of 1 char!
+
+            BTW, $/=?, helps in this case only because , is not a number. if the seperator is 0, i.e. the input is 10203 and we want 1 2 3, the input "lines" are respectively 10 20 3 which to_i's into 10 20 3. to_i is smart about non-numericals however, and 1, 2, 3 is neatly squeezed into 1 2 3
+          :replies:
+          - :author: BluFoot
+            :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9ixten/
+            :body: |-
+              Wow, the splat operator to make it an array is next level. I'll do anything for 1 char in golf! ANYTHING!
+
+              I think end product after all your suggestions is pretty sexy. 162 chars, not bad!
+
+              ```ruby
+              $/=?,
+              g=*$<
+              100.times{|x|100.times{|y|h=g.map &:to_i
+              h[1,2]=x,y
+              h.each_slice(4){|a,b,c,d|a==99?(h[0]==19690720&&p(100*x+y);break):h[d]=a==1?h[b]+h[c]:h[b]*h[c]}}}
+              ```
+            :replies: []
+  - :author: UnconstrainedRibhus
+    :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9flov9/
+    :body: |-
+      Ah, I like the assignment of `a, b, c, d`
+
+      I am more of a beginner and try to keep it a bit more object oriented. It might actually help as it was hinted that we might need to reuse the `IntCode`
+
+      So my solution looks more something like this:
+
+      ```ruby
+      class IntCode
+        attr_reader :memory
+        # array of numbers
+        def initialize(input, fix: true) ...
+
+        def compute ...
+
+        def memory ...
+
+        def result ...
+
+        def noun= value ...
+
+        def verb= value ...
+
+        private
+
+        def terminate ...
+
+        # parameters
+        def argument_1 ...
+
+        def argument_2 ...
+
+        def target ...
+
+        def fix_programm ...
+      end
+      ```
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/e4u0rw/2019_day_2_solutions/f9h0hpu/
+  :body: |-
+    **Ruby**
+
+    Using `array.repeated_permutation.find` to brute force part 2. Quite a lot cleaner imo than nesting for loops and what-not.
+
+    ```ruby
+    input = File.read('input/input02.txt').scan(/\d+/).map(&:to_i)
+
+    def run(program, noun, verb)
+      memory = program.dup
+
+      memory[1] = noun
+      memory[2] = verb
+
+      memory.each_slice(4) { |opcode, n1, n2, target|
+        case opcode
+        when 1
+          memory[target] = memory[n1] + memory[n2]
+        when 2
+          memory[target] = memory[n1] * memory[n2]
+        when 99
+          break
+        end
+      }
+
+      return memory[0]
+    end
+
+    # Part 1
+
+    p run(input, 12, 2)
+
+    # Part 2
+
+    output = 19690720
+
+    possible_inputs = [*0..99]
+    combinations = possible_inputs.repeated_permutation(2)
+
+    p combinations
+      .find { |noun, verb| run(input, noun, verb) == output }
+      .then { |noun, verb| 100 * noun + verb }
+    ```
+  :replies: []