Back to Questions
2.5k
views3
comments
KataFizzBuzz Design Problem
f#functional

Hello everybody :)

I'm new to F# and I like it a lot. So I started with some easy Katas. The easiest I know is KataFizzBuzz. So I started to implement it using BDD with NaturalSpec. But I came arround a design issue which myself can't solve. Maybe someone can help me :)

Here's my code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

module implementation

type output =
| Fizz
| Buzz
| FizzBuzzR
| Number of int

let isDivisableBy divisors value =
     divisors |> Seq.forall (fun divisor -> value % divisor = 0)

let FizzBuzz value = 
    match value with
    | value when value |> isDivisableBy [3;5] -> FizzBuzzR
    | value when value |> isDivisableBy [3] -> Fizz
    | value when value |> isDivisableBy [5] -> Buzz
    | _ -> Number(value)

The problem I see is that the FizzBuzz function is somehow very redundant. Does anybody have a better solution for this problem? Maybe the way i tackled the problem is also wrong. I'm open for all suggestions. I only did OOP before and I think it takes time to get used to the functional way of thinking :)

I'll also add the tests maybe the problem is in the way I wrote them:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

module tests

open NaturalSpec
open implementation

[<Scenario>]
let ``When the number is divisible by 3 it should return Fizz``() =
    Given 6
    |> When FizzBuzz
    |> It should equal Fizz
    |> Verify

[<Scenario>]
let ``When the number is divisible by 5 it should return Buzz``() =
    Given 10
    |> When FizzBuzz
    |> It should equal Buzz
    |> Verify

[<Scenario>]
let ``When the number is divisible by 3 and 5 it should return FizzBuzz``() =
    Given 30
    |> When FizzBuzz
    |> It should equal FizzBuzzR
    |> Verify

[<Scenario>]
let ``When the number is not divisible by 3 or 5 it should return the number``() =
    Given 2
    |> When FizzBuzz
    |> It should equal (Number(2))
    |> Verify

P.S.: Can anybody tell me how to format stuff in this forum? Especially code?

.

Without giving it to much thought: here is what I might do:

1
2
3
4
5
6
7
8
9
10

 

    let fizzbuzz n = 
        let divBy d n = n % d = 0
        match (divBy 3 n), (divBy 5 n) with
        | true, true -> "FizzBuzz"
        | true, false -> "Fizz"
        | false, true -> "Buzz"
        | _ -> sprintf "%d" n

Of course you might want to change my strings with your algebraic type.

You have to divide by both numbers 3 and 5 so you can't take out this - but you can do this once and be done with it.

By on 7/22/2011 1:20 AM ()

Nice idea :)

I also saw a solution using active patterns. It also looked very clean. What I like about your solution is that you don't have then 'when' part. This is something I don't like in my solution. It looks like a kind of missuse of pattern matching.

By on 7/24/2011 11:40 AM ()

was thinking about the active patterns too.

This might gain you readability but you have to add a lot of boiler-code (the patterns-definition) and I think the patterns would fire at every match-case (so you fire the 3/5-test twice instead of just once)

By on 7/25/2011 11:57 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper