Fizz Buzz - Solution & Explanation

Problem 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.