Classic Warm-Ups: FizzBuzz and Friends

FizzBuzz asks you to print the numbers from 1 to n, replacing the multiples of three with the word Fizz, the multiples of five with the word Buzz, and the multiples of both with FizzBuzz. The twist is that the puzzle itself is not the point, because it is really a filter for basic fluency with the language.

What it reveals is whether you can write a loop that checks two conditions, whether you remember to use the modulo operator to test for divisibility, and whether you can produce the combined case instead of only the two separate ones. It also reveals whether you notice the ordering rule. A number that is divisible by fifteen has to print both words, and that is the case that most candidates forget on their first attempt.

It also tests whether you can read a specification carefully. The wording matters, because you have to know whether it says FizzBuzz or FizzBuzzBuzz, whether the output is separated by spaces or printed on separate lines, and what happens at the edges of the range. A candidate who asks those questions before writing a single line of code looks careful, and that is worth a lot.

What FizzBuzz does not test is difficult algorithm design. Nobody is impressed by a clever solution to FizzBuzz. The signal sits entirely in the basics, which are a clean loop structure, correct use of modulo, and handling the combined case. If you ever get stuck on the puzzle itself rather than on the syntax, that is worth knowing before the interview starts.

Writing the general version stops you from hard-coding the answer, and it makes the structure of the program obvious. The earlier question in this page explained what FizzBuzz really tests, and this one shows the code that an interviewer would like to see.

def fizzbuzz(n, rules=None):
    """Return the FizzBuzz lines for the numbers from 1 to n."""
    if rules is None:
        rules = [(3, 'Fizz'), (5, 'Buzz')]

    output = []
    for number in range(1, n + 1):
        words = []
        for divisor, word in rules:
            if number % divisor == 0:
                words.append(word)

        if words:
            output.append(''.join(words))
        else:
            output.append(str(number))

    return output


print(fizzbuzz(5))                       # ['1', '2', 'Fizz', '4', 'Buzz']
print(fizzbuzz(15)[-1])                 # FizzBuzz
print(fizzbuzz(15, [(3, 'Three'), (5, 'Five')])[-1])   # ThreeFive

The main design decision is that the function collects the matching words instead of branching. For each number, the inner loop finds every rule whose divisor divides it, and the join puts the words together in the order that the rules were given. That handles the ordinary FizzBuzz case with no special branch at all, because fifteen matches both rules and produces FizzBuzz.

The order of the rules matters, because the rules list defines the order of the output. Swapping Fizz and Buzz in that list gives BuzzFizz. Mentioning this in an interview shows that you have thought about the specification and not only about the arithmetic.

The remaining details are the ones that trip people up. The range starts at one and not at zero, because zero is divisible by everything and would print FizzBuzz as the very first line. The result is a list and not a printed string, so the caller decides how to present it. And the default value of the rules argument lets the function work with no arguments at all while still supporting custom rules.