advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,598 @@
+---
+- :author: lo-crawfish
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hqleezb/
+  :body: |-
+    Both part 1 & 2 in Ruby:
+
+    ```ruby
+    class DayThree
+      attr_accessor :gamma_rate, :epsilon_rate, :consumption_rate, :oxygen_generator_rating, :co2_scrubbing_rating, :life_support_rating
+      def get_input
+        File.readlines('input.txt', chomp: true).map(&:to_str)
+      end
+
+      def initialize()
+        @gamma_rate = ''
+        @epsilon_rate = ''
+
+        @oxygen_generator_rating = ''
+        @co2_scrubbing_rating = ''
+
+        @consumption_rate = 0
+        @life_support_rating = 0
+      end
+
+      def get_rates(input)
+        z = 0
+        gamma_rate = ''
+        epsilon_rate = ''
+        length = input[0].length
+        while z < length
+          gamma_rate += input.map {|x| x[z]}.group_by(&:itself).values.max_by(&:size).first
+          epsilon_rate += input.map {|x| x[z]}.group_by(&:itself).values.min_by(&:size).first
+          z += 1
+        end
+        @gamma_rate = gamma_rate.to_i(2)
+        @epsilon_rate = epsilon_rate.to_i(2)
+
+        @consumption_rate = @gamma_rate * @epsilon_rate
+      end
+
+      def get_life_support_rating(input)
+        o2_input = input.clone
+        co2_input = input.clone
+        z = 0
+        length = input[0].length
+        oxygen_generator_rating = ''
+        co2_scrubbing_rating = ''
+        while z < length
+          grouping = o2_input.map {|x| x[z]}.group_by(&:itself)
+          oxygen_generator_rating += grouping['0'].length <= grouping['1'].length ? '1' : '0'
+
+          c_grouping = co2_input.map {|x| x[z]}.group_by(&:itself)
+          co2_scrubbing_rating+= if c_grouping['0'] && c_grouping['1']
+                                    c_grouping['1'].length >= c_grouping['0'].length ? '0' : '1'
+                                  elsif c_grouping['0'].nil?
+                                    '1'
+                                  else
+                                    '0'
+                                  end
+          o2_input.select!{ |k| k.start_with? oxygen_generator_rating }
+          co2_input.select! { |k| k.start_with? co2_scrubbing_rating }
+          z += 1
+        end
+        @co2_scrubbing_rating = co2_scrubbing_rating.to_i(2)
+        @oxygen_generator_rating = oxygen_generator_rating.to_i(2)
+        @life_support_rating = @oxygen_generator_rating * @co2_scrubbing_rating
+      end
+    end
+    ```
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hnmrn32/
+  :body: |-
+    **Ruby**
+
+    Many days late, but just because I haven't seen anyone else do this approach and because it's particularly short compared to others I've seen: [Gist](https://gist.github.com/peterc/d6e1272a9ba9707e8bde17f04491d119)
+  :replies: []
+- :author: LyleiLanar
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hngnphq/
+  :body: |-
+    My Day3 Ruby solution:
+
+    [I love unnecessary long code in Ruby :D](https://github.com/LyleiLanar/advent-of-code/blob/main/2021/day_3.rb)
+  :replies: []
+- :author: jeffers0n
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7o0iy/
+  :body: |-
+    [Ruby Solution](https://git.doublehack.me/s00ner/AoC2021/src/branch/master/day03/solution.rb)
+
+    I got part 1 done quickly and then got stuck on part 2 for a long time because I didn't read carefully and wasn't updating the most common bits part after each run through the list.
+  :replies:
+  - :author: Mountain_Ad_9551
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn95e39/
+    :body: I did the exact same thing, definitely spent way more time than I should have - lesson learned.
+    :replies: []
+  - :author: ignurant
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7xyvk/
+    :body: |-
+      What led you to know `report[0].length.times { masks.push(2**_1) }` would be a good move? A friend did this in elixir yesterday and used a similar move, just hardcoded: `(1 <<< 12) - 1` for max, then max - gamma for epsilon.
+
+      What was your thought process for solving? I feel like I’m in a place where I can recognize certain tools could be handy, but don’t know enough about it to do anything.
+    :replies:
+    - :author: jeffers0n
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7zqft/
+      :body: Mostly laziness and not wanting to write different code to handle the sample input and the real input since they were different lengths. I was a computer science student a long time ago (never graduated) but my intro classes were in C and we spend a good amount of time working with numbers in binary to really hammer home how computers see numbers so I think a lot of that knowledge is still in the back of my mind.
+      :replies: []
+  - :author: greatfool66
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7xufd/
+    :body: Thank you! In hindsight if I had read the example calculations it would've been clear, but it would have been nice to say "be sure to dynamically update the common bits each time you change position of which bit you're looking at"
+    :replies:
+    - :author: la_nirna
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn8psle/
+      :body: thank you. you are the only person I read so far that explained clearly what was causing the weird behavior I observed. I knew I was doing something wrong but... THANK YOU.
+      :replies: []
+  - :author: ignurant
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7vr0i/
+    :body: Lovely! I look forward to picking this apart. I knew there was some but masking stuff that could be applied, but don’t really know how. I was trying to take an approach where I was iterating per column for gamma and epsilon, and thought to use a bit array for masking the valid candidates for 02 and c02 at the same time. I’m not really sure if that would have worked like I wanted it to, but your solution is next level of what I was considering. You can see what I came up with [here](https://www.reddit.com/r/adventofcode/comments/r7r0ff/comment/hn4r52b/). Sadly, it’s confusing af. Thanks for sharing!
+    :replies:
+    - :author: jeffers0n
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn7xzsu/
+      :body: Thanks! Feel free to reach out if you have any questions. Part 1 I was able to make sense of in my head and code it out pretty smoothly. Part 2 was a different story since I didn't read it properly at first and ended up just fixing spaghetti code for the final working solution. I'd think it has potential be be less clunky.
+      :replies: []
+- :author: Remarkable_Stick4000
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn716s4/
+  :body: "**Ruby - Part 2 with transpose**\n\n[https://gist.github.com/kenzan100/797b993d5c6bff16ccf068c23e27ab2b](https://gist.github.com/kenzan100/797b993d5c6bff16ccf068c23e27ab2b)\n\nlet me know what you think about it \U0001F64F"
+  :replies: []
+- :author: antoniotto
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn6z195/
+  :body: |-
+    # Ruby
+
+    https://github.com/antoniotto71/Advent\_of\_Code\_2021/blob/master/Day%203/day3.rb
+  :replies: []
+- :author: tom_collier2002
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn46c7o/
+  :body: |-
+    Ruby, part 1 only
+
+    ```ruby
+                                 TWO=2
+                                  .to_s(2).
+    to_i ;TEN=eval(
+     '0'.+ ?b.+'10');NET=
+     (TEN^TWO )/TEN/TEN/TEN;INF=
+      (TWO^TEN)- ( TEN^TWO);TWENTY=(+TEN.+(TWO)).times;càll=
+       open('input.txt').map{|cəll|Integer(cəll,TEN)};cãll=->(cäll,cåll){TEN*
+       cäll.map{|cəll|(cəll>>cåll)&NET}.sum>=cäll.count};cáll =->(cåll,cäll){
+      cãll.call(cåll,cäll)?NET<<cäll:INF};câll=->(cåll,cäll){cãll.call(cåll,
+     cäll)?INF: NET << cäll};puts(TWENTY.map{|cəll|cáll.call(càll,
+    cəll )} .sum*TWENTY.map{|cəll |câll.
+                              call(càll ,cəll)}
+                            .sum)
+    ```
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn5kkk7/
+    :body: |-
+      formatted for us old folk on old reddit
+
+      ```ruby
+                                   TWO=2
+                                    .to_s(2).
+      to_i ;TEN=eval(
+       '0'.+ ?b.+'10');NET=
+       (TEN^TWO )/TEN/TEN/TEN;INF=
+        (TWO^TEN)- ( TEN^TWO);TWENTY=(+TEN.+(TWO)).times;càll=
+         open('input.txt').map{|cəll|Integer(cəll,TEN)};cãll=->(cäll,cåll){TEN*
+         cäll.map{|cəll|(cəll>>cåll)&NET}.sum>=cäll.count};cáll =->(cåll,cäll){
+        cãll.call(cåll,cäll)?NET<<cäll:INF};câll=->(cåll,cäll){cãll.call(cåll,
+       cäll)?INF: NET << cäll};puts(TWENTY.map{|cəll|cáll.call(càll,
+      cəll )} .sum*TWENTY.map{|cəll |câll.
+                                call(càll ,cəll)}
+                              .sum)
+      ```
+    :replies: []
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hnotpsy/
+    :body: H... how?
+    :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn17c3c/
+  :body: |-
+    Ruby, 28 / 79
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDqAgAAAAAAAAARiAbIwVXFxjAFiL9gXvewd+HrJP/qqsKzkLBBoZc5Elwn77lWUB+ndDEKyvfvWRD3AtLW7gMtNQBbzo93UAXKSyzrW9TdYlkUT1d1tMdfTJIpZ5r3D0Nf7v5ydxjpPRXcB95xUAAeVc/lTZTFQsA8VytvYvKfp3/cGZmyBuXgm++n0eYGQUxQrEDxrojCaQkWkjpR1b/2AOgTWaFg2hdY/FiiFyKocY+TuNg/6FSZwmiTiLiIltK0E0RbP0ApsOfNwrsNi6cqaP38hbAYP09tdrfwwuuMGuJ8+y/nCqa12c056Ij1IMspsV4TABCY0qry/Tb0eOh4Njkp1qngDtWwl3UkLZ1V8jUr7EvSbql9rdavJvzRvjsgGzMd0+FPV1EV/d1CJrGLEwS9iHgS9d41wKOY8iTVv4gET8+k3P/0v6dK)
+
+    To group input data by bit position, one can convert each string into chars and transpose them:
+
+    ```ruby
+    $<.to_a.map(&:strip).map(&:chars).transpose
+    ```
+  :replies:
+  - :author: dtinth
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn17g51/
+    :body: |-
+      To find the most common, I used the group-then-count technique:
+
+      ```ruby
+      bits.group_by(&:itself).max_by { [_2.length, _1] }.first
+      ```
+
+      In hindsight, there’s only 0 and 1, I could have used:
+
+      ```ruby
+      bits.count('1') >= bits.count('0') ? '1' : '0'
+      ```
+
+      EDIT: u/ni3t and u/gurgeous [recommended](https://www.reddit.com/r/adventofcode/comments/r7r0ff/comment/hn1hqag/?utm_source=reddit&utm_medium=web2x&context=3) [`Enumerable#tally`](https://ruby-doc.org/core-2.7.0/Enumerable.html#method-i-tally), which is new in Ruby 2.7.
+    :replies:
+    - :author: gurgeous
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1evv8/
+      :body: Also see `tally`. I like the count solution, though, since (unlike tally) it returns 0 if the value isn't present.
+      :replies: []
+    - :author: ni3t
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1hqag/
+      :body: |-
+        I used tally:
+
+        ```ruby
+        val,count = bits.tally.max_by { _2 } #=> returns [char, n]
+        ```
+      :replies:
+      - :author: dtinth
+        :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1mulo/
+        :body: "Awesome, TIL about `Enumerable#tally` introduced in Ruby 2.7.\n\nMy Ruby knowledge is so 2.0. \U0001F972 Thank you, doing Advent of Code is a great way to learn new Ruby features."
+        :replies:
+        - :author: ni3t
+          :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1zb2s/
+          :body: The numbered default positional params (\_1, \_2, etc) were introduced in 2.7 as well!
+          :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn18m07/
+  :body: |-
+    Ruby, 408/58. I always use strings for binary puzzles.
+
+    ```ruby
+    def tally(data, ii)
+      Hash.new(0).tap do |h|
+        data.each { h[_1[ii]] += 1 }
+      end
+    end
+
+    n = data.first.length
+
+    # part 1
+    gamma = (0...n).map do |ii|
+      tally = tally(data, ii)
+      tally['0'] > tally['1'] ? 0 : 1
+    end
+    gamma = gamma.join.to_i(2)
+    epsilon = gamma ^ ((1 << n) - 1)
+    p gamma * epsilon
+
+    # part 2
+    oxy, co2 = data.dup, data.dup
+    (0...n).each do |ii|
+      if oxy.length > 1
+        tally = tally(oxy, ii)
+        keep = tally['0'] > tally['1'] ? '0' : '1'
+        oxy.select! { _1[ii] == keep }
+      end
+      if co2.length > 1
+        tally = tally(co2, ii)
+        keep = tally['0'] > tally['1'] ? '1' : '0'
+        co2.select! { _1[ii] == keep }
+      end
+    end
+    oxy, co2 = oxy.first.to_i(2), co2.first.to_i(2)
+    p oxy * co2
+    ```
+  :replies: []
+- :author: madethemcry
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1ewz3/
+  :body: |-
+    **Ruby** Naturally I recognized the opportunities for bitwise opertations. I know about bit planes and such. I even recognized that I can flip the bits in part 1 to get epsilon. Part 2 required to update epsilon and gamma after each turn (which I forget the first time). My mind constantly nagged me to make it beautiful with bitwise operations and such but this would have opened yet another rabbit hole I didn't want. So here we are with some naive solution. I'm happy I can move on.
+
+    **Part 1**
+
+    ```ruby
+    path = File.join( __dir__ , 'input.txt')
+    input = File.read(path)
+
+    transposed = input.split.map {|binary| binary.split("")}.transpose
+
+    gamma = transposed.map do |number|
+      number.count("1") > number.count("0") ? "1" : "0"
+    end
+
+    gamma = gamma.join.to_i(2)
+    epsilon = gamma ^ 0xfff
+
+    puts gamma * epsilon
+    ```
+
+    **Part 2:**
+
+    ```ruby
+    path = File.join( __dir__ , 'input.txt')
+    input = File.read(path)
+    numbers = input.split
+
+    def calculate_gamma(numbers)
+      bit_layers = numbers.map {|binary| binary.split("")}.transpose
+       bit_layers.map do |number|
+        number.count("1") >= number.count("0") ? "1" : "0"
+      end.join
+    end
+
+    def calculate_epsilon(numbers)
+      bit_layers = numbers.map {|binary| binary.split("")}.transpose
+       bit_layers.map do |number|
+        number.count("0") <= number.count("1") ? "0" : "1"
+      end.join
+    end
+
+    def calculate_oxygen (numbers)
+      0xffff.to_s(2).length.times do |index|
+        gamma = calculate_gamma(numbers)
+
+        numbers = numbers.filter do |number|
+          number[index].eql?(gamma[index])
+        end
+      end
+
+      numbers[0]
+    end
+
+    def calculate_co2 (numbers)
+      0xffff.to_s(2).length.times do |index|
+        epsilon = calculate_epsilon(numbers)
+
+        numbers = numbers.filter do |number|
+          number[index].eql?(epsilon[index])
+        end
+
+        if numbers.count == 1
+          break
+        end
+
+        numbers
+      end
+
+      numbers[0]
+    end
+
+    oxygen = calculate_oxygen(numbers.clone).to_i(2)
+    co2 = calculate_co2(numbers.clone).to_i(2)
+    puts oxygen * co2
+    ```
+  :replies:
+  - :author: masterinthecage
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1f2ne/
+    :body: This is so nice, I did everything manually lol
+    :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1bcqb/
+  :body: |-
+    **Ruby** : 4:28/12:10, 360/182
+
+    Here's a [recording](https://youtu.be/lsCQvMg5vtE) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec03.rb). I stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    Having a function to convert a string of 1s and 0s is a must of any coding competition, huh. I tried to outsmart Part 2 but it didn't work. That cost me some time, but I don't think it would have gotten me on the leaderboard.
+  :replies:
+  - :author: siebharinn
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1dr66/
+    :body: binarystring.to\_i(2) will convert a binary string to an integer. No need to write your own.
+    :replies:
+    - :author: CodeIsTheEnd
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn3k7it/
+      :body: Oh, wow! I didn't know that! Thanks for the tip.
+      :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1ea53/
+  :body: |-
+    **Ruby**
+
+    Begin by parsing the puzzle input into an array called `data`.
+
+    Part 1:
+
+    ```ruby
+    def find_common(data, bit)
+      total = data.map{|n| n[bit].to_i}.reduce(&:+)
+      total >= data.length / 2.0 ? 1 : 0
+    end
+
+    bits = data[0].length
+    gamma = [*0...bits].map{|bit| find_common(data, bit)}.join("").to_i(2)
+    epsilon = 2 ** bits - 1 - gamma
+    puts gamma * epsilon
+    ```
+
+    I'm not sure if there is a quick way to get a one's complement, so I just calculated it out.
+
+    Part 2:
+
+    ```ruby
+    def find_rating(data, is_oxygen)
+      (0...data[0].length).each do |position|
+        break if data.length == 1
+        bit_to_find = is_oxygen ? find_common(data, position) : 1 - find_common(data, position)
+        data = data.filter{|l| l[position].to_i == bit_to_find}
+      end
+      data.first.to_i(2)
+    end
+
+    oxy = find_rating(data, true)
+    carb = find_rating(data, false)
+    puts oxy * carb
+    ```
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn5q21z/
+    :body: |-
+      I normally do the one's compliment while the data is still still a String
+
+      `"100101".tr("01", "10") # => "011010"`
+    :replies: []
+- :author: Darth5harkie
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1ke7f/
+  :body: |-
+    ## Rust
+
+    https://github.com/DarthSharkie/advent_of_code\_2021/blob/main/day03/src/main.rs
+
+    Learnings today: \* Trying to mix string and integral representations is a disaster. Pick one and use it. \* Re-implementing [from_str_radix](https://doc.rust-lang.org/std/primitive.u32.html#method.from_str_radix) isn't hard, but it's unnecessary. \* Iterators have lots of fun methods. I used partition, while others used retain. \* Bit shifts look nicer than `2u32.pow(bit)`... \* Rust ranges remind me of Ruby ranges, but I like the `..=` version!
+  :replies: []
+- :author: roundscribehector5
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn3bg24/
+  :body: |-
+    [WET mess in Ruby](https://topaz.github.io/paste/#XQAAAQBaCQAAAAAAAAA5GUqKNoFH6SMnPH0B27EPe2miWFK6m8EZRtBouhvTjCYQJvou4Gfr/FLDUcNQ7hIiDLTf8/+t7QhPhBRZrmC5tIzUIK8riVbsmcmBxHmncTbFiX0h0fv/wBkVsBXz2VYS4f26lTSB2J1Fu0BWxlL7DdH4DdeSYLjXnDo3cC9yYK5pWJgx9HyjjNiq2hR9v+DBnMo+njcYq001k6aOJ0bD4sWO3w6wo7xJ0678fGm7+HudymArdQXKMNYhdHdb9r9fnv96xNUiAf+htKYOaCtNDlkLhJvMxMjOU5ZYKPUXz8wcQ+qnmVinIyP7ZHMjYkK4QJpihaolGuElUJ+kKeWvRLz2x9RjY4Zl+BPF8X+TL8N/jX5ym0OToKtWbqXAfEWrCSyyeukoEqQWsOcgCYBXVXATQC7d0a1hcPTSzWdVcnXfQ1iXgaWkfpC4mdRRYpQUNhyGr530lBxnCQTvx4AtyexLWpRoPXurW+0aM16TmmoqRT/A0fJ9//xHJ4IzpYECpYQKNB0M3Agn7ElBwdz0FyoPLga1BncaOvxsKUNGrZ3utbuVK8gBl0QZOZQJe0C2gSoJYrJnHqcSi+OyCCK+8gFOQRneoFxpPcDw2S/eDXnrW79AYvN++mCnmkp5go03lmLfiKz4qXWa+J1bu9ZhY+gwJ6HxJzJru0FWgywaxyLQlrelmcdyVUnvbW3PRI8RzarOGNCAd6woM6W5LHKbAXmAkl+E7x5sqigUpLsm+aSwhPNm/hj7nvbHl8t7EMmANwLWLiMwGMQvy22qc48v7AH97iSUjTclA4+jkmR7X6WGDmE1i2o4AlD9y/Ng4n7fTtCS+HcDN47MXAvQmO/+ah2cbErt1ULzv7r+/pA1)
+
+    Any feedback is welcome.
+  :replies: []
+- :author: johnboker
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn3r5jp/
+  :body: |-
+    Just learning some ruby
+
+    [https://github.com/johnboker/AoC2021/blob/master/Solutions/day\_03.rb](https://github.com/johnboker/AoC2021/blob/master/Solutions/day_03.rb)
+
+    Comments welcome.
+  :replies:
+  - :author: J-Swift
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn3yi23/
+    :body: Small thing, but `for i in 0...length` is the same thing as `for i in 0..length - 1`
+    :replies:
+    - :author: johnboker
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn43m8h/
+      :body: Thanks!
+      :replies: []
+  - :author: BertZZ
+    :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn5bduo/
+    :body: |-
+      This is a really cool solution, I hope you don't mind I heavily borrowed yours to help me with stage 1, I was having a nightmare. As thanks let me help you with your stage 2 refactor by sharing a method I wrote to find the oxygen value
+
+      https://gist.github.com/BertZZ/1993cec70a282c8223c0ed0fc065a004
+    :replies:
+    - :author: johnboker
+      :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn5gsh0/
+      :body: I don’t mind at all. Looking at your method I see a couple things I’ve not seen before.
+      :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn4r52b/
+  :body: My [Ruby solution](https://tzarnal.github.io/Opal/#XQAAAQABDQAAAAAAAAAxmwhIY/U9UKqMaKWbe6Flsjc1zTEY2+ua+vLboCxGNrQpGt0SFHrtoPmMM5vR5wJxgdvXzC+p5NGFMc3S6/qHLqYJNwfHDuxrMWueJHbAxiyJhXPXck3Fjv0ZSzfetcRwFTQ9iBhfIx5kv5NP0n8nRZb4j71B927wRLGt9RItQ4qrH2z0Bf2QA5GaxrUKPy4dxBwGi2vmkYubJ+Fd8bO5Gg9L8fYAE4L9ynH5yO3qGTJR02SAR/a61gtEOL2gI9qRSQinKyP/NU1LXbAs1hSTfN7sDuDjlu+1YloukkqeS+uJ1lhVxFWmehpYiU6pocB0FuFSD4LiAmDLkyUtpoJv2+iZorkSkC7lGzYD8RVpicM8GsJ3e5L7Qpn57LHmsU+NGfmolVf4S0PsXXwCqJKPr6akJKanGXA4ZMCJKQtFTw0UMET6nJPcc14bNZn4NNRkaFmkEvcbtxgWKgAHgyYWO0cvzrXXWod1q4sc4oz3gDCXG7U4F0x22jnOAWsjpx1JBkIEx3opfRhnqalj3uDRzpKr7Dls9oEr9Ao5Vkyy1mf6+rwSJ61B5BUNd8wi9UpNoJDoP/wW0Os3Y2Z+T3YWyEq5BlUv4fpek94d49tsxlQvU6itZWWgASCS0FS0qVaktASYaVQMfrJ30hJQvXz90B5yMLwLaiLBw8tivbKh0Oc9OxCpZvXcVNPSaIunTeRcZv3Ixyr2za92xwtBuINu+sy290BIxqsZNl28rU4T7vJfbgCXzVD48qti1NqwIewywhgA3t77ctNmrITVFmAE9oICrl3ZMnCMgrTaxN1Ob+LM6XqUWDoLjZtSdIz+MUEhDCNRGAg3DKfs+huMPSNY50mfOUlDiCYOql+c5vwO0me8F1s4wOe5TrUPhTtZRz2ehguYAG5fvUk1PTasZTbn4ATxgoizlXw3SYsSoN2UYHF5Z8E/9qSHckPOrQ4zdwGol0EUZXDsY4KqC+yg2RTKmyPlvcjry1mN4cwBkGqkjy/V9UtWC1uEQN+R8jpUmjqG4Rva+MXZBsVOlm15YsbENmmbNNMsNi7TRcTpO9bQRZoJpVB99Z1oQYhdrqT2fET8FgDYqt/RWx2pwoc8u4CkvdPc1hmnwzC9IkTO/VtWL7JOMsrR/yfNVkdQkklTQPCWZFoheZrm6OoWq8VrJ/WlKYqD+7C2oswK++J2+cuR/Woj95dVupjEF0zcndNEU2Bv7+NXdVTsc2qJdOEKW7nAI1/4i68YlhvcO2N7toLU1Eph5qpVSEMWTyRv7np2I6LJ0gME/mIolc94ootdpfxNYUKTab9XrMkoUzBqC4Q6jM4iVoBHiPY+3Y/GxAJl3V2ijlbie8lh3bDstZpc70G+RhMewSOKSoAClBA5VynVqPLOcKRFnK+XbgAIGh7/sw3bYcFUWAxbmcJeXmcBtcjMjntQajqen/vRlUGZxWZiDKOtPIk3qxLO0i2Zj4oRtpFIaG09l+IrF0/EFMEW0aw33K6s+JS7XVEg1DtrFVq4szZPJTkjZMecHF+VI8HK0+FVLphxGyv09vmztIT/fDidAA==). After seeing your guys' moves... man, alive.
+  :replies: []
+- :author: EIykris
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn5jp9y/
+  :body: |-
+    # Ruby, rb
+
+    Decided to use Ruby today because my TypeScript was taking too long to run.
+
+    ```ruby
+    input = File.read("./inputs/3.txt").split("\n").map { _1.chars.map &:to_i }
+
+    gamma = input[0].size.times.reduce("") { |a, b|
+        a += (bits = input.map { _1[b].to_i }).max_by { bits.count _1 }.to_s
+    }
+
+    p gamma.to_i(2) * gamma.tr("10", "01").to_i(2)
+
+    p [input, input].each_with_index.map { |n, s|
+        n[0].size.times { |i|
+            break if n.size <= 1
+            n = n.filter { |b| b[i] == (n.map{ _1[i] }.sort[n.size >> 1] ^ s) }
+        }
+
+        n[0].join.to_i(2)
+    }.inject :*
+    ```
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1h3p8/
+  :body: |-
+    ### Ruby
+
+    The initial solve was much dirtier, but cleaned up:
+
+    ```ruby
+    @data = DATA.each_line.map(&:chomp).map(&:chars)
+    @ex1 = ex1.each_line.map(&:chomp).map(&:chars)
+
+    data = @data
+
+    bitcount = data.first.count
+
+    minbits = data.dup
+    maxbits = data.dup
+
+    transposed = data.transpose
+
+    a1 = []
+
+    bitcount.times do |i|
+      maxval, maxcount = transposed[i].tally.max_by { _2 }
+      maxval = '1' if maxcount == bitcount.to_f / 2
+      minval = maxval == '1' ? '0' : '1'
+      a1 << [maxval, minval]
+
+      unless maxbits.count == 1
+        maxval, maxcount = maxbits.transpose[i].tally.max_by { _2 }
+        maxval = '1' if maxcount == maxbits.length.to_f / 2
+        maxbits = maxbits.filter { _1[i] == maxval }
+      end
+
+      next if minbits.count == 1
+
+      minval, mincount = minbits.transpose[i].tally.min_by { _2 }
+      minval = '0' if mincount == minbits.length.to_f / 2
+      minbits = minbits.filter { _1[i] == minval }
+    end
+
+    puts a1.transpose.map {_1.join.to_i(2)}.reduce(:*)
+    puts [maxbits, minbits].map { _1.join.to_i(2) }.reduce(:*)
+
+    __END__
+    ```
+  :replies: []
+- :author: snowe2010
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1i9zq/
+  :body: |-
+    Ruby:
+
+    very messy part 1 and I'm embarrassed by part 2, but you can view it on [github](https://github.com/snowe2010/advent-of-code/blob/e6bc01b526f41d3e8c9af0e1c21baa6ce43d7953/ruby_aoc/2021/day03/day03.rb):
+
+    ```ruby
+      length = lines[0].split('').length
+      sum = Array.new(length, 0)
+      lines.map do |line|
+        bits = line.split('')
+        bits.each_with_index do |bit, i|
+          if bit == "0"
+            sum[i.to_i] -= 1
+          end
+          if bit == "1"
+            sum[i.to_i] += 1
+          end
+        end
+      end
+      sum.map { |i|i>0?1:0}.join.to_i(2) *sum.map { |i| i>0?0:1 }.join.to_i(2)
+    ```
+  :replies: []
+- :author: StMonty
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn1m7c7/
+  :body: |-
+    Ruby Part 1: This is pretty hacky, still learning but was fun
+
+    ```ruby
+    DATA = File.readlines("input").map {|line| line.strip.chars}
+    arr = DATA.transpose
+    gamma, epsilon = "", ""
+    arr.each do |sub|
+        result = sub.max_by {|c| sub.count(c)}
+        gamma += result
+        result == "1" ? epsilon += "0" : epsilon += "1"
+    end
+    puts gamma.to_i(2) * epsilon.to_i(2)
+    ```
+  :replies: []
+- :author: lucianoq
+  :url: https://www.reddit.com/r/adventofcode/comments/r7r0ff/2021_day_3_solutions/hn2enf9/
+  :body: |-
+    Ruby, part1:
+
+    ```ruby
+    lines = ARGF.map { |line| line.strip }
+
+    gamma = [*0...12].map do |bit|
+      lines.map { |l| l[bit] }.tally.sort_by { |_, v| -v }.to_h.keys[0]
+    end.join
+
+    epsilon = gamma.tr("01", "10").to_i(2)
+    gamma = gamma.to_i(2)
+
+    p gamma * epsilon
+    ```
+  :replies: []