FizzBuzz in 10 languages!

  • FizzBuzz
  • challenge
  • languages
December 29, 2018

FizzBuzz, as you might have heard, is a simple programming challenge given as an interview question to see if someone can code or not.

Write a short program that prints each number 
from 1 to 100 on a new line. 

> For each multiple of 3, print "Fizz" instead of the number. 
> For each multiple of 5, print "Buzz" instead of the number. 
> For numbers which are multiples of both 3 and 5, 
print "FizzBuzz" instead of the number.

Simple modulo operations to see if something is divisible by 3 and/or 5, a loop and printing to the console. It doesn't sound complicated. And it isn't, unless you are doing it in an obscure language you've never used before or in a programming paradigm which is less than common. So the thought occurred to me, FizzBuzz is actually perfect for learning the basics of a new language. It's simple enough, it doesn't leave much room for interpretation and we've all done it before in a language we are familiar with.

So I thought to myself, why not use some time this holiday to experiment with FizzBuzz? Oh boy did I experiment.

##javascript (node) I started with JavaScript, more for calibration purposes if nothing else. To remind myself of the problem and do it in a language I am very familiar with. Nothing special, here it is.

for (let i = 1; i <= 100; ++i) {
  const divBy3 = i % 3 === 0;
  const divBy5 = i % 5 === 0;

  if (divBy3 && divBy5) {
    console.log(`FizzBuzz`);
  } else if (divBy3) {
    console.log(`Fizz`);
  } else if (divBy5) {
    console.log(`Buzz`);
  } else {
    console.log(i);
  }
}

##haskell Then I thought, you know what I haven't used in a while? A functional language. I did a bit of Haskell in university so this wasn't soo unknown to me, but it wasn't super easy either. About 20 minutes. The hardest part was probably the fact that there is no loop, the loop is implicit. But this code is really elegant.

fb :: Integer -> String
fb n
  | mod n 3 == 0 && mod n 5 == 0    = "FizzBuzz"
  | mod n 3 == 0                    = "Fizz"
  | mod n 5 == 0                    = "Buzz"
  | otherwise                       = show n

main = do 
  putStrLn $ unlines (map fb [1..100])

##rust Rust. I've been hearing about rust from a bunch of people, and now I finally got around to trying it. It was quite nice, I liked the pattern matching. I can't say I got into the more complex aspects of the language like the reference counting or friendly compiler messages, but I liked what I saw so far.

fn main() {
    for x in 1..=100 {
        match (x % 3, x % 5) {
            (0, 0) => println!("FizzBuzz"),
            (0, _) => println!("Fizz"),
            (_, 0) => println!("Buzz"),
            _ => println!("{}", x),
        }
    }
}

##python Not even worth discussing. Probably around a minute.

for i in range(1, 101):
  divBy3 = i % 3 == 0
  divBy5 = i % 5 == 0
  if divBy3 and divBy5:
      print("FizzBuzz")
  elif divBy3:
      print("Fizz")
  elif divBy5:
      print("Buzz")
  else:
      print(i)

##ada Now, this one was quite interesting. My observations were:

  • it reminded me a lot of Pascal with the := assignment syntax and begins and ends
  • I thought it was a bit verbose
  • I found it a bit ugly (I mean for I in Integer range 1 .. 100 loop is quite considerably less elegant than for x in 1..101)

Overall it was an enjoyable experience though, I can't complain.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
procedure Hello is
    Div_By_3 : Boolean := false;
    Div_By_5 : Boolean := false;
begin
For_Loop :
   for I in Integer range 1 .. 100 loop
  
      Div_By_3 := I mod 3 = 0;
      Div_By_5 := I mod 5 = 0;
      
    if Div_By_3 and Div_By_5 then 
        Put_Line("FizzBuzz");
    elsif Div_By_3 then
        Put_Line("Fizz");
    elsif Div_By_5 then
        Put_Line("Buzz");
    else
        Put( I );
        New_Line(1);
    end if;
      
   end loop For_Loop;

end Hello;

##go Probably around a minute (even though I don't know go). At this point I realized a few things:

  • it's getting a little repetitive, so maybe it's time to pick a wilder language
  • I developed a system for breaking the problem down:
  • how do I loop though a list of numbers? (which normally also comes with the how to print those numbers)
  • how to do a modulus operator?
  • how to do an else-if
package main

import (
    "fmt"
)

func main() {

    for i := 1; i <= 100; i++ {
        divBy3 := i%3 == 0
        divBy5 := i%5 == 0

        if divBy3 && divBy5 {
            fmt.Println("FizzBuzz")
        } else if divBy3 {
            fmt.Println("Fizz")
        } else if divBy5 {
            fmt.Println("Buzz")
        } else {
            fmt.Println(i)
        }
        
    }
}

##brainfuck So, remember how I was saying I was getting a little bored? Enter brainfuck. Let me start by saying this language really serves its name. I am going to assume you don't know anything about it (because let's be honest, it's not taught in CS101), so I will tell you it only supports these operations: <>+_.,[]. You have a registry of numbers (255 I think) and you can do left right on the registry, increment and decrement, print something and loop while a registry's value is not zero. Yep. That's it. That is literally everything that comes as part of a language.

So I took a small intermission to the problem solving to read these guides:

And then I thought, ah, let me see how I can print a list of numbers. Well, here is a page telling you how to do: x = 0, x = y, x = x < y ... Umm, ok. This approach might not work.

Fast forward a couple of hours, I figure out how to print Fizz. Here it is.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++.>

I change my approach for this one to:

  • figure out how to print a string
  • figure out how to print a number
  • figure out how to do modulo
  • figure out how to do and if statement
  • figure out how to do if x = 0
  • figure out how to do if x and y
  • figure out how to store one number
  • figure out how to check if that number is divisible by 3
  • ... then by 5
  • ... then by both
  • ... then by neither
  • connect this with the prints
  • loop through a list of numbers

At the time of writing this, I got through everything apart from the loop. So the code below will print Fizz, Buzz, FizzBuzz or the numbers correctly, given a hardcoded number.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++><<<<<<<<>>>>>>>>>+++++++++++++++>>+++<<[>+>->+<[>]>[<+>-
]<<[<]>-]>>[-]>>+<[>-<[-]]>[<<<<<<<<<<<<<.>.>.>.<<<>>>>>>>>>>>>>-]<+++
++<<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]>>+<[>-<[-]]>[<<<<<<<<<<.>.>.>.<<<>
>>>>>>>>>-]<+++<<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]>>+<[>-<[-]]>[>>>>>>+<
<<<<<-]<+++++<<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]>>+<[>-<[-]]>[>>>>>>+<<<
<<<-]>>>>>><[>>[-]+<<[-]]>[>[-]+<[-]]>[<<+>>-]<<>+<[>-<[-]]>[<<<<<<<<<
[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<
<<<<]>[-]++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++
++>-]]<[.[-]<]<>>>>>>>>>-]<<<<<<<<<

Wow. I spent a good afternoon on this and I solved like 80% of the problem. 1435 characters. But I will say this, getting anything to work in brainfuck was amazing. Even printing something so simple as Fizz is incredibly rewarding, cause you have to build those ASCII codes yourself.

The best part though, in a normal language when you are stuck on something, you can easily google around for an answer. You look at some snippet of code and you're like: ah, I get it now. I was so silly. Doing the same for brainfuck just doesn't work. You look at how to do a modulus, you see [>+>->+<[>]>[<+>-]<<[<]>-] and you're like: well, I (still) don't get it.

But it was fun! It also piqued my interest into the esoteric languages. Shakespeare and Chef also sounded interesting but didn't get to those yet.

##bash I needed a quick break to keep me going after the brainfuck adventure and bash did the trick. Ugly syntax if you ask me but overall nothing special or unexpected.

#!/bin/bash
# GNU bash, version 4.3.46

for i in {1..100}
do
    if [ `expr $i % 3` == 0 ] && [ `expr $i % 5` == 0 ]; then
        echo "FizzBuzz"
    elif [ `expr $i % 3` == 0 ]; then
        echo "Fizz"
    elif [ `expr $i % 5` == 0 ]; then
        echo "Buzz"
    else
        echo $i
    fi
done

##prolog You know you're off to a good start when you see you can't do a for loop. I thought this might be the second brainfuck but it ended up being quite easy and enjoyable actually.

divBy3(X) :- 0 is mod(X, 3).
divBy5(X) :- 0 is mod(X, 5).

print_fizz_buzz(X) :- 
    (divBy3(X),divBy5(X))
    	-> write('FizzBuzz') 
    	; divBy3(X) 
    		-> write('Fizz') 
    		; divBy5(X) 
    			-> write('Buzz') 
    			; write(X).

print_numbers(100) :- print_fizz_buzz(100), !.
print_numbers(X) :- print_fizz_buzz(X), nl, Next is X + 1, print_numbers(Next).

##lolcode Now, at last, another esoteric language, LOLCODE. It looks weird, it's weird to write, it's weird to read and just weird all around.

HAI 1.2

IM IN YR loop UPPIN YR var TIL BOTH SAEM var AN 101

    DIFFRINT 0 AN var
    O RLY?
      YA RLY
    	I HAS A by3 ITZ BOTH SAEM 0 AN MOD OF var AN 3
    	I HAS A by5 ITZ BOTH SAEM 0 AN MOD OF var AN 5
    	
    	BOTH OF by3 AN by5 
        O RLY?
          YA RLY
            VISIBLE "FizzBuzz"
          NO WAI
        	by3
            O RLY?
              YA RLY
                VISIBLE "Fizz"
              NO WAI
                by5
                O RLY?
                  YA RLY
                    VISIBLE "Buzz"
                  NO WAI
                    VISIBLE var
                OIC
            OIC
        OIC
    OIC
	
IM OUTTA YR loop
KTHXBYE

##what have I learnt 10 languages and a couple of afternoons later, what have I learnt?

  • I genuinely enjoy writing code even for the sake of writing code
  • Most languages that we use every day really aren't that different from each other on a fundamental syntax level, they all have for loops and ifs and variables, etc.
  • Functional, declarative and low-level languages are fundamentally different from the rest and programming in them requires a complete mind shift (like operating on a list in haskell using recursion instead of a loop, or moving the register pointer around in brainfuck)
  • Language syntax has evolved somewhat from verbose to implicit and elegant (not sure if that is a good or bad thing, probably neither)

And if you'are after the code, it's all on github. Let me know what you thought of my FizzBuzz challenge and if you want to make your own and/or contribute to the repo let me know!

Share something about this post.

Made with ❤️ in 2018-2024
The views expressed on this website are entirely my own and not associated with any company past or present.