advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2023/11.yml

@@ -0,0 +1,363 @@
+---
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcyshi4/
+  :body: |-
+    [Part 1](https://github.com/SleepingInsomniac/adventofcode2023/blob/master/2023-12-11/part_1.rb)
+
+    In part 1 I actually expanded the grid,
+
+    [Part 2](https://github.com/SleepingInsomniac/adventofcode2023/blob/master/2023-12-11/part_2.rb)
+
+    For part 2, I just counted how many times a galaxy pair crossed an expansion and added that to the distance.
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcwuxjw/
+  :body: |-
+    I stored the galaxy coordinates as a hash from X coordinate to array of Y coordinates, and I expanded space with the following function:
+
+    ```ruby
+    # Space.galaxies is a hash from X coordinate to array of Y coordinates
+    def expand_horizontally(factor = 2)
+      ret = Space.new
+      cols = galaxies.keys.sort
+      x0 = cols.shift
+      ret.galaxies[x0] = galaxies[x0]
+      expansion = 0
+      while (x = cols.shift)
+        expansion += (x - x0 - 1) * (factor - 1)
+        ret.galaxies[x + expansion] = galaxies[x]
+        x0 = x
+      end
+      ret
+    end
+    ```
+
+    I then transposed the array and repeated for the other axis, i.e.
+
+    ```ruby
+    def expand(factor = 2)
+      expand_horizontally(factor).transpose.
+        expand_horizontally(factor).transpose
+    end
+    ```
+
+    For part 2, all I had to do was add the factor argument. My initial answer was too high until I realized I needed to subtract 1 from the scale factor.
+
+    [Full solution](https://github.com/jstanley0/advent-2023/blob/main/11.rb)
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcvc079/
+  :body: |-
+    Nice easy one after last night:
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCpAgAAAAAAAAARiAqGkkN2w8uW9zdu4QV9huA3XtLPyAMJ+BUFIW/0tlJ05GEjbzGbpJ/rHVTmRpgeuahr+5Hp9htXWjnoQu+9zgWkc88D6vYgpVMbYUeyugJvbW3A+du35kd185oV5nxgW6/J2rVW8v5uYC0jQV5YOF2RCj5i7dO6DacK23eyXmS8fQWenB1IA+8s05eV9rHUM0WiMpIvdBH9ftZSYWJEZDMxCXLPnXDdXDqerxTKp7HwuKLeSP6Mo1tEbuQX9nePbO6W2zCP23Kcm3ySvBRW9hwXaplvlDcPfI50Ge+wczTtKOjwza+JFhwP4zd7G1F98lgiTFrJmyV3y79dTbRWZ4xNQRbipOxSKSiDnKauebwnEAa3JVSjTEDkKdf5FyXpuLoprBkj9t6MnxkJHlNNbp2HYazcreTAcniNf3rt/rassEMO2Own5/A48+qsitDoNZqSKxbBnXydIQfJ2pb3hT/+nZ9lkmyxRp3HjH5bKfYRZH5/Tkbd1eZC5DtxfQRRUd5chnH/zDNOMA==)
+  :replies: []
+- :author: glebm
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcvc6tn/
+  :body: |-
+    Parts 1 and 2 (for part 1, change `1000000` to `2`):
+
+    ```ruby
+    rows = $<.readlines(chomp: true).map(&:chars)
+
+    inflated_y, inflated_x = [rows, rows.transpose].map { |xs|
+      xs.reduce([]) { |inflated, col|
+        prev = inflated.empty? ? -1 : inflated[-1]
+        inflated << prev + (col.all? { _1 == '.' } ? 1000000 : 1)
+      }
+    }
+
+    stars = []
+    (0...rows.size).each { |y|
+      (0...rows[0].size).each { |x|
+        stars << [inflated_x[x], inflated_y[y]] if rows[y][x] == '#'
+      }
+    }
+
+    result = 0
+    (0...stars.size).each { |i|
+      (0...i).each { |j|
+        a, b = stars[i], stars[j]
+        dist = (a[0] - b[0]).abs + (a[1] - b[1]).abs
+        result += dist
+      }
+    }
+    puts result
+    ```
+
+    https://github.com/glebm/advent-of-code
+  :replies: []
+- :author: Jonathan_Frias
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcw0fyd/
+  :body: |-
+    I used native ranges to signify the distance between the range bounds and some fancy matrix transpose stuff :)
+
+    This was a really fun one
+
+    ```ruby
+    input = File.read("./sample")
+
+    range = 1..2 # part1
+    range = 1..1000000 # part2
+
+    range_diff = range.end - range.begin
+
+    input.lines.map do |line|
+      line.strip.split("")
+    end.map do |line|
+      if line.all? { |c| c != '#' }
+        [line.map { range }]
+      else
+        [line]
+      end
+    end.flatten(1).transpose.map do |column|
+      if column.all? { |c| c != '#' }
+        [column.map { range }]
+      else
+        [column]
+      end
+    end.flatten(1).transpose.then do |grid|
+      coordinates = grid.each_with_index.map do |row, x|
+        row.each_with_index.map do |char, y|
+          [x, y] if grid[x][y] == '#'
+        end
+      end.flatten(1).compact
+
+      coordinates.combination(2).reduce(0) do |acc, ((x1, y1), (x2, y2))|
+        acc += (x1 - x2).abs + (y1 - y2).abs +
+          (grid[x1][Range.new(*([y1, y2].sort))].count { |cell| cell.is_a?(Range) } * (range_diff)) +
+          (grid.transpose[y1][Range.new(*([x1, x2].sort))].count { |cell| cell.is_a?(Range) } * (range_diff))
+      end
+    end => result
+
+    puts result
+    ```
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcw2i1k/
+  :body: |-
+    I'm extracting all row and col indices of empty lines
+
+    Then I do an range check of the unordered `#` coordinates, counting the intersected spaces and multiply the age factor
+
+    ```ruby
+    input = *$<
+    rowidx = ->(l) { (0...l.size).filter { l[_1] =~ /^\.+$/ } }
+    cols = rowidx[input]
+    rows = rowidx[input.map(&:chars).transpose.map(&:join)]
+
+    w = input[0].size
+    pos = []
+    input.join.scan(/[#]/) { pos << [$`.size % w, $`.size / w] }
+
+    cdist = lambda { |((a, b), (c, d))|
+        ex = rows.count { _1 > a != _1 > c }
+        ex += cols.count { _1 > b != _1 > d }
+        (a - c).abs + (b - d).abs + ~-$age * ex
+    }
+
+    $age = 2
+    puts "Part 1: #{pos.combination(2).map(&cdist).sum}"
+    $age = 1_000_000
+    puts "Part 2: #{pos.combination(2).map(&cdist).sum}"
+    ```
+  :replies: []
+- :author: Annual-Management613
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcw3kts/
+  :body: |-
+    One day less!
+
+    ```ruby
+    # frozen_string_literal: true
+
+    class DayEleven2023
+      def self.part_one(lines)
+        solve(lines, coeficient: 1)
+      end
+
+      def self.part_two(lines)
+        solve(lines, coeficient: 999_999)
+      end
+
+      class << self
+        def solve(lines, coeficient:)
+          galaxies, vertical_expansion, horizontal_expansion = create_universe(lines)
+          galaxies.combination(2).sum do |(x1, y1), (x2, y2)|
+            distance = (x2 - x1).abs + (y2 - y1).abs
+            vertical_expansion.each do |expansion|
+              min, max = [x1, x2].minmax
+              distance += coeficient if (min..max).cover? expansion
+        end
+            horizontal_expansion.each do |expansion|
+              min, max = [y1, y2].minmax
+              distance += coeficient if (min..max).cover? expansion
+            end
+            distance
+          end
+        end
+
+        def create_universe(lines)
+          vertical_expansion = Set.new
+          horizontal_expansion = Set.new
+          galaxies = lines.each_with_index.with_object([]) do |(column, idx), acc|
+            vertical_expansion.add(idx) if column.chars.uniq.size == 1
+            column.chars.each_with_index do |row, idy|
+              horizontal_expansion.add(idy) if lines.map { |line| line[idy] }.uniq.size == 1
+              acc << [idx, idy] if row == "#"
+            end
+          end
+
+          [galaxies, vertical_expansion, horizontal_expansion]
+        end
+      end
+    end
+    ```
+  :replies: []
+- :author: WindyMiller2006
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcw7r3p/
+  :body: |-
+    [paste](https://pastebin.com/x6TtP1ML)
+
+    Haven't seen much love for Ruby on here, so here's my solution
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcwfawq/
+  :body: |-
+    Nice one today, simple hash map for the points, some maths for handling expansion and then Manhattan distance!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/11)
+
+    [Video Walkthrough](https://youtu.be/ccrQzihAfhU)
+  :replies: []
+- :author: comforttiger
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcwjgx8/
+  :body: |-
+    https://github.com/comforttiger/advent_of_code/blob/main/2023/ruby/day11.rb
+
+    im glad i found out about #transpose and #combination, they were useful here
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcwrhp5/
+  :body: |-
+    Update of my [previous solution](https://www.reddit.com/r/adventofcode/comments/18fmrjk/comment/kcw2i1k), which doesnt calculate on point but on the axes individually.
+
+    ```ruby
+    input = *$<
+    rowidx = ->(l) { (0...l.size).filter { l[_1] =~ /^\.+$/ } }
+    cols = rowidx[input]
+    rows = rowidx[input.map(&:chars).transpose.map(&:join)]
+
+    w = input[0].size
+    pos = []
+    input.join.scan(/[#]/) { pos << [$`.size % w, $`.size / w] }
+    pos = pos.transpose.zip([rows, cols])
+
+    cdist = lambda { |(a, b), r, f|
+        ex = r.count { _1 > a != _1 > b }
+        (a - b).abs + f * ex
+    }
+    solve = ->(n) { pos.map { |(c, r, _)| c.combination(2).sum { cdist[_1, r, n] } }.sum }
+
+    puts "Part 1: #{solve[1]}"
+    puts "Part 2: #{solve[999999]}"
+    ```
+
+    Golfed solution 282 bytes. I tried to use complex numbers and calculate the result at the end with `p w=z.real+z.imag,w+z.imag*99999`, but accessing real and imag actually made this `10` bytes longer
+
+    ```ruby
+    i=*$<;r=->(l){(0...l.size).filter{l[_1]=~/^\.+$/}}
+    w=i[0].size;p=[];i.join.scan(/[#]/){p<<[$`.size% w,$`.size/w]}
+    v=->(f){p.transpose.zip([r[i.map(&:chars).transpose.map(&:join)],r[i]])
+    .map{|(c,r,_)|c.combination(2).sum{|(a,b)|(a-b).abs+f*r.count{_1>a!=_1>b}}}.sum}
+    p v[1],v[999999]
+    ```
+  :replies: []
+- :author: michiexile
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcx4jfv/
+  :body: |-
+    Running time: 100ms for each part of the problem.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQB/AwAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1esX/W02rPyQBiSoPmfIi3W4h0i6AsYWl3So3gWCZREGK7TvBStDM2GBa+3lYXgKW5GvrDaTFMB/dBIF3eUHOVTrYx52IiinhO/zCsVcsf2xwTBKh8z2YFxVTVYNVr0hiVSs2+fRcz4Q5LTRnpJsl0r9QA3xT/KC2WbaqQkMnZlbrjGBgNewRSmjUrWFLZUh7nm+t/dzvNx6o7Vr/tnp5GxDRjX2+QcpO9toKul/XeQJrcEi1GOVcnhUMavAuEpPC5eY9jtD6hgpw3C2inNrVtw1LKJuGPKcoMf1V8Bl3beyId0HIXKmBuSCJXmoqxo5iqI/bO5U/B0MQJWArfXNm9vU5joyZS/LxtLt59R0aYCKDyyo7o/Iv8VZSoqnXeW9DonjRt+ZBw9AZIfmYmY7+x9mrhKyWrXEjIBQ2DMNCV6nBl1K8E+yHFE5POxZ0udrGSvMcMCek5LhlWzpvBkXq2pM3IenYaTbYYegJ+74KtOeIc7zGkNq25xEXAXxCfeEheR3IMkdRdrbA8jrB78uCdJiA473PhR6JeFaUZZBR2DHEXErPWGYuh9UdPoSMSszZ3mmxP+n+J+6mMEgzviRlZEGgiTyixnGI8bZlUzx8cYnEM8e8r1SBSJGeXbMaTeYuJsxEVNk4R+L0G/6xrj8=)
+
+    Basically, I iterated through raw string lines to pick out coordinates of the stars, stored in `stars` as an array of arrays of length 2. Finding the empty rows and columns then boiled down to:
+
+    ```ruby
+    rows = stars.map { |x,y| x }
+    cols = stars.map { |x,y| y }
+    $emptyrows = (0 .. rows.max).to_a - rows
+    $emptycols = (0 .. cols.max).to_a - cols
+    ```
+
+    With this, a parametrizable expansion becomes:
+
+    ```ruby
+    def expand(stars, factor=2)
+      stars.map do |x,y|
+        [x + (factor-1)*$emptyrows.count { |r| r < x },
+         y + (factor-1)*$emptycols.count { |c| c < y }]
+      end
+    end
+    ```
+
+    Ruby's `Array#combination` and recognizing the Manhattan distance letting me use `(from[0]-to[0]).abs + (from[1]-to[1]).abs` for the pairwise distances wrapped it all up.
+  :replies: []
+- :author: coderhs
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcvdzk7/
+  :body: |-
+    Took me a while to google and find this formula called Manhattan distance. Once that was found it was easy. [https://xlinux.nist.gov/dads/HTML/manhattanDistance.html](https://xlinux.nist.gov/dads/HTML/manhattanDistance.html)
+
+    [https://gist.github.com/coderhs/eb4c9ff2aa5c5f71f3a7f1fd104b9bc0](https://gist.github.com/coderhs/eb4c9ff2aa5c5f71f3a7f1fd104b9bc0)
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcve1am/
+  :body: |-
+    ```ruby
+    require 'set'
+
+    POSITIONS = ARGF.readlines(chomp: true).flat_map.with_index { |line, y|
+      line.chars.map.with_index { [_1, _2] }.select { |c, _| c == ?# }.map { [_2, y] }
+    }
+
+    XS, YS = POSITIONS.map { [_1[0], _1[1]] }.transpose.map { _1.to_set }
+
+    WIDTH = XS.max + 1
+    HEIGHT = YS.max + 1
+
+    EMPTY_X = (0...WIDTH).select { !XS.include?(_1) }.to_set
+    EMPTY_Y = (0...HEIGHT).select { !YS.include?(_1) }.to_set
+
+    def dist(a, b)
+      x1, x2, y1, y2 = a[0], b[0], a[1], b[1]
+      x_min, x_max = [x1, x2].minmax
+      y_min, y_max = [y1, y2].minmax
+      ex = (x_min..x_max).count { EMPTY_X.include? _1 }
+      ey = (y_min..y_max).count { EMPTY_Y.include? _1 }
+      dist = (x1 - x2).abs + (y1 - y2).abs
+      [dist + ex + ey, dist + ex * 999_999 + ey * 999_999]
+    end
+
+    puts POSITIONS.combination(2).to_a.map { dist _1, _2 }.transpose.map(&:sum)
+    ```
+
+    ([GitHub link](https://github.com/Sharparam/advent-of-code/blob/main/src/2023/11/solve.rb))
+
+    Part 2 took a bit to figure out :| But I like when I can combine both parts in the same code.
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcvh44q/
+  :body: |-
+    6825 / 6309
+
+    Got a late start on this one, but it was pretty easy. In part 1, I did the expansion of the data array and then just did manhattan distance. But realized I needed something smarter for part 2. So I just created a Set for each empty row and another one for each empty column, then and'ed that with the Set of cols and rows between my galaxies.
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/11/solution.rb)
+  :replies: []
+- :author: HAEC_EST_SPARTA
+  :url: https://www.reddit.com/r/adventofcode/comments/18fmrjk/2023_day_11_solutions/kcvj8up/
+  :body: |-
+    ##### [Solution on sourcehut](https://git.sr.ht/%7Eawsmith/advent-of-code/tree/2023-ruby/item/lib/day11.rb)
+
+    I decided to represent each coördinate as a complex number (_d_ + _si_), where _d_ is the number of dense rows or columns betweeen the origin and a coördinate, and _s_ the number of sparse (_i.e._ no galaxies) rows or columns. The Manhattan distance computation can then be computed simply by multiplying the imaginary component by the length assigned to sparse spaces for each dimension in the coördinates whose interstitial distance to compute.
+
+    On an unrelated note, the frequency of the phrase "shortest path" in Part 1 definitely made me think that I'd need to reach for a pathfinding algorithm in Part 2 — alas, I suppose that'll have to wait for another day.
+  :replies: []

data/data/solutions/reddit/ruby/2023/12.yml

@@ -0,0 +1,49 @@
+---
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18ge41g/2023_day_12_solutions/kd1g2u9/
+  :body: |-
+    It took me 4 very long hours of tryharding ways to optimize the recursion until it dawned me that all my efforts were wasted and I should maybe use caching to solve part 2.
+
+    I like the core part of my recursion though - simple 6 line 3-way condition of consuming individual characters
+
+    Part 2 takes 10 seconds to complete iteratively, 1 second when using parallel forked processes
+
+    I kept one recursion optimization though: Before the recursion I count how many `?` can be skipped to still be able to fulfill the required total `#`. When the limit is reached the recursion returns early and saves a bit of time
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBeBQAAAAAAAAA5GUqKNoFH6SMqfBlGQHyGCNGeiQzN+nrwlZ3Ae8mLEFKGLOUItrisg/NJEqxJxWBXT4eTjntttsPpM9AXPGdGXOwMWb7IQAgdlGCPMyZp3oczzrD+4eRQ5ckatQD338LwEgnZ3JISCWt1lHeA6pE3PRIqrm1qY2GgDSpfG/gOloCZF76swcanH/i2UgmI/X9D897yfIv0ADaskQ48nFlBWKoynhFeyhKktnIU2GXBjhExEzIz2/hyeXcYcIybnj6NHlUo/a1N+j/zh7wJja8x2uCY/ZF3GjOEFyySecdKnNYWDXQZvd0X2YnuX7cJuOS5+hrdzqexWUL8Eb/HNWGasCVxShzyqal0MLdj5MdP6O0dwDyfxZdYDbYl+Pa6by/dXq1Tb+nmruh2AwxRxDimqckCsSZzr7uaTLCixXxZYLDkf9bJDDy1UG5VDsPYFxPtArMdH/4cj0xdj7xMmHfifzHgsDRbWeB70BGMAE9/kLtaFcklGJV+WKXjpS5CyjQK9eVScmwRJ4aV1zlzbi9ALNI1SDf98kJ7pFK4uPAdyHpfZ86WZKuz/K4vG6rf3PqWrqPAmNJbsvwJsxT8xDnhPeu+ba8UzmJirPW37lRLWKeKZOzi9x3LIt3dHsQ+jrJFcG34dPupjIypfUcy04Vs3zNWg+C9npHzB/XNPyJQIocxwBI2jH9JqU9kE4VSvQfcuidDYyGHQOpKZ+EjgXhmkx4u3VTtc2KimAN48E845PA99tWv80vJOfUR3eXkd6WAmp0Nc4oELiOsFKzlSeJ4J8P+zH2W)
+  :replies:
+  - :author: squirrelhoodie
+    :url: https://www.reddit.com/r/adventofcode/comments/18ge41g/2023_day_12_solutions/kd1iqul/
+    :body: Luckily, I figured out the caching solution a bit quicker, but I let my inefficient code run for 32 minutes before I implemented the cache and found the correct solution in a runtime of... about 0.3 seconds. Insane what a difference it makes. My guess is that non-caching code would have needed at least 5 to 10 hours.
+    :replies:
+    - :author: Symbroson
+      :url: https://www.reddit.com/r/adventofcode/comments/18ge41g/2023_day_12_solutions/kd1oe23/
+      :body: |-
+        I timed the individual input lines and let it run on 20 processes for about an hour, and it reached about line 450. the times varied from milliseconds, to couple minutes up to half an hour for a single line! (from what I monitored)
+
+        so yes it would've taken at least two more hours, if the times wouldn't grow even more
+
+        I bet programmers from the networking/web field would've used caching from the start in part one
+      :replies: []
+- :author: Alkyonios
+  :url: https://www.reddit.com/r/adventofcode/comments/18ge41g/2023_day_12_solutions/kd3d838/
+  :body: |-
+    Kind of surprised of how "quickly" I got part 1 (20-25 minutes), to a problem that seemed quite complex initially.
+
+    I counted the wildcards in the string ("?") and then generated every binary string of that length and replaced every wildcard with the character from the binary string in that position.
+
+    Time complexity so bad that I'll have to work on something else for part 2. Perhaps BFS could work (since you can ditch a permutation as soon as you get the first group, if it's not the correct length).
+
+    Any kind of feedback is highly appreciated
+
+    [Solution](https://topaz.github.io/paste/#XQAAAQAWBAAAAAAAAAAFCPgHbQq4AMkIJWYxjn/lQHzoMyngt1m2nqwQAsFhnyZiivVjX2w6tjXvSZGmy/ibWueEk4o+QVkOa1UTKMY3rdRICK6J0hSL4zizJIURMjcNS0WzGAwUti6/yy57f/va8alZ5M9IC4ZYy2mxqpQF7xqqoo0va6gPKuVGZSmPnBQDZx0eVYx3qOi3SfTodmzms+aapJCYTYlnL3MOqLkTpEsUvdz2mSshrz6KBHyxDbG3cBTAk81X3uH7OBHeHGZpuf5KEX+COIVnu6reV0QMHyLkXSAa5gcgzDifiotVRlkP6lX9q1okNBxNeV2lpCbhdhCOn9amEbFH4qeGxxWGdu7YrgVRfdkn+JMJZzTCd8nBkYJXxCIjGR5c8WrMFi4SXNazNsS2JWDNphQtdzaIY32iIwCC8YfPkBs+ZOcQ2jmOdS+EC4EViB3+p3LSOhLyzKMptaDnK3Mjmq4BLCXhP54sOxUH03sIhbOiRSJbmFEtKqnf1LNYXTBBKmuaww5/3lIMvHT/yTrthg==) (@input is just an array of every line in the input)
+  :replies: []
+- :author: glebm
+  :url: https://www.reddit.com/r/adventofcode/comments/18ge41g/2023_day_12_solutions/kd2vepr/
+  :body: |-
+    Part 1: Brute force all possible `?` substitutions and count the valid ones.
+
+    Part 2: Recursion with memoization. Possibly overly complicated, took me several hours to get working. Finishes in 5 seconds for part 2.
+
+    [https://github.com/glebm/advent-of-code/tree/main/2023/12](https://github.com/glebm/advent-of-code/tree/main/2023/12)
+  :replies: []

data/data/solutions/reddit/ruby/2023/13.yml

@@ -0,0 +1,135 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kdb034y/
+  :body: |-
+    A day late but still going, this was tough!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/13)
+
+    [Video Walkthrough](https://youtu.be/ng88PiHxLCo)
+  :replies: []
+- :author: grimlyforming
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kd9sbam/
+  :body: |-
+    [https://pastebin.com/iwbrMUac](https://pastebin.com/iwbrMUac)
+
+    I tried the brute-force method of changing every character in the graph, wasn't getting the answer, and it was too cumbersome to debug. Then I realized that instead of changing every char and looking for a reflection, look for a modified reflection. The wrapper around the code is too full of print stmts etc, but I'm happy with the core solution.
+  :replies: []
+- :author: glebm
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kd5o37o/
+  :body: |-
+    No clever tricks needed today, simply brute-force.
+
+    Part 1:
+
+    ```ruby
+    def solve(data)
+      (1...data.size).find { |i|
+        len = [i, data.size - i].min
+        (1..len).all? { data[i - _1] == data[i + _1 - 1] }
+      } || 0
+    end
+
+    puts loop.map {
+      data = $<.lazy.map(&:chomp).take_while { !_1.empty? }.to_a.map(&:chars)
+      raise StopIteration if data.empty?
+      row = solve(data)
+      column = solve(data.transpose)
+      row * 100 + column
+    }.sum
+    ```
+
+    Part 2:
+
+    ```ruby
+    def solve(data, ignore = -1)
+      (1...data.size).find { |i|
+        next if i == ignore
+        len = [i, data.size - i].min
+        (1..len).all? { data[i - _1] == data[i + _1 - 1] }
+      } || 0
+    end
+
+    def smudge(c) = c == '#' ? '.' : '#'
+
+    puts loop.map {
+      data = $<.lazy.map(&:chomp).take_while { !_1.empty? }.to_a.map(&:chars)
+      raise StopIteration if data.empty?
+      initial_row = solve(data)
+      initial_column = solve(data.transpose)
+      row, column = (0...data.size).lazy.filter_map { |y|
+        (0...data[0].size).lazy.filter_map { |x|
+          data[y][x] = smudge(data[y][x])
+          row = solve(data, initial_row)
+          column = solve(data.transpose, initial_column)
+          data[y][x] = smudge(data[y][x])
+          [row, column] if row != 0 || column != 0
+        }.first
+      }.first
+      row * 100 + column
+    }.sum
+    ```
+
+    https://github.com/glebm/advent-of-code
+  :replies: []
+- :author: Various_Frosting4888
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kd6hozf/
+  :body: "[https://pastebin.com/gRvQvrWx](https://pastebin.com/gRvQvrWx)"
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kd6j5b3/
+  :body: |-
+    My initial code was horrible, after cleanup it actually looks quite nice.
+
+    Until I started golfing my solution, which turned the code back into a horrible mess. I adopted some of it back into my initial code, but some things were pure evil just to save like 2 bytes...
+
+    ```ruby
+    test = lambda { |l, nudge|
+        for i in 0...l.size - 1
+            k = i + 1
+            next unless l[i].zip(l[k]).count { _1 != _2 } <= nudge
+
+            m2 = (0...[k, l.size - k].min).filter { l[k + _1] != l[i - _1] }
+            next unless m2.size == nudge
+
+            nudged = m2[0] && l[i - m2[0]].zip(l[k + m2[0]]).count { _1 != _2 }
+            return k if nudge == 0 || nudged == 1
+        end
+        0
+    }
+
+    res = $<.read.tr("\r", '').split("\n\n").sum do |l|
+        m = l.split("\n").map(&:chars)
+        (
+            100 * test[m, 0] + test[m.transpose, 0] +
+            100i * test[m, 1] + 1i * test[m.transpose, 1])
+    end
+    puts "Part 1: #{res.real}"
+    puts "Part 2: #{res.imag}"
+    ```
+
+    Golfed Ruby: `308` bytes.
+
+    The main thing was that I was able to write the whole `test` function into a single line statement using various tricks. After that I nudged it even more using a negative range for reverse iteration, to be able to store the first match index from the last iteration.
+
+    Also the main test loop starts from 1 to size because it is 2 bytes shorter in total to calculate `i` from `k = (i+1)` than the other way around
+
+    I wonder if some of the conditions could be made even shorter but I'm quite happy with it, not considering the awful amount of time I spent on this
+
+    ```ruby
+    t=->(l,n){(1...(h=l.size)).sum{|k|l[i=k-1].zip(l[k]).count{_1!=_2}<=n&&(
+    (-[k,h-k].min+1..w=0).count{l[k-_1]!=l[i+_1]&&w=_1}==n&&
+    (n==0||l[i+w].zip(l[k-w]).count{_1!=_2}==1)&&k)||0}}
+    p *$<.read.tr(?\r,'').split("\n\n").map{m=_1.split(?\n).map(&:chars)
+    [0,1].map{|n|100*t[m,n]+t[m.transpose,n]}}.transpose.map(&:sum)
+    ```
+  :replies: []
+- :author: Unhappy_Adeptness_93
+  :url: https://www.reddit.com/r/adventofcode/comments/18h940b/2023_day_13_solutions/kd72ekb/
+  :body: |-
+    Finding hamming distance in part 2 was easy after using int representations of the rows/columns for debugging on part 1.
+
+    The thing I think is _pretty_ neat, is that I compared every combination of rows, and then grouped those by the average of their indexes, which gives you the center line. You have to filter out half the pairs, because the mirror would be _on_ a row or column.
+
+    [https://github.com/andyAtChime/advent\_of\_code/blob/solutions-2023/2023/code/day\_13.rb](https://github.com/andyAtChime/advent_of_code/blob/solutions-2023/2023/code/day_13.rb)
+  :replies: []