advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2020/08.yml

@@ -0,0 +1,451 @@
+---
+- :author: jeffers0n
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf6d3jz/
+  :body: |-
+    Ruby. I found this much easier than day 07.
+
+    ```ruby
+    #!/bin/env ruby
+
+    def run_code (instructions)
+        acc = 0
+        tracker = Array.new(instructions.length, false)
+        i = 0
+        success = false
+        while tracker[i] == false do
+            tracker[i] = true
+            case instructions[i][0..2]
+            when 'acc'
+                acc += instructions[i].split(' ')[1].to_i
+                i += 1
+            when 'jmp'
+                i += instructions[i].split(' ')[1].to_i
+            when 'nop'
+                i += 1
+            end
+            success = true if i == instructions.length
+        end
+        return success, acc, tracker
+    end
+
+    input = File.readlines('./input').to_ary.map(&:strip)
+    succ, acc, tracker = false, 0, []
+
+    input.each.with_index do |instruction, i|
+        mod = input.map(&:clone)
+        if instruction[0..2] == 'jmp'
+            mod[i][0..2] = 'nop'
+        elsif instruction[0..2] == 'nop'
+            mod[i][0..2] = 'jmp'
+        else
+            next
+        end
+        succ, acc, tracker = run_code(mod)
+        break if succ == true
+    end
+
+    p acc
+    ```
+  :replies:
+  - :author: rune_kg
+    :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gfkdzu8/
+    :body: Very pretty!
+    :replies: []
+- :author: tckmn
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf0zdyb/
+  :body: "[ruby 6/2](https://gist.github.com/tckmn/ba6c243bfde8d73c4e92033f7f0cabef), unedited from my part 2 submission, posting because it's pretty silly. nothing like reading the input file 635 times to avoid bugs from forgetting to copy / reset things lol"
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf1nh3w/
+  :body: |-
+    # Ruby
+
+    Wasted time trying to think of a 'clever' solution for part two. Which I did but then had other work to do so just brute forced it :-D
+
+    ```ruby
+    # Parser and lexer ;-)
+    code = $<.readlines
+             .map(&:split)
+             .map { |is| [is[0].to_sym, is[1].to_i] }
+
+    # Interpreter
+    def execute(code, no_loops = false)
+      pc = acc = cycles = 0
+      coverage = []
+
+      while (cycles += 1) < 1000
+        return acc if pc >= code.length || (coverage[pc] && no_loops)
+        coverage[pc] = true
+
+        ins, op = code[pc]
+        acc += op if ins == :acc
+        pc += op - 1 if ins == :jmp
+        pc += 1
+      end
+    end
+
+    # Run code for part one
+    puts execute(code, true)
+
+    # Change code for part two
+    code.each.with_index do |_, loc|
+      next unless %i{jmp nop}.include?(code[loc][0])
+
+      code[loc][0] = code[loc][0] == :nop ? :jmp : :nop
+      res = execute(code)
+      code[loc][0] = code[loc][0] == :nop ? :jmp : :nop
+
+      puts "#{loc} - #{res}" if res
+    end
+    ```
+  :replies: []
+- :author: Ryuujinx
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf2g2b8/
+  :body: |-
+    # Ruby
+
+    This one I didn't find terribly difficult, just moving some pointers around an array really. Code: https://github.com/Ryuujinx/aoc2020/tree/main/day8
+  :replies: []
+- :author: Karl_Marxxx
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf2jcsg/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    main_prog = ARGF.readlines.map { |line|
+        code, value = line.split
+        [code, value.to_i, false]
+    }
+
+    def run_program(prog)
+        p_counter = 0
+        acc = 0
+        while true
+            op, val, visited = prog[p_counter]
+            return acc, false if visited == true
+            return acc, true if p_counter == prog.length
+            prog[p_counter][2] = true
+            case op
+            when "nop"
+                p_counter += 1
+            when "acc"
+                acc += val
+                p_counter += 1
+            when "jmp"
+                p_counter += val
+            else
+                raise "op: #{op}"
+            end
+        end
+    end
+
+    def copy(prog)
+        return prog.map { |line|
+            op, val, visited = line
+            [op, val, visited]
+        }
+    end
+
+    # part 1
+    acc, success = run_program(copy(main_prog))
+    puts acc
+
+    # part 2
+    main_prog.each.with_index do |line, i|
+        op, val, _ = line
+        if op == "jmp"
+            new_op = "nop"
+        elsif op == "nop"
+            new_op = "jmp"
+        else
+            new_op = op
+        end
+        new_prog = copy(main_prog)
+        new_prog[i][0] = new_op
+        acc, success = run_program(new_prog)
+        p acc if success
+    end
+    ```
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf0yz10/
+  :body: |-
+    Ruby 423/218
+
+    ```ruby
+    require 'set'
+
+    class Interpreter
+      def initialize(instructions)
+        @instructions = instructions
+      end
+
+      def run
+        accumulator = 0
+        offset = 0
+        visited = Set.new
+
+        while true
+          return [accumulator, true] if offset >= @instructions.size
+
+          instruction, value = @instructions[offset]
+          case instruction
+          when 'nop'; offset += 1
+          when 'acc'; accumulator += value; offset += 1
+          when 'jmp'; offset += value
+          end
+
+          return [accumulator, false] if visited.include?(offset)
+          visited.add(offset)
+        end
+      end
+    end
+
+    instructions = File.read('08.txt').lines(chomp: true).map { |l| i, v = l.split(' '); [i, v.to_i] }
+    interpreter = Interpreter.new(instructions)
+
+    # part 1
+    puts Interpreter.new(instructions).run[0]
+
+    # part 2
+    (0...instructions.size).each do |change|
+      saved = instructions[change][0]
+      next if saved == 'acc'
+
+      instructions[change][0] = saved == 'jmp' ? 'nop' : 'jmp'
+      accumulator, halted = interpreter.run
+      puts accumulator if halted
+
+      instructions[change][0] = saved
+    end
+    ```
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf12k89/
+  :body: |-
+    **Ruby:** 4:41/9:25, 348/203
+
+    Here's a [recording](https://youtu.be/vOs2QW8GEeg) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/b10dc253003990f01d06639aaad43d380df35ddd/2020/dec08.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Forgot to increment the instruction pointer after updating the accumulator in Part 1 and lost 40 seconds waiting for the submission timeout. But otherwise pretty straightforward. Will have to clean it up before the next processor problem!
+  :replies:
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf1n8t6/
+    :body: |-
+      I took a similar approach to you, but got majorly screwed by `dup` not being a deep clone, as I was editing the inner array directly (e.g. like `new_ops[i][0] = :nop` would have been in your scenario) and screwing up my original code ;-) Wasted 10 minutes of my time debugging that one.. oops! :-)
+
+      Also thought I'd bring up some shortcuts you can take in processing the input, e.g.
+
+      ```ruby
+      ops = $<.readlines
+              .map(&:split)
+              .map { |is| [is[0], is[1].to_i] }
+      ```
+    :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf159kl/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    PROGRAM = File.readlines("day8_input.txt").map{ |line| line.chomp.split(' ') }
+
+    def run_program(program)
+      ip = 0
+      acc = 0
+      seen = Array.new(program.size) { |i| 0 }
+
+      while (0...program.size).include?(ip)
+        instr = program[ip][0]
+        val = program[ip][1].to_i
+
+        seen[ip] += 1
+        break if seen[ip] == 2
+
+        case instr
+        when 'acc'
+          acc += val
+          ip += 1
+        when 'jmp'
+          ip += val
+        when 'nop'
+          ip += 1
+        else
+        end
+      end
+
+      [ip, acc]
+    end
+
+    # Part 1
+    _, acc = run_program(PROGRAM)
+    puts "#{ acc }"
+
+    # Part 2
+    def fixed_program_acc(program)
+      program.each_with_index do |instr, idx|
+        next if instr[0] == 'acc'
+
+        program[idx][0] = instr[0] == 'jmp' ? 'nop' : 'jmp'
+
+        ip, acc = run_program(program)
+        return acc if ip >= program.size
+
+        program[idx][0] = instr[0] == 'jmp' ? 'nop' : 'jmp'
+      end
+
+      "unfixable"
+    end
+    puts "#{ fixed_program_acc(PROGRAM) }"
+    ```
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf19a9e/
+  :body: |-
+    The worst possible solution in ruby:
+
+    [https://github.com/sreedevk/advent-of-code/blob/master/2020/day8/main.rb](https://github.com/sreedevk/advent-of-code/blob/master/2020/day8/main.rb)
+  :replies: []
+- :author: hamnixster
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf1a0rj/
+  :body: |-
+    Here is my ruby solution. For part 2, using the marked up instructions from part one, it works backwards from the last intcode looking for candidates to flip that were visited in the course of executing part1. Checking these, I got the answer.
+
+    I feel like there are edge cases that would cause this to fail, but it worked for my input at least.
+
+    Does anybody else have a solution where they did not iterate over all the possible swaps?
+
+    ```ruby
+    part2_input = File.read("8").split("\n").map { |ins| ins.split.tap { |ins| ins[-1] = ins.last.to_i } }.map.with_index { |ins, i| ins.unshift(i) }
+    part1_input = Marshal.load(Marshal.dump(part2_input))
+
+    def run_intcode(instructions)
+      pointer, acc, count = 0, 0, 0
+      while (ins = instructions[pointer]) && (val = ins[2]) && ins[-1] != "visited"
+        inc = 1
+        ins << count
+        count += 1
+        ins << "visited"
+        case ins[1]
+        when "acc"
+          acc += val
+        when "jmp"
+          inc = val
+        end
+        pointer += inc
+      end
+      acc
+    end
+
+    # finds all potential swaps that would lead to the final instruction
+    def swap_index(input, start = nil)
+      start ||= input.size - 1
+      bottom, top = start - 1, start
+      candidates = []
+      range_to_reach = loop {
+        bottom_ins = input[bottom]
+        # if bottom was visited, this means it was a jmp away since start has not been visited
+        # therefore, flipping it to be a nop would lead to start, so it's a swap candidate
+        if bottom_ins[-1] == "visited"
+          candidates << bottom
+          break [bottom + 1, top]
+        end
+        val = bottom_ins[2]
+        # if the bottom instruction is a jump back, or a forward jump over the entire range,
+        # we know the bounds of the range and break out.
+        if bottom_ins[1] == "jmp" && (val <= 0 || val > (top - bottom) + 1)
+          break [bottom + 1, top]
+        end
+        # otherwise, we loop back checking more instructions until we find a jmp that leads out
+        # of the range, giving us the bound of the range we need to consider jmps into
+        bottom -= 1
+      }
+
+      # Next, we look for jmps, or nops that can become jmps, into the range.
+      (
+        input.select.with_index { |ins, pos|
+          code, val = ins[1..3]
+          # look for any insructions, that if they were jumps, would land in the range
+          if (val + pos).between?(*range_to_reach) && !pos.between?(*range_to_reach)
+            # if the position is a visited nop, it's a candidate directly
+            candidates << pos if code == "nop" && ins[-1] == "visited"
+            code == "jmp"
+          end
+        }.map.with_index { |candidate, i|
+          # for jumps that lead to the range, recursively find more visited candidates
+          swap_index(input, input.index(candidate))
+        } +
+        candidates # add the candidates from this fn call with recursive calls
+      ).flatten.compact.uniq # clean up
+    end
+
+    puts run_intcode(part1_input)
+
+    swap_index(part1_input)[0].tap { |index| part2_input[index][1] = part2_input[index][1] == "jmp" ? "nop" : "jmp" }
+
+    puts run_intcode(part2_input)
+    ```
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/k8xw8h/2020_day_08_solutions/gf28t0s/
+  :body: |-
+    Here's my [Ruby solution](https://github.com/odlp/advent-of-code-2020/blob/main/day-8/boot.rb):
+
+    ```ruby
+    require "set"
+
+    Instruction = Struct.new(:type, :value, :index, keyword_init: true)
+
+    original_instructions = ARGF.map.with_index do |raw_instruction, index|
+      type, raw_value = raw_instruction.split(" ")
+      Instruction.new(type: type, value: raw_value.to_i, index: index)
+    end
+
+    def execute(instructions)
+      visited_instructions = Set.new
+      accumulator = 0
+      pointer = 0
+
+      while current_instruction = instructions[pointer]
+        if visited_instructions.include?(current_instruction)
+          return [:looped, accumulator]
+        end
+
+        visited_instructions << current_instruction
+        pointer = current_instruction.index + 1
+
+        case current_instruction.type
+        when "acc"
+          accumulator += current_instruction.value
+        when "jmp"
+          pointer = current_instruction.index + current_instruction.value
+        end
+
+        if current_instruction == instructions.last
+          return [:finished, accumulator]
+        end
+      end
+    end
+
+    puts "Part 1:", execute(original_instructions).last
+
+    TYPE_MUTATIONS = { "jmp" => "nop", "nop" => "jmp" }
+
+    mutants = original_instructions.map do |instruction|
+      if (mutation = TYPE_MUTATIONS[instruction.type])
+        instruction.dup.tap { |mutant| mutant.type = mutation }
+      end
+    end.compact
+
+    mutants.detect do |mutant|
+      revised_instructions = original_instructions.dup
+      revised_instructions[mutant.index] = mutant
+      halt_reason, value = execute(revised_instructions)
+
+      if halt_reason == :finished
+        puts "Part 2:", value
+        true
+      end
+    end
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2020/09.yml

@@ -0,0 +1,220 @@
+---
+- :author: skawid
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf7vzdf/
+  :body: |-
+    Ruby!
+
+    https://github.com/simonbrahan/aoc2020/blob/master/day9/main.rb
+
+    Part 2 took some head scratching to find an algorithm that didn't take forever.
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf7tg41/
+  :body: |-
+    **ruby**
+
+    This gist will solve parts 1 and 2 and will log them both to the console.
+
+    [https://gist.github.com/Clashbuster/ec68e13f15ae69235bde42ef5c3f1f08](https://gist.github.com/Clashbuster/ec68e13f15ae69235bde42ef5c3f1f08)
+
+    It is not a particularly efficient solution in terms of time or space complexity but it is generic and should work on any input.
+
+    This is a brute force solution but it stops looping when it finds the target for both parts. The approximate completion time is ~5 seconds.
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf7edop/
+  :body: |-
+    # Ruby
+
+    Trying all `combination`s
+
+    ```ruby
+    input = File
+      .readlines('input-09.txt')
+      .map(&:to_i)
+
+    part1 =
+      input
+        .each_cons(25+1)
+        .find { |*prev, current| prev.combination(2).none? { |a,b| a + b == current } }
+        .then(&:last)
+
+    puts part1
+
+    part2 =
+      [*0...input.length]
+        .combination(2)
+        .lazy
+        .map { |a,b| input.values_at(a..b) }
+        .find { |range| range.sum == part1 }
+
+    puts part2.minmax.sum
+    ```
+  :replies:
+  - :author: zeeba_neighba
+    :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf7sog7/
+    :body: Nice! I didn't know about `.lazy` I want to implement that in the future
+    :replies: []
+- :author: dearshrewdwit
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf79fe3/
+  :body: |-
+    Functional [Ruby](https://github.com/dearshrewdwit/adventofcode/blob/master/2020/9/cypher-functional.rb) with recursion
+
+    Edit: got told off for pasting code, sorry! See link for code
+  :replies: []
+- :author: kawzeg
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5pkr1/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    xs = File.open("input").read.split("\n").map(&:to_i)
+    p (x, i = (25..xs.size).each{|i|
+      break [xs[i],i] if !xs[i-25..i].combination(2).map(&:sum).include? xs[i]})[0]
+    p (2..i).each{|j| k = (0..i).detect{|k| xs[k,j].sum==xs[i]}
+      break xs[k,j].min + xs[k,j].max if k}
+    ```
+  :replies: []
+- :author: damyvv
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5q7sm/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    input = File.read("day9_input.txt").split.map(&:to_i)
+    # Part 1:
+    p d = input[25..-1].select.with_index { |n,i| !input[i..i+24].any? {|k| input[i..i+24].include?(n-k) } }.first
+    # Part 2
+    (4..input.count).each { |s| input.each_cons(s) { |a| return p (a.min+a.max) if a.reduce(:+) == d } }
+    ```
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5n55h/
+  :body: |-
+    # Ruby
+
+    Ruby made short work of this one thanks to some of its useful builtin methods :-) [Gist here.](https://gist.github.com/peterc/515f260c68c89a7460602fcf0969ecd4)
+
+    However, here's a funnier golfed solution which uses a totally different algorithm - randomness!
+
+    ```ruby
+    n=$<.readlines.map(&:to_i);a=loop{i=rand(
+    n.size-25)+25;r=n[i-25,25].combination(2)
+    .map(&:sum).all?{|x|x!=n[i]};break n[i] if
+    r};p a;p loop{r=n[rand(n.size),rand(18)+2]
+    break r.min+r.max if r.sum==a}
+    ```
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf51h87/
+  :body: |-
+    Ruby 1507/706. I forgot to convert the input to ints before adding them, took way too long to figure out
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAgAwAAAAAAAAARiAqGkkN7pUjVWW5PmC0L6aBapSEWgmKw16LRnqk8MWLR0XniOEFoHImRzzHbojWP9/KPFyWlRwlf9iuxcCPOF3cwEecpGcDtvpNvX4s0TtaqjSZswu4WXzB4X+spXJnNaUo+Ps9+3O4csu9ETgBALRvcc9ZR+UPnydkXsoHeX+33uO/7/2yBUoveTl2fr3r+Jy7H+D54SKUuwx0M6/UxysDIRhXg9Dv2j2a7kq4NOtwIha7MtDbRnx6Tw3+ut++qywRaWTxfAfNSHL3oM42iMLdYMnWgjghR7j9CaieSdPBdBFVH1zbUy9/WeWaq0KyidvNc7sR7vGScKZIQPjOyuda6ArYH6YUWlUD89mOQmOQ+6VYVMWQAVnpltYDTCUQb8zy8JVeg9mRtYfIbiww3iGoYPAhPj1K8toNHLFmCm0FZShbrZRQ3ykgTWFe+UKSNaAZfqk85RfS8myg7s+sv78rxm0xyyYVHR17MWUf+VX9B0sL9v/3lUNU=)
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf546jm/
+  :body: |-
+    # Ruby
+
+    308/144 using some enumerable magic:
+
+    ```ruby
+    i = DATA.each_line.map(&:to_i)
+    i[25..(i.size - 1)].map.with_index do |j, k|
+      (puts j; break j) unless i[k..(k + 24)].combination(2).map { |l| l.reduce(&:+) }.include?(j)
+    end.tap { |a| (2..i.size - 2).each { |x| i.each_cons(x) { |j| (puts j.min + j.max; exit) if j.reduce(&:+) == a } } }
+    ```
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5msmo/
+  :body: Here's my [solution in Ruby](https://github.com/odlp/advent-of-code-2020/blob/main/day-9/solution.rb).
+  :replies: []
+- :author: blafunke
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf55til/
+  :body: "[**Ruby**](https://topaz.github.io/paste/#XQAAAQBpAwAAAAAAAAARiEJHiiMzw3cPM/1Y611SZZy8dLcvLPFv5CaI5QAeyDUOD9g6sOqRoHNTUi8vG310j7C40PhkIuDkIfK9LbzmPHL5jWRBHMH9yR5NOmbSsS4BF8FHwzXFHxMtBLjdmCODNvRiPMNfQOxOhHvbbHDUYEWvYg64I3tbZ81WBS4PHm35X/+55lmYBGw6YCnMN07oZ0H/AEjR3rbRTE5ymST2UKrtHL6Yh63ofbNkU2lzC7bD3iwrETmuXRjnwMjuZc7jSw9G6rLKh27rgesAUJ7g8ftT8bd5Qhl7iK0P1b+rzWXc1ZiSA+UT9Awiu/1ZWRCre6OVjiXjnkKhbMZn4nwQTO2D2WiLX2UkWIIZTr4l1YvaPKyv1bAQAOlPoq8RelGPKzWNUqWMSr2O+p2YLL2+ZKf8k4ehfC/1bgVEZSaOF1vF6ghkYmL2rZoM60T6K6Wt+fsFzr25lydHVFElzYffJYgTmXMvXBRkU4wxrSWS+/6r6mBkSCvYACeNV/63RDu0L0IwV2nuwOmHCPPjt3W5c2NbPeSN5sH5G+jLZ1fNgvoKh6mdqBn/+QQsQQ==)"
+  :replies: []
+- :author: zxywx
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf56juf/
+  :body: |-
+    # Ruby Solution
+
+    ```ruby
+    # frozen_string_literal: true
+    module Year2020
+      class Day09
+        def part_1(input, preamble_length = 25)
+          entries = input.split.map(&:to_i)
+          pointer = preamble_length
+          pointer += 1 while entry_valid(entries[pointer], entries[pointer - preamble_length, preamble_length])
+          entries[pointer]
+        end
+
+        def part_2(input, preamble_length = 25)
+          invalid_number = part_1(input, preamble_length)
+          entries = input.split.map(&:to_i)
+          (0..entries.length).each do |lower_bound|
+            (lower_bound..entries.length).each do |upper_bound|
+              set = entries[lower_bound..upper_bound]
+              break if set.sum > invalid_number
+              return set.minmax.sum if set.sum == invalid_number
+            end
+          end
+        end
+
+        private
+          def entry_valid(entry, test_group)
+            test_group.uniq.permutation(2).to_a.any? { |vals| vals.sum == entry }
+          end
+      end
+    end
+    ```
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5aq7n/
+  :body: |-
+    **Ruby:** 4:37/11:27, 345/634
+
+    Here's a [recording](https://youtu.be/on4DaUsLBXA) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/46ccb0106bf8280266067f7c32028fb98040115f/2020/dec09.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Gah, I tried to get fancy and it cost me! For Part 1 I was initially going to sort the previous 25 numbers so it would be easier to check if two numbers added up to the solution, before I realized that then I wouldn't know which value to remove from the sorted array. (Nevermind that you can still check if any two numbers sum to the value in linear time even with them being sorted (See Day 1), and that with the index I could easily figure out which value I needed to remove...) Then in Part 2 I initially tried to implement the linear time solution, but it didn't work, and I mistakenly thought it _couldn't_ work so switched over to the standard n^2 solution.
+  :replies:
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5njrb/
+    :body: Fellow Rubyist chiming in again :-D We ran similar times today (you just beat me overall, I was slightly ahead for part 1) but I had a very different approach this time unlike other days. I'm pretty amazed you got all of that down within that time! :-)
+    :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5df5n/
+  :body: |-
+    # Ruby
+
+    I'm liking how versatile arrays are in Ruby. A bit disappointed that it seems weird to break out of a nested loop though, but if anyone has better suggestions for doing this I'm open to suggestions. :)
+
+    [paste](https://topaz.github.io/paste/#XQAAAQD7AgAAAAAAAAAnFUW8WzF1WEoJx9V0hOKfg4NcZ7WDhdZEbbwcIoUqv1+y3wBBrL2nBKRx9PDu2eqWV5w7eZ8p/dHEMvzPdtqMoTg8ubrtrjtjf+6OUUPiJ/l+L7PA7kZxnaeraDwwz5V1gGClahEcV2kJenOadVBIJ49iA9X8aOwk6+7R1PQM0mZ1tbA5Y+v4uw3Ahoex/N1uRfqzZZlyC+P4dedhdXKTtribrpUo1Fddw/X+BJWtL4SsNvlu7knEoKdp/MH1xPp8+a8mO7ghXgj4sXWzCR9pgloJxk3KEgEuwzOOmt+dKoBkZG3xxrvM5ncaTP3mvDxVzDpNWNye8TAsqw37cXV71KHLNiK3Ye/6nt3K55hKxDc5PnqUoc2BUbiTW65lBEsWeLvMM/ZFp3U1TCaohJvgE6/C0y2CQpYUG8s+XPirj4NRjUQN1rqCIk9Llry2/SKcsCAAZACHGUAGzIBN3CyUXRhV9qZL9n5VU8wX8NRmV5vwCIATOmH3mtdYidbQ1wH+RD7RJf9yZbkA)
+  :replies:
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5neve/
+    :body: One way is to refactor out the nested loop. `each_cons` would assist in this situation. Consider that `arr.each_cons(3)` will return an enumerator of each block of 3 elements. See my solution elsewhere on this post if you want to see it in situ.
+    :replies: []
+  - :author: Intro245
+    :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf5oq1j/
+    :body: One solution for this problem that works in most languages is to put the loops into a separate function and use `return` to break out. So in this case, the return value could be either `contiguous_numbers` or the solution to part 2.
+    :replies: []
+- :author: 2k3
+  :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf6hsy4/
+  :body: |-
+    Another [Ruby](https://github.com/Kyrremann/advent-of-code/blob/main/y2020/day-09.rb) solution.
+
+    Most interesting for me was to use `combination()` in the first part.
+  :replies:
+  - :author: sky_badger
+    :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf6itm4/
+    :body: Interesting to see a different language (I'm doing AoC in Python). Did you know the input file is different for every competitor? So the hardcoded target in star\_2() will only work for your input. You cold make the solution more generic by storing the star\_1() result in a variable and using that as your star\_2() target instead. Just a though. Is Ruby fast?
+    :replies:
+    - :author: 2k3
+      :url: https://www.reddit.com/r/adventofcode/comments/k9lfwj/2020_day_09_solutions/gf6mkxl/
+      :body: |-
+        Didn't think about the different input, should use the return value for part two. Thanks!
+
+        Depends of what you mean by fast. Ruby 3 that is coming later this year, is a lot faster the good old ruby 1.8/9.
+      :replies: []