advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,420 @@
+---
+- :author: '442401'
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0my8nw/
+  :body: |-
+    This was a fun one, implementing a custom sort algorithm. I have no idea what type of sort I created, or what the Big O notation might be, but it works and seems to be fairly performant.
+
+    [pastie](https://topaz.github.io/paste/#XQAAAQBcBAAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw3D1UZFlD3WW8r2Z9pYT30X7PldGU70XB3egANSDGaglT19UFgzZK2FcUaGiOj2QwDkRsdSI8VlTlRHSx96rEK2fgYkMopVYMKvFrxYEOtlpraQtqXI869FkwIsNbKnv6kcagyhdLWfX1FrLl8cJPgtkQe8xLG+avOac7tsm2wzZjJAichGLIJe9pTdisr1vtXsU3qY0B+qxOP04rSWBTWOsIUzYidqufpLIMbHSc2mRiKVRtfOPytmcjdxuNZ88HGUtQYhQj5oRfApkIikmSc7LwHkj+/qxyQ/14ilCVT1UA+dggc1BlIiGBMDdiyKElBXCnuPhwhZnHZ4ydwmaw0i0QafjZcAQiq8KsDn+SSZLxk3cL1AS5MkB8D+vl96hAPL1U8Q4cZVmMA/0hp4tZOrPZrdm6H1jpMMPLFq4MR5QxHAEgv+AG8Q+uPPtIoba+uvxlwXQyuEEUWUudm3ee1Xfvsj5vOZVA/YVg8F1LwpawkD46eKBV8A2at6zmXymUBhK3JhHhAQIb2drHe61bY5XIkjxHzKoS4SSjWwlExFQ7Z05kxWy3WsxazIE7ID/mP6iVSLUE1kMpUhcd1I8oidpQBtSBHCSEXRhC8c2+F8spS5DlP0//yr/1AA=)
+  :replies:
+  - :author: nullset_2
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0t597s/
+    :body: "+1 for ruby \\<3"
+    :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0hz686/
+  :body: |-
+    ```ruby
+    orderings, updates = ARGF.read.split "\n\n"
+
+    orderings = orderings.lines.map { _1.split("|").map(&:to_i) }
+    rules = orderings.reduce(Hash.new { _1[_2] = Set.new }) { |a, (l, r)| a[l].add(r); a }
+    updates = updates.lines.map { _1.split(",").map(&:to_i) }
+
+    incorrect = []
+
+    puts updates.sum { |pages|
+      next pages[pages.size / 2] if pages.size.times.all? { |i|
+        pages[..i].then { |*h, t| h.all? { !rules[t].include? _1 } }
+      }
+      incorrect << pages
+      0
+    }
+
+    puts incorrect.map { _1.sort { |a, b|
+      rules[a].include?(b) ? -1 : rules[b].include?(a) ? 1 : 0
+    } }.sum { _1[_1.size / 2] }
+    ```
+
+    It took a while for me to grasp how to solve it, but then it turns out it wasn't so complex.
+
+    Part 2 was quite easy by just using the rules in a custom comparator for the `sort` method.
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i076g/
+  :body: |-
+    3324/5754
+
+    well this was horrible. I think I should have used the TSort module in the stdlib, but then I got carried away. Very unhappy with the logic to check if a solution is good for part 1 (which I reused in part 2 but it's not needed), which I think should be simpler
+
+    [https://gist.github.com/riffraff/70e9feca5b8d3c236557a7e0796268db](https://gist.github.com/riffraff/70e9feca5b8d3c236557a7e0796268db)
+  :replies:
+  - :author: musifter
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iepv5/
+    :body: Don't worry about not using a topological sort. The input is not a DAG, it has loops. There is no complete sort of the pages, only subsets of them.
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kiv0k/
+  :body: |-
+    Had a hunch about this one. Felt pretty good when on part 2 I just had to change a `.filter` into a `.partition` and the rest just fell in place by itself :)
+
+    ```ruby
+    require 'set'
+
+    input = File.read('input05.txt')
+
+    order = Hash.new { |h,k| h[k] = Set[] }
+    input.scan(/(\d+)\|(\d+)/) { order[$1.to_i] << $2.to_i }
+
+    updates = input[/(?<=\n\n).*/m].lines.map { _1.scan(/\d+/).map &:to_i }
+
+    (correct,incorrect) = updates.partition { |update|
+      update.map.with_index.all? { |page,i|
+        update[0...i].none? { |before| order[page].include? before }
+      }
+    }
+
+    # Part 1
+    p correct.sum { _1[_1.length/2] }
+
+    # Part 2
+    p incorrect
+      .map { _1.sort { |a,b| order[a].include?(b) ? -1 : order[b].include?(a) ? 1 : 0 } }
+      .sum { _1[_1.length/2] }
+    ```
+
+    ([part 2 diff](https://github.com/daniero/code-challenges/commit/6923d035a911359c626333c75bae423c28d0c553))
+  :replies:
+  - :author: TailorSubstantial863
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kylv4/
+    :body: |-
+      I'm pretty sure my code does the exact same thing as yours (algorithmically speaking) but it takes 83 lines.
+
+      nicely done. I'm gonna have to put your code in debug mode to figure it out I think.
+    :replies: []
+- :author: gosshedd
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iagt3/
+  :body: |-
+    Using the spaceship operator makes both parts equally simple.
+
+    [Gist](https://gist.github.com/gmitrev/47b0498c2bd403589cd866b2b077689a)
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ihywy/
+  :body: |-
+    Part 1
+
+    ```ruby
+    rules, input = File.read("input.txt").split("\n\n").map{|l| l.split("\n")}
+
+    rules = rules.map{ _1.split("|")}
+    input = input.map{ _1.split(",")}
+
+    p input.filter{ |l| rules.all?{|a,b| !l.include?(a) || !l.include?(b) || l.index(a) < l.index(b)}}
+           .map{ _1[_1.size/2]}
+           .sum(&:to_i)
+    ```
+
+    Part 2
+
+    ```ruby
+    rules, input = File.read("input.txt").split("\n\n").map{|l| l.split("\n")}
+
+    rules = rules.map{ _1.split("|")}
+    input = input.map{ _1.split(",")}
+
+    incorrect = input.filter{ |l| !rules.all?{|a,b| !l.include?(a) || !l.include?(b) || l.index(a) < l.index(b)}}
+
+    p incorrect.map{ |l| [l, rules.filter{|a,b| l.include?(a) && l.include?(b)}]}
+               .map{ |l,r| l.map{|n| [n,r.map(&:first).count(n)]}}
+               .map{ |p| p.sort_by(&:last).map(&:first)}
+               .map{ _1[_1.size/2]}
+               .sum(&:to_i)
+    ```
+  :replies:
+  - :author: Ill_Information_9522
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0lng6f/
+    :body: Enjoying following along with your solutions after solving them myself with my beginner's grasp of Ruby. Thanks for sharing.
+    :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k2hny/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQA0AwAAAAAAAAA5GUqKNoFH6SMqoVC09YUYn9dyScIBDNYTI4hnvKYWXrPwLsHeHO6l2A0mcRl8Ns3HhQylr3Khfz4JY3+czGhZ93QRGZ/H13DAhWFK7sa7Zv6wWS5++4B4VBZWS5ooiS9de/AlbgI7SjS9heaT2QZnwnZj8giLuaos879X3tI0OJIAogzVUHsgYA0ss0NCeSeaaYRd5dTDriXvXcR0BJQhPeX656k0aWJc79qLHua5fmyFZlpkgrmWHeyQcwm2HzboaMyI/PkhtftOcshzo6ZF1Fn7BRPLa0yZS+JtnWne3EwZRdofK4WG9fc//SX9tbDPgPzr6nYntRd6tKj6WoQNGbtVnOEMA2gKAm4nkVd5SxafWvtFGYpqVBu+r5l6ZIef8H3S7eXUz8qMynQtLBemtp5tY8OnRd6NYf6pRe5XfCBYuuihZxi63r2bpv7S2qR0C/ZenWzHdeCYwMvvEg8M2GwIASjVE1KXXIh38dhsMemXkqdBaX1CUWqSYebyBGT9zhDtieKKnpdIk/18Tf3qLsMSzff/tJCSSw==)
+
+    Very interesting problem that is actually quite educational about binary relation and total ordering. Might write up a tutorial post later as a review for myself as well ([done!](https://www.reddit.com/r/adventofcode/comments/1h7mm3w/2024_day_05_part_2_how_nice_is_the_input_a_binary))
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kvznz/
+  :body: |-
+    both parts, quick and easy:
+
+    ```ruby
+    order, list = $<.read.split("\n\n").map { |l|
+        l.split("\n").map { _1.split(/\||,/).map(&:to_i) }
+    }
+
+    ogt = order.group_by(&:first).transform_values { _1.map(&:last) }
+    olt = order.group_by(&:last).transform_values { _1.map(&:first) }
+
+    sol = list.reduce(Hash.new(0)) { |h, l|
+        pl = l.sort { |a, b|
+            ogt[a]&.include?(b) ? -1 :
+            (olt[a]&.include?(b) ? 1 : 0)
+        }
+        h[l.zip(pl).all? { _1[0] == _1[1] }] += pl[pl.size/2]
+        h
+    }
+
+    print('Part 1: ', sol[true], "\n")
+    print('Part 2: ', sol[false], "\n")
+    ```
+  :replies: []
+- :author: The_Jare
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0l9y1s/
+  :body: |-
+    ```ruby
+    rules, reports = ARGF.map(&:strip).reject(&:empty?).partition { | l | l.index("|") }
+
+    $rules_db = Hash.new { |h,k| h[k] = [] }
+    rules.each do | line |
+      a, b = line.strip.split("|").map(&:to_i)
+      $rules_db[a].push(b)
+    end
+
+    def compare(a, b)
+      return -1 if $rules_db.include?(a) && $rules_db[a].include?(b)
+      return 1 if !$rules_db.include?(b) || $rules_db[b].include?(a)
+      0
+    end
+
+    reports.map! { | line | line.split(",").map(&:to_i) }
+    correct, incorrect = reports.partition do | report |
+      report.each_cons(2).all? { | a, b | compare(b, a) != -1 }
+    end
+    incorrect.map! { _1.sort { | a, b | compare(b, a) } }
+
+    p [correct, incorrect].map { _1.sum { | r | r[r.length/2] } }
+    ```
+  :replies: []
+- :author: HAEC_EST_SPARTA
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i5hkk/
+  :body: |-
+    [Solution on sourcehut](https://git.sr.ht/%7Eawsmith/advent-of-code/tree/2024-ruby/item/lib/day05.rb)
+
+    I wasted a significant amount of time implementing a topological sort of the ordering constraints, just to discover that my input had cycles, so that sort wasn't really possible. After that, I implemented the non-graph solution above. Notable features are the reversal of the updates in `unordered?`, which allows me to check whether any ordering constraint is violated without having to iterate through the constraints, and the usage of an insertion-sort-style first-fit allocation algorithm for pages in Part 2 to perform the allocation of each page in linear time.
+  :replies:
+  - :author: Eilip999
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6mgo/
+    :body: |-
+      It should not be possible for cycles in input to happen, if it was a case you wouldn't be able to sort it even with your algorithm which is not based on graph.
+
+      Edit, Okay it might be possible to have cycle in rules, but then cycle should not be visible in list of pages, so like, you have the edges, but vertices are missing so these edges should not be included in the graph.
+    :replies:
+    - :author: HAEC_EST_SPARTA
+      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i7zul/
+      :body: Right, the global set of ordering constraints does contain cycles, although if you pare it down to only the pages contained in each update, then that is no longer the case. I realised that a bit too late, but _c'est la vie_.
+      :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6xkn/
+  :body: |-
+    I initially wasted time creating "before rules" and "after rules" for part 2, thinking I would need the reverse map to 'squeeze' a value in to the right place. But saw through testing after I was done that it was pointless. I wish I would've thought of the 'sort' method though as that's a clean result.
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/05/solution.rb)
+  :replies: []
+- :author: im_sofi
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ix512/
+  :body: |-
+    Interesting day. Worked a bit on my `std++` library and added a `Enumerable#partitions` function to allow a partitioned scan of `|left, current, right|` over the elements so i could handle the rules being defined as `before` and `after`.
+
+    Later realized that you only really need to check one of these, and `Enumerable#partitions` lost a lot of its value. Still a fun experiment.
+
+    https://github.com/soupglasses/advent-of-code/blob/main/2024/ruby/day\_05.rb
+  :replies: []
+- :author: Independent_Top_8716
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iy7eq/
+  :body: |-
+    After (not unexpectedly) realizing that a recursive or permutations based approach would not scale for part2 I used a hinted approach for part 2
+
+    ```ruby
+    preface, body = input.split("\n\n")
+    rules = preface.lines.each_with_object(Set.new) { |l,a|
+        a << l.strip.split("|").map(&:to_i)
+        a
+    }
+    updates = body.lines.map { |l|
+        update = l.strip.split(",").map(&:to_i)
+    }
+
+    def valid?(update,rules)
+            update.each_cons(2).map { |curr, nxt|
+                rules.include? [curr,nxt]
+            }.all?
+    end
+
+    def score(updates, rules)
+        updates.map { |update|
+            if valid?(update,rules) then
+                update[(update.size-1)/2].to_i
+            else
+                0
+            end
+        }.sum
+    end
+
+    part1 = score(updates,rules)
+
+    invalid = updates.filter { |update|
+        !valid?(update,rules)
+    }
+
+    def sort(update, rules)
+        workdone = 0
+        loop do
+            # p update
+            (0..update.size-1).each { | idx |
+                l = update[idx]
+                r = update[idx+1]
+                next if rules.include? [l,r]
+                if rules.include? [r,l] then
+                    update[idx] = r
+                    update[idx+1] = l
+                    workdone = 1
+                end
+                }
+                break if valid? update, rules
+            end
+        update
+    end
+
+    validated = invalid.map{ |update| sort(update, rules) }
+
+    part2 = score(validated, rules)
+    [part1, part2]
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j6f41/
+  :body: |-
+    It wasn't immediately obvious to me that implementing a ruby sort function would just work here, but it seems there is only one validly sorted order for the string based on the rules, making this leap confirmed the solution to me.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/5](https://github.com/careyi3/aoc_2024/tree/master/solutions/5)
+  :replies:
+  - :author: FCBStar-of-the-South
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jtl71/
+    :body: I did not want to implement sorting because there is not any guarantee that the | relation is transitive but apparently it is
+    :replies:
+    - :author: careyi4
+      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k1hjd/
+      :body: Yeah, same, it didn't feel like it should work, but when I tried it and it did work I was surprised. I felt like there surely should be multiple orders that satisified the rules, apparently not per the rules.
+      :replies:
+      - :author: FCBStar-of-the-South
+        :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k23ww/
+        :body: I was probably reading between the lines too closely haha. The example explicitly checked the ordering between every pair instead of just the adjacent pairs and I thought that's a sign the relation might not be transitive
+        :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j9e9o/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day05.rb)"
+  :replies: []
+- :author: masterarms
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jm95n/
+  :body: |-
+    Part 2 took me quite some time before realizing a sort would work.
+
+    ```ruby
+    preface, body = input.split("\n\n")
+    rules = preface.lines.each_with_object(Set.new) { |l,a|
+        a << l.strip.split("|").map(&:to_i)
+        a
+    }
+    updates = body.lines.map { |l|
+        update = l.strip.split(",").map(&:to_i)
+    }
+
+    def valid?(update,rules)
+            update.each_cons(2).map { |curr, nxt|
+                rules.include? [curr,nxt]
+            }.all?
+    end
+
+    def score(updates, rules)
+        updates.map { |update|
+            if valid?(update,rules) then
+                update[(update.size-1)/2].to_i
+            else
+                0
+            end
+        }.sum
+    end
+
+    part1 = score(updates,rules)
+
+    invalid = updates.filter { |update|
+        !valid?(update,rules)
+    }
+
+    # Considering the rules are a complete set of a|b combinations
+    # If a|b is not a rule a must be after b
+
+    validated = invalid.map { |i| i.sort {| a, b | if rules.include?([a,b]) then -1 else 1 end }}
+
+    part2 = score(validated, rules)
+    [part1, part2]
+    ```
+  :replies: []
+- :author: fredster231
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jploy/
+  :body: |-
+    ```ruby
+    rules, updates = File.readlines('005.input')
+      .map { _1.strip }
+      .reject { _1.empty? }
+      .partition { _1.include? '|' }
+      .map { |list| list.map { _1.split(/\D/).map(&:to_i) } }
+
+    correct, incorrect = updates
+      .partition { |u| !rules.any? { u.include?(_1) && u.include?(_2) && u.index(_1) >= u.index(_2) } }
+
+    # Part 1
+    p correct.sum { _1[_1.size/2] }
+
+    # Part 2
+    p incorrect
+      .map { |pages|
+        # Filtering the list of rules once and then iterating over that list pairwise is quite a lot
+        # faster than iterating over the list every pair, for the relevant sizes of the lists: rules, update.
+        relevant_rules = rules.filter { |r| r.all? { pages.include?(_1) } }
+        pages.sort { relevant_rules.include?([_1, _2]) ? -1 : 0 }
+      }
+      .sum { _1[_1.size/2] }
+    ```
+  :replies: []
+- :author: clonewolf
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kh6du/
+  :body: |-
+    Unable to do a TSort on the whole set, I'm doing TSorts on each subset of the graph defined by each update.
+
+    [https://github.com/christopher-b/advent-of-code/blob/main/lib/advent/year2024/day05.rb](https://github.com/christopher-b/advent-of-code/blob/main/lib/advent/year2024/day05.rb)
+  :replies: []
+- :author: sigmazero13
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kl2i7/
+  :body: |-
+    Parts 1 and 2 together.
+
+    [2025 Day 05](https://topaz.github.io/paste/#XQAAAQB1BgAAAAAAAAARiArHwcXVMMi3ARNdxyce9ZWdY4wAZS5105VirpgIVjqsFysGsQ1Md9jiWx3r6ZOwrvi9TSxnbWFcRH8V3hqszL1EkvVGMEAHUtCGxRwFXdSZXKIbJvZyCTWIhdpmB71/PjYRh5scBVZCrAKGzmnJtSzMPYR6xHaakk1oEoPEsrW67zfbQPqIUFDkO7ZI1Ar369GmOAuoymaDxfrQVsLEenRoFYR4a57SSm6pnWNbM6TUir70nNBme/xwpxpoiLl2Cpdrq+yTZd19v/PUNcNQN31gbGDCNDq/du2JBGf5mmK8W6oMZ2nkO9nFqzknuH4uPNaBsJZ6OlNuGEQI27bDGTQghNRbc8z8A769z1yFdBZuViuk+1h+0w0II26PiL6PlR0PCKmxZio/X7iT30KKROsd64On7yIr00TdYvMBqZuoqwh0y8h98tZjMDdKHd5+Jm7pJj4b9VWHdaRVgNiBYJDg0RfJhzAZJeQWYppCJi+VlbZ0I41c6MTE34Dt1mj80VFLPHR0IP1DUhf/mjW8uDkicZE8ccfBeT8OX8eat7BPFySc822OL8Q1pLAzLNIxGM6z+j7QjnlplnRpRA2slhUqDaEW4v2B3XjbUStWpYxRxy/l3i2fizkWW5h+/V/tkMyuZP3B2Ey8NATG8ULx7ukX/UTHpdq7BHWBf7UMeF9YWXuOWCEjSFwdHDRjin01OSLnEZ7p+vSHThidGOcf+WZKTGlVst7pP1ZkA65fjLdy/LeiZNlCuw8mOMYgQBBnFaXHtZieEeXtE/UutuOYUGKPamBJRhtqvLXJ4IYjKoFTu9Egj9QaHi/w2d2W3TlmTRacmVTBPIGiRnDkvp+dcMxRv8DAUWAungPnSeCT6NT15Jnn8KVG9WtrlE6yAL4c4qXSYb60DcOifdW2TLJWix5R2W3efotNY8cyGngx/ZSsNg==)
+
+    Basically, just created a Page class with methods to allow for custom sorting using the rules. From there, finding the valid updates (and fixing the invalid ones) was a piece of cake.
+  :replies:
+  - :author: rcraggs
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kpg4l/
+    :body: |-
+      I did the same thing in Python. No idea about efficiency but it makes for really tidy code and a simple idea
+
+      ```ruby
+      def page_sort(page1, page2, rules):
+          if [page1, page2] in rules:
+              return -1
+          elif [page2, page1] in rules:
+              return 1
+          else:
+              return 0
+      ```
+    :replies: []

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

@@ -0,0 +1,170 @@
+---
+- :author: tycoon177
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0xo9lk/
+  :body: |-
+    [Part 1 and 2](https://github.com/BenMcH/advent-of-code/blob/df8325ce8e633e307b599a8e367537351c993e8b/2024/lib/day_06.rb)
+
+    My initial solve took roughly 60 seconds to solve part 2 despite only placing items in the guard's original path. I spent some time optimizing today after my day 7 solve and settled on a mildly recursive solution that places an obstacle in front of the guard after every step they take, runs a simulation from there, and continues with the original.
+
+    By re-using that previous state in this manner, I was able to shave this solution down to 1.5 seconds with ease. I'm sure I could further optimize, but I'm happy at this point.
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pdsmr/
+  :body: |-
+    Just brute force today...
+
+    [https://pastebin.com/LqRbJUxi](https://pastebin.com/LqRbJUxi)
+
+    Edit: Optimized my solution a bit, but still takes ~17 sec for part 2.
+  :replies:
+  - :author: quokka70
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qlk97/
+    :body: Using a Set for @grid instead of an array will make `grid.include?` faster (unless the hashing overhead is too much).
+    :replies:
+    - :author: _tfa
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0uf1wc/
+      :body: You are right. That was the optimization I did after I sent the code to pastebin (couldn't edit it there)
+      :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0q4x8j/
+  :body: |-
+    Biggest thing that tripped me up was I was failing to recheck if I was facing another wall after rotating. A litreal one word change from an if statement to a while loop fix it for me.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/6](https://github.com/careyi3/aoc_2024/tree/master/solutions/6)
+  :replies:
+  - :author: globalreset
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qdjv8/
+    :body: Same!
+    :replies: []
+- :author: nothimofc
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ny6iz/
+  :body: |-
+    While Part 1 (counting distinct positions visited) works relatively fast, Part 2 (finding loop-causing obstacle positions) is extremely slow for large grids.
+
+    [github](https://github.com/osu/advent-of-code/blob/main/day6/joe.rb)
+  :replies:
+  - :author: nothimofc
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0nywg2/
+    :body: I would appreciate any advice from fellow ruby enjoyers I could have gotten a much better placement than 70/10 :( if it was faster.
+    :replies:
+    - :author: Lucky_Menu3724
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o4twa/
+      :body: |-
+        Here is what I did. I tested your code and mine was about twice as fast, but it took me a lot longer than you to write :) 18s to run on an old laptop.
+
+        [https://gist.github.com/imme5150/d51ab9746902aa1e2609bc7d1cbb3866](https://gist.github.com/imme5150/d51ab9746902aa1e2609bc7d1cbb3866)
+      :replies:
+      - :author: nothimofc
+        :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o6704/
+        :body: Sheesh nice
+        :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o89vy/
+  :body: |-
+    Got stuck for an hour on part 2 before realizing that the obstacle created a situation where you could turn away from a wall to find another wall. Tricky since I got away without handling that case in part 1. Seems like the input was constructed just to allow that mistake on part 1 and kill me on part 2. Just a matter of changing "if(grid[nextPos]=='#' || nextPos==obstructedPos)" into "while(...)".
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/06/solution.rb)
+  :replies: []
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0oma65/
+  :body: |-
+    [https://gist.github.com/vincentwoo/bff280de0b1fb16d4e511d85c339879a](https://gist.github.com/vincentwoo/bff280de0b1fb16d4e511d85c339879a)
+
+    Was pleased enough to find a formulation that uses the same code for both initially running through the maze as well as splitting off to see if each next step's hypothetical obstacle would generate a loop. Sharing the in-progress seen list saves quite a bit of time. 35 lines and about 2s runtime.
+  :replies: []
+- :author: masterarms
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ot8pg/
+  :body: |-
+    It was quickly obvious that trying a block on every empty grid position would not scale. But with 2 optimisations the runtime was tolerable.
+
+    ```ruby
+    grid = AOC.grid(input,nil) # Make a grid hasmap of the input
+
+    def step(guard, g)
+        rotate_right = {'>': 'v', 'v': '<', '<': '^', '^': '>'}
+        x,y = guard[:pos]
+        dir = guard[:dir]
+        next_pos = case dir
+            when '^'
+                [x,y-1]
+            when '>'
+                [x+1,y]
+            when 'v'
+                [x,y+1]
+            when '<'
+                [x-1,y]
+          end
+        return {pos: [x,y], dir: rotate_right[dir.to_sym]} if ['#', 'O'].include? g[next_pos]
+        return {pos: next_pos, dir: dir} if ['.', 'X','^'].include? g[next_pos]
+        nil
+    end
+
+    def visited(g)
+        guard = {pos: g.find { |k,v| v == '^' }.first, dir: '^'}
+        states = Set.new # Whoever said an Array here was slow wasn't lying
+        has_loop = loop do
+            states << guard
+            g[guard[:pos]] = 'X'
+            nxt = step(guard,g)
+            break false if nxt.nil?
+            break true if states.include? nxt
+            guard = nxt
+        end
+        visited = states.map { |state| state[:pos] }.to_set
+        {visited: visited, has_loop: has_loop}
+    end
+
+    g = grid.clone
+    guard = {pos: g.find { |k,v| v == '^' }.first, dir: '^'}
+    start = guard[:pos]
+
+    part1 = visited(g)
+    count = 0
+    RubyVM::YJIT.enable
+    # Try the only spots that can make a difference
+    cands = part1[:visited].filter { | e | e != start }
+    part2 = cands.map { |cand|
+        p count if count % 100 == 0
+        testgrid = grid.clone
+        testgrid[cand] = 'O'
+        count += 1
+        visited(testgrid)[:has_loop]
+    }.count(true)
+    p [part1[:visited].size, part2]
+    ```
+  :replies:
+  - :author: masterarms
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pa90y/
+    :body: |-
+      I was not too happy with the rotation and moving logic, so I made a second version using Complex numbers as the coordinates. In that case a movement is simply an addition and a rotation of the direction a multiplication by `Complex::I`.
+
+      It turned out to be slightly faster as well:
+
+      ```ruby
+      Array coords: 32.170975 0.438696 32.609671 ( 32.810754)
+      Complex coords: 29.965841 0.369446 30.335287 ( 30.568308)
+      ```
+    :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pjb4l/
+  :body: |-
+    Brute force solution for part 2, runs in 40s for both parts.
+
+    [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day06.rb)
+  :replies: []
+- :author: Infinite-Club4374
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0podjn/
+  :body: "Hey all! I’m having a bit of trouble locating the last edge cases, anyone have any ideas?\n\nWith my custom input my solution gives 1573 but should be 1686. Would really appreciate any insights or help \U0001F499\n\n[GitHub](https://github.com/Leftyxiv/advent_of_code/blob/main/2024/day6/day6.rb)"
+  :replies:
+  - :author: ash30342
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0prpve/
+    :body: I think you missed that when you turn right, you can immediately encounter an obstacle again. You should keep turning until you can move on. That tripped me up :)
+    :replies:
+    - :author: Infinite-Club4374
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pse59/
+      :body: "You just saved my life!!\n\nI had a check for that initially but I only turned once instead of looping and you gave me the idea to loop until a direction was good!\n\nTHANK YOU SO MUCH INTERNET FRIEND\U0001F499\U0001F499\U0001F499\U0001F499"
+      :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0sbg2g/
+  :body: "[paste](https://topaz.github.io/paste/#XQAAAQA9BwAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8e/u+sq3cCy1X/xTZynv7KRl8RXO1kbXSYEeewqIPU0fRMdhsu3XI1mrs7eplcKLDUV5gsYYjnL57KBqLKkESiAilkCA2oAYk88/KK9PDxx8gLQ8UR3fan3QjqEMmpkVn9gsXhcp76M+iRq5JO7RtciTlNresld3ohY6cDF4LkORgw1x+6070yQMPm6H73KV3/ZqetWgQsuoQGbRsIZKIJ1g1dF7+lXRk/Q2acJ9bjkLkBoB2nI3LIzyhJWhDRZaF6AITEktez3wabyinxaV6WxtS5DgefV7XzSVjD62J8lnwOs5/8bT/Q3pjLeHBqDNq7ygcMtuTRzO6H1fiVfovOq06jEFwuCgmFJc+T7+Qs9Vx+t/ah2QhVWBTg2OKP95QrtbtEgyWf/zZIm+JnGb6Mpy2tkr+Mb9JVC2GqlVwofAR9yWURwil94aW8EN4nyO7IvbCU9e2jbmqzPcw9w5wkytEmOuI++GC7i7vYkZoJwSFaIy/kv2gUO8vtmqt3jdlizWjXdV1bmq/AZtPYMl5ZRpFqYkL6G5I25oEX5bV5IzYQGz857jPbLPjhTMjmNYvZO5jr88co3qhPc3UzVPFw0zjL5C1sSn1OTDk2LnWetfwvu6BoQ5+X6R+JuEdMP/256fHSruPzd3ZURw2rZg3gzuqBPgVcHyLXQlqy0TsWJm8Sq5qwFHqcAiceCHzDIBAkq28j8mkO05HJz9pOoRTDqrkdQeyWKqVYnP9HKsC4/qf8+3KG8HVgka6pSgOSgFZ4PdcYB+IH+2z3v179uN2/uc2AGp7L/31Ylg=)"
+  :replies: []