trackler 2.2.0.4 → 2.2.0.5

data/tracks/java/exercises/forth/src/test/java/ForthEvaluatorTest.java

@@ -0,0 +1,355 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+
+/*
+ * version: 1.2.0
+ */
+public class ForthEvaluatorTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    private ForthEvaluator forthEvaluator;
+
+    @Before
+    public void setUp() {
+        forthEvaluator = new ForthEvaluator();
+    }
+
+    @Test
+    public void testEmptyProgramResultsInEmptyStack() {
+        assertEquals(
+                Collections.emptyList(),
+                forthEvaluator.evaluateProgram(Collections.emptyList()));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testNumbersAreJustPushedOntoTheStack() {
+        assertEquals(
+                Arrays.asList(1, 2, 3, 4, 5),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 3 4 5")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoNumbersCanBeAdded() {
+        assertEquals(
+                Collections.singletonList(3),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 +")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfAdditionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Addition requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("+"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfAdditionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Addition requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 +"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoNumbersCanBeSubtracted() {
+        assertEquals(
+                Collections.singletonList(-1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("3 4 -")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfSubtractionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Subtraction requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("-"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfSubtractionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Subtraction requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 -"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoNumbersCanBeMultiplied() {
+        assertEquals(
+                Collections.singletonList(8),
+                forthEvaluator.evaluateProgram(Collections.singletonList("2 4 *")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfMultiplicationAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Multiplication requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("*"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfMultiplicationAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Multiplication requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 *"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTwoNumbersCanBeDivided() {
+        assertEquals(
+                Collections.singletonList(4),
+                forthEvaluator.evaluateProgram(Collections.singletonList("12 3 /")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThatIntegerDivisionIsUsed() {
+        assertEquals(
+                Collections.singletonList(2),
+                forthEvaluator.evaluateProgram(Collections.singletonList("8 3 /")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfDividingByZero() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Division by 0 is not allowed");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("4 0 /"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfDivisionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Division requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("/"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfDivisionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Division requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 /"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCombinedAdditionAndSubtraction() {
+        assertEquals(
+                Collections.singletonList(-1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 + 4 -")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCombinedMultiplicationAndDivision() {
+        assertEquals(
+                Collections.singletonList(2),
+                forthEvaluator.evaluateProgram(Collections.singletonList("2 4 * 3 /")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDupCopiesTheTopValueOnTheStack() {
+        assertEquals(
+                Arrays.asList(1, 1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 DUP")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDupParsingIsCaseInsensitive() {
+        assertEquals(
+                Arrays.asList(1, 2, 2),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 Dup")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfDuplicatingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Duplicating requires that the stack contain at least 1 value");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("dup"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDropRemovesTheTopValueOnTheStackIfItIsTheOnlyOne() {
+        assertEquals(
+                Collections.emptyList(),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 drop")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDropRemovesTheTopValueOnTheStackIfItIsNotTheOnlyOne() {
+        assertEquals(
+                Collections.singletonList(1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 drop")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfDroppingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Dropping requires that the stack contain at least 1 value");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("drop"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSwapSwapsTheTopTwosValueOnTheStackIfTheyAreTheOnlyOnes() {
+        assertEquals(
+                Arrays.asList(2, 1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 swap")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSwapSwapsTheTopTwosValueOnTheStackIfTheyAreNotTheOnlyOnes() {
+        assertEquals(
+                Arrays.asList(1, 3, 2),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 3 swap")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfSwappingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Swapping requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("swap"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfSwappingAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Swapping requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 swap"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testOverCopiesTheSecondElementIfThereAreOnlyTwo() {
+        assertEquals(
+                Arrays.asList(1, 2, 1),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 over")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testOverCopiesTheSecondElementIfThereAreMoreThanTwo() {
+        assertEquals(
+                Arrays.asList(1, 2, 3, 2),
+                forthEvaluator.evaluateProgram(Collections.singletonList("1 2 3 over")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfOveringAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Overing requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("over"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfOveringAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Overing requires that the stack contain at least 2 values");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("1 over"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testUserDefinedOperatorsCanConsistOfBuiltInOperators() {
+        assertEquals(
+                Arrays.asList(1, 1, 1),
+                forthEvaluator.evaluateProgram(Arrays.asList(": dup-twice dup dup ;", "1 dup-twice")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testUserDefinedOperatorsAreEvaluatedInTheCorrectOrder() {
+        assertEquals(
+                Arrays.asList(1, 2, 3),
+                forthEvaluator.evaluateProgram(Arrays.asList(": countup 1 2 3 ;", "countup")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCanRedefineAUserDefinedOperator() {
+        assertEquals(
+                Arrays.asList(1, 1, 1),
+                forthEvaluator.evaluateProgram(Arrays.asList(": foo dup ;", ": foo dup dup ;", "1 foo")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCanOverrideBuiltInWordOperators() {
+        assertEquals(
+                Arrays.asList(1, 1),
+                forthEvaluator.evaluateProgram(Arrays.asList(": swap dup ;", "1 swap")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCanOverrideBuiltInArithmeticOperators() {
+        assertEquals(
+                Collections.singletonList(12),
+                forthEvaluator.evaluateProgram(Arrays.asList(": + * ;", "3 4 +")));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testCannotRedefineNumbers() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Cannot redefine numbers");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList(": 1 2 ;"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testErrorIfEvaluatingAnUndefinedOperator() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("No definition available for operator \"foo\"");
+
+        forthEvaluator.evaluateProgram(Collections.singletonList("foo"));
+    }
+
+}

data/tracks/java/exercises/settings.gradle

@@ -25,6 +25,7 @@ include 'difference-of-squares'
 include 'etl'
 include 'flatten-array'
 include 'food-chain'
+include 'forth'
 include 'gigasecond'
 include 'grade-school'
 include 'hamming'

data/tracks/javascript/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "javascript",
   "language": "JavaScript",
-  "repository": "https://github.com/exercism/javascript",
   "active": true,
   "test_pattern": ".*[.]spec[.]js$",
   "exercises": [

data/tracks/kotlin/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "kotlin",
   "language": "Kotlin",
-  "repository": "https://github.com/exercism/kotlin",
   "active": true,
   "foregone": [
 
@@ -479,6 +477,16 @@
 
       ]
     },
+    {
+      "uuid": "5607dae5-13aa-4cd4-8b4c-d270516182d7",
+      "slug": "say",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 6,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "f754e1cc-cb88-4776-ab11-3e6ae8362d5a",
       "slug": "anagram",
@@ -499,6 +507,16 @@
 
       ]
     },
+    {
+      "uuid": "d617987e-64b8-4c21-89a9-66a932c4668d",
+      "slug": "meetup",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 7,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "1dcefdea-5447-4622-a064-079aad781398",
       "slug": "clock",
@@ -539,6 +557,16 @@
 
       ]
     },
+    {
+      "uuid": "eecd4f8b-eedc-49a3-adad-49747521ef66",
+   	  "slug": "forth",
+   	  "core": false,
+   	  "unlocked_by": null,
+      "difficulty": 9,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "240788cd-afa5-4fd6-8df0-a158239c0610",
       "slug": "react",

data/tracks/kotlin/exercises/forth/README.md

@@ -0,0 +1,32 @@
+# Forth
+
+Implement an evaluator for a very simple subset of Forth.
+
+[Forth](https://en.wikipedia.org/wiki/Forth_%28programming_language%29)
+is a stack-based programming language. Implement a very basic evaluator
+for a small subset of Forth.
+
+Your evaluator has to support the following words:
+
+- `+`, `-`, `*`, `/` (integer arithmetic)
+- `DUP`, `DROP`, `SWAP`, `OVER` (stack manipulation)
+
+Your evaluator also has to support defining new words using the
+customary syntax: `: word-name definition ;`.
+
+To keep things simple the only data type you need to support is signed
+integers of at least 16 bits size.
+
+You should use the following rules for the syntax: a number is a
+sequence of one or more (ASCII) digits, a word is a sequence of one or
+more letters, digits, symbols or punctuation that is not a number.
+(Forth probably uses slightly different rules, but this is close
+enough.)
+
+Words are case-insensitive.
+
+
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/kotlin/exercises/forth/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/kotlin/exercises/forth/src/example/kotlin/ForthEvaluator.kt

@@ -0,0 +1,138 @@
+import java.util.*
+
+sealed class Token {
+
+    data class OpDefToken(val newOp: String, val newOpDefTokens: List<Token>): Token() {
+
+        companion object {
+            fun fromString(string: String): OpDefToken {
+                val trimmedLine = string.substring(2..string.lastIndex - 2)
+                val newOpEnd = trimmedLine.indexOf(" ")
+
+                require(newOpEnd >= 0) { "Incomplete operation definition" }
+
+                val newOpToken = Token.fromString(trimmedLine.substring(0 until newOpEnd)).first()
+
+                require(newOpToken is OpToken) { "Cannot redefine numbers" }
+
+                val newOpDefTokens = Token.fromString(trimmedLine.substring(newOpEnd + 1))
+                return OpDefToken((newOpToken as OpToken).op, newOpDefTokens)
+            }
+        }
+
+    }
+
+    data class OpToken(val op: String): Token()
+    data class IntToken(val rawValue: Int): Token()
+
+    companion object {
+        val opChars = "A-z+/*\\-"
+
+        fun fromString(string: String): List<Token> {
+            return when {
+                string.startsWith(':') -> listOf(OpDefToken.fromString(string))
+                string.matches(Regex("[$opChars]+(?:-[$opChars]+)*")) -> listOf(OpToken(string.toLowerCase()))
+                string.matches(Regex("\\d+")) -> listOf(IntToken(string.toInt()))
+                else -> string.split(delimiters = " ").flatMap { Token.fromString(it) }
+            }
+        }
+    }
+
+}
+
+class ForthEvaluator {
+
+    companion object {
+        private val builtInOps = mapOf<String, (Deque<Int>) -> Any>(
+                Pair("+") { values ->
+                    require(values.size >= 2) { "Addition requires that the stack contain at least 2 values" }
+                    values.push(values.pop() + values.pop())
+                },
+
+                Pair("-") { values ->
+                    require(values.size >= 2) { "Subtraction requires that the stack contain at least 2 values" }
+                    val topValue = values.pop()
+                    val secondValue = values.pop()
+                    values.push(secondValue - topValue)
+                },
+
+                Pair("*") { values ->
+                    require(values.size >= 2) { "Multiplication requires that the stack contain at least 2 values" }
+                    values.push(values.pop() * values.pop())
+                },
+
+                Pair("/") { values ->
+                    require(values.size >= 2) { "Division requires that the stack contain at least 2 values" }
+                    val topValue = values.pop()
+                    val secondValue = values.pop()
+                    require(topValue != 0) { "Division by 0 is not allowed" }
+                    values.push(secondValue / topValue)
+                },
+
+                Pair("dup") { values ->
+                    require(values.isNotEmpty()) { "Duplicating requires that the stack contain at least 1 value" }
+                    values.push(values.peek())
+                },
+
+                Pair("drop") { values ->
+                    require(values.isNotEmpty()) { "Dropping requires that the stack contain at least 1 value" }
+                    values.pop()
+                },
+
+                Pair("swap") { values ->
+                    require(values.size >= 2) { "Swapping requires that the stack contain at least 2 values" }
+                    val topValue = values.pop()
+                    val secondValue = values.pop()
+                    values.push(topValue)
+                    values.push(secondValue)
+                },
+
+                Pair("over") { values ->
+                    require(values.size >= 2) { "Overing requires that the stack contain at least 2 values" }
+                    val topValue = values.pop()
+                    val secondValue = values.peek()
+                    values.push(topValue)
+                    values.push(secondValue)
+                }
+        )
+    }
+
+    private val values = ArrayDeque<Int>()
+
+    private val tokens = mutableListOf<Token>()
+
+    private val userOps = mutableMapOf<String, List<Token>>()
+
+    fun evaluateProgram(program: List<String>): List<Int> {
+        parse(program)
+        evaluate()
+        return values.toList().asReversed()
+    }
+
+    private fun parse(program: List<String>) = tokens.addAll(program.flatMap(Token.Companion::fromString))
+
+    private fun evaluate() {
+        while (tokens.isNotEmpty()) {
+            val token = tokens.removeAt(0)
+
+            when (token) {
+                is Token.OpDefToken -> userOps.put(token.newOp.toLowerCase(), token.newOpDefTokens)
+                is Token.OpToken    -> evaluateOpToken(token)
+                is Token.IntToken   -> values.push(token.rawValue)
+            }
+        }
+    }
+
+    private fun evaluateOpToken(opToken: Token.OpToken) {
+        val op = opToken.op
+
+        if (userOps.containsKey(op)) {
+            userOps[op]!!.asReversed().forEach { token -> tokens.add(index = 0, element = token) }
+        } else if (builtInOps.containsKey(op)) {
+            builtInOps[op]!!.invoke(values)
+        } else {
+            throw IllegalArgumentException("No definition available for operator \"$op\"")
+        }
+    }
+
+}