trackler 2.0.8.2 → 2.0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 628be9992a422198cd22ca843fb2037ba6c03d72
-  data.tar.gz: 2ee76fac59c86929d2224dcaa3b4ca3843dc7f4b
+  metadata.gz: f0c444d7b94d362ffd61d031a2c19aa0648aec67
+  data.tar.gz: b89e89a7208130f5c3609cdfc7d489b9049ceb7e
 SHA512:
-  metadata.gz: 950598d86876b07601a68378108358eeeceb09dac2a380d8d5cc607eaa8b6282d0ef2dcd660900dcede06a36b1e5d3fed69ae5ed8c522715b3320c68df20b75b
-  data.tar.gz: 1c2ba152ea54815a1be22d9224f210cfc0b6d0dd402020481666c914569f02b69a36417f7307dddd5ca342fd6ad6df6ea45bce30e9e4b87fb2ba4a4604caee2f
+  metadata.gz: 04579958808938ab72cb8921a7c432c814a219a283b375a732da663b2060cf688640a7cd7ca0f185af4d8c5d2874fcd88c51be3ec0db0f39dde08c46f8203e4a
+  data.tar.gz: 4b4b7d1cde0197fba10b59031fb9355ee2fa4e4a36f5a131b198df6129516e7891ef05f10f3d4117b909a71d6c3ef27b5b91b1bed520d4288159c294427779cb

data/common/exercises/bowling/canonical-data.json

@@ -1,134 +1,172 @@
 {
-  "#": [
+  "exercise": "bowling",
+  "version": "1",
+  "comments": [
     "Students should implement roll and score methods.",
     "Roll should accept a single integer.",
     "Score should return the game's final score, when possible",
-    "For brevity the tests display all the rolls in an array;",
-    "each element of the rolls array should be passed to the roll method",
-    "The final tests define situations where the score can not be returned",
-    "The expection for these tests is -1, indicating an error",
-    "In these cases you should expect an error as is idiomatic for your language",
-    "When to error is also left up to your implementation. There are two options",
-    "  - Error as soon as an invalid roll is made",
-    "  - Error when scoring a game with an invalid roll",
-    "You can also error in both cases."
+    "For brevity the tests display all the previous rolls in an array;",
+    "each element of the previous_rolls array should be passed to the roll method",
+    "and each of those previous rolls is expected to succeed.",
+    "",
+    "Two properties are tested:",
+    "",
+    "`score`: All rolls succeed, and taking the score gives the expected result.",
+    "The expected result may be an integer score or an error.",
+    "",
+    "`roll`: All previous_rolls succeed, and rolling the number of pins in `roll` produces the expected result.",
+    "Currently, all cases of this type result in errors.",
+    "",
+    "In all error cases you should expect an error as is idiomatic for your language",
+    "whether that be via exceptions, optional values, or otherwise."
   ],
-  "score": {
-    "description": [
-      "returns the final score of a bowling game"
-    ],
-    "cases": [{
-      "description": "should be able to score a game with all zeros",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 0
-    }, {
-      "description": "should be able to score a game with no strikes or spares",
-      "rolls": [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6],
-      "expected": 90
-    }, {
-      "description": "a spare followed by zeros is worth ten points",
-      "rolls": [6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 10
-    }, {
-      "description": "points scored in the roll after a spare are counted twice",
-      "rolls": [6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 16
-    }, {
-      "description": "consecutive spares each get a one roll bonus",
-      "rolls": [5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 31
-    }, {
-      "description": "a spare in the last frame gets a one roll bonus that is counted once",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7],
-      "expected": 17
-    }, {
-      "description": "a strike earns ten points in a frame with a single roll",
-      "rolls": [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 10
-    }, {
-      "description": "points scored in the two rolls after a strike are counted twice as a bonus",
-      "rolls": [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 26
-    }, {
-      "description": "consecutive strikes each get the two roll bonus",
-      "rolls": [10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 81
-    }, {
-      "description": "a strike in the last frame gets a two roll bonus that is counted once",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1],
-      "expected": 18
-    }, {
-      "description": "rolling a spare with the two roll bonus does not get a bonus roll",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3],
-      "expected": 20
-    }, {
-      "description": "strikes with the two roll bonus do not get bonus rolls",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10],
-      "expected": 30
-    }, {
-      "description": "a strike with the one roll bonus after a spare in the last frame does not get a bonus",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10],
-      "expected": 20
-    }, {
-      "description": "all strikes is a perfect game",
-      "rolls": [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
-      "expected": 300
-    }, {
-      "description": "rolls can not score negative points",
-      "rolls": [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": -1
-    }, {
-      "description": "a roll can not score more than 10 points",
-      "rolls": [11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": -1
-    }, {
-      "description": "two rolls in a frame can not score more than 10 points",
-      "rolls": [5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": -1
-    }, {
-      "description": "bonus roll after a strike in the last frame can not score more than 10 points",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11],
-      "expected": -1
-    }, {
-      "description": "two bonus rolls after a strike in the last frame can not score more than 10 points",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6],
-      "expected": -1
-    }, {
-      "description": "two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6],
-      "expected": 26
-    }, {
-      "description": "the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10],
-      "expected": -1
-    }, {
-      "description": "second bonus roll after a strike in the last frame can not score than 10 points",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 11],
-      "expected": -1
-    }, {
-      "description": "an unstarted game can not be scored",
-      "rolls": [],
-      "expected": -1
-    }, {
-      "description": "an incomplete game can not be scored",
-      "rolls": [0, 0],
-      "expected": -1
-    }, {
-      "description": "a game with more than ten frames can not be scored",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": -1
-    }, {
-      "description": "bonus rolls for a strike in the last frame must be rolled before score can be calculated",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10],
-      "expected": -1
-    }, {
-      "description": "both bonus rolls for a strike in the last frame must be rolled before score can be calculated",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10],
-      "expected": -1
-    }, {
-      "description": "bonus roll for a spare in the last frame must be rolled before score can be calculated",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3],
-      "expected": -1
-    }]
-  }
+  "cases": [{
+    "description": "should be able to score a game with all zeros",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 0
+  }, {
+    "description": "should be able to score a game with no strikes or spares",
+    "property": "score",
+    "previous_rolls": [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6],
+    "expected": 90
+  }, {
+    "description": "a spare followed by zeros is worth ten points",
+    "property": "score",
+    "previous_rolls": [6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 10
+  }, {
+    "description": "points scored in the roll after a spare are counted twice",
+    "property": "score",
+    "previous_rolls": [6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 16
+  }, {
+    "description": "consecutive spares each get a one roll bonus",
+    "property": "score",
+    "previous_rolls": [5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 31
+  }, {
+    "description": "a spare in the last frame gets a one roll bonus that is counted once",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7],
+    "expected": 17
+  }, {
+    "description": "a strike earns ten points in a frame with a single roll",
+    "property": "score",
+    "previous_rolls": [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 10
+  }, {
+    "description": "points scored in the two rolls after a strike are counted twice as a bonus",
+    "property": "score",
+    "previous_rolls": [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 26
+  }, {
+    "description": "consecutive strikes each get the two roll bonus",
+    "property": "score",
+    "previous_rolls": [10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "expected": 81
+  }, {
+    "description": "a strike in the last frame gets a two roll bonus that is counted once",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1],
+    "expected": 18
+  }, {
+    "description": "rolling a spare with the two roll bonus does not get a bonus roll",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3],
+    "expected": 20
+  }, {
+    "description": "strikes with the two roll bonus do not get bonus rolls",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10],
+    "expected": 30
+  }, {
+    "description": "a strike with the one roll bonus after a spare in the last frame does not get a bonus",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10],
+    "expected": 20
+  }, {
+    "description": "all strikes is a perfect game",
+    "property": "score",
+    "previous_rolls": [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
+    "expected": 300
+  }, {
+    "description": "rolls can not score negative points",
+    "property": "roll",
+    "previous_rolls": [],
+    "roll": -1,
+    "expected": {"error": "Negative roll is invalid"}
+  }, {
+    "description": "a roll can not score more than 10 points",
+    "property": "roll",
+    "previous_rolls": [],
+    "roll": 11,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "two rolls in a frame can not score more than 10 points",
+    "property": "roll",
+    "previous_rolls": [5],
+    "roll": 6,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "bonus roll after a strike in the last frame can not score more than 10 points",
+    "property": "roll",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10],
+    "roll": 11,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "two bonus rolls after a strike in the last frame can not score more than 10 points",
+    "property": "roll",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5],
+    "roll": 6,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6],
+    "expected": 26
+  }, {
+    "description": "the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike",
+    "property": "roll",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6],
+    "roll": 10,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "second bonus roll after a strike in the last frame can not score than 10 points",
+    "property": "roll",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10],
+    "roll": 11,
+    "expected": {"error": "Pin count exceeds pins on the lane"}
+  }, {
+    "description": "an unstarted game can not be scored",
+    "property": "score",
+    "previous_rolls": [],
+    "expected": {"error": "Score cannot be taken until the end of the game"}
+  }, {
+    "description": "an incomplete game can not be scored",
+    "property": "score",
+    "previous_rolls": [0, 0],
+    "expected": {"error": "Score cannot be taken until the end of the game"}
+  }, {
+    "description": "cannot roll if game already has ten frames",
+    "property": "roll",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "roll": 0,
+    "expected": {"error": "Cannot roll after game is over"}
+  }, {
+    "description": "bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10],
+    "expected": {"error": "Score cannot be taken until the end of the game"}
+  }, {
+    "description": "both bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10],
+    "expected": {"error": "Score cannot be taken until the end of the game"}
+  }, {
+    "description": "bonus roll for a spare in the last frame must be rolled before score can be calculated",
+    "property": "score",
+    "previous_rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3],
+    "expected": {"error": "Score cannot be taken until the end of the game"}
+  }]
 }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.2"
+  VERSION = "2.0.8.3"
 end

data/tracks/java/exercises/pangram/src/test/java/PangramsTest.java

@@ -8,62 +8,62 @@ public class PangramsTest {
 
 
     @Test
-    public void sentenceEmpty() {
+    public void emptySentenceIsNotPangram() {
         assertFalse(Pangrams.isPangram(""));
     }
 
     @Ignore
     @Test
-    public void pangramWithOnlyLowerCase() {
+    public void pangramWithOnlyLowerCaseLettersIsRecognizedAsPangram() {
         assertTrue(Pangrams.isPangram("the quick brown fox jumps over the lazy dog"));
     }
 
     @Ignore
     @Test
-    public void missingCharacterX() {
+    public void phraseMissingCharacterXIsNotPangram() {
         assertFalse(Pangrams.isPangram("a quick movement of the enemy will jeopardize five gunboats"));
     }
 
     @Ignore
     @Test
-    public void anotherMissingCharacterX() {
+    public void anotherPhraseMissingCharacterXIsNotPangram() {
         assertFalse(Pangrams.isPangram("the quick brown fish jumps over the lazy dog"));
     }
 
     @Ignore
     @Test
-    public void pangramWithUnderscores() {
+    public void pangramWithUnderscoresIsRecognizedAsPangram() {
         assertTrue(Pangrams.isPangram("\"the_quick_brown_fox_jumps_over_the_lazy_dog\""));
     }
 
     @Ignore
     @Test
-    public void pangramWithNumbers() {
+    public void pangramWithNumbersIsRecognizedAsPangram() {
         assertTrue(Pangrams.isPangram("\"the 1 quick brown fox jumps over the 2 lazy dogs\""));
     }
 
     @Ignore
     @Test
-    public void missingLettersReplacedByNumbers() {
+    public void phraseWithMissingLettersReplacedByNumbersIsNotPangram() {
         assertFalse(Pangrams.isPangram("\"7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog\""));
     }
 
     @Ignore
     @Test
-    public void pangramWithMixedCaseAndPunctuation() {
+    public void pangramWithMixedCaseAndPunctuationIsRecognizedAsPangram() {
         assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""));
     }
 
     @Ignore
     @Test
-    public void pangramWithNonAsciiCharacters() {
+    public void pangramWithNonAsciiCharactersIsRecognizedAsPangram() {
         assertTrue(Pangrams.isPangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."));
     }
 
 
     @Ignore
     @Test
-    public void panagramInAlphabetOtherThanAscii() {
+    public void panagramInAlphabetOtherThanAsciiIsNotRecognizedAsPangram() {
         assertFalse(Pangrams.isPangram("Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства."));
     }
 

data/tracks/kotlin/config.json

@@ -228,6 +228,11 @@
       "slug": "change",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "triangle",
+      "topics": []
+    },
     {
       "difficulty": 10,
       "slug": "react",

data/tracks/kotlin/exercises/settings.gradle

@@ -40,4 +40,5 @@ include 'isogram'
 include 'bracket-push'
 include 'largest-series-product'
 include 'change'
-include 'binary-search'
+include 'binary-search'
+include 'triangle'

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

@@ -0,0 +1,29 @@
+buildscript {
+    ext.kotlin_version = '1.0.6'
+    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/triangle/src/example/kotlin/Triangle.kt

@@ -0,0 +1,15 @@
+class Triangle<out T: Number>(val a: T, val b: T, val c: T) {
+
+    init {
+        require(a > 0 && b > 0 && c > 0, {"Sides must be > 0"})
+        require(a + b >= c && b + c >= a && c + a >= b, { "Sides must satisfy triangle inequality"})
+    }
+
+    val isEquilateral = a == b && b == c
+    val isIsosceles = a == b || b == c || c == a
+    val isScalene = !isIsosceles
+
+    private infix operator fun <T: Number> T.compareTo(other: T): Int = this.toDouble().compareTo(other.toDouble())
+    private infix operator fun <T: Number> T.plus(b: T): Double = this.toDouble().plus(b.toDouble())
+
+}

data/tracks/kotlin/exercises/triangle/src/test/kotlin/TriangleTest.kt

@@ -0,0 +1,109 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TriangleTest {
+
+    @Test
+    fun equilateralIfAllSidesAreEqual() {
+        assertTrue(Triangle(2, 2, 2).isEquilateral)
+    }
+
+    @Ignore
+    @Test
+    fun notEquilateralIfAnySideIsUnequal() {
+        assertFalse(Triangle(2, 3, 2).isEquilateral)
+    }
+
+    @Ignore
+    @Test
+    fun notEquilateralIfNoSidesAreEqual() {
+        assertFalse(Triangle(5, 4, 6).isEquilateral)
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun allZeroSidesAreIllegalSoNotEquilateral() {
+        assertFalse(Triangle(0, 0, 0).isEquilateral)
+    }
+
+    @Ignore
+    @Test
+    fun equilateralSidesMayBeFloatingPoint() {
+        assertTrue(Triangle(0.5, 0.5, 0.5).isEquilateral)
+    }
+
+    @Ignore
+    @Test
+    fun isoscelesIfLastTwoSidesAreEqual() {
+        assertTrue(Triangle(3, 4, 4).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun isoscelesIfFirstTwoSidesAreEqual() {
+        assertTrue(Triangle(4, 4, 3).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun isoscelesIfFirstAndLastSidesAreEqual() {
+        assertTrue(Triangle(4, 3, 4).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun equilateralIsAlsoIsosceles() {
+        assertTrue(Triangle(4, 4, 4).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun notIsoscelesIfNoSidesAreEqual() {
+        assertFalse(Triangle(2, 3, 4).isIsosceles)
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun sidesViolateTriangleInequalitySoNotIsosceles() {
+        assertFalse(Triangle(1, 1, 3).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun isoscelesSidesMayBeFloatingPoint() {
+        assertTrue(Triangle(0.5, 0.4, 0.5).isIsosceles)
+    }
+
+    @Ignore
+    @Test
+    fun scaleneIfNoSidesAreEqual() {
+        assertTrue(Triangle(5, 4, 6).isScalene)
+    }
+
+    @Ignore
+    @Test
+    fun notScaleneIfAllSidesAreEqual() {
+        assertFalse(Triangle(4, 4, 4).isScalene)
+    }
+
+    @Ignore
+    @Test
+    fun notScaleneIfTwoSidesAreEqual() {
+        assertFalse(Triangle(4, 4, 3).isScalene)
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun sidesViolateTriangleInequalitySoNotScalene() {
+        assertFalse(Triangle(7, 3, 2).isScalene)
+    }
+
+    @Ignore
+    @Test
+    fun scaleneSidesMayBeFloatingPoint() {
+        assertTrue(Triangle(0.5, 0.4, 0.6).isScalene)
+    }
+
+}

data/tracks/scala/config.json

@@ -318,6 +318,14 @@
             "Tuples"
          ]
       },
+      {
+         "slug":"isogram",
+         "difficulty":1,
+         "topics":[
+            "Strings",
+            "Filtering"
+         ]
+      },
       {
          "slug":"bracket-push",
          "difficulty":1,

data/tracks/scala/exercises/isogram/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/isogram/example.scala

@@ -0,0 +1,8 @@
+object Isogram {
+  def isIsogram(s: String): Boolean =
+    !s.filter(_.isLetter)
+      .map(_.toLower)
+      .groupBy(identity)
+      .values
+      .exists(_.length > 1)
+}

data/tracks/scala/exercises/isogram/src/test/scala/IsogramTest.scala

@@ -0,0 +1,52 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class IsogramTest extends FunSuite with Matchers {
+
+  test("empty string") {
+    val result = Isogram.isIsogram("")
+    result should be (true)
+  }
+
+  test("isogram with only lower case characters") {
+    pending
+    val result = Isogram.isIsogram("isogram")
+    result should be (true)
+  }
+
+  test("word with one duplicated character") {
+    pending
+    val result = Isogram.isIsogram("eleven")
+    result should be (false)
+  }
+
+  test("longest reported english isogram") {
+    pending
+    val result = Isogram.isIsogram("subdermatoglyphic")
+    result should be (true)
+  }
+
+  test("word with duplicated character in mixed case") {
+    pending
+    val result = Isogram.isIsogram("Alphabet")
+    result should be (false)
+  }
+
+  test("hypothetical isogrammic word with hyphen") {
+    pending
+    val result = Isogram.isIsogram("thumbscrew-japingly")
+    result should be (true)
+  }
+
+  test("isogram with duplicated non letter character") {
+    pending
+    val result = Isogram.isIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax")
+    result should be (true)
+  }
+
+  test("made-up name that is an isogram") {
+    pending
+    val result = Isogram.isIsogram("Emily Jung Schwartzkopf")
+    result should be (true)
+  }
+
+}

data/tracks/scala/testgen/src/main/scala/IsogramTestGenerator.scala

@@ -0,0 +1,37 @@
+import play.api.libs.json.Json
+
+import scala.io.Source
+
+class IsogramTestGenerator {
+  implicit val testCaseReader = Json.reads[IsogramTestCase]
+
+  private val filename = "isogram.json"
+  private val fileContents = Source.fromFile(filename).getLines.mkString
+  private val json = Json.parse(fileContents)
+
+  def write {
+    val testCases = (json \ "cases").get.as[List[IsogramTestCase]]
+
+    implicit def testCaseToGen(tc: IsogramTestCase): TestCaseGen = {
+      val callSUT =
+        s"""Isogram.isIsogram("${tc.input}")"""
+      val expected = tc.expected.toString
+
+      TestCaseGen(tc.description, callSUT, expected)
+    }
+
+    val testBuilder = new TestBuilder("IsogramTest")
+    testBuilder.addTestCases(testCases)
+    testBuilder.toFile
+  }
+}
+
+case class IsogramTestCase(description: String,
+                           input: String,
+                           expected: Boolean)
+
+object IsogramTestGenerator {
+  def main(args: Array[String]): Unit = {
+    new IsogramTestGenerator().write
+  }
+}

data/tracks/typescript/Makefile

@@ -44,11 +44,7 @@ moveAllIntoCommonDir:
 moveCommonIntoSubDir:
 	@for assignment in $(ASSIGNMENTS); do ASSIGNMENT=$$assignment $(MAKE) moveAssigmentToSub || exit 1; done
 	
-<<<<<<< HEAD
-all: replacePackageFileFromCommonToSubFolders
-=======
 all: replacePackageFilesFromCommonToSubFolders
->>>>>>> f5528ecd7751462ac6590cc77304a7ac2489c895
 
 copyPackageFilesToSubFolder:
 	@cp ./common/package.json exercises/$(ASSIGNMENT)/package.json
@@ -56,10 +52,6 @@ copyPackageFilesToSubFolder:
 	@cp ./common/tslint.json exercises/$(ASSIGNMENT)/tslint.json
 	@cp ./common/yarn.lock exercises/$(ASSIGNMENT)/yarn.lock
 
-<<<<<<< HEAD
-replacePackageFileFromCommonToSubFolders:
-=======
 replacePackageFilesFromCommonToSubFolders:
->>>>>>> f5528ecd7751462ac6590cc77304a7ac2489c895
 	@for assignment in $(ASSIGNMENTS); do ASSIGNMENT=$$assignment $(MAKE) copyPackageFilesToSubFolder || exit 1; done
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.2
+  version: 2.0.8.3
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-22 00:00:00.000000000 Z
+date: 2017-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -4602,6 +4602,10 @@ files:
 - tracks/kotlin/exercises/strain/src/example/kotlin/Strain.kt
 - tracks/kotlin/exercises/strain/src/main/kotlin/.keep
 - tracks/kotlin/exercises/strain/src/test/kotlin/StrainTest.kt
+- tracks/kotlin/exercises/triangle/build.gradle
+- tracks/kotlin/exercises/triangle/src/example/kotlin/Triangle.kt
+- tracks/kotlin/exercises/triangle/src/main/kotlin/.keep
+- tracks/kotlin/exercises/triangle/src/test/kotlin/TriangleTest.kt
 - tracks/kotlin/exercises/word-count/build.gradle
 - tracks/kotlin/exercises/word-count/src/example/kotlin/WordCount.kt
 - tracks/kotlin/exercises/word-count/src/main/kotlin/.keep
@@ -7175,6 +7179,10 @@ files:
 - tracks/scala/exercises/house/example.scala
 - tracks/scala/exercises/house/src/main/scala/.keep
 - tracks/scala/exercises/house/src/test/scala/HouseTest.scala
+- tracks/scala/exercises/isogram/build.sbt
+- tracks/scala/exercises/isogram/example.scala
+- tracks/scala/exercises/isogram/src/main/scala/Isogram.scala
+- tracks/scala/exercises/isogram/src/test/scala/IsogramTest.scala
 - tracks/scala/exercises/kindergarten-garden/build.sbt
 - tracks/scala/exercises/kindergarten-garden/example.scala
 - tracks/scala/exercises/kindergarten-garden/src/main/scala/.keep
@@ -7388,6 +7396,7 @@ files:
 - tracks/scala/testgen/src/main/scala/BowlingTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/BracketPushTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/CustomSetTestGenerator.scala
+- tracks/scala/testgen/src/main/scala/IsogramTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/PangramsTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/RailFenceCipherTestGenerator.scala
 - tracks/scala/testgen/src/main/scala/TestBuilder.scala