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 <= 104Problem Overview: Given an integer n, generate a list of strings representing numbers from 1 to n. Replace multiples of 3 with "Fizz", multiples of 5 with "Buzz", and numbers divisible by both with "FizzBuzz". Otherwise, append the number itself as a string.
Approach 1: Simple Iteration with Condition Checks (Time: O(n), Space: O(1) auxiliary)
The direct solution iterates from 1 to n and checks divisibility using the modulo operator. For each number, evaluate i % 3 and i % 5. If both are zero, append "FizzBuzz". If only divisible by 3, append "Fizz". If only divisible by 5, append "Buzz". Otherwise convert the number to a string. The algorithm touches every number exactly once, giving O(n) time complexity. Aside from the output list, it uses constant extra space, so auxiliary space is O(1). This approach relies on basic math operations and straightforward simulation of the rules.
The key detail is ordering the conditions correctly. Check divisibility by 15 or both 3 and 5 first. If you check 3 before the combined case, numbers like 15 would incorrectly return "Fizz". Most implementations either check i % 15 == 0 or concatenate strings when conditions match.
Approach 2: Hash Map Optimized Approach (Time: O(n), Space: O(1))
This version stores divisor–string pairs in a small hash map such as {3: "Fizz", 5: "Buzz"}. During iteration from 1 to n, check each key in the map and append its string when the number is divisible by that key. Build the result string dynamically. If nothing was appended, convert the number to a string and add it to the result list.
The hash map keeps the logic extensible. Adding new rules like 7 → "Bazz" only requires inserting another key-value pair without rewriting conditional chains. The iteration over divisors is constant because the map size is fixed, so total complexity remains O(n) time and O(1) extra space. The approach highlights how small lookup structures simplify repetitive condition checks, a common technique when combining rules in string generation problems.
Recommended for interviews: The simple iteration with condition checks is what interviewers typically expect. It demonstrates clean control flow and understanding of divisibility logic. The hash map variation shows extensibility and cleaner scaling when rules increase, but the classic conditional version proves you can translate problem rules directly into efficient code.
This approach iterates through numbers from 1 to n and applies conditional logic using modulus operations to determine if a number should be represented as "Fizz", "Buzz", or "FizzBuzz". If none of these conditions are met, the number itself is returned as a string.
The function fizzBuzz takes an integer n and generates an array of strings. It checks each number from 1 to n for divisibility by 3 and 5. The use of strdup efficiently allocates memory for the strings returned.
Time Complexity: O(n) as we iterate through each number from 1 to n once.
Space Complexity: O(n) for the output array.
This approach uses a hash map to store possible outputs, simplifying conditional checks. By mapping integers to their respective Fizz or Buzz values, we consolidate decision logic, reducing redundancy in the code.
This C solution defines a constant array storing potential word outputs for Fizz, Buzz, and FizzBuzz. Indexes based on divisibility determine which string to select, reducing the number of branch conditions.
Time Complexity: O(n), since each element is evaluated once.
Space Complexity: O(n) due to storage for result strings.
| Approach | Complexity |
|---|---|
| Simple Iteration with Condition Checks | Time Complexity: |
| Hash Map Optimized Approach | Time Complexity: |
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Simple Iteration with Condition Checks | O(n) | O(1) auxiliary | Standard interview solution when rules are fixed (3 and 5) |
| Hash Map Optimized Approach | O(n) | O(1) | When rules may expand or you want cleaner extensible logic |
LeetCode Fizz Buzz Solution Explained - Java • Nick White • 21,734 views views
Watch 9 more video solutions →Practice Fizz Buzz with our built-in code editor and test cases.
Practice on FleetCodePractice this problem
Open in Editor