Fizz Buzz - Practice Coding Problems

Fizz Buzz - Problem

The classic FizzBuzz problem is a popular programming exercise often used in coding interviews and programming assessments. Your task is to generate a sequence of strings based on specific divisibility rules.

Given an integer n, return a string array answer (1-indexed) where:

answer[i] == "FizzBuzz" if i is divisible by both 3 and 5
answer[i] == "Fizz" if i is divisible by 3 but not 5
answer[i] == "Buzz" if i is divisible by 5 but not 3
answer[i] == i (as a string) if none of the above conditions are true

Example: For n = 15, the sequence would be: ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"]

Input & Output

example_1.py — Small Input

$ Input: n = 3

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

💡 Note: 1 and 2 are not divisible by 3 or 5, so we output their string representations. 3 is divisible by 3, so we output "Fizz".

example_2.py — Medium Input

$ Input: n = 5

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

💡 Note: Numbers 1, 2, and 4 become their string representations. 3 is divisible by 3 ("Fizz"), and 5 is divisible by 5 ("Buzz").

example_3.py — FizzBuzz Case

$ Input: n = 15

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

💡 Note: This example shows all cases: regular numbers, Fizz (multiples of 3), Buzz (multiples of 5), and FizzBuzz (multiples of both 3 and 5). The number 15 is divisible by both 3 and 5, so it becomes "FizzBuzz".

Visualization

Tap to expand

Understanding the Visualization

Count Normally

Start counting from 1, saying each number

Apply Fizz Rule

When you reach a multiple of 3, say 'Fizz' instead

Apply Buzz Rule

When you reach a multiple of 5, say 'Buzz' instead

Apply FizzBuzz Rule

When you reach a multiple of both 3 and 5, say 'FizzBuzz'

Key Takeaway

🎯 Key Insight: FizzBuzz is fundamentally about applying conditional logic in the correct order - always check the most specific condition (divisible by both) first, then the individual conditions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each number from 1 to n exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(n)

We need to store n strings in the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
The output should be a string array of length n
Follow-up: Could you solve this without using the modulo operator?

Asked in

G Google 25 a Amazon 20 ⊞ Microsoft 18 f Meta 15

The FizzBuzz problem is solved optimally with a simple linear iteration approach. Loop through numbers 1 to n, checking divisibility conditions in the correct order: first check if divisible by both 3 and 5 (FizzBuzz), then by 3 alone (Fizz), then by 5 alone (Buzz), otherwise use the number itself. Time complexity is O(n) and space complexity is O(n) for the output array.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation	O(n)	O(n)	Iterate through numbers 1 to n and apply FizzBuzz rules directly

Direct Simulation — Algorithm Steps

Initialize an empty result array
Loop through numbers from 1 to n
For each number, check if divisible by both 3 and 5 (add 'FizzBuzz')
If not, check if divisible by 3 (add 'Fizz')
If not, check if divisible by 5 (add 'Buzz')
Otherwise, add the number as a string
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty result array and counter at 1

Check Divisibility

For each number, check divisibility by 3 and 5

Apply Rules

Add appropriate string based on divisibility rules

Continue

Increment counter and repeat until n

Code -

solution.c — C

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

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each number from 1 to n exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(n)

We need to store n strings in the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
The output should be a string array of length n
Follow-up: Could you solve this without using the modulo operator?

89.6K Views

Very High Frequency

~8 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler