advent_of_ruby 0.3.4 → 0.3.6

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

@@ -0,0 +1,324 @@
+---
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsl0mch
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_5/part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_5/part_1.rb)
+
+    Explanation: `id.between?(range.first, range.last)` this is how ruby solve it.
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_5/part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_5/part_2.rb)
+
+    Explanation: Sort + two while loops + one condition = done.
+  :replies: []
+- :author: Basic_Ent
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsiegyo
+  :body: |-
+    [https://github.com/ceautery/advent2025/blob/main/app/day\_5.rb](https://github.com/ceautery/advent2025/blob/main/app/day_5.rb)
+
+    Nothing overly fancy. This puzzle exposes the dark side of a ruby feature: You can declare a range with ints as strings, and it behaves like you'd expect, but it can't do math to calculate size or to see if a number is in the range. So size is nil, and checking for members takes a full scan of the elements, and goes much slower.
+
+    TL;DR make sure you (&:to\_i) all the things.
+
+    ```ruby
+    ~ # pry
+    [1] pry(main)> r = ("11".."22")
+    => "11".."22"
+    [2] pry(main)> r.to_a
+    => ["11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"]
+    [3] pry(main)> r.size
+    => nil
+    [4] pry(main)> (11..22).size
+    => 12
+    [5] pry(main)>
+    ```
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nshjak9
+  :body: |-
+    The 'work' was just to condense the list of ranges down. From there using a Ruby block was trivial to solve (Part 1 counting ingredients in range, part 2 simply summing the ranges).
+
+    [GitHub link for solution to both Part 1 and Part 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-05.rb)
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nshifiu
+  :body: |-
+    https://github.com/SleepingInsomniac/adventofcode/blob/master/2025-12-05/part\_2.rb
+
+    ```ruby
+    class FreshDB
+      def initialize
+        @ranges = []
+      end
+
+      def <<(range)
+        return if @ranges.any? { |r| r.cover?(range) }
+
+        @ranges.reject! { |r| range.cover?(r) }
+
+        if index = @ranges.index { |r| r.cover?(range.begin) }
+          updatable = @ranges.delete_at(index)
+          b = range.begin < updatable.begin ? range.begin : updatable.begin
+          self << (b..range.end)
+        elsif index = @ranges.index { |r| r.cover?(range.end) }
+          updatable = @ranges.delete_at(index)
+          e = range.end > updatable.end ? range.end : updatable.end
+          self << (range.begin..e)
+        else
+          @ranges << range
+        end
+      end
+
+      def fresh?(ingredient_id)
+        @ranges.any? { |range| range.cover?(ingredient_id) }
+      end
+
+      def fresh_total
+        @ranges.reduce(0) { |m, r| m + r.count }
+      end
+    end
+
+    # ..parse
+    db << range
+    ids.count { |id| db.fresh?(id) } # Part 1
+    db.fresh_total # Part 2
+    ```
+  :replies: []
+- :author: Mahedros
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsffljv
+  :body: |-
+    Foolishly wasted my first attempt at part 2 by forgetting that Ruby's default sort doesn't sort in place. I was sorting and then immediately discarding the sorted list
+
+    [Code](https://topaz.github.io/paste/#XQAAAQDGBQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw6AjPxsUgu9rdE7zg7+tZ3WD1ORhBz4OK9efDPXPJ0R3el67IYpr6wJJeO4USW2W5T4/K2vtXmBaNGBedkIQ6c2hdYcno4+KLsRmsFcq8x6kkG4aOWgylrI/hK21x8AKx701DRHi9Go3OKnY3JveVADxzWs/EsJLhTVE+wbKkuM1mAjJ2fKwNscGqqgU4BSsPfqKrxW0IRxHB4A+UXpyjHX48oY80g5sH+1N0ZONesiDUbt5XXGZnQCY33vrDqZyS57mazMMP/bJPCnbHeTw+soZsFxZIoZue93SrWrWBvP+2OqpgW4w/VR1hK7sZIQ8JSt+poGC7ZUTYaSOVYGsICKxVRHuCGzVtcT3l0qdiFJosHsSCGHqM2lIMXHw0jokQX3SW9LwYivIkofp0K4sm0dCkdOecgentnPasXeayl1ez2I4BiFlfj8x5YhZ9Kwo0ST1TW29HuuiAMrDmSPwe9B6zOfpqR+GhI94VFQao/g7WUPxXwm0llwCHLzvTPXx8Sh84a/K/oRbFmJBfDbFt2+EA8xYdgUbN+pmIkJJ+V5o9ZPE5EdyM0UA+TXp8sjLBZeV4bYfjuuS1S/Gg0IPK0y8p9hxOMxtcoO8UJSrtCr/lhKNR+5MrUP9niEK)
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsdv36t
+  :body: |-
+    ```ruby
+        def solve_easy(input)
+          ranges, ids = input
+          ids.count do |id|
+            ranges.any? { |r| r.include?(id) }
+          end
+        end
+
+        def extend_range(a, b)
+          [a.begin, b.begin].min..[a.end, b.end].max
+        end
+
+        def solve_hard(input)
+          ranges, _ids = input
+          stack = ranges.sort_by(&:begin)
+          isolated = []
+
+          while stack.any?
+            left_range = stack.shift
+            if stack.empty?
+              isolated << left_range
+              break
+            end
+            stack.dup.each_with_index do |right_range, i|
+              if right_range.begin > left_range.end + 1
+                isolated << left_range
+              else
+                left_range = extend_range(left_range, right_range)
+                stack.delete_at(i)
+                stack.unshift(left_range)
+              end
+              break
+            end
+          end
+          isolated.sum(&:size)
+        end
+    ```
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nse3ksf
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_05](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_05)"
+  :replies: []
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nse74m0
+  :body: |-
+    I find the `consolidate!` method to be quite clunky - if I hadn't just woken up in the morning I might have found a more higher-order way to do it. Still, the rest of this class is relatively cute and it runs quickly.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    require 'set'
+
+    class Ims
+      attr_reader :ranges, :io
+
+      def initialize(io)
+        @io = io
+        @ranges = Set.new
+        until /^$/ =~ (l=io.readline)
+          add_range! l
+        end
+        consolidate!
+      end
+
+      def add_range!(s)
+        r = s.split('-').then {_1.to_i .. _2.to_i}
+        ranges << r
+      end
+
+      # Consolidate any ranges that overlap... could be more elegant I reckon
+      def consolidate!
+        ranges.dup.each do |r|
+          if overs = ranges.find_all {(it != r) && it.overlap?(r)}
+            to_delete = overs << r
+            to_delete.each {ranges.delete it}
+            ranges << (to_delete.map(&:min).min .. to_delete.map(&:max).max)
+          end
+        end
+      end
+
+      def fresh?(n)
+        ranges.any? {it.include? n.to_i}
+      end
+
+      def n_fresh
+        io.count {fresh? it}
+      end
+
+      def n_possible
+        ranges.sum(&:count)
+      end
+
+    end
+
+    i = Ims.new(ARGF)
+    p i.n_fresh
+    p i.n_possible
+    ```
+  :replies: []
+- :author: im_sofi
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nse9a1e
+  :body: |-
+    Another fun day. A classic advent of code range set theory question. Getting to use [my std++ library](https://codeberg.org/soupglasses/advent-of-code/src/commit/a8f20c537bd86b994df924601a28f2630ace7814/std++.rb#L68-L103) which implements a subset of set theory for the Range class in Ruby. Quite trivial once you have those functions implemented. :D
+
+    https://codeberg.org/soupglasses/advent-of-code/src/branch/main/2025/day\_05.rb
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsed21x
+  :body: |-
+    Part 1
+
+    ```ruby
+    input = File.read("input.txt").split("\n\n")
+    ranges = input[0].lines.map{ it.split(?-).map(&:to_i)}.map{Range.new(*it)}
+    ing = input[1].lines.map(&:to_i)
+
+    puts ing.count{ |i| ranges.any?{ |r| r.include?(i)}}
+    ```
+
+    Part 2
+
+    ```ruby
+    class Range
+      def subtract(other)
+        return [] if (other.begin <= self.begin && other.max >= self.max)
+        return [self] if other.begin > self.end || other.end < self.begin
+        res = []
+        res << (self.begin..other.begin-1) if self.begin < other.begin
+        res << (other.max+1..self.max) if other.max < self.max
+        res
+      end
+      alias_method :-, :subtract
+    end
+
+    input = File.read("input.txt").split("\n\n")
+    ranges = input[0].lines.map{ it.split(?-).map(&:to_i)}.map{Range.new(*it)}
+
+    s = []
+
+    ranges.each do |r|
+      n = s.inject([r]){|a,i| a.map{it-i}.flatten}
+      n.each{ s << it }
+    end
+
+    puts s.sum(&:size)
+    ```
+  :replies: []
+- :author: bulinutza
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nseed5w
+  :body: |-
+    Part 2:
+
+    ```ruby
+    total_fresh = 0
+    previous_max = 0
+
+    input.
+      lines.
+      map { |line| line.split('-').map(&:to_i) }.
+      sort { |range1, range2| range1[0] <=> range2[0] }.
+      each do |range|
+        min = range[0]
+        min = previous_max + 1 if min <= previous_max
+
+        delta = range[1] - min + 1
+
+        if delta > 0
+            total_fresh += delta
+            previous_max = range[1]
+        end
+    end
+    ```
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1pemdwd/2025_day_5_solutions/nsgue98
+  :body: |-
+    \
+
+    ```ruby
+    require 'set'
+
+    input = File
+              .readlines("05_input.txt", chomp: true)
+    split = input
+              .find_index("")
+    ranges = input[0..split-1]
+              .map { |x| x.split("-")}
+              .map { |x| x.map(&:to_i) }
+              .sort_by { |min, max| [min, max] }
+    ids = input[1+split..-1]
+              .map(&:to_i)
+
+    # Part 1
+
+    fresh = Set.new
+
+    ids.each do |id|
+      ranges.each do |min, max|
+        if id.between?(min, max) then fresh.add(id) end
+      end
+    end
+
+    puts "Part 1: ", fresh.size
+
+    # Part 2
+
+    freshranges = 0
+
+    ranges.each_with_index do |x, idx|
+      next unless idx < ranges.length - 1
+      nextone = ranges[idx+1]
+
+      if nextone[0] <= x[1]
+        nextone[0] = x[0]
+        if nextone[1] <= x[1]
+          nextone[1] = x[1]
+        end
+        x[0] = 0; x[1] = 0
+      end
+    end
+
+    ranges.each do |min, max|
+      next unless min != 0 and max != 0
+      freshranges += (max - min) + 1
+    end
+
+    puts "Part 2: ", freshranges
+    ```
+  :replies: []

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

@@ -0,0 +1,246 @@
+---
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsodrwg
+  :body: |-
+    https://github.com/SleepingInsomniac/adventofcode/tree/master/2025-12-06
+
+    ```ruby
+    def part_1(input)
+      lines = input.readlines(chomp: true)
+      ops = lines.pop.split(/\s+/).map(&:to_sym)
+      numbers = lines.map { |l| l.strip.split(/\s+/).map(&:to_i) }
+        .transpose.map.with_index { |col, i| col.reduce(ops[i]) }.sum
+    end
+
+    def part_2(input)
+      lines = input.readlines(chomp: true)
+      ops = lines.pop.scan(/[^\s]\s+/)
+      start, stop = 0, 0
+      ranges = ops.map.with_index { |op, i| stop += op.size ; (start...(i == ops.size - 1 ? stop : stop - 1)).tap { start = stop } }
+      ops.map! { it.strip.to_sym }
+      lines.map { |l| ranges.map { |r| l[r].chars } }.transpose.map.with_index { |r, i| r.transpose.reverse.map { it.join.to_i }.reduce(ops[i]) }.sum
+    end
+    ```
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsnzd8r
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_06](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_06)"
+  :replies: []
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsngua5
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_6/part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_6/part_1.rb)
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_6/part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_6/part_2.rb)
+  :replies: []
+- :author: Mahedros
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsmks32
+  :body: |-
+    Ah, there's the difficulty jump we've been waiting for. The "eureka" moment for me was realizing the operators are always left-aligned, so I can parse that line first and use the widths of its splits to parse the value lines
+
+    [Code Link](https://topaz.github.io/paste/#XQAAAQAACgAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw6AjPxsUgu9rdE7zhPPHPyXwxOHK81zITg/yhxqdKmLQEniJYuRkLq8JUbpiJpEA6fYdDJgmkC1iyEhNq7J/hMXfeBM7NBbT67a1yG8RgnjkgUPVEYlNurj/c2JWc0WYvGqpfQEiA718N3V8PqQ1+koJpRieOv0eD6pvg2Sqzc4CM0ZV7bPPq5l5hWZcM5y6V4jbGdhnmt2WUdl9Elpt7/HSK6C7MXz/CO82zd/W1vQhH57EHKmSkUQKV9caoP8VawNvCwH0koI9gcNAkGd8b/99IpMHJ1wPxxQmA8FlD3sWsfv59PVngcrp+JshELiMGnHWqhFzGSwFr+R3vdAsqmwsGs8qjTPsAgq1IK8tKrCtWAs3TRwXIDBLSL64bxnB3iVQqaYdjP2uTad98KyPw3oFAPDYObtdLQCSGIrTWpU2D6NuK7tzamiOPl8ksDHiJjOf9AwgEod2ahqA/VAHq+hdRUMwG5G2hr9y3Q1CgAWv7OKKP5fDEBeX/ltOucJS3DXc61VSWT6Fud8W/xCkqJGtTefovvfthQc32ukCaqNvoKDLO3PNWntxh7KIdGOHiGr9GVGlY70eUhOxnMKEFWu9mJ/aNtH+ghrUXfiglUjT2LppJJmEUcxWa6BrbzH5k8Vfp+Lh7+hcNLPkt9Uqc+AH+AFCAwfZd4NoOdcr19GVa8SXIJvX+HKopi3hNKY2QhAM6y7IPRYvcvpBPiUdkbTOZJFLse1RKEZ5HMaSNpHYjqo2Hu87kisVwtqQxMmHyTBAmFEQj8oX0wcjN7Vg67unfzlFiEVT0Xx1ARIN214SS/LBZ1UHm+80ksBAFz5SMkuLcfFQCKef8TXMKU7nYetNvmCBD3cJYkKuk1tkY2geN14L+xM8yxEySEVxQTQxY5tn24cmRFL6zFDFfk7x10ZsZEGVf7R91D46E/T2x0pLuafqgiijQdwFywo92WEb04ZeOgqgh58Kb/R5IV/tBukaFhxL3I6XrlQXCqAUlI3QfCzs/I5sAaDBl8K1hmcTFxQ/muyPENPQpUs1FbNLwm4IJXlJNBTIZ/KqGisSa5gFC7gwhlsg4fqJd/cw8Aa+PJSZO/+Pw8ai)
+  :replies:
+  - :author: isaacfink
+    :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsmmgqb
+    :body: I had the same realization, I was dreading having to parse each line character by character with a lookahead
+    :replies: []
+- :author: systemnate
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nslvhbm
+  :body: |-
+    Finished part 1 very quickly, but failed to read the "right-aligned" part and went down an approach where I was trying to add the ones, then tens, then hundreds, etc. of the number.
+
+    Fun fact: the problem mentions a "magnetically sealed garbage smasher", like in Star Wars: Episode IV. The solution to the sample input for part 2 is 3263827, which is the number of the trash compactor in Star Wars.
+
+    ```ruby
+    require "debug"
+    require_relative "../utils.rb"
+
+    raw = AOC::Input.resolve(ARGV, DATA)
+    data = AOC::Parser.raw_data(raw).split("\n")
+
+    part_one_data = data.map { _1.split(" ") }.transpose
+    part_two_data = data.map(&:chars).transpose.slice_before { _1.all?(" ") }
+
+    PartOne = Struct.new(:problems) do
+      def numbers
+        problems[0..-2].map(&:to_i)
+      end
+
+      def operand
+        problems[-1].to_sym
+      end
+
+      def solution
+        numbers.reduce(operand)
+      end
+    end
+
+    PartTwo = Struct.new(:problems) do
+      def numbers
+        problems.map { |arr| arr[..-2] }.map(&:join).map(&:to_i).reject(&:zero?)
+      end
+
+      def operand
+        problems.flatten.detect { |char| %w[* +].include?(char) }
+      end
+
+      def solution
+        numbers.reduce(operand)
+      end
+    end
+
+    part_one = part_one_data.map { PartOne.new(_1) }
+    part_two = part_two_data.map { PartTwo.new(_1) }
+
+    puts part_one.map { _1.solution }.sum
+    puts part_two.map { _1.solution }.sum
+    __END__
+    123 328 51 64
+     45 64 387 23
+      6 98 215 314
+    * + * +
+    ```
+  :replies: []
+- :author: Prior-Advice-5207
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nskr8yo
+  :body: |-
+    Today I felt like revisiting a language I loved like a decade ago… `Array#transpose` was very handy for part 2!
+
+    https://github.com/diktomat/AdventOfCode/blob/main/2025/d06/d06.rb
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsli9n2
+  :body: |-
+    Part 1
+
+    ```ruby
+    input = File.readlines("input.txt").map{it.split}
+    values = input[..-2].map{it.map(&:to_i)}
+    ops = input.last.map(&:to_sym)
+
+    puts values.first.zip(*values[1..]).each_with_index.sum{|l,i| l.reduce(ops[i])}
+    ```
+
+    Part 2
+
+    ```ruby
+    *values, ops = File.readlines("input.txt")
+    total = i = 0
+
+    while i < ops.size
+        j = ops.index(/[+*]/, i+1) || ops.size + 1
+        a = values.map{it[i...j-1].chars}
+        total += a.first.zip(*a[1..]).map{it.join.to_i}.reduce(ops[i].to_sym)
+        i = j
+    end
+    puts total
+    ```
+  :replies: []
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsk4m2h
+  :body: |-
+    No time to do part 2 yet so haven't looked at other people's solutions. But I'm very happy with my one-liner for part 1!
+
+    ```ruby
+    #!/usr/bin/env ruby
+    p ARGF.readlines.map(&:split).transpose.map {|l| l.pop.then {l.map(&:to_i).reduce(it.to_sym)}}.sum
+    ```
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsk95yt
+  :body: |-
+    not quite happy with the fact I'm parsing the data two different ways, but hey, it works
+
+    ```ruby
+    def solve_easy(text)
+      lines = text.lines.map(&:split)
+      last = lines.pop
+      matrix = lines.map { |l| l.map(&:to_i) }
+      matrix << last
+      matrix.transpose.sum { |col| col[..-2].inject(col.last) }
+    end
+
+    def solve_hard(text)
+      matrix = text.lines.map { |l| l.chars }.transpose
+      stack = []
+      results = 0
+      op = nil
+      while line = matrix.shift
+        if line.all? { _1 == ' ' } || matrix.empty?
+          results += stack.inject(op)
+          stack = []
+          op = nil
+          next
+        end
+        op ||= line.last
+        stack << line[..-2].join.to_i
+      end
+      results
+    end
+    ```
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1pfguxk/2025_day_6_solutions/nsl3rrd
+  :body: |-
+    If it works, it works...
+
+    ```ruby
+    # Part 1
+
+    input = File
+              .readlines("06_input.txt", chomp: true)
+              .map { |x| x.split(" ") }
+
+    input.each_with_index do |x, idx|
+      next unless idx < input.length - 1
+      x.map!(&:to_i)
+    end
+
+    result = 0
+
+    input.transpose.each do |x|
+      operator = x.length - 1
+      case x[operator]
+      when "*"
+        result += x[0..operator-1].inject(:*)
+      when "+"
+        result += x[0..operator-1].inject(:+)
+      end
+    end
+
+    puts "Part 1: ", result
+
+    # Part 2
+
+    input = File
+              .readlines("06_input.txt", chomp: true)
+              .map(&:chars)
+              .transpose
+              .map { |x| x.join.delete(" ") }
+
+    result = 0
+    input.delete("")
+    values = Array.new
+    operator = "+"
+
+    input.each_with_index do |x, idx|
+      if x.match?(/\+|\*/)
+        if values.length != 0
+          operator.include?("+") ? i = values.inject(:+) : i = values.inject(:*)
+          result += i
+        end
+        values.clear
+        values << x.chop.to_i
+        operator = x[-1]
+      else
+        values << x.to_i
+      end
+    end
+
+    # Ugly... but it gets the job done. Should've written a method.
+    operator.include?("+") ? i = values.inject(:+) : i = values.inject(:*)
+    result += i
+
+    puts "Part 2: ", result
+    ```
+  :replies: []