Today we are going to take a quick break from looking at some different library methods for today’s Ruby Tuesday post.

Last Friday I was going back and forth with a teammate over our chat tool about some different programming problems we could use to do some very basic screening of candidates, and I mentioned that if nothing else there is always fizzbuzz.

fizzbuzz, for anybody who at this point has yet to encounter it, even by just blog posts such as this, take a number N, and prints out fizz if the number is a multiple of three, buzz if the number is a multiple of 5, fizzbuzz if the number is both a multiple of three and five, or else just the number itself if none of the conditions hold true.

While fizzbuzz, isn’t a great problem, and, depending on the circles you are in, can be pretty worthless because most candidates have seen it already, it can still have its place. But, sadly, there are developer candidates we encounter that have a hard time translating the problem above, which states the algorithm in English, directly into code. The reason I think fizzbuzz can be interesting, as I mentioned to my coworker, is it can give candidates a chance to show off some more advanced topics that they wish to show off, if they wish.

After mentioning that benefit to him on Friday, I came across the post “Bro, Do You Even FizzBuzz?!?” on fizzbuzz in Clojure and shows off a solution of not using the modulus operator to determine the result.

I decided I would attempt to translate the solution to Ruby, to prove out the point of our conversation.

def do_fizzbuzz(n)
  fizz = ['', '', 'fizz'].cycle.lazy
  buzz = ['', '', '', '', 'buzz'].cycle.lazy
  fizzbuzz = fizz.zip(buzz).map(&:join)
  puts (1..n).
         zip(fizzbuzz).
         map {|number, translation| if translation.empty? then number else translation end}.
         join("n")
end

First, we declare the “fizzes” as a lazy repeating array of blank strings, where every third is the string ‘fizz’, by using cycle and lazy. We do the same for the occurrences of buzz, but have it be every fifth item in an array.

We then zip the fizz and buzz lazy enumerations together, and then map over that result joining the two strings together, e.g. ["", ""].join, ["fizz", ""].join, ["", "buzz"].join, or ["fizz", "buzz"].join.

After we have our lazy enumeration of fizzbuzz translations, we take the range of numbers from 1 to N, zip that together with the translations, pick the translation if it is not an empty string, otherwise pick the number, and then join all of the results together with a newline separator, so each entry will print on its own line.

There you have it, a functional programming style fizzbuzz solution that does not use the modulus operator to arrive at a solution.

–Proctor

Today’s Ruby Tuesday is on String#squeeze.

String#squeeze replaces runs of repeated characters in a source string down to a single character in the returned string.

"foo".squeeze
# => "fo"
"bar".squeeze
# => "bar"
"Mississippi".squeeze
# => "Misisipi"

String#squeeze can also take a string an argument. If a string is passed in, that string is seen as a set of characters to use for squeezing against the source string.

"Mississippi".squeeze("")
# => "Mississippi"
"Mississippi".squeeze("s")
# => "Misisippi"
"Mississippi".squeeze("abcprt")
# => "Mississipi"
"Mississippi".squeeze("sp")
# => "Misisipi"

If a string contains a - between two characters, that string is seen as containing a sequence of characters to include in the set of chacters to match for squeezing against the source string, but if it is first or last the - is seen as a character by itself.

"Mississippi".squeeze("a-r")
# => "Mississipi"
"Mississippi".squeeze("q-z")
# => "Misisippi"
"Mississippi".squeeze("pr-t")
# => "Misisipi"
"^^--~".squeeze('-~^')
# => "^-~"

If a string starts with a ^ then that string is seen as the negation of the set of characters that were given in that string to use, but if it is not the first character, then it is just seen as a normal ^ character.

"Mississippi".squeeze("^a-r")
# => "Misisippi"
"^^--~".squeeze('-^')
=> "^-~"

Backslashes can also be used to escape characters from any special meaning, but when using the backslash character in a double quoted string, then you have to make sure to escape that backslash with another backslash for it to be treated as an escape character in the string to String#squeeze.

"^^--~".squeeze('^')
# => "^--~"
"^^--~".squeeze("\^")
# => "^--~"
"^^--~~".squeeze('~-^')
# => "^-~"

String#squeeze doesn’t modify the source string given, but returns a new instance of a string for the result. If you do need to modify the string in place for some reason, there exists a String#squeeze! as well, but like many other Ruby methods that end in a !, if the original item is not modified a nil is returned.

str = "Mississippi"
# => "Mississippi"
str.squeeze
# => "Misisipi"
str
# => "Mississippi"
str.squeeze!
# => "Misisipi"
str
# => "Misisipi"
"bar".squeeze!
# => nil
"foo".squeeze!
# => "fo"

–Proctor

Today’s Ruby Tuesday covers a variation of one of my personal favorite set of Ruby methods, Array#fetch.

Array.fetch takes an integer for an argument and gets the element for a given index, using 0-based index scheme.

icao = [:alpha, :bravo, :charlie, :delta, :foxtrot]
# => [:alpha, :bravo, :charlie, :delta, :foxtrot]
icao.fetch 1
# => :bravo
icao.fetch 0
# => :alpha

It also can get you the elements walking backward from a list

icao.fetch -1
# => :foxtrot
icao.fetch -4
# => :bravo

If an index is out of bounds of the array, either positive of negative, an IndexError is raised.

icao.fetch 5
# IndexError: index 5 outside of array bounds: -5...5
# from (pry):5:in `fetch'
icao.fetch -7
# IndexError: index -7 outside of array bounds: -5...5
# from (pry):11:in `fetch'

At this point, I can hear you saying:

So what?! I can do this using a subscript to an array and not get exceptions but a nil when something is not found.
–You

icao[4]
# => :foxtrot
icao[0]
# => :alpha
icao[-1]
# => :foxtrot
icao[-7]
# => nil
icao[5]
# => nil

And you would be right.

But where you might run into trouble with just using a subscript index, is if you have nils in your array.

some_nils[2]
# => nil
some_nils[100]
# => nil

This is where Array#fetch makes its way to one of my favorite Ruby methods.

When you decide to use Array#fetch over just subscripts, you can specify a default value that you get back if the index is out of bounds.

icao.fetch 2, :fubar
# => :charlie
icao.fetch 5, :snafu
# => :snafu
icao.fetch -7, :fubar
# => :fubar

And to top it off, you can even pass a whole block which is called with the index passed to fetch, so you can do more detailed logic if needed.

icao.fetch(-7) { |index| "SNAFU occured trying to fetch with index #{index}" }
# => "SNAFU occured trying to fetch with index -7"

–Proctor

Today’s Ruby Tuesday is on Array#sample.

Array#sample has a couple of different forms it can take.

The first form it can take is a version where no arguments are passed; in this case it returns a random element from the array it was called on, or nil if the array is empty.

[1, 2, 3, 4, 5].sample
# => 4
[1, 2, 3, 4, 5].sample
# => 1
[1, 2, 3, 4, 5].sample
# => 2
[].sample
# => nil
[:heart, :diamond, :club, :spade].sample
# => :club

Array#sample can also take as its argument a count of the number of random items to be returned.

[1, 2, 3, 4, 5].sample 2
# => [1, 2]
[1, 2, 3, 4, 5].sample 2
# => [2, 1]
[1, 2, 3, 4, 5].sample 2
# => [1, 3]
[1, 2, 3, 4, 5].sample 2
# => [3, 5]
[1, 2, 3, 4, 5].sample 2
# => [5, 2]

If the argument to the count is greater than, or equal to, the number of items in the array, then the array is returned.

[:heart, :diamond, :club, :spade].sample 6
# => [:heart, :diamond, :spade, :club]

This has two subtle but important consequences. First if we call sample with a count on an empty array, an empty array is returned, instead of a nil like we would get back if we just call Array#sample with no count argument. This includes calling Array#sample with a count of zero on an empty array.

[].sample
# => nil
[].sample 0
# => []
[].sample 1
# => []
[].sample 3
# => []

Second, it shows that as we sample the array, we are not going to get duplicate elements, unless they were in the array to being with.

On both of these forms, a random number generator can also be passed. This can give us a repeatable generation sequence as we can prime the generator with a given seed.

generatorA = Random.new 1
# => #<Random:0x007f86c3925878>
(1..100).to_a.sample(random: generatorA)
# => 38
(1..100).to_a.sample(random: generatorA)
# => 13
(1..100).to_a.sample(random: generatorA)
# => 73
generatorB = Random.new 1
# => #<Random:0x007f86c497dd10>
(1..100).to_a.sample(random: generatorB)
# => 38
(1..100).to_a.sample(random: generatorB)
# => 13
(1..100).to_a.sample(random: generatorB)
# => 73
(1..100).to_a.sample(random: generatorB)
# => 10
(1..100).to_a.sample(random: generatorA)
# => 10

(1..100).to_a.sample(4, random: generatorA)
# => [76, 6, 82, 66]
(1..100).to_a.sample(4, random: generatorA)
# => [17, 2, 79, 74]
(1..100).to_a.sample(4, random: generatorB)
# => [76, 6, 82, 66]
(1..100).to_a.sample(4, random: generatorB)
# => [17, 2, 79, 74]

And if we want to pick a random card from a deck of cards, or even draw a 5 card hand we can use Array#sample on an array of “playing cards”.

suit = [:heart, :diamond, :club, :spade]
# => [:heart, :diamond, :club, :spade]
rank = [:ace, 2, 3, 4, 5, 6, 7, 8, 9, :jack, :queen, :king]
# => [:ace, 2, 3, 4, 5, 6, 7, 8, 9, :jack, :queen, :king]
suit.product(rank).sample 1
# => [[:heart, :jack]]
suit.product(rank).sample 5
# => [[:club, 2], [:diamond, 2], [:spade, 7], [:club, 8], [:spade, :king]]

–Proctor