412. Fizz Buzz

Problem Statement

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 <= 104

Solution:

Rust

impl Solution {
    pub fn fizz_buzz(n: i32) -> Vec<String> {
        let mut res = Vec::new();

        for i in 1..=n {
            // same as divisible by 3 and 5
            if i % 15 == 0 {
                res.push("FizzBuzz".to_string());
            } else if i % 3 == 0 {
                res.push("Fizz".to_string());
            } else if i % 5 == 0 {
                res.push("Buzz".to_string());
            } else {
                res.push(i.to_string());
            }
        }

        res
    }
}

Java

class Solution {
    private static final int MINIMUM_RANGE = 1;
    private static final String FIZZ = "Fizz";
    private static final String BUZZ = "Buzz";
    private static final String FIZZ_BUZZ = "FizzBuzz";

    private static final int FIZZ_DIVISOR = 3;
    private static final int BUZZ_DIVISOR = 5;


    public List<String> fizzBuzz(int rangeEnd) {
        List<String> sequence = new ArrayList<>(rangeEnd);

        for (int number = MINIMUM_RANGE; number <= rangeEnd; number++) {
            sequence.add(generateFizzBuzzValue(number));
        }

        return sequence;
    }


    private String generateFizzBuzzValue(int number) {
        boolean isDivisibleByFizz = isDivisibleBy(number, FIZZ_DIVISOR);
        boolean isDivisibleByBuzz = isDivisibleBy(number, BUZZ_DIVISOR);

        if (isDivisibleByFizz && isDivisibleByBuzz) return FIZZ_BUZZ;
        if (isDivisibleByFizz) return FIZZ;
        if (isDivisibleByBuzz) return BUZZ;

        return String.valueOf(number);
    }

    private boolean isDivisibleBy(int dividend, int divisor) {
        return dividend % divisor == 0;
    }
}

C#

public class Solution {
    // Constants for divisibility checks
    private const int DIVISIBLE_BY_THREE = 3;
    private const int DIVISIBLE_BY_FIVE = 5;

    // Output string constants
    private const string FIZZ = "Fizz";
    private const string BUZZ = "Buzz";
    private const string FIZZ_BUZZ = "FizzBuzz";

    public IList<string> FizzBuzz(int n) {
        return GenerateFizzBuzzSequence(n);
    }

    /// <summary>
    /// Generates the FizzBuzz sequence for valid input n.
    /// </summary>
    /// <param name="n">The upper bound of the sequence</param>
    /// <returns>The FizzBuzz sequence as a list of strings</returns>
    private static IList<string> GenerateFizzBuzzSequence(int n) {
        var result = new List<string>(n); // Preallocate for performance

        for (int i = 1; i <= n; i++) {
            result.Add(GetFizzBuzzValue(i));
        }

        return result;
    }

    /// <summary>
    /// Determines the FizzBuzz value for a given number.
    /// </summary>
    /// <param name="number">The number to evaluate</param>
    /// <returns>The corresponding FizzBuzz string value</returns>
    private static string GetFizzBuzzValue(int number) {
        bool isDivisibleByThree = number % DIVISIBLE_BY_THREE == 0;
        bool isDivisibleByFive = number % DIVISIBLE_BY_FIVE == 0;

        return (isDivisibleByThree, isDivisibleByFive) switch {
            (true, true) => FIZZ_BUZZ,
            (true, false) => FIZZ,
            (false, true) => BUZZ,
            _ => number.ToString()
        };
    }
}

...