Oinak

Posted on

# Can you solve FizzBuzz ... in a tweet?

FizzBuzz is a (in)famous programming puzzle that it is used mainly just to filter people who can code from people who can't.

The problem statement is as follows:

Write a function that prints the 100 first integers, but for every multiple of 3 prints "Fizz" (instead or the number), for every multiple of 5 prints "Buzz", for a mutipe of both 3 and 5 prints "FizzBuzz",

One naive impementation would be something like:

``````def fizz_buzz
(1..100).each do |n|
print 'Fizz' if n % 3 == 0
print 'Buzz' if n % 5 == 0
print n unless n % 3 == 0 || n % 5 == 0
print "\n"
end
end
``````

This works, but has several shortcomings with no easy workarounds. The most immediate one: you are checking modulo twice (or have cumbersome elses)

See this alternative:

``````def fizz_buzz
(1..100).each do |n|
if n % 3 == 0
puts "Fizz#{n % 5 == 0 ? 'Buzz' : ''}"
else
puts "#{n % 5 == 0 ? 'Buzz' : n}"
end
end
end
``````

Where you only repeat the 5 check, but the code is extra complex.

This is a bad test, not a good predictor of future software engineering performace. But that does not mean you cannot use it to learn stuff about ruby. For example, you could choose to solve it with no if's, no methods, no classes and no method calls (other than operator-like)...

Let me take you to the end and then see how do we get there:

``````-> n {
t = ->(d, s, x) { n % d == 0 && -> _ { s + x[''] } || x }
f = -> x { t[3, "Fizz", x] }
b = -> x { t[5, "Buzz", x] }
f[b[-> x { x }]][n]
}.yield_self { |fb|
p (1..100).map { |n| fb[n] } * ','
}
``````

What do we get here:

• "Fizz" appears only once
• "Buzz" appears only once
• 3 appears only once
• 5 appears only once
• modulo check is generalized and appears only once
• we use lambdas
• we use function composition
• we use higher order functions (functions receiving functions as parameter)

And now the parts:

## Test function

``````t = ->(d, s, x) {
n % d == 0 && -> _ { s + x[''] } || x
}
``````

But for the analysis lets have better identifiers:

``````test = lambda do |divisor, string, executable|
# if the number is a multiple of divisor...
number % divisor == 0 &&
# return a lambda that prefixes string
(lambda do |_| string + executable[''] end) ||
# otherwise return the received function
executable
end
``````

I don't know how much ruby you know so I will try to explain it all:

`lambda` creates an anonymous method that can be stored in a variable or passed as argument

``````a = lambda do |x|
puts "#{x} #{x}"
end
a.call('hi')
``````

prints `hi hi`

`->(x){ puts "#{x} #{x}"}` is just an alternate syntax to define lambdas, it is sometimes called the stabby operator

Inside the test lambda we have this structure: `a && b || c` `&&` is ruby and operator (for expressions, there is also `and` for action, with different precedence)
and `||` is the or.

This is used in substitution of `if` and `else`
`a && b` short-cirtuits in ruby so it only evaluates `b` if `a` is true (if `a` is false, the and already is).
On the other hand: `b || c` only evaluates `c` if `b` is falsey (if it's true, the expression already is)

So the translation of the test function is:

``````test = lambda do |divisor, string, executable|
if number % divisor == 0
(lambda { |_| string + executable[''] })
else
executable
end
end
``````

This whole return a function business sounds complicated but is key to be able to use test for both Fizz and Buzz

## Fizz function

Test function is pretty generic, but can be translated as:

if n is a mutiple of d, perfix s to what you receive, otherwise leave it be.

Being so generic, allows us to build two functions, `f` (for fizz) and `b` (buzz) by feeding different arguments to `test`, so

``````f = -> x { t[3, "Fizz", x] }
``````

which can be translated to the verbose version:

``````fizz = lambda do |executable|
test.call(3, "Fizz", executable)
end
``````

What `fizz`does is call `test` (`t`) with two literal parameters, `3` and `"Fizz"` and a dynamic one, `executable` (`x`).

With this example you can imagine that `buzz` (`b`) is constructed in very much the same way replacing 3 with 5 and "Fizz" with "Buzz".

## Function composition

One of the things we did not like on the original version was the repeated checks. The only way to avoid them in this case is to nest them.

We are building a fizz function that receives a buzz function as an argument so that it can run that code sometimes.

There is a whole branch os programming/mathematics that deals with this kind of thing. It is called Lambda Caculus and that is where the name of ruby's `lambda` function comes from.

## Multiple function composition

Now we have the last mysterious part:

``````f[
b[
-> x { x }
]
][n]
``````

f: returns a function that
if n is divisible by 3
returns a function that returns:
"Fizz" + received code run on "" (empty string)
else
returns a function that runs the received code
The code that f receives is `b[->x{x}]`

b: returns a function that
if n is divisible by 5
returns a function that returns:
"Buzz" + received code run on "" (empty string)
else
returns a function that runs the received code

But now the most important:
`b` receives this code `-> x { x }`
This is a function that returns its argument. Think of:

``````def executable(x)
return x
end
``````

This is the part of the code that will return the integer ONLY when it is not a multiple of neither 3 nor 5 because, and this is the key, both `f` and `b` run this function on their `else` sides, and run something like `executable("")` (or `x['']` in the abbreviated version) instead when the modulo is 0.

I am almost sure that this might not be absolutely clear, so please, copy this code, paste it into your `irb`, play with it... and come with your questions.

I would love to improve this article with each question received in the comments, and encourage you to play with even the smallest piece of code you lay your hands on, to push the boundaries of your knowledge, or at east have some fun.