The original problem of “412. Fizz Buzz” was published on LeetCode.com

Given an integer `n`

, return *a string array *`answer`

* ( 1-indexed) where*:

`answer[i] == "FizzBuzz"`

if`i`

is divisible by`3`

and`5`

.`answer[i] == "Fizz"`

if`i`

is divisible by`3`

.`answer[i] == "Buzz"`

if`i`

is divisible by`5`

.`answer[i] == i`

(as a string) if none of the above conditions are true.

**Example 1:**

**Input:** n = 3
**Output:** ["1","2","Fizz"]

**Example 2:**

**Input:** n = 5
**Output:** ["1","2","Fizz","4","Buzz"]

**Example 3:**

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

**Constraints:**

`1 <= n <= 10`

^{4}

## Solution

You must understand basic operations like modulo and string concatenation to solve this problem. Additionally, you will need to be familiar with looping logic to iterate over a range of numbers and make decisions based on criteria. Furthermore, you will need to be capable of translating such decisions into code. Finally, you should be aware of the constraints specified in the problem so that you can craft a solution that meets these conditions.

## What is the modulo operation?

The modulo operation, denoted by %, is a mathematical operation that calculates the remainder of two numbers when they are divided. It is commonly used to determine whether one number is divisible by another. For example, using the modulo operation on 10 % 3 will return 1, which indicates that 10 is not divisible by 3 without a remainder.

## What is string concatenation?

String concatenation is the process of joining two strings together. It is often used when constructing strings by combining literals with other strings and variables. For example, the operation “Hello ” + “World” would produce the string “Hello World”.

## What is looping logic?

Looping logic is repeating an operation over a series of data. With Python, this can be accomplished using while loops, for loops, and list comprehensions. These different looping constructs let you quickly iterate over a data set and apply repeated operations. This is essential for the FizzBuzz problem, as you must loop over a range of numbers and decide whether to print a “Fizz,” “Buzz,” or a number.

## What are the constraints?

The constraints specified in the problem are that 1 <= n <= 104. This means that the number (n) must be within 1 and 104 (inclusive) range. Any number outside of this range would not meet the constraints specified.

## Let’s develop a solution in Python.

To solve the FizzBuzz problem in Python, we can use a for loop to iterate over a range of numbers from 1 to n (as specified in the constraints). Within the loop, we will use the modulo operation to check if the current number is divisible by 3 and/or 5 and then concatenate the appropriate strings on each iteration. Finally, we will store the result of each iteration in a string array and then return it once the loop is complete.

## Here’s the code for our solution:

```
def fizzBuzz(self, n):
answer = []
for n in range(1, n + 1):
if n % 3 == 0 and n % 5 == 0:
answer.append("FizzBuzz")
elif n % 3 == 0:
answer.append("Fizz")
elif n % 5 == 0:
answer.append("Buzz")
else:
answer.append(str(n))
return answer
```

## What is the time complexity of this code?

The time complexity of this code is O(n), where n is the range of numbers. This is because for each iteration, the loop needs to check if the current number is divisible by 3 and/or 5, before deciding on the appropriate string to append and store in the array.

## What is the space complexity of this code?

The space complexity of this code is O(n) which indicates that the amount of memory used to store the data increases linearly with the number of elements. This means that for each iteration of the loop, the array storing the messages will grow in size and the total amount of memory will be proportionate to the value of n itself.

## Can the solution code be shortened to a one-liner?

Yes, the solution code can be shortened to a one-liner using a list comprehension. List comprehensions provide a concise way to loop over a range of data and create a list of the desired results. For example, the one-liner solution for the FizzBuzz problem would be:

```
def fizzBuzz(self, n):
return [("FizzBuzz" if i % 3 == 0 and i % 5 == 0 else "Fizz" if i % 3 == 0 else "Buzz" if i % 5 == 0 else str(i)) for i in range(1, n + 1)]
```

This single line of code replaces the original loop, performing the same logic while evaluating each number to determine if it is divisible by 3 or by 5. Depending on the result, the code will return “FizzBuzz,” “Fizz,” “Buzz,” or the number itself.