Displanting a Function OR Folding a Reverse

"Displant a town, reverse a prince's doom"
-- Shakespeare, Romeo and Juliet
Act III, Scene III, Line 60

Reverse

The interesting thing about the Reverse function is that it is not really doing anything.  With a small clerical error in a visit and recombine function you have reverse.

In Dr. Hutton's excellent paper, "A tutorial on the universality and expressiveness of fold", the following definition is given for reversing:

reverse :: [α] → [α]
reverse = fold (λx xs → xs ++ [x]) [ ]

We see that we concat the memoize with the member, in that order, thus reversing the collection.

Since I like advertising myself, let us go through an example with my name (someone has to advertise for me).

First time the Memoize has nothing and X has M.

Second time the Memoize has M and X is i.

Third time Memoize has i and M and X has k.

Fourth time Memoize has k, i, and M while X has e.

Leaving us with ekiM.

Let us look at some code examples.

Clojure

	(ns fold-reverse)
	(defn fold-reverse
	"reverse = fold (λx xs → xs ++ [x]) [ ]"
	[coll]
	(reduce #(cons %2 %1) [] coll))

view raw fold_reverse.clj hosted with ❤ by GitHub

	(ns fold-reverse.tests
	(require
	[clojure.test :refer [deftest testing is are run-tests]]
	[fold-reverse :as sut]))
	(deftest fold-reverse-tests
	(testing "Given an empty collection it must return an empty collection"
	(is (empty? (sut/fold-reverse []))))
	(testing "Given a string it must return the sames as clojure.string/reverse"
	(are [s] (= (clojure.string/reverse s) (->> s sut/fold-reverse (apply str)))
	"Mike Harris"
	"clojure"
	"something, something, dark side"))
	(testing "Given a vector it must return the same as reverse"
	(are [v] (and
	(vector? v)
	(= (reverse v) (sut/fold-reverse v)))
	[]
	[1]
	[1 2]
	[1 2 3]))
	(testing "Given a non-empty vector it must return the same as rseq"
	(are [v] (and
	((comp vector? not-empty) v)
	(= (rseq v) (sut/fold-reverse v)))
	[1]
	[1 2]
	[1 2 3])))
	(run-tests)

view raw fold_reverse.tests.clj hosted with ❤ by GitHub

We see with the Clojure code we are using the cons function to place the current member in the front of the memoize.  We do this for the whole collection thus giving us the collection in reverse.

C#

	using System.Collections.Generic;
	using System.Linq;
	namespace Folder
	{
	public class Reverse
	{
	public static IEnumerable<T> It<T>(IEnumerable<T> coll)
	{
	return coll.Aggregate(
	new List<T>(),
	(m, x) => new List<T> {x}.Concat(m).ToList());
	}
	}
	}

view raw Folder.cs hosted with ❤ by GitHub

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using Folder;
	using Xunit;
	namespace FolderTests
	{
	public class ReverseTests
	{
	[Fact]
	public void GivenAnEmptyCollectionItMustReturnAnEmptyCollection()
	{
	Assert.Empty(Reverse.It(new List<object>()));
	}
	[Theory]
	[InlineData("")]
	[InlineData("Mike Harris")]
	[InlineData("C#")]
	[InlineData("something, something, dark side")]
	public void GivenStringItMustReturnStringEqualToReverseString(string s)
	{
	var expected = String.Concat(s.Reverse());
	var actual = String.Concat(Reverse.It(s));
	Assert.Equal(expected, actual);
	}
	[Theory]
	[InlineData(new [] {1})]
	[InlineData(new [] {1, 2})]
	[InlineData(new [] {1, 2, 3})]
	public void GivenCollectionItMustReturnCollectionEqualToReverse(int[] coll)
	{
	var expected = coll.Reverse();
	var actual = Reverse.It(coll);
	Assert.Equal(expected, actual);
	}
	}
	}

view raw FolderTests.cs hosted with ❤ by GitHub

With the C# code we see that we need to create something to contain the resulting collection, in this case we'll create a List.  We create the reversed collection in an immutable way by creating a new List every time in the lambda.

ECMAScript 2015

	let _ = require("lodash");
	exports.foldReverse = coll =>
	_.foldl(coll, (m, x) => { m.unshift(x); return m; }, []);

view raw foldReverse.js hosted with ❤ by GitHub

	let sut = require("../src/foldReverse"),
	expect = require("expect.js"),
	_ = require("lodash");
	describe("foldReverse", () => {
	it("Given an empty collection it must return same", () => {
	expect(sut.foldReverse([])).to.be.empty();
	}),
	it("Given string it must return same as string in reverse", () => {
	let reverse = s => s.split("").reverse().join("");
	expect(reverse("hi")).to.equal("ih");
	let sameAsReverse = s =>
	expect(sut.foldReverse(s.split("")).join(""))
	.to.equal(reverse(s));
	sameAsReverse("Mike Harris");
	sameAsReverse("ECMAScript 2015");
	sameAsReverse("something, something, dark side");
	}),
	it("Given collection it must return same as reverse", () => {
	let sameAsReverse = coll =>
	expect(sut.foldReverse(coll)).to.eql(coll.reverse());
	sameAsReverse([]);
	sameAsReverse([1]);
	sameAsReverse([1, 2]);
	sameAsReverse([1, 2, 3]);
	});
	});

view raw foldReverseSpec.js hosted with ❤ by GitHub

With JavaScript (ECMAScript 2015) we us the unshift method on the array.  Since unshift returns the length of the array after the member is added to the head of the array (which I totally did not expect) we need to manually return the memoize after applying unshift.

Fin

There you have it again, yet another function which can be created using Fold.  Showing once again that all you need is Fold.

Think About Length OR How Fold Can Do Everything, Even Count

"Leave nothing out for length, and make us think"
-- Shakespeare, Coriolanus
Act II, Scene II, Line 47

How Long is It?

I am not sure why but before I start reading a chapter or watching something I've recorded I almost always check to see how long it is.  Today's post will be using Fold to find the length of a collection.  In Dr. Hutton's excellent paper, "A tutorial on the universality and expressiveness of fold", the following definition is given for finding the length:

length :: [α] → Int
length = fold (λx n → 1 + n) 0

We see with this definition we do nothing with the current member of the collection (x above) and instead only act on the memoize (n above).

In the simple example below we will see that the string "Mike" has 4 characters in it.

At the start we have a Seed of 0 and a collection with the members M, i, k, and e.

First time Memoize has 0 in it and X has M.

Second time Memoize has 1 in it and X has i.

Third time Memoize has 2 in it and X has the letter k.

Last time Memoize has 3 and X has e.

There you have it (maybe I should have used my sister Kim name instead).  Let us see some code.

Clojure

	(ns fold-length)
	(defn fold-length
	"length = fold (λx n → 1 + n) 0"
	[coll]
	(reduce (fn [m _] (inc m)) 0 coll))

view raw fold_length.clj hosted with ❤ by GitHub

	(ns fold-length.tests
	(require
	[clojure.test :refer [deftest testing are is run-tests]]
	[fold-length :as sut]))
	(deftest fold-length-tests
	(testing "Given an empty collection it must return 0"
	(is (zero? (sut/fold-length []))))
	(testing "Given a repeated single value it must return the number of times the value is repeated"
	(are [number] (= number (sut/fold-length (repeat number \q)))
	0
	1
	2
	11
	1010))
	(testing "Given a string it must return the number of characters in it"
	(are [s] (= (count s) (sut/fold-length (seq s)))
	"Mike Harris"
	"clojure"
	"something, something, dark side")))
	(run-tests)

view raw fold_length.tests.clj hosted with ❤ by GitHub

We see in the clojure example that function we give the reduce must have two parameters, so we call the second one _ to denote that it is not used.

C#

	using System.Collections.Generic;
	using System.Linq;
	namespace Folder
	{
	public class FoldLength<T>
	{
	public static int Of(ICollection<T> collection)
	{
	return collection.Aggregate(0, (m, _) => m + 1);
	}
	}
	}

view raw FoldLength.cs hosted with ❤ by GitHub

	using System;
	using System.Collections.Generic;
	using Folder;
	using Xunit;
	namespace FolderTests
	{
	public class FoldLengthTests
	{
	[Fact]
	public void GivenEmptyCollectionItMustReturn0()
	{
	var actual = FoldLength<object>.Of(new List<object>());
	Assert.Equal(0, actual);
	}
	[Theory]
	[InlineData(0)]
	[InlineData(1)]
	[InlineData(2)]
	[InlineData(11)]
	[InlineData(1010)]
	public void GivenRepeatedSingleValueItMustReturnNumberOfTimeTheValueRepeats(int repeat)
	{
	var collection = new String('q', repeat);
	var actual = FoldLength<char>.Of(collection.ToCharArray());
	Assert.Equal(repeat, actual);
	}
	[Theory]
	[InlineData("Mike Harris")]
	[InlineData("C#")]
	[InlineData("something, something, dark side")]
	public void GivenStringItMustReturnNumberOfCharInIt(string s)
	{
	var actual = FoldLength<char>.Of(s.ToCharArray());
	Assert.Equal(s.Length, actual);
	}
	}
	}

view raw FoldLengthTests.cs hosted with ❤ by GitHub

With the C# code the lambda we give Aggregate has two values of which we give the second one the name of _ to denote not using it.

JavaScript (ECMAScript 2015)

	let _ = require("lodash");
	exports.foldLength = (coll) =>
	_.foldl(coll, m => m + 1, 0);

view raw foldLength.js hosted with ❤ by GitHub

	let sut = require("../src/foldLength"),
	expect = require("expect.js"),
	_ = require("lodash");
	describe("foldLength", () => {
	it("Given an empty collection it must return 0", () => {
	expect(sut.foldLength([])).to.equal(0);
	}),
	it("Given a repeated single value it must return the number of times the value is repeated", () => {
	let expectRangeSizeEqualsLength =
	(size) => expect(sut.foldLength(_.range(size))).to.equal(size);
	expectRangeSizeEqualsLength(0);
	expectRangeSizeEqualsLength(1);
	expectRangeSizeEqualsLength(2);
	expectRangeSizeEqualsLength(11);
	expectRangeSizeEqualsLength(1010);
	}),
	it("Given a string it must return the number of characters in it", () => {
	let expectStringEqualsLength =
	(s) => expect(sut.foldLength(s.split(""))).to.equal(s.length);
	expectStringEqualsLength("Mike Harris");
	expectStringEqualsLength("ECMAScript2015");
	expectStringEqualsLength("somthing, somthing, dark side");
	});
	});

view raw foldLengthSpec.js hosted with ❤ by GitHub

With ECMAScript 2015 we use lodash's foldl and see that the lambda only has to have one value which is the memoize.

Fin

There you have it counting with Fold, showing that you need is Fold.

If True or False I Know Not

"I idly heard; if true or false I know not."

-- Shakespeare, King John
Act IV, Scene II, Line 124

Welcome Back

This is the next in the series of post on Dr. Graham Hutton's excellent paper, "A tutorial on the universality and expressiveness of fold", this time around we'll look at Oring.  Dr. Hutton has given Oring the following definition:

or :: [Bool] → Bool
or = fold (∨) False

The idea is that we Fold an Or function with a seed value of False.  If one of the members of the collection is True we Or it with False giving us True, else if none of the members of the collection are True we will end up with the value of False.

In the simple example below we'll see that if we have a single value of True then the end result will be True.

At the start we have a Seed value of False with collection containing False, True, and False.

First time the Memorize has False and X has False.

Second time the Memorize has False and X has True.

Third time the Memorize has True and X has False giving use the finally value of True.

Let us now look at this in sweet, sweet code.

Clojure

	(ns fold-or)
	(defn fold-or
	"or = fold (∨) False"
	[& facts]
	(reduce #(or %1 %2) false facts))

view raw Fold_Or.clj hosted with ❤ by GitHub

	(ns fold-or.tests
	(require
	[clojure.test :refer [deftest testing are run-tests]]
	[fold-or :as sut]))
	(deftest fold-or-tests
	(testing "Given all true it must return true"
	(are [truths] (true? (apply sut/fold-or truths))
	[true]
	[true true]
	(repeat 100 true)))
	(testing "Given all false it must return false"
	(are [falsehoods] (false? (apply sut/fold-or falsehoods))
	[false]
	[false false]
	(repeat 100 false)))
	(testing "Given some true and false it must return true"
	(are [facts] (true? (apply sut/fold-or facts))
	[false true]
	[true false]
	[false true false]
	[true false false])))
	(run-tests)

view raw Fold_Or.Tests.clj hosted with ❤ by GitHub

In the Clojure code that we use the or macro and a seed value of false in order to create an Oring function using the higher order function of reduce.  Since reduce is expecting a function and not a macro we need to create a lambda function to wrap the or macro.

C#

	using System.Linq;
	namespace Folder
	{
	public static class Folder
	{
	public static bool Or(params bool[] facts)
	{
	return facts.Aggregate(false, (m, x) => m || x);
	}
	}
	}

view raw Folder.cs hosted with ❤ by GitHub

	using Xunit;
	using static Folder.Folder;
	namespace FolderTests
	{
	public class FolderTests
	{
	[Theory]
	[InlineData(new[] { true })]
	[InlineData(new[] { true, true })]
	[InlineData(new[] { true, true, true })]
	public void GivenOnlyTrueItMustReturnTrue(bool[] truths)
	{
	Assert.True(Or(truths));
	}
	[Theory]
	[InlineData(new[] { false })]
	[InlineData(new[] { false, false })]
	[InlineData(new[] { false, false, false })]
	public void GivenOnlyFalseItMustReturnFalse(bool[] falsehoods)
	{
	Assert.False(Or(falsehoods));
	}
	[Theory]
	[InlineData(new[] { true, false })]
	[InlineData(new[] { false, true })]
	[InlineData(new[] { false, true, false })]
	[InlineData(new[] { false, false, true })]
	public void GivenSomeTrueAndFalseItMustReturnTrue(bool[] facts)
	{
	Assert.True(Or(facts));
	}
	}
	}

view raw FolderTests.cs hosted with ❤ by GitHub

We see in the C# code that we can use the LINQ aggregate method on the collection we are folding.  We give the aggregate a seed value of false and in the lambda we simply takes the memorize and the current member and or them.

JavaScript (ECMAScript 2015)

	let _ = require("lodash");
	exports.foldOr = (...facts) =>
	_.foldl(facts, (m, x) => m || x, false);

view raw foldOr.js hosted with ❤ by GitHub

	let sut = require("../src/foldOr"),
	expect = require("expect.js");
	describe("foldOr", () => {
	it("Given all true it must return true", () => {
	expect(sut.foldOr(true)).to.be.ok();
	expect(sut.foldOr(true, true)).to.be.ok();
	expect(sut.foldOr(true, true, true)).to.be.ok();
	}),
	it("Given all false it must return false", () => {
	expect(sut.foldOr(false)).not.to.be.ok();
	expect(sut.foldOr(false, false)).not.to.be.ok();
	expect(sut.foldOr(false, false, false)).not.to.be.ok();
	}),
	it("Given some true and false it must return true", () => {
	expect(sut.foldOr(true, false)).to.be.ok();
	expect(sut.foldOr(false, true)).to.be.ok();
	expect(sut.foldOr(false, true, false)).to.be.ok();
	expect(sut.foldOr(false, false, true)).to.be.ok();
	});
	});

view raw foldOrSpec.js hosted with ❤ by GitHub

Using lodash's foldl function along with Babel.js we are able to create an Oring function by folding over the collection and passing it to a lambda function which ors the current member of the collection with the memorize value.  We give a seed value of false thus causing the initial value of the memorize to be false.

Until Next Time

There you have it an Oring function using nothing but Fold.  Thus "proving" that all you need is Fold.

Approaching the Fold

"Approach the fold and cull th' infected forth"
-- Shakespeare, Timon of Athens
Act V, Scene IV, Line 43

Welcome

In Graham Hutton's excellent paper, "A tutorial on the universality and expressiveness of fold", the first function that is looked at is And.  Dr. Hutton gives And the following definition:

and :: [Bool] → Bool
and = fold (∧) True

The idea being that we give Fold an And function with a seed value of True.  If one of the members of the collection given is False the Anding it with True will yield a value of False and thus the end result will be False.  If no member of the collection given is False then the end result will be True.

Let us look at this in code.

Clojure

	(ns fold-and)
	(defn fold-and
	"and = fold (∧) True"
	[& facts]
	(reduce #(and %1 %2) true facts))

view raw Fold_And.clj hosted with ❤ by GitHub

	(ns fold-and.tests
	(require
	[clojure.test :refer [deftest testing are is run-tests]]
	[fold-and :as sut]))
	(deftest fold-and-tests
	(testing "Given all true it must return true"
	(are [truths] (true? (apply sut/fold-and truths))
	[true]
	[true true]
	(repeat 100 true)))
	(testing "Given all false it must return false"
	(are [falsehoods] (false? (apply sut/fold-and falsehoods))
	[false]
	[false false]
	(repeat 100 false)))
	(testing "Given some true and some false it must match every's result"
	(are [facts] (= (every? identity facts) (apply sut/fold-and facts))
	[true]
	[false true]
	[true true]
	[false true]
	[false false]
	(repeat 100 true)
	(repeat 100 false))))
	(run-tests)

view raw Fold_And.Tests.clj hosted with ❤ by GitHub

To create an Anding function we'll use reduce along with the and macro with a seed of true.  Since and is a macro, we'll need to wrap it in a function in order to be able to use it in reduce.

C#

	using System.Linq;
	namespace Folders
	{
	public class FoldAnd
	{
	public bool And(params bool[] facts)
	{
	return facts.Aggregate(true, (m, x) => m && x);
	}
	}
	}

view raw FoldAnd.cs hosted with ❤ by GitHub

	using System.Linq;
	using Folders;
	using Xunit;
	namespace FoldersTests
	{
	public class FoldAndTests
	{
	[Theory]
	[InlineData(new[] { true })]
	[InlineData(new[] { true, true })]
	[InlineData(new[] { true, true, true })]
	public void GivenTrueValuesItMustReturnTrue(bool[] truths)
	{
	var sut = new FoldAnd();
	var actual = sut.And(truths);
	Assert.True(actual);
	}
	[Theory]
	[InlineData(new[] { false })]
	[InlineData(new[] { false, false })]
	[InlineData(new[] { false, false, false })]
	public void GivenFalseValuesItMustReturnFalse(bool[] falsehoods)
	{
	var sut = new FoldAnd();
	var actual = sut.And(falsehoods);
	Assert.False(actual);
	}
	[Theory]
	[InlineData(new[] { true })]
	[InlineData(new[] { false, true })]
	[InlineData(new[] { true, true })]
	[InlineData(new[] { false, false })]
	[InlineData(new[] { false, false, false })]
	[InlineData(new[] { false, true, false })]
	[InlineData(new[] { true, true, true })]
	public void GivenSomeTrueAndSomeFalseValuesItMustReturnFalse(bool[] facts)
	{
	var expected = facts.All(a => a);
	var sut = new FoldAnd();
	var actual = sut.And(facts);
	Assert.Equal(expected, actual);
	}
	}
	}

view raw FoldAndTests.cs hosted with ❤ by GitHub

We'll use the LINQ function Aggregate along && and a value of true to create an Anding function.

JavaScript

	var _ = require("lodash");
	exports.foldAnd = function foldAnd(/*facts*/) {
	var facts = _.toArray(arguments);
	return _.foldl(facts, function(m, x) {return m && x}, true);
	};

view raw foldAnd.js hosted with ❤ by GitHub

	var sut = require("../src/foldAnd"),
	expect = require("expect.js"),
	_ = require("lodash");
	describe("foldAnd", function(){
	it("Given all true it must return true", function(){
	expect(sut.foldAnd(true)).to.be.ok();
	expect(sut.foldAnd(true, true)).to.be.ok();
	expect(sut.foldAnd(true, true, true)).to.be.ok();
	}),
	it("Given all false it must return false", function(){
	expect(sut.foldAnd(false)).not.to.be.ok();
	expect(sut.foldAnd(false, false)).not.to.be.ok();
	expect(sut.foldAnd(false, false, false)).not.to.be.ok();
	}),
	it("Given some true and false it must return the same result as every", function(){
	expect(sut.foldAnd(true, false)).to.equal(_.every([true, false]));
	expect(sut.foldAnd(false, true)).to.equal(_.every([false, true]));
	expect(sut.foldAnd(false, true, false)).to.equal(_.every([false, true, false]));
	expect(sut.foldAnd(false, false, true)).to.equal(_.every([false, false, true]));
	})
	});

view raw foldAndSpec.js hosted with ❤ by GitHub

We see that by using lodash's foldl function with && and the value true we can create an Anding function.

ECMAScript 2015

	let _ = require("lodash");
	exports.foldAnd = (...facts) =>
	_.foldl(facts, (m, x) => m && x, true);

view raw foldAnd.js hosted with ❤ by GitHub

	let sut = require("../src/foldAnd"),
	expect = require("expect.js"),
	_ = require("lodash");
	describe("foldAnd", () => {
	it("Given all true it must return true", () => {
	expect(sut.foldAnd(true)).to.be.ok();
	expect(sut.foldAnd(true, true)).to.be.ok();
	expect(sut.foldAnd(true, true, true)).to.be.ok();
	}),
	it("Given all false it must return false", () => {
	expect(sut.foldAnd(false)).not.to.be.ok();
	expect(sut.foldAnd(false, false)).not.to.be.ok();
	expect(sut.foldAnd(false, false, false)).not.to.be.ok();
	}),
	it("Given some true and false it must return the same result as every", () => {
	expect(sut.foldAnd(true, false)).to.equal(_.every([true, false]));
	expect(sut.foldAnd(false, true)).to.equal(_.every([false, true]));
	expect(sut.foldAnd(false, true, false)).to.equal(_.every([false, true, false]));
	expect(sut.foldAnd(false, false, true)).to.equal(_.every([false, false, true]));
	})
	});

view raw foldAndSpec.js hosted with ❤ by GitHub

Since we live in the future, we'll use Babel to allow us to use ECMAScript 2015.  We see again that by using lodash's foldl with && along with the value true we now have an Anding function.

Fin

There you have it the And function using Fold, showing once again that all you need is Fold.

Bro, Do You Even FizzBuzz?!?

"Do you bite your thumb at us, sir?"
-- Shakespeare, Romeo and Juliet
Act I, Scene I, Line 43

FizzBuzz as an interview kata has been getting a lot of bad press lately.  Part of the bad press has been around having to use modulus in the solution.  I am not sure how people have been explaining FizzBuzz in interviews, but you do not have to know anything about the mod operator in order to solve the problem.

Here is a solution in Clojure which does not use modulus.

	(ns fizz-buzz)
	(defn fizz-buzzer [n]
	(let [translation (->
	(map str (cycle ["Fizz" "" ""]) (cycle ["Buzz" "" "" "" ""]))
	(nth n))]
	(if (empty? translation)
	(str n)
	translation)))

view raw Fizz_Buzz.clj hosted with ❤ by GitHub

	(ns fizz-buzz.tests
	(require
	[clojure.test :refer [deftest testing is run-tests]]
	[fizz-buzz :as sut]))
	(deftest fizz-buzz-tests
	(testing "Given a value divisible by 3 result must contain Fizz"
	(is (.contains (sut/fizz-buzzer 0) "Fizz"))
	(is (.contains (sut/fizz-buzzer 3) "Fizz"))
	(is (.contains (sut/fizz-buzzer 9) "Fizz"))
	(is (.contains (sut/fizz-buzzer 15) "Fizz")))
	(testing "Given a value divisible by 5 result must contain Buzz"
	(is (.contains (sut/fizz-buzzer 0) "Buzz"))
	(is (.contains (sut/fizz-buzzer 5) "Buzz"))
	(is (.contains (sut/fizz-buzzer 25) "Buzz"))
	(is (.contains (sut/fizz-buzzer 15) "Buzz")))
	(testing "Given a value divisible by 15 it must return FizzBuzz"
	(is (= "FizzBuzz" (sut/fizz-buzzer 0)))
	(is (= "FizzBuzz" (sut/fizz-buzzer 15)))
	(is (= "FizzBuzz" (sut/fizz-buzzer 225))))
	(testing "Given a value not divisible by 3, 5, or 15 it must return value as string"
	(is (= "1" (sut/fizz-buzzer 1)))
	(is (= "2" (sut/fizz-buzzer 2)))
	(is (= "1111" (sut/fizz-buzzer 1111)))))
	(run-tests 'fizz-buzz.tests)

view raw Fizz_Buzz.Tests.clj hosted with ❤ by GitHub

This solution is using cycles and zip.  The odds are low of someone knowing how to use cycle and zip but not knowing modulus.  The point is that you do not need to know about modulus to do the kata.

In interviews I do, I'll tell the person about modulus if they get stuck.  The point of using a kata in an interview is to make sure that person who claims to be a programmer can actually program and that you can work with the person.

Still if the whole modulus thing has you worried, try the Roman Numeral kata.

Here is a solution in C# I did few minutes before an interview on Thursday (pro-tip, always make sure you can do the kata in short amount of time before you ask someone else to do it in an interview).

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Runtime.InteropServices.ComTypes;
	using System.Text;
	using System.Threading.Tasks;
	using Xunit;
	namespace RomanNumeral
	{
	public class Romanize
	{
	public string ToRoman(int value)
	{
	return new Dictionary<int, string>
	{
	{40, "XL"},
	{10, "X"},
	{9, "IX"},
	{5, "V"},
	{4, "IV"},
	{1, "I"}
	}.Aggregate(string.Empty, (m, _) =>
	{
	while (_.Key <= value)
	{
	value -= _.Key;
	m += _.Value;
	}
	return m;
	});
	}
	}
	public class RomanizeTests
	{
	[Theory]
	[InlineData(0, "")]
	[InlineData(1, "I")]
	[InlineData(2, "II")]
	[InlineData(3, "III")]
	[InlineData(4, "IV")]
	[InlineData(5, "V")]
	[InlineData(9, "IX")]
	[InlineData(39, "XXXIX")]
	[InlineData(49, "XLIX")]
	public void Given0ItMustReturnEmptyString(int value, string expected)
	{
	var sut = new Romanize();
	var actual = sut.ToRoman(value);
	Assert.Equal(expected, actual);
	}
	}
	}

view raw Romanize.cs hosted with ❤ by GitHub

Again, the goal of the interview kata should be to see if the person can actually program and to see what they are like to work with.

"No, sir, I do not bite my thumb at you, sir. But
I bite my thumb, sir."

-- Shakespeare, Romeo and Juliet
Act I, Scene I, Lines 49-50