2018-05-24 (#61)

* tests

* 2018-05-24 Roman numbers

Author: nkbt

2018/05-04-2018/berlin-clock-kata/test.js

@@ -11,7 +11,7 @@ function fiveHoursStatus(hours){
 		const a = Math.floor(hours / 5);
 		if (a == 0)
 			return "OOOO";
-		else if (a ==    1)
+		else if (a == 1)
 			return "ROOO";
 		else if (a == 2)
 			return "RROO";
@@ -21,6 +21,40 @@ function fiveHoursStatus(hours){
 			return "RRRR";
 }
 
+function oneHourStatus(hours) {
+		const a = hours % 5;
+		if(a == 1)
+			return "ROOO";
+		else if (a == 2)
+			return "RROO";
+		else if (a == 3)
+			return "RRRO";
+		else if (a == 4)
+			return "RRRR";
+		else
+			return "OOOO";
+}
+
+function fiveMinuteStatus(minutes) {
+	const b = Math.floor(minutes /5);
+	let string = "OOOOOOOOOOO";
+	if (b ==12) {
+		return string;
+	} else {
+		let array = string.split("");
+		for (var i = 0; i < b; i++){
+ 			if ((i+1)%3 == 0){
+ 				array[i] = "R";
+ 			} else { 
+ 				array[i] = "Y";
+ 			}
+		}
+		return array.join("");
+	}
+}
+
+
+
 describe("Berlin Clock", () => {
 
 	it("Given a 1 second, returns OFF", () => {
@@ -38,19 +72,94 @@ describe("Berlin Clock", () => {
 	it("Given 1 hour, returns OOOO", () => {
 		assert.equal(fiveHoursStatus(1), "OOOO")
 	});
+
 	it("Given 5 hour, returns ROOO", () => {
 		assert.equal(fiveHoursStatus(5), "ROOO")
 	});
+	
 	it("Given 10 hour, returns RROO", () => {
 		assert.equal(fiveHoursStatus(10), "RROO")
 	});
+	
 	it("Given 12 hour, returns RROO", () => {
 		assert.equal(fiveHoursStatus(12), "RROO")
 	});
+	
 	it("Given 15 hour, returns RRRO", () => {
 		assert.equal(fiveHoursStatus(15), "RRRO")
 	});
+	
 	it("Given 20 hour, returns RRRR", () => {
 		assert.equal(fiveHoursStatus(20), "RRRR")
 	});
+
+	it("Given 1 hour, returns ROOO", () => {
+		assert.equal(oneHourStatus(1), "ROOO")
+	});
+
+	it("Given 2 hours, returns RROO", () => {
+		assert.equal(oneHourStatus(2), "RROO")
+	});
+
+	it("Given 3 hours, returns RRRO", () => {
+		assert.equal(oneHourStatus(3), "RRRO")
+	});
+
+	it("Given 4 hours, returns RRRR", () => {
+		assert.equal(oneHourStatus(4), "RRRR")
+	});
+
+	it("Given 5 hours, returns OOOO", () => {
+		assert.equal(oneHourStatus(5), "OOOO")
+	});
+
+  it(" Given 5 minutes, returns YOOOOOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(5), "YOOOOOOOOOO")
+  });
+
+  it(" Given 10 minutes, returns YYOOOOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(10), "YYOOOOOOOOO")
+  });
+
+  it(" Given 15 minutes, returns YYROOOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(15), "YYROOOOOOOO")
+  });
+
+  it(" Given 20 minutes, returns YYRYOOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(20), "YYRYOOOOOOO")
+  });
+
+  it(" Given 25 minutes, returns YYRYYOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(25), "YYRYYOOOOOO")
+  });
+
+  it(" Given 30 minutes, returns YYRYYROOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(30), "YYRYYROOOOO")
+  });
+
+  it(" Given 35 minutes, returns YYRYYRYOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(35), "YYRYYRYOOOO")
+  });
+    
+  it(" Given 40 minutes, returns YYRYYRYYOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(40), "YYRYYRYYOOO")
+  });
+
+  it(" Given 45 minutes, returns YYRYYRYYROO", ()=> {
+  	assert.equal(fiveMinuteStatus(45), "YYRYYRYYROO")
+  });
+
+  it(" Given 50 minutes, returns YYRYYRYYRYO", ()=> {
+  	assert.equal(fiveMinuteStatus(50), "YYRYYRYYRYO")
+  });
+
+  it(" Given 55 minutes, returns YYRYYRYYRYY", ()=> {
+  	assert.equal(fiveMinuteStatus(55), "YYRYYRYYRYY")
+  });
+
+  it(" Given 60 minutes, returns OOOOOOOOOOO", ()=> {
+  	assert.equal(fiveMinuteStatus(60), "OOOOOOOOOOO")
+  });
+
+
 });

2018/2018-05-24/roman-numerals/README.md

@@ -0,0 +1,44 @@
+# Roman Numerals
+
+## Problem Description
+
+The Romans were a clever bunch. They conquered most of Europe and ruled it for
+hundreds of years. They invented concrete and straight roads and even bikinis.
+One thing they never discovered though was the number zero. This made writing
+and dating extensive histories of their exploits slightly more challenging, but
+the system of numbers they came up with is still in use today. For example the
+BBC uses Roman numerals to date their programmes.
+
+The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice these
+letters have lots of straight lines and are hence easy to hack into stone
+tablets).
+
+The Kata says you should write a function to convert from normal numbers to
+Roman Numerals. E.g.:
+
+   1  -> I
+   10 -> X
+   7  -> VII
+
+For a full description of how it works, take a look at
+https://en.wikipedia.org/wiki/Roman_numerals
+
+There is no need to be able to convert numbers larger than about 3000 (the
+Romans themselves didn't tend to go any higher). Note that you can't write
+numerals like "IM" for 999. Wikipedia says: Modern Roman numerals (…) are
+written by expressing each digit separately starting with the left most digit
+and skipping any digit with a value of zero. To see this in practice, consider
+the (…) example of 1990. In Roman numerals 1990 is rendered: 1000=M, 900=CM,
+90=XC; resulting in MCMXC. 2008 is written as 2000=MM, 8=VIII; or MMVIII.
+
+Here are a few more examples you can use as test cases:
+
+1954 -> MCMLIV
+1990 -> MCMXC
+2014 -> MMXIV
+
+# Extension:
+
+Write a function to convert in the other direction, i.e. numeral to digit.
+
+From: http://codingdojo.org/kata/RomanNumerals/

2018/2018-05-24/roman-numerals/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "roman-numerals",
+  "scripts": {
+    "test": "mocha -w"
+  },
+  "devDependencies": {
+    "mocha": "3.2.0"
+  }
+}

2018/2018-05-24/roman-numerals/test.js

@@ -0,0 +1,72 @@
+const assert = require('assert');
+
+function convertToRoman(digital) {
+    const numbers = {1: "I", 5: "V", 10: "X", 50: "L", 100: "C", 500: "D", 1000: "M"};
+    if (numbers[digital]) {
+        console.log(digital);
+        console.log(numbers[digital]);
+        return numbers[digital];
+    } else {
+        return "II";
+    }
+
+    // switch (digital){
+    // case 1:return "I";
+    // break;
+    // case 5:return "V";
+    // break;
+    // case 50:return "L";
+    // break;
+    // default: return "X";
+    //}
+}
+
+
+describe('Roman Numerals', () => {
+
+    it('works', () => {
+        const expected = true;
+        const actual = true;
+
+        assert.equal(actual, expected);
+    });
+
+    it('Should convert 1 to "I"', () => {
+        const expected = 'I';
+        const actual = convertToRoman(1);
+
+        assert.equal(actual, expected);
+    });
+
+    it('Should convert 2 to "II"', () => {
+        const expected = 'II';
+        const actual = convertToRoman(2);
+        assert.equal(actual, expected);
+    });
+
+    it('Should convert 5 to "V"', () => {
+        const expected = 'V';
+        const actual = convertToRoman(5);
+
+        assert.equal(actual, expected);
+    });
+
+    it('Should convert 10 to "X"', () => {
+        assert.equal(convertToRoman(10), 'X');
+    });
+
+    it('Should convert 50 to "L"', () => {
+        assert.equal(convertToRoman(50), 'L');
+    });
+    it('Should convert 100 to "C"', () => {
+        assert.equal(convertToRoman(100), 'C');
+    });
+    it('Should convert 500 to "D"', () => {
+        assert.equal(convertToRoman(500), 'D');
+    });
+    it('Should convert 1000 to "M"', () => {
+        assert.equal(convertToRoman(1000), 'M');
+    });
+});
+
+