LeetCode 412: Fizz Buzz Solution in Python – A Step-by-Step Guide

What Is LeetCode 412: Fizz Buzz?

In LeetCode 412: Fizz Buzz, you’re given an integer n, and you need to return a list of strings representing the Fizz Buzz sequence from 1 to n. The rules are simple:

• If a number is divisible by 3, say "Fizz."
• If divisible by 5, say "Buzz."
• If divisible by both (15), say "FizzBuzz."
• Otherwise, just say the number as a string.

For example, with n = 5, you get ["1","2","Fizz","4","Buzz"]. It’s a coding twist on a childhood game, testing your ability to handle conditions cleanly.

Problem Statement

• Input: An integer n.
• Output: A list of strings—the Fizz Buzz sequence from 1 to n.
• Rules:
• Divisible by 3 → "Fizz."
• Divisible by 5 → "Buzz."
• Divisible by 15 → "FizzBuzz."
• Else → number as string.

Constraints

• 1 <= n <= 10⁴.

Examples

• Input: n = 3
• Output: ["1","2","Fizz"].
• Input: n = 5
• Output: ["1","2","Fizz","4","Buzz"].
• Input: n = 15
• Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"].

Understanding the Problem: Counting with a Twist

To solve LeetCode 412: Fizz Buzz in Python, we need to create a list from 1 to n, replacing numbers with "Fizz," "Buzz," or "FizzBuzz" based on divisibility rules. A naive idea might be to write out each case manually—but that’s no fun for big n! Instead, we’ll use:

• Best Solution (Conditional Iteration): O(n) time, O(1) space (excluding output)—checks conditions simply.
• Alternative Solution (Hash Map Approach): O(n) time, O(1) space—maps rules flexibly.

Let’s dive into the conditional iteration solution with a clear, step-by-step explanation.

Best Solution: Conditional Iteration

Why This Is the Best Solution

The conditional iteration method is the top pick because it’s fast—O(n) time, O(1) space (not counting the output)—and as straightforward as the game itself. It loops from 1 to n, checks divisibility with simple if-statements, and builds the list in one pass. It’s like counting out loud with your friends, swapping in the right words as you go!

How It Works

Think of it as counting with a rulebook:

• Step 1: Set Up the List:
• Create an empty list to hold the sequence.
• Step 2: Count and Check:
• For each number from 1 to n:
• Divisible by 15 (3 and 5)? Add "FizzBuzz."
• Divisible by 3 only? Add "Fizz."
• Divisible by 5 only? Add "Buzz."
• Otherwise, add the number as a string.
• Step 3: Build It Up:
• Append each result to the list.
• Step 4: Why This Works:
• Direct checks ensure every rule is applied correctly.
• Single loop keeps it fast and simple.
• It’s like playing the game step-by-step, writing down what you’d say!

Step-by-Step Example

Example: n = 5

• Start: List = [].
• 1: Not 3 or 5, List = ["1"].
• 2: Not 3 or 5, List = ["1", "2"].
• 3: Div by 3, List = ["1", "2", "Fizz"].
• 4: Not 3 or 5, List = ["1", "2", "Fizz", "4"].
• 5: Div by 5, List = ["1", "2", "Fizz", "4", "Buzz"].
• Result: ["1","2","Fizz","4","Buzz"].

Example: n = 15

• Up to 14: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14"].
• 15: Div by 15, add "FizzBuzz".
• Result: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"].

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down so you can follow every step:

Copy codeclass Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        # Step 1: Initialize result list
        result = []

        # Step 2: Loop from 1 to n
        for i in range(1, n + 1):
            # Step 3: Check conditions
            if i % 15 == 0:  # Divisible by 3 and 5
                result.append("FizzBuzz")
            elif i % 3 == 0:  # Divisible by 3 only
                result.append("Fizz")
            elif i % 5 == 0:  # Divisible by 5 only
                result.append("Buzz")
            else:  # Not divisible by 3 or 5
                result.append(str(i))

        return result

• Line 4: Create an empty list to store the sequence.
• Line 7-14: Loop from 1 to n:
• Line 8-9: Check i % 15 == 0 first (3×5 = 15), add "FizzBuzz" (e.g., 15).
• Line 10-11: Else if i % 3 == 0, add "Fizz" (e.g., 3).
• Line 12-13: Else if i % 5 == 0, add "Buzz" (e.g., 5).
• Line 14: Otherwise, convert i to string and add (e.g., "1").
• Line 16: Return the completed list.
• Time Complexity: O(n)—one pass through 1 to n.
• Space Complexity: O(1)—excluding output list, just a loop variable.

This is like counting with a Fizz Buzz rulebook in hand!

Alternative Solution: Hash Map Approach

Why an Alternative Approach?

The hash map approach uses a dictionary to map divisors to words, making it flexible for adding rules (e.g., "Bazz" for 7). It’s O(n) time and O(1) space too—more extensible but slightly overkill here. It’s like setting up a rule chart and checking it as you count!

How It Works

Picture it as a lookup game:

• Step 1: Map divisors to words (3 → "Fizz", 5 → "Buzz").
• Step 2: For each number, check all divisors, build string.
• Step 3: If no matches, use the number.

Step-by-Step Example

Example: n = 5

• Map: {3: "Fizz", 5: "Buzz"}.
• 1: No divisors match, ["1"].
• 2: No match, ["1", "2"].
• 3: 3 matches, ["1", "2", "Fizz"].
• 4: No match, ["1", "2", "Fizz", "4"].
• 5: 5 matches, ["1", "2", "Fizz", "4", "Buzz"].
• Result: ["1","2","Fizz","4","Buzz"].

Code for Hash Map Approach

Copy codeclass Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        # Step 1: Define rule map
        rules = {3: "Fizz", 5: "Buzz"}

        # Step 2: Build sequence
        result = []
        for i in range(1, n + 1):
            temp = ""
            for div, word in rules.items():
                if i % div == 0:
                    temp += word
            if not temp:
                temp = str(i)
            result.append(temp)

        return result

• Time Complexity: O(n)—loop with constant checks.
• Space Complexity: O(1)—fixed map.

It’s a flexible Fizz Buzz chart!

Comparing the Two Solutions

• Conditional Iteration (Best):
• Pros: O(n), O(1), simple and direct.
• Cons: Less extensible.
• Hash Map (Alternative):
• Pros: O(n), O(1), flexible for more rules.
• Cons: Extra overhead.

Conditional wins for simplicity.

Additional Examples and Edge Cases

• 1: ["1"].
• 15: Ends with "FizzBuzz".
• 10⁴: Works up to max constraint.

Conditional handles all.

Complexity Breakdown

• Conditional: Time O(n), Space O(1).
• Hash Map: Time O(n), Space O(1).

Conditional’s lean.

Key Takeaways

• Conditional: Check and go!
• Hash Map: Map it out!
• Fizz Buzz: Rules are fun.
• Python Tip: Loops are key—see [Python Basics](/python/basics).

Final Thoughts: Fizz That Buzz

LeetCode 412: Fizz Buzz in Python is a counting classic. Conditional iteration keeps it simple, while hash maps add flair. Want more sequence fun? Try LeetCode 118: Pascal’s Triangle or LeetCode 119: Pascal’s Triangle II. Ready to count? Head to Solve LeetCode 412 on LeetCode and buzz your way through today!