advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/gchan/2024/24_2.yml

@@ -0,0 +1,264 @@
+---
+- :name: day-24-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-24
+  :solution: |-
+    wires, raw_gates = input.split("\n\n")
+
+    wires = wires
+      .split(?\n)
+      .map { _1.split(": ") }
+      .map { [_1, _2.to_i ] }
+      .to_h
+
+    bin_length = wires.size / 2
+
+    gates = raw_gates.split(?\n)
+      .map { _1.gsub("->", "").split }
+
+    outputs = gates.map(&:last)
+
+    outputs.each { wires[_1] = nil }
+
+    deps = Hash.new { |h, k| h[k] = Set.new }
+
+    gates.each do
+      w1, _rule, w2, _out = _1
+
+      deps[w1].add(_1)
+      deps[w2].add(_1)
+    end
+
+    def compute(x, y, deps, bin_length)
+      wires = {}
+
+      x.to_s(2).rjust(bin_length, ?0).chars.reverse.each.with_index {
+        wires["x#{_2.to_s.rjust(2, ?0)}"] = _1.to_i
+      }
+
+      y.to_s(2).rjust(bin_length, ?0).chars.reverse.each.with_index {
+        wires["y#{_2.to_s.rjust(2, ?0)}"] = _1.to_i
+      }
+
+      queue = wires
+        .select { _2 }
+        .map(&:first)
+
+      while queue.any?
+        wire = queue.shift
+
+        deps[wire].each { |gate|
+          w1, rule, w2, out = gate
+
+          next if wires[out]
+          next if wires[w1].nil?
+          next if wires[w2].nil?
+
+          output =
+            case rule
+            when "XOR"
+              wires[w1] ^ wires[w2]
+            when "AND"
+              wires[w1] & wires[w2]
+            when "OR"
+              wires[w1] | wires[w2]
+            end
+
+          wires[out] = output
+
+          queue << out
+        }
+      end
+
+      wires.keys.sort
+        .select { _1.start_with?(?z) }
+        .map { wires[_1] }
+    end
+
+    #x = wires.select { _1.start_with?(?x) }.sort
+    #  .map(&:last).join.reverse.to_i(2)
+    #y = wires.select { _1.start_with?(?y) }.sort
+    #  .map(&:last).join.reverse.to_i(2)
+
+    def bit_errors(deps, bin_length)
+      errors = []
+      bin_length.times do |bin|
+        n = 2 ** bin
+
+        [[0, n], [n, 0], [n, n]].each do |x, y|
+          z = x + y
+
+          z_bin = z.to_s(2).rjust(bin_length + 1, ?0).chars
+            .map(&:to_i).reverse.join
+
+          output = compute(x, y, deps, bin_length)
+
+          if output.join != z_bin
+            errors << bin
+          end
+        end
+      end
+
+      errors.uniq.sort
+    end
+
+    errors = bit_errors(deps, bin_length)
+    puts "#{errors.count} bit errors"
+    p errors
+    puts
+
+    # The wires and gates represent a Ripple-carry adder which is composed
+    # many full adders, one for each bit. The first bit is a half adder as
+    # it has no input carry bit.
+    #
+    # https://en.wikipedia.org/wiki/Adder_(electronics)#Ripple-carry_adder
+    # https://en.wikipedia.org/wiki/Adder_(electronics)#Full_adder
+    #
+    # Truth table from Wikipedia:
+    #
+    # Inputs   Outputs
+    # A B Cin  Cout S
+    # 0 0 0    0    0
+    # 0 0 1    0    1
+    # 0 1 0    0    1
+    # 0 1 1    1    0
+    # 1 0 0    0    1
+    # 1 0 1    1    0
+    # 1 1 0    1    0
+    # 1 1 1    1    1
+    #
+    # Which can be expressed by the logic gates:
+    #
+    # S = A XOR B XOR Cin
+    # Cout = (A AND B) OR ( (A XOR B) AND Cin )
+    #
+    # Cin is the carry bit from the previous bit as Cout.
+    #
+    # S is the 'z' wires in our case so we expect an XOR operator
+    # where 'z' is the output.
+    # Observation: Z shouldn't be part of any OR and AND operators.
+    #
+    # A and B is 'x' and 'y' in our case, so we should expect
+    # to find 'x XOR y -> M' where M is then featured in 'M XOR Cin'
+    # and 'M AND Cin'.
+    # Observation: M shouldn't be in an OR operators, where x XOR y -> M
+    #
+    # 'x AND y -> N' contributes to the carry bit, Cout. It should be always
+    # fed into an OR operator.
+    # Observation: N must be invovlved in an OR operator, where x AND y -> N
+    #
+    # Observation: Cout, the output carry bit is the result of an OR operator
+    # Observation: Cin, the incoming carry bit operator is not
+    # invovled in any OR operators
+    #
+
+    # Gates where Z is the output and the operator isn't XOR
+    # All these need swaping
+    z_swaps = gates.select { |a, op, b, out| out.start_with?(?z) && op != "XOR" }
+
+    # The last z bit is a carry bit so it can be the output of an OR operator
+    z_swaps.reject! { _4 == "z#{bin_length}" }
+
+    # Gates with XOR operators but no Z output and do not involve X and Y as
+    # inputs and also doesn't involve M where x XOR y -> M
+    xor_swaps = gates.select { |a, op, b, out|
+      !out.start_with?(/z/) &&
+        op == "XOR" &&
+        !a.start_with?(/[xy]/)
+    }
+
+    # Wires in the first set need to swap with items in the second
+    p z_swaps
+    p xor_swaps
+    puts
+
+
+    # x XOR y -> M and M must be invovled in as inputs for XOR and AND
+    # gates (i.e. can't be involved with an OR operator)
+    m = gates.select { |a, op, b, out| op == "XOR" && a.start_with?(/[xy]/) }
+      .map { _4 }
+
+    incorrect_m = gates
+      .select { |a, op, b, out|
+        op == "OR" && (m.include?(a) || m.include?(b))
+      }
+      .flat_map { [_1, _3] }
+      .select { m.include?(_1) }
+
+    m_swaps = gates.select { |a, op, b, out|
+      op == "XOR" && incorrect_m.include?(out)
+    }
+
+    # 'x AND y -> N' and N must be involved in an OR operator
+    n = gates.select { |a, op, b, out| op == "AND" && a.start_with?(/[xy]/) }
+      .map { _4 }
+
+    incorrect_n = gates
+      .select {
+        |a, op, b, out| op != "OR" && (n.include?(a) || n.include?(b))
+      }
+      .flat_map { [_1, _3] }
+      .select { n.include?(_1) }
+      .uniq
+
+    n_swaps = gates.select { |a, op, b, out|
+      op == "AND" && incorrect_n.include?(out)
+    }
+
+    # x00 AND y00 -> N do not invovle an OR operator as there is no input
+    # carry bit. So x00 AND y00 simply becomes the output carry bit
+    n_swaps.reject! { _1.first.end_with?("00") }
+
+    # Wires in the first set need to swap with items in the second
+    p m_swaps
+    p n_swaps
+    puts
+
+    z_wires = z_swaps.map(&:last)
+    xor_wires = xor_swaps.map(&:last)
+    m_wires = m_swaps.map(&:last)
+    n_wires = n_swaps.map(&:last)
+
+    # Superfluous verification step
+    z_perms = z_wires.permutation(z_wires.size).to_a
+    z_swap_pairs = z_perms.map { _1.zip(xor_wires) }
+
+    m_perms = m_wires.permutation(m_wires.size).to_a
+    nm_swap_pairs = m_perms.map { _1.zip(n_wires) }
+
+    swap_pairs = z_swap_pairs.product(nm_swap_pairs)
+      .map { _1.inject(&:concat) }
+
+    swap_pairs.each do |attempt|
+      attempt.concat(attempt.map(&:reverse))
+
+      deps_copy = Hash.new { |h, k| h[k] = Set.new }
+
+      regex = Regexp.new(
+        attempt.map(&:first).map { "(?<=-> )#{_1}" }.join(?|)
+      )
+
+      gates = raw_gates
+        .gsub(regex, attempt.to_h)
+        .split(?\n)
+        .map { _1.gsub("->", "").split }
+
+      gates.each do
+        w1, _rule, w2, _out = _1
+
+        deps_copy[w1].add(_1)
+        deps_copy[w2].add(_1)
+      end
+
+      errors = bit_errors(deps_copy, bin_length)
+
+      if errors.count == 0
+        puts "swap pairs"
+        p attempt
+        break
+      end
+    end
+
+    wire_swap = z_wires + xor_wires + m_wires + n_wires
+
+    puts
+    puts wire_swap.sort.join(?,)

data/data/solutions/github/gchan/2024/25_1.yml

@@ -0,0 +1,21 @@
+---
+- :name: day-25-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-25
+  :solution: |-
+    schematics = input.split("\n\n")
+      .map(&:split)
+
+    locks = schematics.select { _1.first.include?(?#) }
+    keys  = schematics.select { _1.last.include?(?#) }
+
+    locks = locks.map { |lock|
+      lock.map(&:chars).transpose.map { _1.count { |col| col.include? ?# } - 1 }
+    }
+
+    keys = keys.map { |key|
+      key.map(&:chars).transpose.map { _1.count { |col| col.include? ?# } - 1 }
+    }
+
+    keys.product(locks)
+      .count { |key, lock| key.zip(lock).all? { _1 + _2 <= 5 } }
+      .tap { p _1 }

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

@@ -0,0 +1 @@
+--- []

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

@@ -0,0 +1,123 @@
+---
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3v3w2f/day_2_solutions/cxk4xpj/
+  :body: |-
+    Not-a-programmer solutions in ruby
+
+    Part 1:
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = File.readlines("input.txt")
+
+    total = 0
+    present = []
+    data.each do |c|
+      temp = c.strip.split("x")
+      present = temp.collect{|i| i.to_i}
+      present = present.sort
+      x = 2 * present[0] * present[1]
+      y = 2 * present[1] * present[2]
+      z = 2 * present[2] * present[0]
+      total += x + y + z + (present[0] * present[1])
+    end
+
+    p total
+    ```
+
+    Part 2:
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = File.readlines("input.txt")
+
+    total = 0
+    present = []
+    data.each do |c|
+      temp = c.strip.split("x")
+      present = temp.collect{|i| i.to_i}
+      present = present.sort
+      ribbon = (present[0] * 2) + (present[1] * 2)
+      bow = present[0] * present[1] * present[2]
+      total += ribbon + bow
+    end
+
+    p total
+    ```
+  :replies:
+  - :author: Aneurysm9
+    :url: https://www.reddit.com/r/adventofcode/comments/3v3w2f/day_2_solutions/cxk5rbh/
+    :body: I'm so proud of you! For a not-a-programmer you came up with pretty much the mirror of my Perl solution.
+    :replies:
+    - :author: gnuconsulting
+      :url: https://www.reddit.com/r/adventofcode/comments/3v3w2f/day_2_solutions/cxki7t4/
+      :body: Heh. Pure coincidence I'm sure :-P
+      :replies: []
+- :author: mikealxmitchell
+  :url: https://www.reddit.com/r/adventofcode/comments/3v3w2f/day_2_solutions/cxk8soe/
+  :body: |-
+    Ruby: Day 2 Part I
+
+    ```ruby
+    sum = 0
+    File.open(ARGV[0]).each do |line|
+      box = line.split('x').map(&:to_i).sort
+      sum += 3*box[0]*box[1] + 2*box[1]*box[2] + 2*box[0]*box[2]
+    end
+    puts sum
+    ```
+
+    Ruby: Day 2 Part II
+
+    ```ruby
+    sum = 0
+    File.open(ARGV[0]).each do |line|
+      box = line.split('x').map(&:to_i).sort
+      sum += 2*box[0] + 2*box[1] + box[0]*box[1]*box[2]
+    end
+    puts sum
+    ```
+  :replies: []
+- :author: adherry
+  :url: https://www.reddit.com/r/adventofcode/comments/3v3w2f/day_2_solutions/cxkqhxw/
+  :body: |-
+    My Ruby solution, could be a bit more dry, but does the job
+
+    ```ruby
+    # Day 2
+    file = File.new("input", "r")
+    arr = []
+    while (line = file.gets)
+      arr << line.split('x')
+      arr[-1][-1] = arr[-1][-1].gsub("\n","")
+    end
+    arr.each do |element|
+      element.map! { |e| e.to_i }
+    end
+    #star 1
+    total_amount_paper = 0
+    arr.each do |element|
+      sides = []
+      sides << element[0]*element[1]
+      sides << element[1]*element[2]
+      sides << element[0]*element[2]
+      smallest_side = sides.min
+      sum_of_sides = 0
+      sides.map { |e| sum_of_sides += e*2 }
+      total_amount_paper += smallest_side + sum_of_sides
+    end
+
+    #star 2
+    total_amount_ribbon = 0
+    arr.each do |element|
+      required_length = 0
+      element.min(2).map { |e| required_length += 2*e}
+      volume = element[0]*element[1]*element[2]
+      total_amount_ribbon += required_length + volume
+    end
+    puts "Total amount of paper needed: #{total_amount_paper}"
+    puts "Total amound of ribbon needed: #{total_amount_ribbon}"
+    ```
+  :replies: []

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

@@ -0,0 +1,220 @@
+---
+- :author: wdomburg
+  :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxm6m18/
+  :body: |-
+    My Ruby solution.
+
+    # Read the data.
+
+    ```ruby
+    input = File.read('input3.txt').split('')
+    ```
+
+    # Puzzle 1
+
+    ```ruby
+    x = 0; y = 0; a = {[0,0] => 1}; input.each { |i| case i; when '>'; x += 1; when '<'; x -= 1; when '^'; y -= 1; when 'v'; y += 1; end; a[[x,y]] = 1 }; a.length
+    ```
+
+    # Puzzle 2
+
+    ```ruby
+    e = [[0,0],[0,0]].cycle; a = {[0,0] => 1}; input.each { |i| p = e.next; case i; when '>'; p[0] += 1; when '<'; p[0] -= 1; when '^'; p[1] -= 1; when 'v'; p[1] += 1; end; a[[x,y]] = 1 }; a.length
+    ```
+
+    To make it a bit more clear, an expanded version of puzzle 2:
+
+    ```ruby
+    # initialize the positions of both santas
+    santas = [[0,0],[0,0]].cycle
+
+    # initialize the list of houses
+    houses = {[0,0] => 1}
+
+    # iterate over the delivery instructions
+    input.each do |instruction|
+        # switch santas
+        position = santas.next
+
+        # move the santa
+        case instruction
+                when '>'; position[0] += 1
+                when '<'; position[0] -= 1
+                when '^'; position[1] -= 1
+                when 'v'; position[1] += 1
+        end
+
+        # drop the gift
+        houses[[position[0],position[1]]] = 1
+    end
+
+    # count the houses
+    houses.length
+    ```
+  :replies:
+  - :author: Monofu
+    :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxnyqsk/
+    :body: Using a cycle was genius! I would never thought to use that. Makes so much sense in hindsight...
+    :replies: []
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxldtie/
+  :body: |-
+    Continuing my non-programmer attempts, I kinda like my part 1 solution (mostly because at first I thought this would be super hard and then I remembered hashes) but the part 2 solution is very hacky. I don't like it at all.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = File.read("input.txt")
+
+    x = 0
+    y = 0
+
+    current = x.to_s + y.to_s
+    locations = {}
+    locations[current] = "visited"
+
+    data.each_char do |c|
+
+      if c == '^'
+        y += 1
+      elsif c == 'v'
+        y -= 1
+      elsif c == '<'
+        x -= 1
+      elsif c == '>'
+        x += 1
+      end
+
+      current = x.to_s + y.to_s
+      locations[current] = "visited"
+
+    end
+
+    p locations.length
+    ```
+
+    Day 2:
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = File.read("input.txt")
+
+    x1 = x2 = y1 = y2 = 0
+
+    current = x1.to_s + "," + y1.to_s
+    locations = {}
+    locations[current] = "visited"
+
+    alt = 0
+    data.each_char do |c|
+      if alt == 0
+        alt = 1
+        if c == '^'
+          y1 += 1
+        elsif c == 'v'
+          y1 -= 1
+        elsif c == '<'
+          x1 -= 1
+        elsif c == '>'
+          x1 += 1
+        end
+        current = x1.to_s + "," + y1.to_s
+        locations[current] = "visited"
+      else
+        alt = 0
+        if c == '^'
+          y2 += 1
+        elsif c == 'v'
+          y2 -= 1
+        elsif c == '<'
+          x2 -= 1
+        elsif c == '>'
+          x2 += 1
+        end
+        current = x2.to_s + "," + y2.to_s
+        locations[current] = "visited"
+      end
+
+    end
+
+    p locations.length
+    ```
+  :replies:
+  - :author: dalfgan
+    :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxmhuu6/
+    :body: |-
+      About the first part:
+
+      ```ruby
+      current = x.to_s + y.to_s
+      locations[current] = "visited"
+      ```
+
+      If x is 12 and y is 1, then it will be "121".
+
+      If x is 1 and y is 21, then it will also be "121".
+
+      At least, 2nd part you put ",".
+    :replies: []
+- :author: eregontp
+  :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxlh10r/
+  :body: |-
+    Cleaned-up Ruby solution using coroutines (Fiber): The first argument chooses the number of santas (or the puzzle number!)
+
+    ```ruby
+    require 'set'
+    map = Set.new
+
+    give_gifts = -> move {
+      map << (x, y = 0, 0)
+      loop {
+        case move
+        when '<' then x -= 1
+        when '>' then x += 1
+        when '^' then y -= 1
+        when 'v' then y += 1
+        else raise move
+        end
+        map << [x, y]
+        move = Fiber.yield
+      }
+    }
+
+    n = Integer(ARGV[0] || 1)
+    santas = n.times.map { Fiber.new(&give_gifts) }
+
+    STDIN.read.each_char.each_slice(n) { |moves|
+      santas.zip(moves) { |santa, move| santa.resume(move) }
+    }
+    p map.size
+    ```
+  :replies: []
+- :author: haitei
+  :url: https://www.reddit.com/r/adventofcode/comments/3v8roh/day_3_solutions/cxlmjj9/
+  :body: |-
+    Relearning Haskell for the nth time:
+
+    ```ruby
+    import Data.Set
+
+    move (x,y) '<' = (x-1,y)
+    move (x,y) '^' = (x,y+1)
+    move (x,y) '>' = (x+1,y)
+    move (x,y) 'v' = (x,y-1)
+
+    visitNext (visited, current) dir = (insert newPos visited, newPos) where newPos = move current dir
+    visitNext2 ((va, vb), ca, cb) dir = ((vb, insert newPos va), cb, newPos) where newPos = move ca dir
+
+    start = singleton (0,0)
+
+    main = do
+        c <- getLine
+        print $ size . fst $ Prelude.foldl visitNext (start, (0,0)) c
+        print $ size $ uncurry union $ (\(a,_,_) -> a) $ Prelude.foldl visitNext2 ((start, start), (0,0), (0,0)) c
+    ```
+
+    Not too pretty but works.
+
+    EDIT: hmm I did the first one in python, the second in ruby, for the fourth I think I'll use Befunge
+  :replies: []

data/data/solutions/reddit/ruby/2015/04.yml

@@ -0,0 +1,72 @@
+---
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxmmh2t/
+  :body: |-
+    Day 4 of the non-programmer's solution.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    require 'openssl'
+
+    for i in 1..10000000 do
+      md5 = OpenSSL::Digest::MD5.hexdigest('ckczppom' + i.to_s)
+      if md5 =~ /^000000/
+        p i
+        p md5
+        break
+      end
+    end
+    ```
+  :replies:
+  - :author: Aneurysm9
+    :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxmml28/
+    :body: You keep calling yourself a non-programmer and your solutions keep looking a lot like mine. I don't know whether that says something about you or about me!
+    :replies: []
+  - :author: Geambanu
+    :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxnceun/
+    :body: what language is this?
+    :replies:
+    - :author: joeyrobert
+      :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxndra5/
+      :body: Ruby.
+      :replies: []
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxpy3d0/
+    :body: |-
+      Nice! I wasn't aware of the =~ operator. These challenges are showing me I have A LOT I still need to learn about Ruby!
+
+      My solution was basically the same except I used the regex
+
+      ```ruby
+      /^0{6}.*$/
+      ```
+    :replies: []
+  - :author: karatedog
+    :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cyik9rc/
+    :body: The 4th day task asks for **at least 5 leading zeros** , not 6.
+    :replies: []
+- :author: baritoneCoder
+  :url: https://www.reddit.com/r/adventofcode/comments/3vdn8a/day_4_solutions/cxn5awm/
+  :body: |-
+    Simple Ruby solution. Definitely not fast but gets the job done.
+
+    ```ruby
+    require 'digest/md5'
+
+    def hashify(string)
+        Digest::MD5.hexdigest(string)
+    end
+
+    base = 'ckczppom'
+    answer = '0'
+    hash = hashify(base)
+
+    until hash.slice(0,5) == '00000' do
+        hash = hashify(base + answer)
+        answer = (answer.to_i + 1).to_s
+    end
+
+    puts "The answer is: #{answer.to_i - 1}"
+    ```
+  :replies: []