FizzBuzz and the Roman Numeral Kata are the Same Thing!

"The same, sir."

-- Shakespeare, Coriolanus

Act IV, Scene III, Line 7

As Homer Simpson pointed out, "Coke and Pepsi are the same thing!"


Similarly I plan to show that the FizzBuzz and Roman Numeral katas are the same thing! 

First let's look at the rules of FizzBuzz.

f(x : int) : string

  if 3 | x and 5 | x then "FizzBuzz"
  if 3 | x then "Fizz"
  if 5 | x then "Buzz"
  default string x

*note, 3 | x reads 3 divides x, in other words x / 3 does not have a remainder

 In general we see that we have two (or three) rules and a default value, we are translating from the domain into the codomain following a set of rules, in other words we have a function.

	namespace FizzBuzz
	module FizzBuzz =
	let fizzbuzzer (n : int) =
	[(3, "Fizz");
	(5, "Buzz")]
	|> List.fold (fun m (x, s) -> m + if n % x = 0 then s else "") ""
	|> (fun s -> if s = "" then string n else s)

view raw FizzBuzz.fs hosted with ❤ by GitHub

	namespace FizzBuzz.Tests
	module FizzBuzzTests =
	open FizzBuzz.FizzBuzz
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Multiples of given value should contain expected`` (given : int) (expected : string) =
	fizzbuzzer given |> should haveSubstring expected

view raw FizzBuzzTests.fs hosted with ❤ by GitHub

How about the Roman Numeral kata?

f(x : int) : string

  fold

    roman-numerals : (int, string)

    lambda((x : int, m : string),

           (k : int, v : string)) : (int, string)

      while k | x then (x / k, concat m v)

    (x, default string) : (int, string)

Again we see a list of rules for translation.

	namespace RomanNumerals
	module RomanNumerals =
	let translate n =
	[(40, "XL");
	(10, "X"); (9, "IX");
	(5, "V"); (4, "IV");
	(1, "I")]
	|> List.fold
	(fun (x, m) (k, v) ->
	if x >= k then (x - (k * (x / k)), m + String.replicate (x / k) v)
	else (x, m))
	(n, "")
	|> snd

view raw RomanNumerals.fs hosted with ❤ by GitHub

	module RomanNumerals.Tests.Translate
	open RomanNumerals.RomanNumerals
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(3, "III")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	[<InlineData(6, "VI")>]
	[<InlineData(7, "VII")>]
	[<InlineData(8, "VIII")>]
	[<InlineData(9, "IX")>]
	[<InlineData(10, "X")>]
	[<InlineData(11, "XI")>]
	[<InlineData(29, "XXIX")>]
	[<InlineData(40, "XL")>]
	[<InlineData(49, "XLIX")>]
	let ``given 1 it must return I``
	(value : int, expected : string) =
	translate value |> should equal expected

view raw RomanNumeralsTests.fs hosted with ❤ by GitHub

The only real difference to FizzBuzz is the fold across the rules, but we've hinted at this in the FizzBuzz description above.  We stated that FizzBuzz has two (or three) rules, we can rewrite it using a fold with just the two rules using the fold to cover the "and" case.

	namespace Translate
	module Translate =
	let translate folding defaulting translations seed n =
	translations
	|> List.fold folding (n, seed)
	|> snd
	|> defaulting
	let fizzbuzzer (n : int) =
	[(3, "Fizz");
	(5, "Buzz")]
	|> List.fold
	(fun (n, r) (x, s) -> (n, r + if n % x = 0 then s else ""))
	(n, "")
	|> snd
	|> (fun s -> if s = "" then string n else s)
	let fizzbuzzer2 (n : int) =
	translate
	(fun (n, r) (x, s) -> (n, r + if n % x = 0 then s else ""))
	(fun s -> if s = "" then string n else s)
	[(3, "Fizz");
	(5, "Buzz")]
	""
	n
	let romanize (n : int) =
	[(5, "V");
	(4, "IV");
	(1, "I")]
	|> List.fold
	(fun (n, r) (x, s) ->
	(n % x, r + if n >= x then String.replicate (n / x) s else ""))
	(n, "")
	|> snd
	|> (fun s -> s)
	let romanize2 (n : int) =
	translate
	(fun (n, r) (x, s) ->
	(n % x, r + if n >= x then String.replicate (n / x) s else ""))
	(fun d -> d)
	[(5, "V");
	(4, "IV");
	(1, "I")]
	""
	n

view raw Translate.fs hosted with ❤ by GitHub

	namespace Translate.Tests
	module TranslateTests =
	open Translate.Translate
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Given value fizzbuzzer should contain expected`` (given : int) (expected : string) =
	fizzbuzzer given |> should haveSubstring expected
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Given value fizzbuzzer2 should contain expected`` (given : int) (expected : string) =
	fizzbuzzer2 given |> should haveSubstring expected
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	let ``Given value should romanize to expected`` (given : int) (expected : string) =
	romanize given |> should equal expected
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	let ``Given value should romanize2 to expected`` (given : int) (expected : string) =
	romanize2 given |> should equal expected

view raw TranslateTests.fs hosted with ❤ by GitHub

We see the FizzBuzz and Roman Numeral as having the same shape which we use in the generalization in the "2 version".  Thus using the same function with a set of rules, a defaulting function, and a seed we create both the FizzBuzz and Roman Numeral kata from the same general function!