advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,256 @@
+---
+- :author: False-Expression-985
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3i1ax2/
+  :body: |-
+    Code: [https://github.com/ChrisBrandhorst/adventofcode/blob/master/2024/23/main.rb](https://github.com/ChrisBrandhorst/adventofcode/blob/master/2024/23/main.rb)
+
+    ```ruby
+    Prep: 3ms
+    Part 1: 45ms
+    Part 2: 1.5ms
+    ```
+
+    For prep, make the trivial `from -> to[]` map.
+
+    Part 1 was just looping through all sets of computers `[a, b, c]` where `c` once again connects to `a` and where one of them started with a `t`.
+
+    Part 2 was interesting. I got the following process by doing some quasi-random intersections on the data (example data shown). On the one hand this feel intuitive to me, but on the other I can't shake the feeling that the way the input is organised results in this method.
+
+    Take one of the entries in your trivial `from -> to[]` map:
+
+    ```ruby
+    de -> [cg,co,ta,ka]
+    ```
+
+    Get all likewise entries for all the `to[]` values:
+
+    ```ruby
+    cg -> [de,tb,yn,aq]
+    co -> [ka,ta,de,tc]
+    ta -> [co,ka,de,kh]
+    ka -> [co,tb,ta,de]
+    ```
+
+    Intersect the complete initial entry (key + value set), with each of the other entries (also key + value set):
+
+    ```ruby
+    [cg,de]
+    [co,ka,ta,de]
+    [co,ka,ta,de]
+    [co,ka,ta,de]
+    ```
+
+    Count the unique ones:
+
+    ```ruby
+    [cg,de] -> 1
+    [co,ta,ka,de] -> 3
+    ```
+
+    The bottom count is equal to the initial entries' `to[].size - 1` (if you include the intersection with itself, you can skip the minus 1). **This only holds for the answer set** , so you can stop after you find the first one (which for me is after just 39 of 3380 input entries).
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gwj71/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQB6BQAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1ep9IBYPPdblNB+e+LbTiO+aeJ6+cRA4yPOmC7Qaz1eL62nSqw7zBuYzSqTOFQgaI2kIHocSAPLoEezoZhVcCkfVH5FIAQyQU0OcylwJssDkMV0w3PaMNhW6cQTeersZZZUr0mekSjDa8+ZRH9ekQB/LYwBKvIiAdv5FzbvVSy+d5x4vlb1w2z6CBmjFMC2TYZVh2n5N8QIZH7ZQ4zDP0NKCsyjHrXTG3F8VrOdBd6XC3cTTYnD2Fh/H76DmJdLQP94jhhQLXfksvRyAOFNvCInesVrqV4AuJZzY63HPM0/r30G9oLhbLEb/I8O+GnDDFdev26UrYVPg4o2FYAVW5SipZceu1bwUhtiyWNzM+Ij+VgD130gLmfJZDbSMtMJtcbu4ZZtZkhgt+4u/1dNEs7bGM1GqpOpV0mK4HFZCkWSVZCJuxApFU2PlSAYgb3Y+gJqnm1EzczY/15xn0dQD3nujF2Mccg7Qt/AXm7WPL59wIjA+qiTx3A2t7ugnOA7ZGKqVXI7uU3F8A0UeMhNxsGEcLIrlyiOpzmiqnv1dC62nrf7nXPkW+nUbvwsIyYDg9c9dbnwlar7HnGjJCGp+A66MeZOUTnxP5h4EKcrUC7OoEU1qRMMohzBcoXbetm/wW7iZFmYAAoX48j33ks0VECGdbsSQjIpJH2jp+kN04jJiHXcAOqU0QkLkp2AeR676ucv328GMdWGNeKFsXwOrYlhAq+JYG0OFLr58WPeN+aIeHvb5B0Q2/OPobygzzr/Gtl/ufGr73AZ0KqmdcZqq03eYiFBeyvb//VQw0AA==)
+
+    Part 1 is pretty straightforward. Complexity is O(|V||E|). There is definitely room for improvement but I don't see a way to a better complexity class.
+
+    For part 2, today I learnt about the [Bron–Kerbosch algorithm](https://en.wikipedia.org/wiki/Bron%E2%80%93Kerbosch_algorithm). Actually a somewhat straight-shot algorithm once you understand it
+  :replies:
+  - :author: ChasmoGER
+    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3him0j/
+    :body: Thanks for sharing the algorithm name!
+    :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gsazr/
+  :body: |-
+    That was fun, did a dumb check every combinations thing for the first part. Then for part 2, I constructed a binary number for each set of points and what it was connected to. I then anded each pair of these sets. A group of connected computers should contain a the same number of computers in common. So by tallying the results of all the ands, you can see the one that occours the most should be the largest number of connected computers.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/23](https://github.com/careyi3/aoc_2024/tree/master/solutions/23)
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gkxv7/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day23/day23.rb)
+
+    Part 1, I built a table of connections for each node, and did a simple dfs with a depth 2 to check for a loop
+
+    Part 2, I used the connections table above, and did a nested loop, which would be alot if we didn't have iterate through only 13 values per loop. Then I used a frequency table to store seqeunces of unique nodes that have connections to each other. Turns out this matters cuz you have different sequences with the same length but their frequencies are different.
+
+    Overall, alot easier than I thought it would be cuz when I did the first part, I had expected another memoization slog fest like a few days ago.
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gd7b0/
+  :body: |-
+    ```ruby
+    require 'set'
+    input = File.readlines('input23.txt', chomp: true).map { _1.split('-') }
+
+    connections = Hash.new { Set[] }
+    input.each { |a,b| connections[a] += [b]; connections[b] += [a] }
+
+    # Part 1
+    ticc = Set[] # (Three Inter-Connected Computers)
+    connections.each { |cmp,cons|
+      cons.each { |con|
+        a = cons - [con]
+        b = connections[con] - [cmp]
+        (a&b).each { ticc << [cmp, con, _1].sort }
+    } }
+    puts ticc.count { |set| set.any? { _1.start_with? 't' } }
+
+    # Part 2
+    subsets = [[]]
+    connections.each { |cmp,cons|
+      new_subsets = []
+      subsets.each { |subset|
+        if subset.all? { cons.include? _1 }
+          new_subsets << subset + [cmp]
+        end
+      }
+      subsets += new_subsets
+    }
+    puts subsets.max_by(&:size).sort.join(',')
+    ```
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fy0wg/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day23.rb)"
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fxw3m/
+  :body: |-
+    Nothing special here. Runs in ~ 100ms
+
+    ```ruby
+    input = File.read("input.txt").scan(/(..)\-(..)/)
+
+    $map = Hash.new {|h,k| h[k] = Set.new}
+
+    input.each do |a,b|
+        $map[a]<<b
+        $map[b]<<a
+    end
+
+    nets = Set.new
+    $map.keys.each do |k|
+        $map[k].to_a
+               .combination(2)
+               .select{ |a,b| $map[a].include?(b)}
+               .each{ |a,b| nets << Set.new([k, a, b])}
+    end
+
+    puts nets.count{ |c| c.any?{|n| n.start_with?(?t)}}
+
+    def findmax(len)
+        $map.each do |k,v|
+            f = v.to_a.combination(len).find{ |m| m.combination(2).all?{ |a,b| $map[a].include?(b)}}
+            (puts [*f, k].sort.join(?,); return true) if f
+        end
+        false
+    end
+
+    $map.values.map(&:size).max.downto(1).find{ findmax(_1) }
+    ```
+  :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ee1s7/
+  :body: |-
+    851/1863
+
+    Not extremely efficient, but still runs in under a second. A much larger dataset could have made this a lot more painful.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQB1BQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw6AjPxo/gbHVfkb/lFqEN/cVLFFRr5hB8At2Ya6RvYvxrcrj9+/hWpyd2xTGLsezZSupxlbZ8zenEPWJeoe7/CshYyiqEEaTOm7lLuqxNFbbIMrN7ugc9qoSceYRu1lQzsT4BsDnLd6zxO0da4l73kExIxHwmjktTM4qNlMhR2mhfRkuOVHu4qnDnt6xGkT7/jjpUvk+yRqvP5ijERekL+j9DBL44H/1L8a8fiupGXI/pzcSWoPv+F2geLy0M81z9UX4obpEPiIyQWPEJ50gWwLXaQSZm5ELexB8ciciGRcQ5nedFd12DJck3atWOGk6MOYQi6H9brjxpRVwr0XWP+AFdetJbUbZXA6UkfIagBn1ioXgjPd4OGfqg1207D4k5uhSPyGFo+2EG65qPsPKt+Vq6lAN+a6htIwz92yEQU4bTtgbwohEnAG660Grc1UhpYyR8xgV93c4sIg2mrXD+TkNxdE3DMFXdKOaJqAD/ubmwUEsZrIZbGLgcpqzYrkhC6tfSa1KeXkGxs7N7Z8QLmop8V9ZAmaYY0SKT7VPN3yTM/gEifrxpW/WGN+zT6g5lwyUYVjFmHAuzbcxOqOAfASlVR044i+kC+9MFPL2e6z996vwJVl2EQIq5IJ0UeMhyx81CdjBacMjeF676MKd3y51ToIPFAVqDVAsWtPOLuAi8wIYAgZovrdWV7oDP0gHXja3H/+Y0b16)
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ekc9i/
+  :body: |-
+    I just recursively tried to build the largest group I could starting with the beginning network of each node. Runtime was longer than I could wait so started looking for speedups. My biggest speedup was maintaining a running max and skipping over nodes whose starting network was smaller than my current max group. Still only got it down to 1.6s so I want to play around with better algorithms.
+
+    ```ruby
+    def build_group(nodes, group, net)
+      return group if nodes.empty?
+      nodes.map { |n|
+        # recursively check the union of current nodes under consideration and
+        # all the nodes connected to 'n' while considering adding 'n' to the group
+        newNodes = nodes & net[n]
+        nodes -= [n] # remove from future consideration as it's redundant
+        build_group(newNodes, group + [n], net)
+      }.max_by { |g| g.size }
+    end
+
+    def part_2
+      net = data.map { |line| line.split("-") }.each.with_object({}) { |(a,b), net|
+        ((net[a] ||= Set.new) << b) && ((net[b] ||= Set.new) << a)
+      }
+
+      max_group = []
+      net.keys.sort_by { |n| -net[n].size }.map { |start|
+        # skip any node with starting network < current max
+        next if net[start].size + 1 <= max_group.size
+        max_group = [max_group, build_group(net[start], [start], net)].max_by { |g| g.size }
+      }
+      max_group.sort.join(",")
+    end
+    ```
+  :replies: []
+- :author: Mon_Ouie
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj1/
+  :body: |-
+    Just for reference, the basic DFS search for a maximum clique seems to have first been described by [Carraghan and Pardalos (1990)](https://www.sciencedirect.com/science/article/abs/pii/016763779090057C). It includes a pruning step that some solutions here don't have (you can backtrack early if the current clique combined with all vertices that can extend it would still not be bigger than the current best clique). The inputs are easy enough that you don't even need this.
+
+    ```ruby
+    edges = DATA.read.each_line.map { |x| x.strip.split("-") }
+
+    graph = Hash.new { |k, v| k[v] = Set.new }
+
+    edges.each do |a, b|
+      graph[a] << b
+      graph[b] << a
+    end
+
+    p graph.sum { |m1, neighbors|
+      neighbors.sum { |m2|
+        next 0 if m2 < m1
+        (graph[m2] & neighbors).count { |m3|
+          m3 > m2 && (m1.start_with?("t") ||
+                      m2.start_with?("t") ||
+                      m3.start_with?("t"))
+        }
+      }
+    }
+
+    def dfs_clique(graph, best_clique = [], current_clique = [],
+                           candidates = Set.new(graph.keys))
+      return best_clique if candidates.size + current_clique.size <= best_clique.size
+
+      remaining_candidates = candidates.dup
+      candidates.each do |k|
+        current_clique << k
+        if current_clique.size > best_clique.size
+          best_clique.replace current_clique
+        end
+
+        remaining_candidates.delete(k)
+        dfs_clique(graph, best_clique, current_clique, remaining_candidates & graph[k])
+
+        current_clique.pop
+      end
+
+      best_clique
+    end
+
+    puts dfs_clique(graph).sort.join(",")
+    __END__
+    [input here]
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj9/
+    :body: "[removed]"
+    :replies:
+    - :author: Mon_Ouie
+      :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3er960/
+      :body: Why is this case sensitive though?
+      :replies: []

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

@@ -0,0 +1,143 @@
+---
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m4achod/
+  :body: |-
+    Finally had time to sit down and go through part 2. Notation explained at the end. My process:
+
+    1. Went and found some old slides and notes about full adders from my computer organization class. I definitely said/thought "why tf am I learning this" back then
+
+    2. First wrote a simple backtracker that expands all gates down to basic x and y inputs. Then I simplified a few gates to get the hang of it. For example, rewriting `z01 = x01 XOR y01` as `z01 = S01`.
+
+    3. Wrote a program to automate the simplification after I got the hang of it. Dumped the simplified formulae into a file and looked for errors. For example, `z05 = (c05) XOR (C04)` when it should be `z05 = (S05) XOR (C04)`. I knew logically how to automate the detecting and switching as well but decided that manual inspection would be faster.
+
+    [code](https://topaz.github.io/paste/#XQAAAQAPCgAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1ep9IBYPPdblNB+e+LbTikMEDr7EPadc0bHnbGAhNR/0tta50i0Ov4WZ8MyyHwuTTp85Epg9N62L3Q3y4Saj203dKd/Pf6JYBh9edMthF81jqnYJIF1qXhYl/7jMQJvs5HjmlauSe8G1QttwlJguqihQp6GriyQ2XBQN7xPEGwv9e+i12mjUTwHLOvv7i3bnpXavvDViZozctMf0/LpskGiVhbeRQtbm5N83M0ZXIPF1genkQ6l01ZtjetRP1z5xQE6VauDp7KubJ3MiU0Gm+vKtBv36MV+l/IqZDSqiIycLVyOVGbAE7S0j2/WCjUO8SaUOgWWZNcvXfPNDk4oO9zJcXhO0nPjNRwEWdYfkWtzVnKLOp0OLUHOeBEUHZdoTa5ROlrcHvjEW4j+u2KkF24+txsXh6y+c/AYz7NRbF3bryLhPAYlS6xh5UitIWuOILmqnbGiN2fhks05xxcwHLWkqNdovPQ/AgzjKjzO4P4deC8UDBUHkssG1u8T7RzI5YjZJ2s/iBtTWty3DpI0PBONHd0vaRHHuXgOHf9aRCaqxSFoC4dN2Yu/rvtLVPaWr9pEng0Dqcm+fOKenzj26TJGEifWrkw6ErN6zwagHqur+CT4NoJwANsoCbDx0ne0ykfGfPhChfy78YT73+2uTttC5nirXKlylMIohlEPw5U4durt4aH/kuAtZC7UBsoiAzEo7/x81v9yjf92ak+NWs7UM0XcMYOO3XehDJwDHX9xasNC0YyKzFNVoNOIH8EgqssCQm/V7Qmt1JLI0y7DslL48a7AGp3mll/P8BP3nSHRuWfyTR6tuPDIoyA1jSG+qysWdRMMHDeId7EJ3tyfxwzZY8i8VSbgNDK0WeiWXCWmX1yUugDDn0TlYWIJA6OGI168KqoWqgVQ1IdA/ZGHgOrv7p3DFVrlahaJDSYeKoY+r1XhNHJTCK5nXpfZIvULkuaJTXKH0HubhP4mr7vM3J44qgWEqDyBAu/tCPMZ7NfZubueBstkqWzIBw7NpKGebeUh94aADb1ZNGjeWBIEBU7+AOaLyYJj7RUpFUUDPV1QQ5sUlTkXSaVoBL8TrqytA8C+Td/BLHXA==)
+
+    Notations:
+
+    There are five gates in a full adder. We summarize each of their inputs and outputs recursively.
+
+    Let x_i and y_i be the input bits, and C\_(i-1) be the input carry bit. Then:
+
+    x_i XOR y_i = S\_i (naive sum)
+
+    x_i AND y_i = c\_i (naive carry)
+
+    S_i AND C_(i-1) = s\_i (carry sum)
+
+    z_i = S_i XOR C\_(i-1) (output bit)
+
+    C_i = c_i OR s\_i (output carry).
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3nq8qw/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day24/day24.rb)
+
+    Part 1. Simple queue that keeps rotating elements until they are all solved.
+
+    Part 2, took forever, and some visualization from the peepz here who showed it for me to bank on a routine that would work. Essentially that was what it was, a routine. There is a particular outcome for every operation, and if the next one isn't the expected ones, then those are your faulty wiring. In fact you don't even need to fix it, you just needed to know which ones are broken.
+
+    Basically the routine is this, x + y will always lead to XOR / AND, if those aren't the outcome, then you found an issue. XORs will either end up with a XOR and AND, or it has a Z value. AND will only have ORs as outcomes, and for ORs, you only have to check if they lead to XORs and ANDs, you don't even have to process those after because your previous routine should covered all the nodes.
+
+    There are two edge cases which is x00, y00, and x45, and y45. They have a bit of a unique behavior but I don't think those are twisted up in anyone's puzzle data.
+  :replies: []
+- :author: RazarTuk
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3n1lex/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQAEAwAAAAAAAAAzGknWt5Bv2rAv+DcT5iE66ZPnRosfrwe0LaRaq6pZwCaP76Bpsar4qeuAw4e9Ixi5xNP/ZyUwagqs339V43rea6G7KVaUGQ7i8MQ6AnOIsjiqzY3D0Bom2hL0ycs4QauTiRfwUF3cuF2LEi8T3+Up6fQ+pR4ym4DHsqqfkyprgCGYT/3q4qsl2meOgwW2hGZyFiF1n5ZhGwu4lIHhI/xmkfuwuvjyFLZl8NfaPH2yC5ZI/re/m1eXbbhGpfuFdhFevPbjvTMg3s4pKIebuGoYtIT5Rj/5LE6vJ/Sux+7X3ihc7dPU9lae5CdmNNf7wYElfrc3DoLfWIELZ/lIPazd2rTMEia3+x9De9/mzj5wy1iIs81aqbbUBV5IO//y2J09aFGonakAjsU0TugvmtKS9covY8aQEHkTdQgmDBUF3+kUGac9desS8/BHFXqwTGh73YOitIRNYjSyV9wgHxXnoy2zizW9sSfES41vNVx5Q0GsEmLkw0Pe1IU8qAXh/+af7uQ=)
+
+    Yeah, Ruby _definitely_ made today go faster. For example, if you want to parse something as a hash, just call `.to_h` with a block that returns `[key, value]` as an array. Or if you're using regexes to match in a `case` statement, the matching groups automatically get extracted into the pseudovariables `$1`, `$2`, `$3`, etc. So for example, this code handled parsing all the gates:
+
+    ```ruby
+    $gates = file[cutoff+1...].to_h do |line|
+        case line
+        when /(.{3}) AND (.{3}) -> (.{3})/ then [$3, [$1, :'&', $2]]
+        when /(.{3}) OR (.{3}) -> (.{3})/ then [$3, [$1, :'|', $2]]
+        when /(.{3}) XOR (.{3}) -> (.{3})/ then [$3, [$1, :'^', $2]]
+        end
+    end
+    ```
+
+    Or similarly, since everything's an object and most operators are secretly just methods, I was able to use things like `wire1.send(:'&', wire2)` to call all the operations.
+
+    So it's definitely some _dense_ code, but I also think it shows off a lot of the syntactic sugar in Ruby.
+  :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3l88sf/
+  :body: |-
+    1396/1765
+
+    Like many here, it took me much longer to implement a solution via code than to find one through analysis. I used DOT and graphviz to generate a graph to help me figure out what was going on. With some colors, the "correct" patterns start to reveal themselves, and weird shapes indicate something is wrong. (Note, my graph below actually highlights the bad nodes, though I didn't add that until later).
+
+    With the graph alone, I was able to actually come up with and validate the answer for my input, but I spent more time afterwards coming up with a programmatic way to derive the solution.
+
+    First, I did individual bit additions to test direct bit output and carry over to identify suspect outputs.
+
+    From these suspect outputs, I identified which ones were not the outputs from XOR operations and observed that of those, the subsequent bit was also suspect. This led me to believe that this z node needed to be swapped for one of the nodes directly upstream of the subsequent z node.
+
+    From this, I was able to identify 3 non-XOR z outputs, and a group of candidates for each of them to swap. I was left with a bunch of other z outputs with XOR outputs with otherwise suspect ancestors, so I grouped them all together to find a pair from that remaining group.
+
+    Then it was a relatively small search space through the combinations of those groups.
+
+    [code](https://github.com/phene/advent-of-code/blob/main/2024/24/24.rb) and [broken graph](https://raw.githubusercontent.com/phene/advent-of-code/refs/heads/main/2024/24/graph-orig.svg) and [fixed graph](https://raw.githubusercontent.com/phene/advent-of-code/refs/heads/main/2024/24/graph-fixed.svg)
+  :replies:
+  - :author: RonGnumber
+    :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3m1k8v/
+    :body: I had a similar idea and similar graph (less fancy). Every year there are are a couple of problems where Graphviz is a life-saver, it's really worth taking the time to learn its basic options and get comfortable generating pictures which tell so much more than numbers! (I've done it yesterday too, and 2023 day 25.)
+    :replies: []
+- :author: birblett
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3kqkl2/
+  :body: |-
+    this solution is _maybe_ functional for any variation of this specific day's input, i have only tested it on two different inputs so far so i can't say for sure that i haven't missed edge cases. i originally solved it by hand and then reverse engineered it to arrive here.
+
+    ```ruby
+    start, out = File.read("in.txt").split(/\n\n/).map { _1.split(/\n/) }
+    start, k = start.map { [(a = _1.split(": "))[0],a[1].to_i] }.to_h, nil
+    final, regs, bad, sregs, is, queue, is_done = "z#{start.keys.sort[-1].scan(/\d+/)[0].to_i + 1}", {}, [], {"x00" => true, "y00" => true}, {}, start.keys.sort, {}
+    out.each { |s|
+      op1, op, op2 = (str, dst = s.split(" -> "))[0].split(" ")
+      regs[dst] ? (regs[dst][0] = op) && (regs[dst][1] = [op1, op2]) : regs[dst] = [op, [op1, op2], []]
+      [op1, op2].each { (is[_1] = is.fetch(_1, [])).push([str, dst]) && (regs[_1] ? regs[_1][2].push(dst) : (regs[_1] = [nil, [], [dst]])) }
+    }
+    regs.each { |k, v|
+      v[2].empty? ? (k == final ? (bad.push(k) if v[0] != "OR") :
+        v[0] != "XOR" || v[1].any? { start[_1] && _1.scan(/\d+/) != k.scan(/\d+/)} ? bad.push(k) : v[1].each { |p|
+          regs[p][1].any? { start[_1] } ? (bad.push(p) if regs[p][0] != "XOR" unless regs[p][1].any? { sregs[_1] }) :
+            (bad.push(p) if regs[p][0] != "OR" unless start[p]) })
+        : (v[1].each { bad.push(_1) if regs[_1][0] != "AND" } if v[0] == "OR") }
+    (is[k].each { |instr, dest|
+      next unless ((op1, op, op2) = instr.split(" ")) and start[op1] and start[op2]
+      is_done[instr + dest] ? next : is_done[instr + dest] = true
+      start[queue.push(dest) && dest] = start[op1].method(op == "AND" ? :& : op == "OR" ? :| : :^).call(start[op2])
+    } if is[k]) while (k = queue.shift)
+    puts start.keys.sort.reduce(0) { |s, k2| (s += start[k2] << (k2.scan /\d+/)[0].to_i if k2.start_with? "z") || s }, bad.sort.join(",")
+    ```
+
+    for p2, basically iterate over all the nodes, following this algorithm:
+
+    ```ruby
+    IF $current is result reg
+      IF $current is last result reg (z45)
+        mark $current as bad IF not result of OR
+      ELSE
+        mark $current as bad IF $current not result of XOR
+        IF $current not bad
+          FOR any parent $par of $current
+            IF $par not child of start node
+              mark $par as bad IF not result of OR
+            ELSE if parents of $par are not first regs (x00 and y00)
+              mark $par as bad IF not result of XOR
+    ELSE IF $current is result of OR
+      FOR any parent $par of $current
+        mark $par as bad IF not result of AND
+
+    sort and concatenate bad regs
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hl698z/2024_day_24_solutions/m3l1mih/
+  :body: |-
+    Very messy, but by knowing the correct structure of a ripple adder, I was able to find paris of adjacent bits that were incorrect. I then used trial and error updating my input each time until there were no more errors. I couldn't think of a clever way to automate what I was trying to do, but because I knew there were a limited number of ways it could go together. Manual checking was not very hard.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/24](https://github.com/careyi3/aoc_2024/tree/master/solutions/24)
+  :replies: []

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

@@ -0,0 +1,190 @@
+---
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3t5vpl/
+  :body: |-
+    ```ruby
+    # frozen_string_literal: true
+
+    require_relative 'utils'
+
+    schematics = File.read('input25.txt').split("\n\n")
+    locks = []
+    keys = []
+
+    schematics.each do |schema|
+      grid = Grid.new(schema.split("\n").map(&:chars))
+      schema_number = 0
+      (0...grid.num_cols).each_with_index do |col, col_index|
+        # least significant three bits is first column
+        schema_number += ((grid.get_col(col).count('#') - 1) << (col_index * 3))
+      end
+      if grid[[0, 0]] == '#'
+        locks << schema_number
+      else
+        keys << schema_number
+      end
+    end
+
+    def check_match(lock, key)
+      (0...5).each do |col|
+        # deal with trailing zero bits by lshift 5 the same amount
+        return 0 if ((lock & (0b111 << (col * 3))) + (key & (0b111 << (col * 3)))) > (5 << (col * 3))
+      end
+      1
+    end
+
+    puts locks.product(keys).map { |lock, key| check_match(lock, key) }.sum
+    ```
+
+    No part 2 because I still need to analyze day 24 part 2 haha
+
+    [Full repo](https://github.com/Casper-Guo/AoC-Language-Exploration)
+  :replies:
+  - :author: dhruvasagar
+    :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3ti2an/
+    :body: |-
+      Here's my ruby solution :
+
+      ```ruby
+      def is_key?(grid) = grid[-1].all? {|c| c == '#'}
+      def is_lock?(grid) = grid[0].all? {|c| c == '#'}
+
+      def key_to_heights(key) = key.transpose.map {|l| l.reverse.rindex('#')}
+      def lock_to_pin_heights(lock) = lock.transpose.map {|l| l.rindex('#')}
+
+      def key_fits_lock(key, lock) = key.zip(lock).map(&:sum).all? {|h| h < 6}
+
+      def part1(keys, locks)
+        key_heights = keys.map {|k| key_to_heights(k)}
+        lock_pin_heights = locks.map {|l| lock_to_pin_heights(l)}
+
+        key_heights.product(lock_pin_heights).filter {|k,l| key_fits_lock(k, l)}.size
+      end
+      def part2(keys, locks) = 0
+      def tdiff(s,e) = "#{(e - s) * 1000}ms"
+
+      lines = ARGF.read.split("\n\n").map {|l| l.split("\n").map(&:chars)}
+      keys, locks = lines.partition {|l| is_key?(l)}
+      s = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      p part1 keys, locks
+      e1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      p part2 keys, locks
+      e2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      puts "Time taken part1: #{tdiff(s,e1)}, part2: #{tdiff(e1,e2)}, total: #{tdiff(s,e2)}"
+      ```
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3qm9ez/
+  :body: |-
+    I couldn't really be bothered counting the rows and all of that, so I just lay the keys and locks on top of each other and check at for each position there is at least one `'.'`
+
+    ```ruby
+    locks, keys = File
+      .read('input25.txt')
+      .split("\n\n")
+      .map { _1.split.map(&:chars) }
+      .partition { _1[0][0] == '#' }
+
+    p locks.product(keys).count { |lock,key|
+      lock.zip(key).all? { |lock_row, key_row|
+        lock_row.zip(key_row).all? { _1.include? '.' }
+      }
+    }
+    ```
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3qi0nw/
+  :body: |-
+    ```ruby
+    input = File.read("input.txt").split("\n\n")
+
+    locks, keys = [], []
+    input.each do |i|
+        r = i.split("\n")
+        (r[0][0] == ?# ? locks : keys) << (0..4).to_a.map{|c| r.map{_1[c]}.count(?#) - 1}
+    end
+
+    p locks.product(keys).map{|l,k| l.zip(k).map{_1 + _2}}.count{ _1.all?{|v| v<=5}}
+    ```
+  :replies:
+  - :author: IvanOG_Ranger
+    :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3qkn3f/
+    :body: Regex is more readable than this, that's crazy
+    :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3qe6ck/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day25/day25.rb)
+
+    basic for loop, with a set to eliminate duplicates. Had a bit of issue of making wrong assumptions during the parsing phase, that is invalidating all rows with "#" that are filled up. Anyway simple fix, just include those and raise the limit by 2.
+  :replies: []
+- :author: bigfunlx
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3plinf/
+  :body: |-
+    I coded it on my iPhone while waiting in the emergency room with symptoms of meningitis, for better or worse this will be my most memorable moment of AoC!
+
+    [Rubist](https://imagebin.co/images/IMG_4243.png) screenshot
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3pf0js/
+  :body: |-
+    Today I will post 2 full solutions in one comment because together they still fit in half a punchcard.
+
+    ```ruby
+    p STDIN.read.split("\n\n").combination(2).count{ _2.tr('#.', '.#')[/#{_1}/] }
+    ```
+
+    * * *
+
+    ```ruby
+    l, k = STDIN.read.split("\n\n").map{ _1.split.map(&:chars).transpose }.
+      partition{ _1[0][0] == ?# }.map{ |x| x.map{ |x| x.map{ _1.count ?# } } }
+    p l.sum{ |l| k.count{ |k| l.zip(k).none?{ _1 + _2 > 7 } } }
+    ```
+
+    - Solution #1 makes no effort to optimize runtime and takes about 1.1 seconds to run on my machine.
+    - Solution #2 runs in around 0.04 seconds over a baseline of `time ruby -e ""`; I'm sure it would be faster with something a little longer than `.map(&:chars).transpose`.
+    - You may replace `.map{ |x| x.map{ |x| x.map{ _1.` with `.map{ |x| x.map{ |x| x.map{ |x| x.` if you like fractals.
+  :replies:
+  - :author: 4HbQ
+    :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3pgl7v/
+    :body: 'Solution #1 is so clever but sooo dirty. I love it!'
+    :replies:
+    - :author: Nnnes
+      :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3pjpar/
+      :body: Thanks! In previous years I've abused various combinations of Regexps and `.tr` but it didn't cross my mind this year until today
+      :replies: []
+- :author: birblett
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3pbi5s/
+  :body: |-
+    1023/890
+
+    merry christmas and thanks for the puzzles!
+
+    ```ruby
+    keys, locks = File.read("in.txt").split("\n\n")
+        .map { _1.split("\n").map(&:chars).transpose }
+        .reduce([[], []]) { |(k, l), q| (q[0][0] == "." ? k : l).push(q.each_with_index.sum { |arr, i| arr.count("#") << (i << 2) }) && [k, l] }
+    puts "#{locks.sum { |lock| keys.sum { (lock + _1) & 559240 > 0 ? 0 : 1 } }}"
+    ```
+
+    moderately cursed bitwise math solution...
+  :replies: []
+- :author: botimoo
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3paoro/
+  :body: |-
+    [Paste](https://pastebin.com/YWnevdb0)
+
+    Repeating the output for part 2 here as well: `Merry Christmas! Congrats on 10 years, Eric!`
+  :replies: []
+- :author: mpyne
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3p6e9k/
+  :body: |-
+    [Solution](https://topaz.github.io/paste/#XQAAAQBlBQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw3D1UZFlDHZo7bAS6PU4u3JQTaPBfElS53PuuvCNKd61mUYVeaYDdAeSC2XFVeCm8Q3FHzXZwO042pLKQpW8DpUxlQZ7m2m2ucv3ZRIB5M1n/6IP9NHaGdvFYRINgn6fTKCyfLi11w2NyW7MyWtYYcFGKPVF5qgC/CR8TFMpHMaQzfZNFBWiu4p66zeIdHVzTuvJuTkwMOVJYe6sv7FgXgvhPE6YRBKHPDxxvRxHDD8nN2lKoCzoOJA2D8A2vuo5iJ3PeE980/uGwMHe+rEanQj52YTy/Ohi8w3Gz2Se2buUnbcmaZosn+tUh37yaAtAllh79qmEGzhgoKbInKWNHuE9/DzZChFLfXW0NJ2o59kDDqHVJrCpt3y7TY5seNgkRzTxooawWc26EmweWuNRbTfKqRKZTlwCf4rM49BXzR/DfDNiLUwXWZkt1skddu6R4tw7JtXUZZTd0lDkuNhPto1O99aF4fZ+KKQt0z2d02slJOURQDNRrLAPc030efst5wOzseIHbeu+FAkHDizdXuneW2B2QDEy8tNjVdJcyv5ZjQ7MiBw/zjLpLScMH6SLOdZDpqsnRI1xoe94SzffCv73eoD/).
+
+    Will probably redo it in Rust later after some sleep but not too bad for not being a competitive programmer.
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hlu4ht/2024_day_25_solutions/m3p79dr/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day25.rb)"
+  :replies: []

data/lib/arb/api/aoc.rb

@@ -8,7 +8,7 @@ module Arb
           url: "https://adventofcode.com",
           headers: {
             "Cookie" => "session=#{cookie}",
-            "User-Agent" => "github.com/fpsvogel/advent_of_ruby by fps.vogel@gmail.com",
+            "User-Agent" => "github.com/fpsvogel/advent_of_ruby by fps.vogel@gmail.com"
           }
         )
       end
@@ -29,7 +29,7 @@ module Arb
         logged_in {
           connection.post(
             "/#{year}/day/#{day.delete_prefix("0")}/answer",
-            "level=#{part}&answer=#{answer}",
+            "level=#{part}&answer=#{answer}"
           )
         }
       end