Solution Explanation for Fizz Buzz

The Fizz Buzz problem requires generating a list of strings representing numbers from 1 to n. The rules are:

• If a number is divisible by 3, print "Fizz".
• If a number is divisible by 5, print "Buzz".
• If a number is divisible by both 3 and 5 (i.e., 15), print "FizzBuzz".
• Otherwise, print the number itself.

Approach

The most straightforward approach is to iterate through numbers 1 to n and apply the rules using modulo operator (%). We check divisibility by 15 first to catch "FizzBuzz" cases, followed by divisibility by 3 and 5 individually. If none of these conditions are met, we convert the number to a string.

Code Implementation and Explanations (Multiple Languages)

The following code snippets demonstrate this approach in several popular programming languages. The core logic remains consistent across all implementations.

Python3

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        ans = []
        for i in range(1, n + 1):
            if i % 15 == 0:
                ans.append('FizzBuzz')
            elif i % 3 == 0:
                ans.append('Fizz')
            elif i % 5 == 0:
                ans.append('Buzz')
            else:
                ans.append(str(i))
        return ans

This Python code uses a simple for loop and if-elif-else chain to check the divisibility conditions. The append() method adds the appropriate string to the ans list.

Java

class Solution {
    public List<String> fizzBuzz(int n) {
        List<String> ans = new ArrayList<>();
        for (int i = 1; i <= n; ++i) {
            String s = "";
            if (i % 3 == 0) s += "Fizz";
            if (i % 5 == 0) s += "Buzz";
            if (s.isEmpty()) s += i; //if s is empty then add the number
            ans.add(s);
        }
        return ans;
    }
}

The Java code is similar, using an ArrayList to store the results. Note how the string s is built incrementally.

C++

class Solution {
public:
    vector<string> fizzBuzz(int n) {
        vector<string> ans;
        for (int i = 1; i <= n; ++i) {
            string s = "";
            if (i % 3 == 0) s += "Fizz";
            if (i % 5 == 0) s += "Buzz";
            if (s.empty()) s = to_string(i);
            ans.push_back(s);
        }
        return ans;
    }
};

The C++ version utilizes a vector<string> and to_string() for number conversion.

JavaScript

var fizzBuzz = function(n) {
    let result = [];
    for (let i = 1; i <= n; i++) {
        let output = "";
        if (i % 3 === 0) output += "Fizz";
        if (i % 5 === 0) output += "Buzz";
        result.push(output || i); //if output is empty push i
    }
    return result;
};

The JavaScript solution uses a similar iterative approach, with a concise way to handle the case where neither 3 nor 5 divides i.

Time and Space Complexity

• Time Complexity: O(n) - The code iterates through the numbers from 1 to n once. The divisibility checks are constant-time operations.
• Space Complexity: O(n) - The space used is primarily for storing the resulting string array, which has a size proportional to n. Auxiliary space usage is constant.

This solution is efficient and easy to understand, making it a good choice for solving the Fizz Buzz problem. More sophisticated approaches are generally unnecessary for this problem due to its simplicity and the already linear time complexity.