The fizz buzz coding challenge

[Bert Bates]

More or less "borrowed" from a discussion over at codinghorror...

Your job is to write a small program that prints the numbers from 1 to 100, except:

- when the number is divisible by 3, print "fizz" instead of the number
- when the number is divisible by 5, print "buzz" instead of the number
- when the number is divisible by BOTH 3 and 5 print "fizzbuzz" instead of the number.

That was the original challenge...

The JavaRanch addition is to write the program in such a way that it:

- implements the above
- is meaningfully different than all previous entries
- can somehow be defended as a "good" way to go

[Ernest Friedman-Hill]

I'll start off. Mine is not the most obvious solution; it's designed to be easy to generalize. You can easily add any number of new checks that follow the same sort of simple rules, and some simple extensions. I thought about making it even more generalized by providing a sort of priority system, so a particular IChecker can insist on being the only one to run for a certain value, for example. That would complicate things too much, though, and this is already a lot longer than the program needs to be. But I think this strikes a nice balance between "Just the facts, ma'am" and the gold-plated Rube Goldberg treatment. It's a good jumping-off point for many other possible extensions, especially the kind that would lead to the values and patterns being specified as data rather than hard-coded.

package com.javaranch.fb;

import java.util.List;
import java.util.ArrayList;

interface IChecker { boolean check(int n); }

class ConstantChecker implements IChecker {
    private int k;
    private String msg;
    ConstantChecker(int k, String msg) { this.k = k; this.msg = msg; }
    public boolean check(int n) {
        boolean nDivisibleByK = (n % k == 0);
        if (nDivisibleByK) System.out.print(msg);
        return nDivisibleByK;
    }
}    
    
public class FizzBuzz {
    public static void main(String[] argv) {
        List<IChecker> checkers = new ArrayList<IChecker>();
        checkers.add(new ConstantChecker(3, "fizz"));
        checkers.add(new ConstantChecker(5, "buzz"));

        for (int n=1; n<=100; ++n) {
            boolean printedSomething = false;
            for (IChecker checker: checkers) 
                printedSomething |= checker.check(n);            
            if (!printedSomething)
                System.out.print(n);
            System.out.println();
        }
    }
}

[Andrew Monkhouse]

seq 1 100 | awk '{printf("%s\n", ($1 % 5 || $1 % 3) ? ($1 % 5) ? ($1 %3) ? $1 : "buzz" : "fizz" : "fizzbuzz");}'

Bert Bates wrote:- implements the above
- is meaningfully different than all previous entries
- can somehow be defended as a "good" way to go

- Yes, it implements your requirements
- It is meaningfully different from EFH's Java solution
- I define it as good because I understand it, but if someone were to try to use this, they would have to understand and explain why it works, (at which point they might as well write their own code (which will be easier to read / maintain / explain)).

[Bert Bates]

this is starting off WAY better than I thought it would

[Mike Simmons]

Seems like the "can somehow be defended as good" has the most wiggle room for us all. Here's my version, written after seeing the other two:

public class FizzBuzz {
  public static void main(String[] args) {
    for (int i = 1; i <= 100; i++) {
      boolean divisibleBy3 = i % 3 == 0;
      boolean divisibleBy5 = i % 5 == 0;
      String output 
          = divisibleBy3 && divisibleBy5 ? "fizzbuzz" 
          : divisibleBy3 ? "fizz" 
          : divisibleBy5 ? "buzz" 
          : String.valueOf(i);
      System.out.println(output);
    }
  }
}

Ways in which it's good, IMO:
(a) It's written in the standard language of these fora, and thus likely to be readable to everyone.
(b) It avoids overdesign. I like EFH's approach, but it also makes assumptions about what sorts of future changes should be designed for. What if there's a new rule that says if a number is divisible by 7, we should output "bang" and the number? We don't really know what future requirements may hold, so this just sticks to what we know now.
(c) It's pretty short while being fairly clear.
(d) It uses an uncommon style for ternary operators that I feel should be more widely known.

Yes, I'm aware (d) may seem to conflict with (a) and (c) for some people. But I don't care.

[Mike Simmons]

Alternate performance-uber-alles version:

public class FizzBuzz {
  public static void main(String[] args) {
    for (int i = 1; i <= 100; i++) {
      switch (i % 15) {
        case 0:
          System.out.println("fizzbuzz");
          break;
        case 3: case 6: case 9: case 12:
          System.out.println("fizz");
          break;
        case 5: case 10:
          System.out.println("buzz");
          break;
        default:
          System.out.println(i);
      }
    }
  }
}

Of course the performance of all the computation is irrelevant next to the performance of System.out, but oh well.

If we need to start adding more conditions, and if they fit the pattern EFH assumes, then I'd jump to his solution in a heartbeat. But for now, I don't see the need.

[Mike Simmons]

Short and easily maintainable, with complexity scaling just as well as EFH's code I think (assuming new requirements fit the same pattern he assumes):

public class FizzBuzz {
  public static void main(String[] args) {
    for (int i = 1; i <= 100; i++) {
      StringBuilder sb = new StringBuilder();
      if (i % 3 == 0) sb.append("fizz");
      if (i % 5 == 0) sb.append("buzz");
      if (sb.length() == 0) sb.append(i);
      System.out.println(sb);
    }
  }
}

[Ernest Friedman-Hill]

Mike Simmons wrote:Alternate performance-uber-alles version:

    for (int i = 1; i <= 100; i++) {

Personal extremely picky pet peeve: "i++" is traditional here, and everybody uses it without a thought. But "++i" is simpler at the opcode level and requires no more typing. I realize any optimizer worth two cents will make the difference irrelevant but still, it irks me.

[Andrew Monkhouse]

Mike Simmons wrote:Alternate performance-uber-alles version:
<snip>
Of course the performance of all the computation is irrelevant next to the performance of System.out, but oh well.

If performance is the main consideration, then this can be improved upon by having only a single call to System.out (yes, this does improve speed, although I don't think it is a guaranteed improvement in all OSes):

public class FizzBuzz2 {
  public static void main(String[] args) {
    StringBuilder output = new StringBuilder(100 * "fizzbuzz".length());
    String LF = System.getProperty("line.separator");
    for (int i = 1; i <= 100; i++) {
      switch (i % 15) {
        case 0:
          output.append("fizzbuzz");
          break;
        case 3: case 6: case 9: case 12:
          output.append("fizz");
          break;
        case 5: case 10:
          output.append("buzz");
          break;
        default:
          output.append(i);
      }
      output.append(LF);
    }
    System.out.print(output);
  }
}

Perhaps still not optimal - I could precompute the optimal size of the StringBuilder backing store, but that is unlikely to make a big change.

[Maneesh Godbole]

Mike Simmons wrote:(d) It uses an uncommon style for ternary operators that I feel should be more widely known.

Oh Wow! I didn't even know this was possible. Thanks Mike.

One small question, to help me understand this better.
How does this even work? I mean its 4 clauses right? For ternary?

[Mike Simmons]

Ernest Friedman-Hill wrote:Personal extremely picky pet peeve: "i++" is traditional here, and everybody uses it without a thought. But "++i" is simpler at the opcode level and requires no more typing. I realize any optimizer worth two cents will make the difference irrelevant but still, it irks me.

Hmmm, both versions compile to exactly the same bytecode for me. Which is consistent with what you said about "any optimizer worth its salt" - I just thought it worth noting that this one is optimized by javac, not the JIT.

javac 1.6.0_24 on a MacBook Pro, for what it's worth.

But hey, irking EFH is another nice bonus.

[Mike Simmons]

Andrew: interesting point about the single print statement. Though if there's enough output, it may be better to print as you go, rather than saving it all up for the end. Perhaps a BufferedOutputStream or BufferedWriter could be worked into the mix, instead of the StringBuilder.

[Mike Simmons]

Maneesh: this section

      String output   
          = divisibleBy3 && divisibleBy5 ? "fizzbuzz"   
          : divisibleBy3 ? "fizz"   
          : divisibleBy5 ? "buzz"   
          : String.valueOf(i);  

can be viewed as

      String output = (d3 && d5) ? "fizzbuzz" 
                                 : (d3 ? "fizz" 
                                       : (d5 ? "buzz" : String.valueOf(i))
                                   );

(I replaced "divisibleBy" with "d" to shorten the lines so we could see the structure more clearly.)

[Andrew Monkhouse]

Mike Simmons wrote:Andrew: interesting point about the single print statement. Though if there's enough output, it may be better to print as you go, rather than saving it all up for the end. Perhaps a BufferedOutputStream or BufferedWriter could be worked into the mix, instead of the StringBuilder.

Good point, but I'll leave that version to the reader to try out.

Maneesh Godbole wrote:I mean its 4 clauses right? For ternary?

Yeah, that's for very large values of two (alternatives).

That's very similar (but more readable) to what I did in my code, where I had all the false statements one after the other ("buzz" : "fizz" : "fizzbuzz").

[Maneesh Godbole]

@Mike
Ah! The brackets make it clearer now. Thanks.

[Stephan van Hulst]

Andrew Monkhouse wrote:Yeah, that's for very large values of two (alternatives). .

When we get quantum computers I envision a data type 'qubool' that will allow a ternary operator with any number of clauses ;)

[David O'Meara]

I felt that lack of support for numbers greater than 2^63-1 was a concern

private static String response(BigInteger num)
{
	StringBuilder sb = new StringBuilder();
	String num3 = num.toString(3);
	if('0'==num3.charAt(num3.length()-1))
	{
		sb.append("fizz");
	}
	String num5 = num.toString(5);
	if('0'==num5.charAt(num5.length()-1))
	{
		sb.append("buzz");
	}
	if(sb.length()==0)
	{
		sb.append(num.toString(10));
	}
	return  sb.toString();
}

[David O'Meara]

I'd also like to write one that was bitwise, and while I know that a number is divisible by 3 if the sum of the modulus bits are divisible by three I can't think of a similar pattern to use for 'divisible by 5'

[Jesper de Jong]

Try to make sense of this one. (Scala with pattern matching).

sealed trait Result
case class Number(x: Int) extends Result
case class Fizz(x: Int) extends Result
case class Buzz(x: Int) extends Result
case class FizzBuzz(x: Int) extends Result

object FizzBuzzChallenge {
  def main(args: Array[String]) {
    def fizz(r: Result) = r match {
      case Number(x) if (x % 3 == 0) => Fizz(x)
      case Buzz(x) if (x % 3 == 0) => FizzBuzz(x)
      case _ => r
    }

    def buzz(r: Result) = r match {
      case Number(x) if (x % 5 == 0) => Buzz(x)
      case Fizz(x) if (x % 5 == 0) => FizzBuzz(x)
      case _ => r
    }

    def toString(r: Result) = r match {
      case Fizz(_) => "fizz"
      case Buzz(_) => "buzz"
      case FizzBuzz(_) => "fizzbuzz"
      case Number(x) => x.toString
    }

    (1 to 100) map { Number(_) } map fizz map buzz map toString foreach println
  }
}

[fred rosenberger]

I apologize for the length, but here is my fizzbuffy.pl script. Go ahead and run it with "perl fizzbuffy.pl", or whatever you name it as.
edit - i forgot to defend why it's "a good way to go"...Because it's a picture of BUFFY!!!

                   ''=~('('.'?'
                .'{'.('`'|"\%").(
              '['^'-').('`'|'!').(
             '`'               | ','
            ).+                (  '"'
           ).+                 (   '#'
          ).+                  (   '!'
         ).+                  (     '/'
        ).(              ('[')^      '.'
        ).(          '['^      (     '('
       )).       ('['           ^     ')'
       ).+     ((                (     '/'
       )))    .                   (    '`'
       |((   (                     ','))))
      .+(    (                      ( (  (
      (   '`') ))))|+      '/').(     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '`')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       |   (        (     ((
      '#'      )        )          )    )).
       ('`'|'!')                   .(('`')|
       ',').'/'.    ('`'|'"')     .(('`')|
       ')').('`'|     '.').     ( ('/')).(
       '['^('+')).(            (  ('`'))|
       '%').('['^')'          )   .("\`"|
       ',').('!'^'+' )      .     (('!')^
       '+').'#'.('{'     ^        '[').( (
       '`')|"\#").(              '`'|'/'   )
       .('['^'+').(              '['^'"'     )
        .('['^',').             ('['^')'     ).('`'|
        ')').("\["^             "\/").(      (      ('`'))|
  '%').('{'^'[').(            ( '^')^(       (             (
 (    ( ('`')))))| (        (   ','))        )              )
.     ( '^'^("\`"|   (   (     '.'))         )              )
.     ('^'^("\`"|       (     '/')           )              )
.    ('^'^("\`"|        (                    (               (
(     '/')))))          )                    .               (
(     ( ',')                                 )               )
.     (                                      (               (
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '{')))))))))))))))))))))))))))^'[').('`'    |           (
(    '&'))).('`'|'"').('['^')').('!'^'+').'#'.('{'            ^
(    '[')).('['^',').('['^')').('`'|')').('['^'/').           (
(   '[')^'/').('`'|'%').('`'|'.').('{'^'[').('`'|'"'          )
.   ('['^'"').('{'^'[').('`'|'&').('['^')').('`'|'%')         .
                   ('`'|"\$").(
                '{'^'[').('['^')'
              ).('`'|'/').('['^'('
             ).(               ( '`'
            )|+                (  '%'
           )).                 (   '`'
          |((                  (   '.'
         )))                  )     .+(
        '`'              |'"').      (((
        '`'          ))|+      (     '%'
       )).       ('['           ^     ')'
       ).(     ((                (     '`'
       )))    |                   (    "'"
       )).   (                     '`'|'%'
      ).(    (                      ( (  (
      (   '[') ))))^+      ')').(     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '!')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       ^   (        (     ((
      '+'      )        )          )    )).
       '#'.('{'^                   ('[')).(
       '`'|')').    ('`'|'.')     .(('[')^
       '/').('`'|     ')').     ( '`'|'!')
       .('`'|',').(            (  ('{'))^
       '[').('['^')'          )   .("\`"|
       '%').('['^'-' )      .     (('`')|
       ')').('['^'('     )        .('`'| (
       ')')).("\`"|              "\/").(   (
       '`')|"\.").(              '{'^'['     )
        .('`'^'!').             ('['^'+'     ).('['^
        ')').("\{"^             "\[").(      (      "\^")^(
  '`'|',')).('^'^(            ( "\`")|       (             (
 (    ( '.')))))). (        (   '^')^        (              (
(     ( '`')))|'/'   )   )     .('^'         ^              (
(     '`')|'/')).       (     '!'^           (              (
(    ('+'))))).(        (                    (               (
(     '!'))))^          (                    (               (
(     ( '+')                                 )               )
)     )                                      )               .
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '#'))))))))))))))))))))))))).('{'^'[').(    (           (
(    '`')))|'&').('`'|')').('['^'!').('['^('!')).(            (
(    '{'))^'[').('`'|'"').('['^'.').('['^'!').('['^           (
(   '!'))).('{'^'[').('['^'(').('`'|'#').('['^')').(          (
(   '`'))|')').('['^'+').('['^'/').('!'^'+').('!'^'+'         )
                   .('['^'.').(
                '['^'(').('`'|'%'
              ).('{'^'[').('['^','
             ).(               ( '`'
            )|+                (  '!'
           )).                 (   '['
          ^((                  (   ')'
         )))                  )     .+(
        '`'              |'.').      (((
        '`'          ))|+      (     ')'
       )).       ('`'           |     '.'
       ).(     ((                (     '`'
       )))    |                   (    "'"
       )).   (                     '['^'('
      ).+    (                      ( (  (
      (   ';') )))).(      ('!')^     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '+')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       )   .        (     ((
      '!'      )        )          ^    '+'
       ).(('`')|                   ('&')).(
       '`'|'/').    ('['^')')     .(('{')^
       '[')."\(".     '\\'.     ( ('$')).(
       '`'|(')')).(            (  ('{'))^
       '[').'='.('{'          ^   "\[").(
       '^'^('`'|'/') )      .     (';').(
       '{'^'[').'\\'     .        "\$".( (
       '`')|"\)").(              '{'^'['   )
       .'<'.('=').(              '{'^'['     )
        .('^'^('`'|             "\/")).(     ('^')^(
        '`'|'.')).(             ('^')^(      (      ('`'))|
  '.')).';'.("\{"^            ( '[')).       (             (
 (    ( '\\')))).+ (        (   '$'))        .              (
(     ( '`'))|')')   .   (     '+').         (              (
(     '+'))).')'.       (     '!'^           (              (
(    '+')))).''.        (                    (               (
(     '\\'))))          .                    (               (
(     ( '{')                                 )               )
)     .                                      (               (
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '!'))))))))))))))))))))))))))^'+').('{'^    (           (
(    '[')))).('{'^'[').('{'^'[').('{'^'[').('\\').            (
(    '$')).('['^'+').('['^')').('`'|')').('`'|'.').           (
(   '[')^'/').('`'|'.').('['^'.').('`'|'-').('{'^'['          )
.   '='.('{'^'[').('^'^('`'|'/')).';'.('!'^'+').('{'^         (
                   '[')).("\{"^
                '[').('{'^"\[").(
              '{'^'[').('`'|')').(
             '`'               | '&'
            ).(                (  '{'
           )^+                 (   '['
          )).                  (   '('
         ).+                  (     (((
        (((              '\\'))      )))
        )).          '$'.      (     '`'
       |((       ')')           )     ).(
       '{'     ^+                (     '['
       )).    (                   (    '%'
       )).   (                     '{'^'['
      ).(    (                      ( (  (
      (   '^') ))))^(      ('`')|     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '-')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       )   )        .     +(
      '{'      ^        (          (    '['
       )))."\=".                   '='.('{'
       ^('[')).(    '^'^('`'|     ('.'))).
       ')'.("\!"^     '+').     ( '{'^'[')
       .('{'^'[').(            (  ('{'))^
       '[').('{'^'['          )   .'\\'.+
       '{'.('!'^'+') .      (     '{'^'['
       ).('{'^'[').(     (        "\{")^ (
       '[')).("\{"^              "\[").(   (
       '{')^"\[").(              '{'^'['     )
        .('{'^'[').             ('['^'+'     ).('['^
        ')').("\`"|             "\)").(      (      ('`'))|
  '.').('['^'/').(            ( "\{")^       (             (
 (    ( "\["))))). (        (   '\\')        )              .
(     ( '"')).('`'   ^   (     '&'))         .              (
(     '`')|')').(       (     '[')           ^              (
(    '!'))).('['        ^                    (               (
(     '!')))).          (                    (               (
(     ( '\\'                                 )               )
)     )                                      )               .
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '"'))))))))))))))))))))))))).';'.(('!')^    (           (
(    '+')))).('{'^'[').('{'^'[').('{'^'[').(('{')^            (
(    '['))).('{'^'[').('{'^'[').('{'^'[').'\\'.'$'.           (
(   '[')^'+').('['^')').('`'|')').('`'|'.').('['^'/'          )
.   ('`'|'.').('['^'.').('`'|'-').('{'^'[').'='.('{'^         (
                   '[')).('^'^(
                '`'|'.')).(';').(
              '!'^'+').('{'^'[').(
             '{'               ^ '['
            ).(                (  '{'
           )^+                 (   '['
          )).                  (   '{'
         ^((                  (     '['
        )))              ).'\\'      .((
        '}'          )).(      (     '!'
       )^+       '+')           .     (((
       '{'     ))                ^     '['
       ).(    (                   (    '{'
       ))^   (                     '[')).(
      '{'    ^                      ( (  (
      (   '[') )))).(      ('{')^     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '[')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       )   .        (     ((
      '`'      )        )          |    ')'
       ).(('`')|                   ('&')).(
       '{'^'[').    '('.'\\'.     '$'.('`'
       |')').('{'     ^'[')     . '%'.('{'
       ^'[').('^'^(            (  ('`'))|
       '+')).(('{')^          (   "\[")).
       '='.'='.('{'^ (      (     '['))).
       ('^'^('`'|'.'     )        ).')'. (
       '!'^('+')).(              '{'^'['   )
       .('{'^'[').(              '{'^'['     )
        .('{'^'[').             '\\'.'{'     .("\!"^
        '+').("\{"^             "\[").(      (      ('{'))^
  '[').('{'^'[').(            ( "\{")^       (             (
 (    ( '['))))).( (        (   '{'))        ^              (
(     ( "\[")))).(   (   (     '{'))         ^              (
(     '['))).('{'       ^     '[')           .              (
(    '[')^'+').(        (                    (               (
(     '['))))^          (                    (               (
(     ( ')')                                 )               )
)     )                                      )               .
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '`'))))))))))))))))))))))))|')').(('`')|    (           (
(    '.')))).('['^'/').('{'^'[').'\\'.'"'.('`'^'"'            )
.    ('['^'.').('`'|'&').('`'|'&').('['^"\"").'\\'.           (
(   '"')).';'.('!'^'+').('{'^'[').('{'^'[').('{'^'['          )
.   ('{'^'[').('{'^'[').('{'^'[').('{'^'[').'\\'.'$'.         (
                   '['^('+')).(
                '['^')').('`'|')'
              ).('`'|'.').('['^'/'
             ).(               ( '`'
            )|+                (  '.'
           )).                 (   '['
          ^((                  (   '.'
         )))                  )     .+(
        '`'              |'-').      (((
        '{'          ))^+      (     '['
       )).       '='.           (     '{'
       ^((     ((                (     '['
       )))    )                   )    ).(
       '^'   ^                     (('`')|
      '.'    )                      ) .  (
      (   ';') ).('!'      ^'+').     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '{')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      ^       (   (        (     ((
      '['      )        )          )    )))
       .('{'^'['                   ).("\{"^
       '[').('{'    ^'[').''.     '\\'.'}'
       .('!'^'+')     .('{'     ^ ('[')).(
       '{'^('[')).(            (  ('{'))^
       '[').('{'^'['          )   .("\`"|
       ')').('`'|'&' )      .     (('{')^
       '[').'('.'\\'     .        "\$".( (
       '[')^"\+").(              '['^')'   )
       .('`'|')').(              '`'|'.'     )
        .('['^'/').             ('`'|'.'     ).('['^
        '.').("\`"|             "\-").(      (      ('{'))^
  '[').'!'.('=').(            ( "\{")^       (             (
 (    ( '['))))).( (        (   '^'))        ^              (
(     ( '`'))|'.')   )   .     ')'.(         (              (
(     '!')))^'+')       .     ('{'           ^              (
(    '['))).('{'        ^                    (               (
(     '[')))).          (                    (               (
(     ( '{')                                 )               )
)     ^                                      (               (
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     '[')))))))))))))))))))))))))))).('{'^'['    )           .
(    '\\').'{'.('!'^'+').('{'^'[').('{'^'[').('{'^            (
(    '['))).('{'^'[').('{'^'[').('{'^'[').('{'^'[')           .
(   '['^'+').('['^')').('`'|')').('`'|'.').('['^'/')          .
(   '{'^'[').'\\'.'"'.'\\'.'$'.('`'|')').'\\'.'"'.';'         .
                   ('!'^"\+").(
                '{'^'[').('{'^'['
              ).('{'^'[').('{'^'['
             ).+               ( (((
            (((                (  (((
           (((                 (   (((
          (((                  (   (((
         (((                  (     (((
        (((              '\\'))      )))
        )))          ))))      )     )))
       )))       ))))           )     )))
       )))     ))                )     )).
       '}'    .                   (    '!'
       ^((   (                     '+'))))
      .+(    (                      ( (  (
      (   '{') ))))^+      '[').(     (  (
      (  (  ((                        (  (
      (  (      ( (( (     ( (( (     (   (
      (  (       '{')       ))))      )   )
      )   )                        )))    )
      )    )))                     )      )
      ))      )       ^   (        (     ((
      '['      )        )          )    )).
       ('{'^'[')                   .(('{')^
       '[').('['    ^('+')).(     '['^')')
       .('`'|')')     .('`'     | ('.')).(
       '['^('/')).(            (  ('{'))^
       '[').'\\'.'"'          .   ('\\').
       '\\'.('`'|'.' )      .     ('\\').
       '"'.';'.('!'^     (        '+')). (
       '\\').('}').              '"'.'}'   .
       ')');$:='.'^              '~';$~=     (
        '@')|'(';$^             =')'^'['     ;$/='`'
        |'.';$,='('             ^'}';$\      =      '`'|'!'
  ;$:=')'^"\}";$~=            ( "\*")|       (             (
 (    ( '`'))));$^ =        (   '+')^        (              (
(     ( '_'))));$/   =   (     '&')|         (              (
(     "\@")));$,=       (     '[')           &              (
(    ('~')));$\=        (                    (               (
(     ','))))^          (                    (               (
(     ( '|')                                 )               )
)     )                                      ;               (
(     (                                      (               (
(     (                                      (      (         (
(     (                                      (      (         (
(     (                                      (     (          (
(     (                                      (     (          (
(     $:))))))))))))))))))))))))))='.'^'~';$~=    (           (
(    '@')))|'(';$^=')'^'[';$/='`'|'.';$,='('^"\}";            (
(    $\))='`'|'!';$:=')'^'}';$~='*'|'`';$^='+'^'_';           (
(   $/))='&'|'@';$,='['&'~';$\=','^'|';$:='.'^'~';$~          =
(   '@')|'(';$^=')'^'[';$/='`'|'.';$,='('^'}';#;#;#;#         ;

[Jesper de Jong]

So the complexity of FizzBuzz in Perl is 7 Buffy's?

Here's a different approach in Scala, in a more functional style. What's better about this one compared to my previous version is that this one is easier to extend if you'd want to check for more numbers.

object FizzBuzzChallenge2 {
  def main(args: Array[String]) {
    def f(n: Int, s: String)(x: Int): Option[String] = if (x % n == 0) Some(s) else None
    def g(fs: (Int => Option[String])*)(x: Int) = fs flatMap { _(x) }

    val fizz = f(3, "fizz") _
    val buzz = f(5, "buzz") _

    val check = g(fizz, buzz) _

    def h(x: Int) = {
      val a = check(x)
      if (a.isEmpty) x.toString else ("" /: a)(_ + _)
    }

    (1 to 100) map h foreach println
  }
}

Suppose that we'd also want to add "bang" when the number is divisible by 7, then in this version I'd just add / change:

    val fizz = f(3, "fizz") _
    val buzz = f(5, "buzz") _
    val bang = f(7, "bang") _

    val check = g(fizz, buzz, bang) _

In my previous version, I'd have to add more case classes with all combinations of fizz, buzz and bang and expand the cases in all the mapping methods.

(Looks like the code formatter is making some underscores invisible...).

[marc weber]

Introducing FizzBuzz100!

Preloaded (non-dynamic) logic mitigates the risk of unexpected output, while ensuring the source code is easy to read and maintain*.

/* FizzBuzz100, v9.7.3b, copyright 2011 by mw, et al. All rights reserved.
User assumes all risk of injury.
Place in bucket of coarse gravel when not in use. */

class FizzBuzz100 {
	public static void main(String[] args) {
		System.out.println(1);
		System.out.println(2);
		System.out.println("fizz");
		System.out.println(4);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(7);
		System.out.println(8);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(11);
		System.out.println("fizz");
		System.out.println(13);
		System.out.println(14);
		System.out.println("fizzbuzz");
		System.out.println(16);
		System.out.println(17);
		System.out.println("fizz");
		System.out.println(19);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(22);
		System.out.println(23);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(26);
		System.out.println("fizz");
		System.out.println(28);
		System.out.println(29);
		System.out.println("fizzbuzz");
		System.out.println(31);
		System.out.println(32);
		System.out.println("fizz");
		System.out.println(34);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(37);
		System.out.println(38);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(41);
		System.out.println("fizz");
		System.out.println(43);
		System.out.println(44);
		System.out.println("fizzbuzz");
		System.out.println(46);
		System.out.println(47);
		System.out.println("fizz");
		System.out.println(49);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(52);
		System.out.println(53);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(56);
		System.out.println("fizz");
		System.out.println(58);
		System.out.println(59);
		System.out.println("fizzbuzz");
		System.out.println(61);
		System.out.println(62);
		System.out.println("fizz");
		System.out.println(64);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(67);
		System.out.println(68);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(71);
		System.out.println("fizz");
		System.out.println(73);
		System.out.println(74);
		System.out.println("fizzbuzz");
		System.out.println(76);
		System.out.println(77);
		System.out.println("fizz");
		System.out.println(79);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(82);
		System.out.println(83);
		System.out.println("fizz");
		System.out.println("buzz");
		System.out.println(86);
		System.out.println("fizz");
		System.out.println(88);
		System.out.println(89);
		System.out.println("fizzbuzz");
		System.out.println(91);
		System.out.println(92);
		System.out.println("fizz");
		System.out.println(94);
		System.out.println("buzz");
		System.out.println("fizz");
		System.out.println(97);
		System.out.println(98);
		System.out.println("fizz");
		System.out.println("buzz");
	}
}

Also available:

FizzBuzz5

FizzBuzz25

FizzBuzz60 (coming fall 2012)

* Within certain undefined parameters.

[David O'Meara]

Solved!

[Bert Bates]

Here's a prototype of a different slant on the "FizzBuzz100". Remember it's just a prototype, but I feel that it could be expanded to solve the entire problem. Yes, yes, it does throw an exception, but after all, it's just a prototype!

As with the FizzBuzz100, it features "Preloaded (non-dynamic) logic", but the source code is also a bit more compact.

public class Fizzer {
  static {
    String[] s = { "1", "2", "fizz", "4", "buzz", 
                   "fizz", "7", "8", "fizz", "buzz",
                   "11", "fizz", "13", "14", "fizzbuzz" };
    for(String s2: s)
      System.out.print(s2 + " ");
  }
}

[Hauke Ingmar Schmidt]

You all are just hacking. No one did specify the process, wrote requirement documents, tells about the team's responsibility structure, there are no unit tests, your solutions don't show any layering, I can't find user stories, no explanation of the build process, I don't see any UML diagrams, no specifications of library dependencies (you don't write Java without supporting frameworks in 2011, do you??), no deployment manual...

[Andrew Monkhouse]

A friend of mine who is heavily into Python suggested the following:

#!/usr/bin/env python

print " ".join([ "fizzbuzz" if (not i%3 and not i%5) else "fizz" if not i%3 else "buzz" if not i%5 else `i` for i in range(1,101) ])

[David O'Meara]

Continuing the pre-cached theme

FizzBuzz2.java

import java.util.HashMap;
import java.util.Map;

public class FizzBuzz2
{

	private static final Map<Integer, String> fb = new HashMap<Integer, String>()
	{{
		put(Integer.valueOf(3), "fizz");
		put(Integer.valueOf(5), "buzz");
		put(Integer.valueOf(6), "fizz");
		put(Integer.valueOf(9), "fizz");
		put(Integer.valueOf(10), "buzz");
		put(Integer.valueOf(12), "fizz");
		put(Integer.valueOf(15), "fizzbuzz");
		put(Integer.valueOf(18), "fizz");
		put(Integer.valueOf(20), "buzz");
		put(Integer.valueOf(21), "fizz");
		put(Integer.valueOf(24), "fizz");
		put(Integer.valueOf(25), "buzz");
		put(Integer.valueOf(27), "fizz");
		put(Integer.valueOf(30), "fizzbuzz");
		put(Integer.valueOf(33), "fizz");
		put(Integer.valueOf(35), "buzz");
		put(Integer.valueOf(36), "fizz");
		put(Integer.valueOf(42), "fizz");
		put(Integer.valueOf(45), "fizzbuzz");
		put(Integer.valueOf(48), "fizz");
		put(Integer.valueOf(50), "buzz");
		put(Integer.valueOf(51), "fizz");
		put(Integer.valueOf(54), "fizz");
		put(Integer.valueOf(55), "buzz");
		put(Integer.valueOf(57), "fizz");
		put(Integer.valueOf(60), "fizzbuzz");
		put(Integer.valueOf(63), "fizz");
		put(Integer.valueOf(65), "buzz");
		put(Integer.valueOf(66), "fizz");
		put(Integer.valueOf(69), "fizz");
		put(Integer.valueOf(70), "buzz");
		put(Integer.valueOf(72), "fizz");
		put(Integer.valueOf(75), "fizzbuzz");
		put(Integer.valueOf(78), "fizz");
		put(Integer.valueOf(80), "buzz");
		put(Integer.valueOf(81), "fizz");
		put(Integer.valueOf(84), "fizz");
		put(Integer.valueOf(85), "buzz");
		put(Integer.valueOf(87), "fizz");
		put(Integer.valueOf(90), "fizzbuzz");
		put(Integer.valueOf(93), "fizz");
		put(Integer.valueOf(95), "buzz");
		put(Integer.valueOf(96), "fizz");
		put(Integer.valueOf(99), "fizz");
	}};
	
	public static void main(String[] args)
	{
		for(int i=1;i<=100;i++)
		{
			if(fb.keySet().contains(i))
			{
				System.out.print(fb.get(i));
			}
			else
			{
				System.out.print(String.valueOf(i));
			}
			System.out.print(" ");
			}
	}
}

FizzBuzz3.java

import java.util.HashSet;
import java.util.Set;

public class FizzBuzz3
{

	private static final Set<Integer> fizzSet = new HashSet<Integer>()
	{{
		add(3);
		add(6);
		add(9);
		add(12);
		add(15);
		add(18);
		add(21);
		add(24);
		add(27);
		add(30);
		add(33);
		add(36);
		add(42);
		add(45);
		add(48);
		add(51);
		add(54);
		add(57);
		add(60);
		add(63);
		add(66);
		add(69);
		add(72);
		add(75);
		add(78);
		add(81);
		add(84);
		add(87);
		add(90);
		add(93);
		add(96);
		add(99);
	}};
	private static final Set<Integer> buzzSet = new HashSet<Integer>()
	{{
		add(5);
		add(10);
		add(15);
		add(20);
		add(25);
		add(30);
		add(35);
		add(40);
		add(45);
		add(50);
		add(55);
		add(60);
		add(65);
		add(70);
		add(75);
		add(80);
		add(85);
		add(90);
		add(95);
		add(100);
	}};

	public static void main(String[] args)
	{
		for (int i = 1; i <= 100; i++)
		{
			if (fizzSet.contains(i) || buzzSet.contains(i))
			{
				if (fizzSet.contains(i))
				{
					System.out.print("fizz");
				}
				if (buzzSet.contains(i))
				{
					System.out.print("buzz");
				}
			} else
			{
				System.out.print(String.valueOf(i));
			}
			System.out.print(" ");
		}
	}
}

I consider double braces to be a hack and usually avoid them, but they suffice. An immutable Map/Set would be preferred.
Both rely on the hash efficiency of java.lang.Integer and avoid storing non fizz/buzz values.
The second form could be expanded using a Map<Integer, Set><Integer>> to abstract the 3=fizz, 5=buzz and allow other (eg 7=razz) values

[Darryl Burke]

I believe regex should be given a chance ;) So this is different on two counts: use of regex, and leveraging the loop increment instead of using the modulo operator. It's also easily scalable by adding entries to the Map.

import java.util.*;

public class FizzBuzz {

  private final static int min = 1;
  private final static int max = 100;

  public static void main(String[] args) {
    Map<Integer, String> map = new LinkedHashMap<Integer, String>();
    map.put(3, "fizz");
    map.put(5, "buzz");

    List<String> list = new ArrayList<String>();
    for (int i = min; i <= max; i++) {
      list.add("" + i);
    }

    for (Integer key : map.keySet()) {
      setStrings(list, key, map.get(key));
    }

    System.out.println(list);
  }

  private static void setStrings(List<String> list, int n, String str) {
    for (int i = min + n - 1; i <= list.size(); i += n) {
      list.set(i - 1, list.get(i - 1).replaceAll("\\d+", "") + str);
    }
  }
}

[Hauke Ingmar Schmidt]

My percent key is broken and °/. doesn't work so one without modulo.

public class FizzBuzz {
	public static void main(final String[] args) {
		int fizzCounter = 3;
		int buzzCounter = 5;
		StringBuilder sb = new StringBuilder();
		for (int i = 1; i <= 100; i++) {
			fizzCounter--;
			buzzCounter--;
			if (fizzCounter == 0) {
				sb.append("fizz");
			}
			if (buzzCounter == 0) {
				sb.append("buzz");
			}
			if (sb.length() == 0) {
				sb.append(i);
			}
			System.out.println(sb.toString());
			sb.setLength(0);
			if (fizzCounter == 0) {
				fizzCounter = 3;
			}
			if (buzzCounter == 0) {
				buzzCounter = 5;
			}
		}
	}
}

[Matthew Brown]

This was my attempt, written before looking at the others. It's similar to Ernest's approach, in that it's (over)designed for extensibility. Obviously, the rules are going to change at some point, aren't they? In fact, why assume that it will always be factors that are the important point? So there's a general interface that just defines how to produce output for a number, and a concrete implementation class that can take an (ordered) set of factors to test.
The class that runs the game then has an instance of the interface injected into it by the main method.

I was tempted to genericise the interface, to avoid assuming that the input are always numbers and the output are always strings...but that's just silly .

package fizzbuzz;

import java.io.PrintStream;
import java.util.LinkedHashMap;
import java.util.Map;

interface NumberAnalyser {
    public String analyse(int i);
}

class MultipleFactorNumberAnalyser implements NumberAnalyser {
    private Map<Integer, String> factorStrings = new LinkedHashMap<Integer, String>();
    
    public void addFactor(int factor, String str) {
        factorStrings.put(factor, str);
    }
    
    @Override
    public String analyse(int i) {
        StringBuilder sb = new StringBuilder();
        for(Map.Entry<Integer, String> entry : factorStrings.entrySet()) {
            if (i % entry.getKey() == 0) {
                sb.append(entry.getValue());
            }
        }
        if (sb.length() == 0) {
            sb.append(Integer.toString(i));
        }
        return sb.toString();
    }
}

class CountingGame  {
    private NumberAnalyser numberAnalyser;
    private int maxCount;
    
    public CountingGame(NumberAnalyser numberAnalyser, int maxCount) {
        this.numberAnalyser = numberAnalyser;
        this.maxCount = maxCount;
    }
    
    public void runGame(PrintStream output) {
        for(int i = 1; i <= maxCount; ++i) {
            output.println(numberAnalyser.analyse(i));
        }
    }
}

public class FizzBuzz {
    public static void main(String[] args) {
        MultipleFactorNumberAnalyser analyser = new MultipleFactorNumberAnalyser();
        analyser.addFactor(3, "fizz");
        analyser.addFactor(5, "buzz");
        CountingGame game = new CountingGame(analyser, 100);
        game.runGame(System.out);
    }
}

(All put in one file for convenience...wouldn't be in real life)

[Bert Bates]

bump

It's been almost a year... any new approaches bubbled up?

[Ernest Friedman-Hill]

Well, as you say, it's been over a year, we've had time. I can now do a one-liner:

macduff:~ ejfried$ cat ~/etc/fizzbuzz

[Jesper de Jong]

Scala, using partial functions.

// FizzBuzz in Scala with partial functions
val fizz: PartialFunction[Int, String] = { case x if x % 3 == 0 => "Fizz" }
val buzz: PartialFunction[Int, String] = { case x if x % 5 == 0 => "Buzz" }

val ops = Seq(fizz, buzz)

1 to 100 map { x => (ops collect { case pf if pf isDefinedAt x => pf(x) }).reduceLeftOption(_ + _) getOrElse x.toString }

[Jesper de Jong]

Something similar in Haskell.

import Data.Maybe

fizz x = if x `mod` 3 == 0 then Just "Fizz" else Nothing
buzz x = if x `mod` 5 == 0 then Just "Buzz" else Nothing

fizzbuzz = map (\x -> let s = concat (mapMaybe ($ x) [fizz, buzz]) in if null s then show x else s) [1..100]

[Martin Vashko]

As far as I know, the modern outsourcing approach has not been used yet. Here you are:

    public static void main(String[] args) 
    {
        System.out.println("Please follow these rules carefully:");
        System.out.println("Write the numbers from 1 to 100 at the prompt, one at each line, with these exceptions:");
        System.out.println("- when the number is divisible by 3, enter 'fizz' instead of the number ");
        System.out.println("- when the number is divisible by 5, enter 'buzz' instead of the number ");
        System.out.println("- when the number is divisible by BOTH 3 and 5 enter 'fizzbuzz' instead of the number");
        System.out.println("");
        System.out.println("At the end of each line press the Enter key.");
        System.out.println("");
        System.out.println("The actual fizzbuzz challenge output starts here:");
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {
            for (int i = 0; i < 100; i++) {
                br.readLine();
            }
        }
        catch (IOException ex) {
            System.out.println("Operator error.");
        }
    }

If you don't get the expected output, it's a mistake of the operator, who needs to be replaced, equipped with a calculator, or both.

To adhere to the rules better, the operator instructions would have to be removed from the program. You'll find them on page 378 of the operations manual.

[Matthew Brown]

Obviously, this is a really calculation-intensive operation, and so it makes sense to do the calculations in parallel to take advantage of the 100 core machine it will obviously be running on. So here's a solution in C# using parallel LINQ:

class Program {
    static void Main(string[] args) {

        Func<int, string> fizzBuzz = i =>
                                     (i%3 == 0 && i%5 == 0)
                                         ? "fizzbuzz"
                                         : i%3 == 0
                                               ? "fizz"
                                               : i%5 == 0
                                                     ? "buzz"
                                                     : i.ToString();

        Enumerable.Range(1, 100).AsParallel().Select(fizzBuzz).ToList().ForEach(Console.WriteLine);
    }
}

What? You wanted the numbers 1 to 100 in order?

(* The ToList is because parallel LINQ enumerables don't have a ForEach method because it implies side effects, which are disapproved of. But List does.)

[Bert Bates]

rofl

[Michael Matola]

jQuery!

<!DOCTYPE html>
<html>
<head>
	<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
	<style>
	ol.custom {
		list-style-type: none;
  		margin-left: 0;
	}
	</style>
<head>
<body>
  <ol class = "custom">
  </ol>
  <script>
  $(function() {
    for(var i = 1; i <= 100; i++) {
  	  $('ol').append('<li>' + i + '</li>');
  	};
  	$('ol li:nth-child(15n)').html('fizzbuzz');
  	$('ol li:nth-child(3n)').not('ol li:nth-child(15n)').html('fizz');
  	$('ol li:nth-child(5n)').not('ol li:nth-child(15n)').html('buzz');  	
  });
  </script>
</body>
</html>

[Jesper de Jong]

Matthew's solution in C# with parallel LINQ inspired me to write one with Java 7's Fork Join framework.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinFizzBuzz extends RecursiveTask<List<String>> {

    private final int start;
    private final int end;

    public ForkJoinFizzBuzz(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected List<String> compute() {
        int length = end - start;
        if (length == 1) {
            return Collections.singletonList(fizzbuzz(start));
        }

        int middle = (start + end) / 2;

        ForkJoinFizzBuzz right = new ForkJoinFizzBuzz(middle, end);
        right.fork();
        
        ForkJoinFizzBuzz left = new ForkJoinFizzBuzz(start, middle);

        List<String> result = new ArrayList<String>(left.compute());
        result.addAll(right.join());
        return result;
    }
    
    private String fizzbuzz(int x) {
        if (x % 15 == 0) return "FizzBuzz";
        if (x % 3 == 0) return "Fizz";
        if (x % 5 == 0) return "Buzz";
        return Integer.toString(x);
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        List<String> result = pool.invoke(new ForkJoinFizzBuzz(1, 101));
        System.out.println(result);
    }
}

[Julien Meddah]

Here is my take on it :

public class FizzBuzz
{
	public static void main(String[] args)
	{
		String[][] fb = { { "" }, { "" }, { "" }, { "Fizz", "", "" }, { "" }, { "Buzz", "", "", "", "" } };
		for (int n = 1; n <= 100; n++)
			System.out.println((fb[3][n % 3] + fb[5][n % 5]).replaceAll("^$", String.valueOf(n)));
	}
}

I wouldn't go so far as to call it "good" but it has multiple things going on for it, like :
- It's short
- It's in Java.
- No explicit imports, so it's "pure" Java actually
- No conditions, only one loop
- No fancy FP stuff
- No "FizzBuzz" special case, "Fizz" or "Buzz" only

But of course you have to decipher the 2d array, recognize "^$" as an empty string regex, pass over some redundancies ...


[EDIT] Something actually simpler:

public class FizzBuzz
{
	public static void main(String... args)
	{
		String[] fizz = { "Fizz", "", "" }, buzz = { "Buzz", "", "", "", "" };
		for (int n = 1; n <= 100; n++)
			System.out.println((fizz[n % 3] + buzz[n % 5]).replaceAll("^$", String.valueOf(n)));
	}
}