Ruby 3.0 was just released, so it's that merry time of year where we take time to experiment and see what all fun new features are out there.

This series of posts will take a look into several Ruby 2.7 and 3.0 features and how one might use them to solve Advent of Code problems. The solutions themselves are not meant to be the most efficient as much as to demonstrate novel uses of features.

I'll be breaking these up by individual days as each of these posts will get progressively longer and more involved, and I'm not keen on giving 10+ minute posts very often.

With that said, let's get into it!

<< Previous | Next >>

Day 06 - Part 01 - Custom Customs

Day six was another fairly easy one. For part one we're not using anything particularly new. Our task this time is to find "yes" answers and count them, where "yes" is signified by a letter. Records are separated by a blank line, but there may be one or more response in each record separated by newlines:

abcx
abcy
abcz

In this case we have 6 unique yes answers from three people, abcxyz. The first part of the problem focuses on this, so let's take a look at the solution:

puts File
  .read(ARGV[0])
  .split(/\n\n/)
  .map { _1.gsub(/\W/, '').chars.uniq.size }
  .sum

gsub on Whitespace

The first new line we see is in the map function:

.map { _1.gsub(/\W/, '').chars.uniq.size }

\W stands for any whitespace, newline or space, meaning that input above goes from this:

abcx
abcy
abcz

...to this:

abcxabcyabcz

uniq Characters

The next part of this solution uses chars, which I believe was introduced in 2.6, to divide the String into its individual characters:

'abcxabcyabcz'.chars
# => ["a", "b", "c", "x", "a", "b", "c", "y", "a", "b", "c", "z"]

After this, we want to know how many unique yes answers we have, so uniq is quite useful here:

'abcxabcyabcz'.chars.uniq
# => ["a", "b", "c", "x", "y", "z"]

...and then all that is left is to find out how many of them there were with size:

'abcxabcyabcz'.chars.uniq.size
# => 6

sumthing to Finish

Then the last part is to get the sum of all yes answers from all of the reports, which we can do with sum:

.map { _1.gsub(/\W/, '').chars.uniq.size }
.sum

...and the first part of our problem is done.

Day 06 - Part 02 - This is Exhaustive

The second part makes things a bit harder: It's no longer that anyone answered yes to a question, but that everyone has. That means for every person who answered we need to find answers they all answered yes to, and that means an intersection.

Let's take a look at the solution:

def answer_intersection(answers) =
  answers
    .lines
    .map { _1.chomp.chars }
    .reduce(&:intersection)
    .size

puts File
  .read(ARGV[0])
  .split(/\n\n/)
  .map { answer_intersection(_1) }
  .sum

chomp the chars

The first thing we want to do in our intersecting answers is to clean up the lines into a format we can use. Normally one would think just chars would work great, but that now means there's a newline in every single answer that counts as a definitive yes, so we want to chomp that off the end so it doesn't throw our count.

reduce Quick Lesson

Now this, this is an incredibly succinct line doing a lot of stuff. For those who don't understand reduce this is a trip, so let's start with a quick lesson on how it works.

Addition is the easiest reference, and before sum we used to do this:

[1, 2, 3].reduce(0, :+)
# => 6

...which expands to this if we use the more explicit form:

[1, 2, 3].reduce(0) { |sum, v| sum + v }
# => 6

reduce is often also called foldLeft in other languages, in that we're folding values to the left starting with an initial value. In this case, 0.

Why 0? Because it's a nice default for sums, if you add it to any number you get back that same number, and if there are no numbers you get back 0 which seems perfectly reasonable to me.

Now on to the block function, which takes two arguments sum and v. sum is often called an accumulator (a) or memo (m) depending on which tutorial.

sum, in this case, starts with an initial value of 0 given to reduce(0). v is an iterator, or every value in the collection we're reducing.

This particular code goes from this:

[1, 2, 3].reduce(0) { |sum, v| sum + v }
# => 6

...to this if we got the effective representation:

0 + 1 + 2 + 3
# => 6

Let's take a quick look at how values go through reduce. You see, sum is the result of the last iteration, and the values flowing through it would look like this:

[1, 2, 3].reduce(0) { |sum, v|
  p(sum: sum, v: v)
  sum + v
}

# {:sum=>0, :v=>1}
# {:sum=>1, :v=>2}
# {:sum=>3, :v=>3}
# => 6

In the first iteration the new sum becomes 1 (0 + 1), the second 3 (1 + 2), and the last it becomes 6 (3 + 3) which is our final result. If we used parens it'd look something like this too:

(((0 + 1) + 2) + 3)

If you want a more detailed explanation of reduce you should check out Reducing Enumerable to learn more.

So, intersection then?

Let's take a look back at that code for reduce then:

.reduce(&:intersection)

There's no initial value, which means that it'll use the first item of the collection it's reducing:

record = [
  ['a', 'b', 'c', 'x'],
  ['a', 'b', 'c', 'y'],
  ['a', 'b', 'c', 'z']
]

If reduce intersperses + when done with + it'd do the same with intersect. Consider:

a, b, c = record
a.intersection(b).intersection(c)
# => ["a", "b", "c"]

Granted we can use & which does the same thing, but I prefer more readable methods when possible.

That's about the size of things

Now that we have all the intersecting answers where everyone said yes we can get how many of them there are with size, and in our main function we can get the sum of all of them to get our final answer.

Wrapping Up Day 06

That about wraps up day six, we'll be continuing to work through each of these problems and exploring their solutions and methodology over the next few days and weeks.

If you want to find all of the original solutions, check out the Github repo with fully commented solutions.

<< Previous | Next >>