## The modulo operator

The standard *FizzBuzz* solution relies on the modulo operator, which it uses to determine if a number is a multiple of 3 or 5.

If you have a math, computer science, or engineering background, the odds are good that you encountered the modulo operator in your studies, as your courses tended to take a mathematical approach to programming. (Remember relational calculus from your intro to databases course?)

If you came into programming from some other field and really got into it because you have a knack for problem-solving, you might not be aware of modulo math. **That doesn’t mean that you can’t come up with a FizzBuzz solution.**

*FizzBuzz* minus the modulo operator

When you present the *FizzBuzz* challenge to a large enough group of programmers — typically a dozen or more — there will be a very determined person who will insist that you provide them with no hints whatsoever. It happens.

When that happens, there’s invariably someone who’s either never heard of the modulo operator (`%`

, which returns the remainder of a division operation) or has forgotten it exists. I’ve also seen a competition comprising quick programming challenges where contestants were told to implement *FizzBuzz*, but *without* using modulo.

The more mathematically-inclined will use a method like this:

def multiple_of_n(factor, number): return math.floor(number / factor) == number / factor

`multiple_of_n()`

determines if a number *n* is a multiple of a factor *f* if the result of *n / f* is the same as *n / f* with the fractional part removed.

Occasionally, you’ll run into programmers who are unaware that there are functions to remove the fractional part of a number, either through rounding or truncation. Some of them make up for their lack of math background with a combination of creativity and grit.

I’ve seen one solution that looked something like this:

def multiple_of_5(number): number_as_string = str(number) last_digit = number_as_string[-1] return last_digit in ['0', '5']

This function turns the given number into a string, isolates the rightmost character of that string, and then returns `True`

if that character is “0” or “5”, which is true for the string form of numbers that are multiples of 5.

My reaction:

That was *nothing* compared to one method I saw that someone cobbled together to determine if a number was a multiple of 3. They remembered the old grade-school rule that if you add the digits of a number and the total is a multiple of 3, then the number is a multiple of 3.

Based on that, they wrote something like this:

def multiple_of_3(number): number_as_string = str(number) total_of_digits = 0 for digit in number_as_string: total_of_digits += int(digit) return total_of_digits in [3, 6, 9, 12, 15, 18]

Again, this function starts by converting the given number into a string. It then iterates through that string character by character, turning each character into a number and adding it to a running total. It then checks to see if that total is in a list of multiples of 3.

Since the standard *FizzBuzz* challenge is supposed to be performed on the numbers 1 through 100, the largest multiple of 3 will be 99, and the sum of its digits will be 18. Hence the list of multiples of 3 starts with 3 and ending with 18.

My reaction:

But hey, it works!

*FizzBuzz* plus grit

I’ve seen a handful of people with bachelors’ and even masters’ degrees in computer science face the *FizzBuzz* test and completely fail to produce working code. I’ve been more impressed by the self-taught coders who, in spite of not knowing about the modulo operator, charge head-first into the problem and solve it. These non-modulo solutions might cause a mathematician to react like this…

…but I think that they’re a sign of **grit**, which is an important quality for a programmer. These people took what they knew, applied a little creativity, and solved a problem that they shouldn’t have been able to solve. They remind me of a line from aviation pioneer Igor Sikorsky:

According to the laws of aerodynamics, the bumblebee can’t fly, but the bumblebee doesn’t know the laws of aerodynamics, so it goes ahead and flies.

Sooner or later, if you’re working on applications that actually matter, you’re going to run into seemingly insurmountable problems. There will always be the fear that something is just too hard to do. Impostor syndrome may rear its ugly head. Developing grit — and yes, it can be developed — is important, and it’s a quality I look for when forming a team.

## What’s next

Using “watchers” to play *FizzBuzz* “properly”.

## Previously, in the “Programmer interview challenge” series

- Programmer interview challenge 1: Anagram
- Programmer interview challenge 1, revisited: Revising “Anagram” in Python and implementing it in JavaScript
- Programmer interview challenge 1, revisited again: “Anagram” in Swift, the easy and hardcore way
- Programmer interview challenge 1, revisited once more: “Anagram” in Ruby and C#
- Programmer interview challenge 2: The dreaded FizzBuzz, in Python
- Programmer interview challenge 2, part 2: Functional FizzBuzz

## One reply on “Programmer interview challenge 2, part 3: FizzBuzz, minus the modulo operator, plus grit”

[…] reading the previous article on FizzBuzz solutions, Reginald “raganwald” Braithwaite, whom I know from my days as part of the Toronto tech scene, […]