Fizz Buzz - Practice Coding Problems

Fizz Buzz - Problem

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.

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: ["1","2","Fizz"]

💡 Note: Numbers 1-3: 1 and 2 are not divisible by 3 or 5, so output as strings. 3 is divisible by 3, so output "Fizz".

Example 2 — Include Buzz

$ Input: n = 5

› Output: ["1","2","Fizz","4","Buzz"]

💡 Note: Numbers 1-5: 1,2,4 output as strings. 3 divisible by 3 → "Fizz". 5 divisible by 5 → "Buzz".

Example 3 — Include FizzBuzz

$ Input: n = 15

› Output: ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

💡 Note: Numbers 1-15: 15 is divisible by both 3 and 5, so output "FizzBuzz". Other multiples follow individual rules.

Constraints

1 ≤ n ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Input

Integer n representing the range 1 to n

Process

Apply FizzBuzz rules to each number

Output

String array with transformed values

Key Takeaway

🎯 Key Insight: Use modulo operations to efficiently determine divisibility and apply the correct FizzBuzz transformation rule.

Asked in

Apple 25 a Amazon 20 M Microsoft 15 G Google 10

The key insight is to use modulo operations to check divisibility by 3 and 5. Check divisibility by both (using % 15 or separate checks), then apply the appropriate FizzBuzz rule. Best approach is the optimized single-pass solution. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Direct Simulation	O(n)	O(1)	Iterate through 1 to n and apply fizz buzz rules for each number
Optimized - Single Modulo Check	O(n)	O(1)	Use single modulo 15 check to optimize divisibility by both 3 and 5

Brute Force - Direct Simulation — Algorithm Steps

Create result array of size n
For each number i from 1 to n, check divisibility
Apply FizzBuzz rules based on modulo results
Add appropriate string to result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Numbers

Test each number for divisibility by 3 and 5

Apply Rules

Use if-else conditions to determine output

Build Result

Add appropriate string to result array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** solution(int n, int* returnSize) {
    char** result = (char**)malloc(n * sizeof(char*));
    *returnSize = n;
    
    for (int i = 1; i <= n; i++) {
        result[i-1] = (char*)malloc(20 * sizeof(char));
        if (i % 3 == 0 && i % 5 == 0) {
            strcpy(result[i-1], "FizzBuzz");
        } else if (i % 3 == 0) {
            strcpy(result[i-1], "Fizz");
        } else if (i % 5 == 0) {
            strcpy(result[i-1], "Buzz");
        } else {
            sprintf(result[i-1], "%d", i);
        }
    }
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int returnSize;
    char** result = solution(n, &returnSize);
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 1 to n with constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using variables, output array doesn't count as extra space

✓ Linear Space

125.0K Views

High Frequency

~10 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler