The FizzBuzz puzzle is a classic programming problem commonly used in interviews to evaluate a developer’s understanding of loops, conditionals, and problem-solving fundamentals. While the problem itself is simple, it can be solved in multiple ways, each highlighting a different coding technique. Let us delve into understanding the Java FizzBuzz problem.

1. Problem Statement

The FizzBuzz problem requires writing a program that iterates through a sequence of integers starting from 1 up to a given positive integer N. For each number in this range, the program must apply a set of conditional rules to determine what should be printed to the output. The goal is to replace certain numbers with specific words based on their divisibility properties, while preserving the original number when none of the conditions apply.

Specifically, the program must follow these rules in the order listed below to ensure correct results:

• Print “Fizz” if the current number is divisible by 3, meaning the remainder of the division by 3 is zero.
• Print “Buzz” if the current number is divisible by 5, meaning the remainder of the division by 5 is zero.
• Print “FizzBuzz” if the number is divisible by both 3 and 5, which typically occurs for multiples of 15.
• If the number does not satisfy any of the above conditions, print the number itself without any modification.

The challenge emphasizes proper use of looping constructs, conditional logic, and correct rule precedence, since numbers divisible by both 3 and 5 must be identified before checking each condition individually. This problem is commonly used to assess a programmer’s ability to translate simple business rules into clean and correct code.

2. Code Example

The following Java program demonstrates all three approaches—naive, concatenation, and counter-based—within a single class. Each approach is implemented as a separate method for clarity and comparison.

// FizzBuzz.java
package com.example;

public class FizzBuzz {

 public static void main(String[] args) {
 int n = 15;

 System.out.println("Naive Approach:");
 naiveApproach(n);

 System.out.println("\nConcatenation Approach:");
 concatenationApproach(n);

 System.out.println("\nCounter-Based Approach:");
 counterBasedApproach(n);
 }

 // 1. Naive Approach
 private static void naiveApproach(int n) {
 for (int i = 1; i <= n; i++) {
 if (i % 3 == 0 && i % 5 == 0) {
 System.out.println("FizzBuzz");
 } else if (i % 3 == 0) {
 System.out.println("Fizz");
 } else if (i % 5 == 0) {
 System.out.println("Buzz");
 } else {
 System.out.println(i);
 }
 }
 }

 // 2. Concatenation Approach
 private static void concatenationApproach(int n) {
 for (int i = 1; i <= n; i++) {
 String result = "";

 if (i % 3 == 0) {
 result += "Fizz";
 }
 if (i % 5 == 0) {
 result += "Buzz";
 }

 System.out.println(result.isEmpty() ? i : result);
 }
 }

 // 3. Counter-Based Approach
 private static void counterBasedApproach(int n) {
 int fizzCounter = 0;
 int buzzCounter = 0;

 for (int i = 1; i <= n; i++) {
 fizzCounter++;
 buzzCounter++;

 if (fizzCounter == 3 && buzzCounter == 5) {
 System.out.println("FizzBuzz");
 fizzCounter = 0;
 buzzCounter = 0;
 } else if (fizzCounter == 3) {
 System.out.println("Fizz");
 fizzCounter = 0;
 } else if (buzzCounter == 5) {
 System.out.println("Buzz");
 buzzCounter = 0;
 } else {
 System.out.println(i);
 }
 }
 }
}

2.1 Code Explanation

The FizzBuzz class is defined inside the com.example package and serves as a single Java program that demonstrates three different ways to solve the FizzBuzz problem. The program starts execution in the main method, where an integer variable n is initialized with the value 15, representing the upper limit of numbers to be processed. The main method then prints a label for each approach and sequentially calls three helper methods—naiveApproach, concatenationApproach, and counterBasedApproach—passing n as an argument so that all approaches operate on the same input range.

The naiveApproach method uses a for loop that iterates from 1 to n and applies modulo operations to check divisibility; it first checks whether the current number is divisible by both 3 and 5 to print "FizzBuzz", then checks divisibility by 3 to print "Fizz", by 5 to print "Buzz", and prints the number itself if none of the conditions match, ensuring correct precedence of conditions.

The concatenationApproach method also iterates from 1 to n but builds the output dynamically using a string variable called result; for each number, it appends "Fizz" if the number is divisible by 3 and "Buzz" if it is divisible by 5, and finally prints either the concatenated string or the number itself if the string is empty, reducing conditional branching and improving readability.

The counterBasedApproach method eliminates modulo operations entirely by maintaining two counters, fizzCounter and buzzCounter, which increment on each loop iteration; when fizzCounter reaches 3 and buzzCounter reaches 5 simultaneously, the method prints "FizzBuzz" and resets both counters, while reaching only one threshold results in printing "Fizz" or "Buzz" and resetting the corresponding counter, and printing the current number otherwise.

Together, these methods illustrate how the same problem can be solved using straightforward conditional logic, string-based composition, and counter-driven optimization, all within a single cohesive Java program.

2.2 Code Output

Naive Approach:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

Concatenation Approach:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

Counter-Based Approach:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

The displayed output shows the results of executing the FizzBuzz program using three different approaches—Naive, Concatenation, and Counter-Based—each applied to the same input range from 1 to 15. For every approach, the numbers are processed sequentially, and the same rules are consistently applied: numbers divisible by 3 are replaced with Fizz, numbers divisible by 5 are replaced with Buzz, and numbers divisible by both 3 and 5 are replaced with FizzBuzz, while all other numbers are printed as-is. The repetition of identical output across all three sections demonstrates that, although the internal implementation logic differs in each approach, they are functionally equivalent and correctly solve the FizzBuzz problem. This consistency confirms that each method adheres to the same business rules and validates the correctness of all three implementations.

3. Conclusion

Combining multiple FizzBuzz implementations into a single program makes it easy to compare different problem-solving strategies. While the naive approach prioritizes clarity, the concatenation approach improves flexibility, and the counter-based approach demonstrates performance-oriented thinking. Mastering these variations strengthens core programming skills and prepares developers for more complex logic-based challenges.