FizzBuzz Problem Solution

Question

I wrote this simple solution about FizzBuzz. Is there any possible way to solve or optimize the solution, such as with bitwise tricks?

public class FizzBuzz{
  public static void main(String[] args){

    for(int i = 1 ; i <= 100 ; ++i){
      if(i % (5*3) == 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);
    }
  }
}

Answer 1

I like this.

if(i % (5*3) == 0){

Most people would have used 15 which I believe to be wrong. The way you've done it, it's clear that the first case is a multiple of the other two cases. Well done!

They are magic numbers though, and should be replaced with meaningful constants. Otherwise, I wouldn't change another thing. (Disclaimer: Someone will come behind me and talk about ways to make the code more efficient, but none of them will be as readable as this algorithm.)

Answer 2

That's a classic FizzBuzz solution. I wouldn't try to do any clever optimization — it won't make any difference to performance. One hundred iterations of anything is trivial for a computer. Furthermore, most of the time will be dominated by the output routines, which you can't do much about.

The code formatting, on the other hand, could be improved. The most glaring issue is the omission of the braces for the final else. Why make your code ugly to save a couple of bytes?

Also note a de facto formatting convention: Put a space after if and for, and before any opening { brace.

Answer 3

You have four calls to System.out.println(arg). If you want to change your code from printing to the console to writing to a file or a database, you have to change four lines in your code even though you're really only changing one "thing". Why not pull out the four System.out.println(arg)s and insert one after the if conditions like so:

public class FizzBuzz{
  public static void main(String[] args){

    for(int i = 1 ; i <= 100 ; ++i){
      String str;
      if(i % (5*3) == 0){
        str = "FizzBuzz";
      }else if(i % 3 == 0){
        str = "Fizz";
      }else if(i % 5 == 0){
        str = "Buzz";
      }else
        str = Integer.toString(i);

       System.out.println(str);
    }
  }
}

I agree with others that your if conditions are ugly.

Answer 4

From a general readability and maintainability standpoint this code could take some improvements.

The else if statements are really quite untidy and frequently end up being the source of trouble. A brace out of place there could cause a real mess - I'd look to refactor them out by putting the work into a function that converts int i into the string to output. It will make the code longer but also clearer because you have a separation of concerns where main controls the overall program flow and output, and the function converts the number to a string (replacing it with keywords as needed).

Once you've abstracted that work into a function you can also toy around with the many various ways that function could work without else if and test them independently of the main code. Some of those other implementations might be:-

• early return (returning from the function as soon as you have the answer)
• switch on the result of n mod 15 0=Fizzbuzz, [3,6,9,12]=fizz, [5,10]=buzz
• string array lookup (based again on n mod 15)

Also, the 3 x 5 could stand some improvement; not because it should be 15 (because that is wrong too) but because they are 'magic numbers'. Neither 3 nor 5 should appear in the body of the code except as constants to define the values for the 'Fizz' and 'Buzz' states, that would mean 'Fizz x Buzz'.

Always consider that in the real world any code you make is likely to grow in complexity or length - getting those kinds of behaviours in place for a very simple piece of code make a huge difference when you start coding on a more complex project.

Aside: As a non-Java developer I was going to say that the K&R brace style is awful but on checking I found it masks an 'issue' in Java. Quite what whitespace is doing affecting output in a C style language I've no idea...

Answer 5

Everybody noticed this, but no one actually said anything about it.

Your else statement is mismatched.

}else
    System.out.println(i);

This is not right in any language.

it should be

} else {
    System.out.println(i);
}

You have a multiple level if statement that makes use of bracing, the else statement must use bracing as well.

Answer 6

This chain if

if(i % (5*3) == 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);
}

is asking for maintenance trouble because you repeat 3 and 5 in unobvious way and distribute the arithmetic and comparison operations across the whole chain.

The following would be slightly better in regard to constant(s) use and also it first computes the actual conditions that matter and then reuses them here and there:

boolean isMultipleOf3 = ((i % 3) == 0);
boolean isMultipleOf5 = ((i % 5) == 0);
if(isMultipleOf3 && isMultipleOf5) {
    System.out.println("FizzBuzz");
} else if(isMultipleOf3) {
    System.out.println("Fizz");
} else if(isMultipleOf5) {
    System.out.println("Buzz");
} else {
    System.out.println(i);
}

Answer 7

I will reiterate the need for braces in your statements as well as the importance of avoiding magic numbers in your code. You also asked for how to 'solve' it and this is an alternative approach:

public class FizzBuzz {
    public static void main(String[] args) {
        final int fizz = 3;
        final int buzz = 5;

        StringBuilder sb = new StringBuilder("");
        for (int i = 1; i <= 100; i++) {
            if (i % fizz == 0) {
                sb.append("Fizz"); 
            }
            if (i % buzz == 0) {
                sb.append("Buzz");
            }
            if (sb.length() == 0) {
                System.out.println(i);
            } else {
                System.out.println(sb.toString());
                sb.setLength(0);
            }               
        }
    }
}

Why I like it: It's extensible, concise and flexible without giving up on readability. It remains immediately apparent how it works and is intuitive to add several more 'buzz' words and their checks.

I stopped preferring the standard method once It occurred to me how cumbersome additional conditionals would be to write in comparison.

Consider, for example, if you had to print Bazz for multiples of 7. With your code this would mean you would need to check for and print:

• Bazz for multiples of 7.
• BuzzBazz for multiples of 5 and 7.
• FizzBazz for multiples of 3 and 7.
• If you went beyond 100, FizzBuzzBazz for multiples of 3, 5 and 7.

This becomes exponentially more evident the more 'buzz' words you want to add and the higher the upper limit.

Meanwhile, this way, you would only need to add two already familiar lines:

final int Bazz = 7; to clearly designate that/eliminate ambiguity

and

if (i % bazz == 0) {
    sb.append("Bazz");
}

within the loop.

Here are the same ideas implemented using Java 8:

import java.util.stream.IntStream;

public class Java8FizzBuzz {
    static final int FIZZ = 3;
    static final int BUZZ = 5;
    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) {
        IntStream.rangeClosed(1, 100).forEach(Java8FizzBuzz::fizzBuzzify);
    }

    private static void fizzBuzzify(int i) {
        if (i % FIZZ == 0) {
            sb.append("Fizz");
        }
        if (i % BUZZ == 0) {
            sb.append("Buzz");
        }
        System.out.println(sb.length() > 0 ? sb.toString() : i);
        sb.setLength(0);
    }
}

Notice that both implementations have the added benefit of only needing to alter a single character, if for example rather than printing fizz for multiples of 3 one had to print fizz for multiples of 4. This is flexible FizzBuzz, however much that is worth.

Answer 8

It's hard to try and optimise the code after what's already mentioned. Here's a mathematical take on it:

• Loop count = 100
• %15 calculation = 100
• %3 calculation = 100 - 6 = 94
• %5 calculation = 100 - 33 = 67
• Total modulu calculation = 261 (100 + 94 + 67)

Let's try this:

boolean isFizz = (i%3 == 0); // 100 times calculation
boolean isBuzz = (i%5 == 0); // 100 times calculation
// Total 200 times , a benefit of 61 for 100, 601 for 1000, etc i.e 23% :)

Answer 9

I would go for Java 8 with Streams and use a more functional approach:

IntStream.rangeClosed(1, 100).mapToObj(x -> "" + x).map(x -> {
    if (Integer.parseInt(x) % (5 * 3) == 0) return "Fizzbuz";
    if (Integer.parseInt(x) % 5 == 0) return "Buzz";
    if (Integer.parseInt(x) % 3 == 0) return "Fizz";
    return x;
}).forEach(System.out::println);

Simple and short. Whether it is better lies in the eye of the beholder.

Answer 10

Is there any possible way to [...] optimize the solution, such as with bitwise tricks?

Bitwise tricks may optimize your code to ONE aspect (speed?). You have to say to which aspect you want your code to be optimzed. But that is not that easy as well. BTW I see a deleted answer that got downvoted as it provided a solution with bit shifting. The best comment to that was "We should write code for people to read".

But if you want to argue for readability: That is totally subjective if you have no real world anchor. If someone sees the code for FizzBuzz then he only can evaluate single statements and say what they do but he cannot evaluate an intention.

If you want to argue for extensibility optimization you have a hard day. FizzBuzz is nothing more than an exercise to train algorithmic thinking. There is no real world anchor so you have nearly no chance to forcast any abstractions that are neccessary for extensibility. Once you are thinking you have the correct abstraction someone can come up with some completely artificial requirement you haven't considered. I do not say that this does not happen with real world requirements but they tend to be easier to be forecasted.

Speed is indeed a measurement you can make. But can we really say that only the fastest code is the optimal code? I don't think so.

Answer 11

To actually answer your question: "Is there any possible way to [...] optimize the solution? Like bitwise tricks?"

for (int i=1;i<=100;i++) {
    int a=((528>>i%15-1)&1)<<2;
    int b=((-2128340926>>(i%15)*2)&3)<<2;
    System.out.println("FizzBuzz".substring(a,b)+(a==b?i:""));
}