# Writing FizzBuzz in Julia

May 28, 2013   #julialang  #tutorial  #code  #easy  #fizzbuzz

One of the simplest first programming exercises to try in a new language is the FizzBuzz problem. It’s a simple toy problem that is less trivial than “Hello, World” because it also involves using basic control-flow structures.

This blog post assumes that you’ve already installed the Julia programming language (hint: see GitHub) and figured out how to open a REPL (hint: run `julia`).

Now that you’ve got a Julia REPL open, let’s go through the very basic syntax of the language: its control flow structures. After we have those under control, you’ll write FizzBuzz in Julia.

## If Statements

Julia uses the keyword `end` to end blocks rather than using whitespace or curly braces (`{}`) as delimeters. Julia is not whitespace sensitive.

A simple if statement:

``````julia> if 5 == 4
print("hello world")
end
``````

`==` is the equality operator; it returns either `true` or `false`. It is both an infix operator and a function.

The simplest possible `if`-statements are:

``````if false
end
``````

and

``````if true end
``````

Julia is not whitespace sensitive; you can sometimes put things all on one line without changing the meaning. This is the case with these very simple `if`-statements.

The tricky part to guess in the `if`-statement syntax is the keyword `elseif`, since there’s so much variation in that keyword between languages.

``````julia> if 5 == 6 # this is a comment
print("five and six are equal")
elseif mod(5,6) == 4 # you will need the mod function later
print("five mod six is four")
else
print("Stefan is awesome")
end
Stefan is awesome
``````

## For Loops

The most straight-forward ways to write FizzBuzz involve `for`-looping over a range of numbers, so here’s an example of that style of loop and its output:

``````julia> for x=1:5
println(x)
end
1
2
3
4
5
``````

Note that the range `1:5` is inclusive; both `1` and `5` appear in the output.

As you would expect, Julia also has `while` loops:

``````julia> while false
print("something is very wrong")
end
``````

### Ranges

The `1:5` in the `for` loop is a range. Ranges are of the form `start:end`. As you can see, both the start and the end are inclusive. (both 1 and 5 are values in the range `1:5`) By default, the range increments by 1.

``````julia> for x=1:2:10
println(x)
end
1
3
5
7
9
``````

In this more complex form of range, you have `start:step:end`. The end value of the range does not have to be included; it is only included if incrementing by `step` lands on it.

## Exercise: FizzBuzz in REPL

Now that you have `if` statements, `for` loops, and the `println`, `mod`, and `==` functions at your disposal, you can write FizzBuzz in the REPL. It should take the form of a `for` loop with an `if` statement inside.

For those unfamiliar with it, FizzBuzz is a common coding problem that involves printing something for each of the first 100 positive integers. You should have 100 lines of output: one for each integer.

What you print depends on the number, as follows:

• If the number is divisible by 3, print ‘Fizz’.
• If the number is divisible by 5, print ‘Buzz’.
• If the number is divisible by both 3 and 5, print ‘FizzBuzz’.
• If none of the above apply, just print the number.

In case the above explanation is unclear, the correct output for `1:20` is:

``````1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
``````

### Solution

Don’t peek before trying it yourself, but if you feel the need to see a correct solution, you can find one here on RosettaCode.