FizzBuzz Classic

easyFREEControl FlowPython Control FlowPython Foundations

Problem Statement

Implement the classic FizzBuzz algorithm.

Background

FizzBuzz is a common programming challenge:

Print "Fizz" for multiples of 3
Print "Buzz" for multiples of 5
Print "FizzBuzz" for multiples of both
Otherwise print the number

Your Task

Write a function fizzbuzz(n) that returns a list of FizzBuzz results from 1 to n.

Output Format

Return a list of strings.

Example

Input

n = 15

Output

['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

Reasoning

Input: n $= 15$ is the inclusive upper limit, so the output covers every integer $k$ from $1$ to $15$ — exactly 15 entries, one per $k$ , in increasing order.
Multiples of 3 only: $3, 6, 9, 12$ leave remainder $0$ when divided by $3$ but not by $5$ , so those positions hold Fizz.
Multiples of 5 only: $5$ and $10$ are divisible by $5$ but not by $3$ , so they become Buzz.
Multiples of both: $15 = 3 \times 5$ is divisible by $3$ and $5$ (equivalently by $\mathrm{lcm}(3,5) = 15$ ). It also satisfies the "multiple of 3" and "multiple of 5" rules, but the combined rule wins, so the last entry is FizzBuzz, not Fizz.
Everything else: $1, 2, 4, 7, 8, 11, 13, 14$ match no rule, so they appear as themselves — but as text, e.g. '1', not the number $1$ , since the result is a list of strings.
Notice that FizzBuzz appears once per 15 numbers; for n $= 5$ the list ends at Buzz and never reaches it.

Constraints

n >= 1
Check divisibility by both 3 and 5 first

Learn this in

Python FoundationsFoundations

More from Python Foundations

Magic Methodsmedium Inheritance and Polymorphismmedium Basic Class Creationeasy Decorator Implementationmedium Higher-Order Functionsmedium

Concept primer

FizzBuzz Classic: Background Knowledge & Strategy

Background Knowledge

Control Flow Fundamentals

FizzBuzz is an excellent introduction to conditional logic and iteration in Python. The problem requires you to understand how to use if, elif, and else statements to make decisions based on different conditions. At its core, you'll be checking whether numbers satisfy certain mathematical properties (divisibility) and responding accordingly. This teaches you how programs can branch into different execution paths based on evaluated conditions.

Modulo Operator & Divisibility

The key mathematical concept here is the modulo operator (%), which returns the remainder after division. When a number is divisible by another, the remainder is zero. For example, 15 % 3 == 0 because 15 is divisible by 3. Understanding divisibility checks is fundamental to many programming problems beyond FizzBuzz, including number theory applications, data validation, and pattern detection.

List Building & String Conversion

You'll need to construct a list by iterating through a range of numbers and appending results to it. Notice that the output format requires strings (notice the quotes in the sample output), so you'll need to convert numbers to strings using str(). This reinforces the concept of type conversion and the importance of matching expected output formats precisely.

Algorithm/Approach

The general pattern for FizzBuzz is a sequential decision-making approach:

Iterate through numbers from 1 to n
For each number, evaluate conditions in a specific order
Determine which condition(s) the number satisfies
Append the appropriate result to your output list

The order of condition checking matters. You must check for the "both" case (multiples of both 3 and 5) before checking individual cases, otherwise you'll never reach the "both" logic.

Step-by-Step Strategy

Initialize: Create an empty list to store results
Iterate: Loop through numbers from 1 to n (inclusive)
Check divisibility by both: Test if the current number is divisible by both 3 and 5
Check divisibility by 3 only: If not both, test divisibility by 3
Check divisibility by 5 only: If not 3, test divisibility by 5
Default case: If none of the above, convert the number to a string
Append & Return: Add the result to your list and return the completed list

Common Pitfalls

Wrong condition order: Checking if divisible by 3 before if divisible by both means you'll append "Fizz" and never reach the "FizzBuzz" case
Off-by-one errors: Remember that range(1, n+1) goes from 1 to n inclusive; range(1, n) stops at n-1
Forgetting string conversion: Numbers need to be converted to strings to match the expected output format
Incorrect divisibility logic: Remember that n % 3 == 0 means divisible, not n % 3 != 0
Returning wrong type: The problem asks for a list, not a string or generator

Time & Space Complexity

Time Complexity: $O(n)$ — You must iterate through each number from 1 to n exactly once, and each iteration performs a constant number of comparisons.

Space Complexity: $O(n)$ — The output list contains n elements, so the space required grows linearly with the input size.

solution.py

Python 3.13

Test results