trackler 2.0.8.12 → 2.0.8.13

data/tracks/go/exercises/luhn/example.go

@@ -1,40 +1,40 @@
 package luhn
 
-const testVersion = 1
+import "strings"
 
-func Valid(n string) bool {
-	if len(n) == 1 {
-		return false
-	}
-	d := extract(n)
-	if len(d) == 0 {
+const testVersion = 2
+
+func Valid(id string) bool {
+
+	if len(strings.TrimSpace(id)) == 1 {
 		return false
 	}
-	last := len(d) - 1
-	return (check(d[:last])+d[last])%10 == 0
-}
 
-func extract(n string) []int {
-	d := make([]int, 0, len(n))
-	for _, r := range n {
-		if r >= '0' && r <= '9' {
-			d = append(d, int(r-'0'))
+	d := make([]int, 0, len(id))
+
+	for _, r := range id {
+		if r == ' ' {
+			continue
+		}
+		if r < '0' || r > '9' {
+			return false
 		}
+		d = append(d, int(r-'0'))
 	}
-	return d
+
+	return sum(d)%10 == 0
 }
 
-func check(d []int) int {
-	for i := len(d) - 1; i >= 0; i -= 2 {
-		x := 2 * d[i]
-		if x > 9 {
-			x -= 9
+func sum(d []int) (s int) {
+	for i, x := range d {
+		j := len(d) - i
+		if j%2 == 0 {
+			x *= 2
+			if x > 9 {
+				x -= 9
+			}
 		}
-		d[i] = x
-	}
-	s := 0
-	for _, x := range d {
 		s += x
 	}
-	return s
+	return
 }

data/tracks/go/exercises/luhn/example_gen.go

@@ -0,0 +1,50 @@
+// +build ignore
+
+package main
+
+import (
+	"log"
+	"text/template"
+
+	"../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("luhn", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Valid []struct {
+		Description string
+		Input       string
+		Expected    bool
+	}
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package luhn
+
+// Source: {{.Ori}}
+{{if .Commit}}// Commit: {{.Commit}}
+{{end}}
+
+var testCases = []struct {
+	description string
+	input       string
+	ok			bool
+}{
+{{range .J.Valid}}{
+	{{printf "%q" .Description}},
+	{{printf "%q" .Input}},
+	{{.Expected}},
+},
+{{end}}
+}`

data/tracks/go/exercises/luhn/luhn_test.go

@@ -2,20 +2,7 @@ package luhn
 
 import "testing"
 
-const targetTestVersion = 1
-
-var testCases = []struct {
-	input       string
-	description string
-	ok          bool
-}{
-	{"1", "single digit strings can not be valid", false},
-	{"0", "a single zero is invalid", false},
-	{"046 454 286", "valid Canadian SIN", true},
-	{"046 454 287", "invalid Canadian SIN", false},
-	{"8273 1232 7352 0569", "invalid credit card", false},
-	{"827a 1232 7352 0569", "strings that contain non-digits are not valid", false},
-}
+const targetTestVersion = 2
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {

data/tracks/go/exercises/perfect-numbers/perfect_numbers_test.go

@@ -4,6 +4,19 @@ import "testing"
 
 var _ error = ErrOnlyPositive
 
+var classificationTestCases = []struct {
+	input    uint64
+	expected Classification
+}{
+	{1, ClassificationDeficient},
+	{13, ClassificationDeficient},
+	{12, ClassificationAbundant},
+	{6, ClassificationPerfect},
+	{28, ClassificationPerfect},
+	{496, ClassificationPerfect},
+	{8128, ClassificationPerfect},
+}
+
 const targetTestVersion = 1
 
 func TestTestVersion(t *testing.T) {
@@ -19,19 +32,7 @@ func TestGivesPositiveRequiredError(t *testing.T) {
 }
 
 func TestClassifiesCorrectly(t *testing.T) {
-	cases := []struct {
-		input    uint64
-		expected Classification
-	}{
-		{1, ClassificationDeficient},
-		{13, ClassificationDeficient},
-		{12, ClassificationAbundant},
-		{6, ClassificationPerfect},
-		{28, ClassificationPerfect},
-		{496, ClassificationPerfect},
-		{8128, ClassificationPerfect},
-	}
-	for _, c := range cases {
+	for _, c := range classificationTestCases {
 		if cat, err := Classify(c.input); err != nil {
 			t.Errorf("%d: Expected no error but got %s", c.input, err)
 		} else if cat != c.expected {

data/tracks/java/exercises/rna-transcription/src/example/java/RnaTranscription.java

@@ -1,6 +1,6 @@
 public class RnaTranscription {
 
-    public static String ofDna(String strand) {
+    public String ofDna(String strand) {
         StringBuilder sb = new StringBuilder();
         for (char c : strand.toCharArray()) {
             switch (c) {

data/tracks/java/exercises/rna-transcription/src/main/java/RnaTranscription.java

@@ -0,0 +1,5 @@
+public class RnaTranscription {
+    public String ofDna(String dnaString) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+}

data/tracks/java/exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

@@ -1,42 +1,49 @@
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.Before;
 import org.junit.Ignore;
+import org.junit.Test;
 
 public class RnaTranscriptionTest {
 
+    private RnaTranscription rnaTranscription;
+
+    @Before
+    public void setUp() {
+        rnaTranscription = new RnaTranscription();
+    }
 
     @Test
     public void testRnaTranscriptionOfEmptyDnaIsEmptyRna() {
-        Assert.assertEquals("", RnaTranscription.ofDna(""));
+        Assert.assertEquals("", rnaTranscription.ofDna(""));
     }
 
     @Ignore
     @Test
     public void testRnaTranscriptionOfCytosineIsGuanine() {
-        Assert.assertEquals("G", RnaTranscription.ofDna("C"));
+        Assert.assertEquals("G", rnaTranscription.ofDna("C"));
     }
 
     @Ignore
     @Test
     public void testRnaTranscriptionOfGuanineIsCytosine() {
-        Assert.assertEquals("C", RnaTranscription.ofDna("G"));
+        Assert.assertEquals("C", rnaTranscription.ofDna("G"));
     }
 
     @Ignore
     @Test
     public void testRnaTranscriptionOfThymineIsAdenine() {
-        Assert.assertEquals("A", RnaTranscription.ofDna("T"));
+        Assert.assertEquals("A", rnaTranscription.ofDna("T"));
     }
 
     @Ignore
     @Test
     public void testRnaTranscriptionOfAdenineIsUracil() {
-        Assert.assertEquals("U", RnaTranscription.ofDna("A"));
+        Assert.assertEquals("U", rnaTranscription.ofDna("A"));
     }
 
     @Ignore
     @Test
     public void testRnaTranscription() {
-        Assert.assertEquals("UGCACCAGAAUU", RnaTranscription.ofDna("ACGTGGTCTTAA"));
+        Assert.assertEquals("UGCACCAGAAUU", rnaTranscription.ofDna("ACGTGGTCTTAA"));
     }
 }

data/tracks/julia/.travis.yml

@@ -6,6 +6,7 @@ os:
 julia:
   - release
   - nightly
+  - 0.5.0
 
 matrix:
   allow_failures:

data/tracks/lisp/docs/ABOUT.md

@@ -1,9 +1,12 @@
-Common Lisp is an offshoot of the long-running family of Lisp programming languages. 
-It's a multi-paradigm programming language that allows you to choose the approach and paradigm 
-according to your application domain.
+Common Lisp is an offshoot of the long-running family of Lisp
+programming languages. It's a multi-paradigm programming language that
+allows you to choose the approach and paradigm according to your
+application domain.
 
-Common Lisp has fast prototyping capabilities, and exceptional support for object oriented programming. 
-It also boasts a macro system which allows you to adapt the language to your needs, 
-and a run-time environment which allows modification of running applications.
+Common Lisp has fast prototyping capabilities, and exceptional support
+for object oriented programming. It also boasts a macro system which
+allows you to adapt the language to your needs, and a run-time
+environment which allows modification of running applications.
 
-To learn more about Common Lisp, take a look at [the Common Lisp homepage](https://common-lisp.net/).
+To learn more about Common Lisp, take a look
+at [the Common Lisp homepage](https://common-lisp.net/).

data/tracks/lisp/docs/INSTALLATION.md

@@ -1,4 +1,6 @@
-Install a lisp implementation such as SBCL or CLisp. Both can be installed via Homebrew on Mac OS X.
+Install a lisp implementation such as [SBCL](http://www.sbcl.org/)
+or [CLisp](http://clisp.org/). Both can be installed via Homebrew on
+Mac OS X.
 
 ```bash
 brew install sbcl
@@ -6,7 +8,11 @@ brew install sbcl
 brew install clisp
 ```
 
-Then install [QuickLisp](http://www.quicklisp.org/beta/#installation) and download
+(See their homepages for instructions for installing on other
+platforms.) 
+
+Then install [QuickLisp](http://www.quicklisp.org/beta/#installation)
+and download
 [http://beta.quicklisp.org/quicklisp.lisp](http://beta.quicklisp.org/quicklisp.lisp).
 
 ```bash
@@ -19,7 +25,8 @@ Load it into your running Lisp implementation, and type:
 (quicklisp-quickstart:install)
 ```
 
-To add the startup code to your init file so that the next time you start the lisp interpreter QuickLisp will be loaded, type:
+To add the startup code to your init file so that the next time you
+start the lisp interpreter QuickLisp will be loaded, type:
 
 ```lisp
 (ql:add-to-init-file)
@@ -31,4 +38,5 @@ Optionally load lisp-unit:
 (ql:quickload "lisp-unit")
 ```
 
-This will be done the first time you run any exercises tests. But you can do it now if you want.
+This will be done the first time you run any exercises tests. But you
+can do it now if you want.

data/tracks/lisp/docs/LEARNING.md

@@ -2,8 +2,14 @@ Exercism provides exercises and feedback but can be difficult to jump
 into for those learning Common Lisp for the first time. These
 resources can help you get started:
 
-* [Cliki.net Getting Start Started Page](http://cliki.net/Getting%20Started), by various contributors
-* [Wikibooks book of Common Lisp, First steps](http://en.wikibooks.org/wiki/Common_Lisp/First_steps), by various contributors
-* [Learn X in Y minutes: where X = Common Lisp](http://learnxinyminutes.com/docs/common-lisp/) by Paul Nathan
-* [Northwestern University EECS 325 Readings](http://www.cs.northwestern.edu/academics/courses/325/readings/readings.php), by Chris Riesbeck
-* [The Common Lisp Cookbook](http://lispcookbook.github.io/cl-cookbook/), by various contributors ([legacy SF site](http://cl-cookbook.sourceforge.net/))
+* [Cliki.net Getting Start Started Page](http://cliki.net/Getting%20Started),
+  by various contributors
+* [Wikibooks book of Common Lisp, First steps](http://en.wikibooks.org/wiki/Common_Lisp/First_steps),
+  by various contributors
+* [Learn X in Y minutes: where X = Common Lisp](http://learnxinyminutes.com/docs/common-lisp/) by
+  Paul Nathan
+* [Northwestern University EECS 325 Readings](http://www.cs.northwestern.edu/academics/courses/325/readings/readings.php),
+  by Chris Riesbeck
+* [The Common Lisp Cookbook](http://lispcookbook.github.io/cl-cookbook/),
+  by various contributors
+  ([legacy SF site](http://cl-cookbook.sourceforge.net/))

data/tracks/lisp/docs/RESOURCES.md

@@ -3,10 +3,14 @@ one of the learning section.
 
 ### Important resources
 
-* [The Common Lisp HyperSpec](http://www.lispworks.com/documentation/common-lisp.html), by X3J13 committee. The Common Lisp Standard
-* [Common Lisp the Language, 2nd Edition](http://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html), by Guy Steele
-* [Common Lisp Document Repository](http://cdr.eurolisp.org/) a collection of emergent and de-facto standards
-* [Common-Lisp.net](http://common-lisp.net/), project hosting and gateway
+* [The Common Lisp HyperSpec](http://www.lispworks.com/documentation/common-lisp.html),
+  by X3J13 committee. The Common Lisp Standard
+* [Common Lisp the Language, 2nd Edition](http://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html),
+  by Guy Steele
+* [Common Lisp Document Repository](http://cdr.eurolisp.org/) a
+  collection of emergent and de-facto standards
+* [Common-Lisp.net](http://common-lisp.net/), project hosting and
+  gateway
 * [The Common Lisp Wiki](http://www.cliki.net/)
 
 ### Free books
@@ -14,16 +18,21 @@ one of the learning section.
 There are many other great books you can find links to. These are the
 most popularly linked introductory works.
 
-* [Practical Common Lisp](http://www.gigamonkeys.com/book/), by Peter Seibel
-* [Common Lisp: A Gentle Introduction to Symbolic Computation](http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html) (PDF), by David S. Touretzky
-* [Common Lisp: An Interactive Approach](http://www.cse.buffalo.edu/~shapiro/Commonlisp/) (PDF), by Stuart C. Shapiro
-* [Successful Lisp: How to Understand and Use Common Lisp](http://psg.com/~dlamkins/sl/cover.html), by David B. Lamkins
+* [Practical Common Lisp](http://www.gigamonkeys.com/book/), by Peter
+  Seibel
+* [Common Lisp: A Gentle Introduction to Symbolic Computation](http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html) (PDF),
+  by David S. Touretzky
+* [Common Lisp: An Interactive Approach](http://www.cse.buffalo.edu/~shapiro/Commonlisp/) (PDF),
+  by Stuart C. Shapiro
+* [Successful Lisp: How to Understand and Use Common Lisp](http://psg.com/~dlamkins/sl/cover.html),
+  by David B. Lamkins
 
 Following these are two more advanced books, but beginners shouldn't
 be afraid of them, they're quite accessible and "classics".
 
 * [On Lisp](http://www.paulgraham.com/onlisptext.html), by Paul Graham
-* [Structure and Interpretation of Computer Programs](http://mitpress.mit.edu/sicp/), by Abelson, Sussman, and Sussman
+* [Structure and Interpretation of Computer Programs](http://mitpress.mit.edu/sicp/),
+  by Abelson, Sussman, and Sussman
 
 The last is actually on a related Lisp dialect, Scheme, but it's very
 helpful book, generally. If you find you prefer Scheme, it's an

data/tracks/lisp/docs/TESTS.md

@@ -1,3 +1,7 @@
+Start up your Lisp implementation in the directory of the exercise you
+are working on (or change the current directory for an already running
+Lisp implementation to that directory).
+
 Load the test file into your running Lisp implementation, for example,
 `(load "point-mutations-test")`. This will run the tests the first
 time automatically. After that you can run the test suite in the REPL

data/tracks/scala/exercises/simple-linked-list/src/test/scala/SimpleLinkedListTest.scala

@@ -61,7 +61,7 @@ class SimpleLinkedListTest extends FlatSpec with Matchers with GeneratorDrivenPr
     reversed.next.next.next.next.value should be (2)
     reversed.next.next.next.next.next.value should be (1)
   }
-  
+
   it should "handle arbitrary list fromSeq toSeq" in {
     pending
     forAll { seq: Seq[Int] =>
@@ -99,6 +99,14 @@ class SimpleLinkedListTest extends FlatSpec with Matchers with GeneratorDrivenPr
     }
   }
 
+  it should "return original arbitrary list from added list elements" in {
+    pending
+    forAll { xs: Seq[Int] =>
+      val list = xs.foldLeft(SimpleLinkedList[Int]())(_.add(_))
+      assert(list.toSeq == xs)
+    }
+  }
+
   it should "handle arbitrary generics" in {
     pending
     forAll { xs: Seq[String] =>

data/tracks/typescript/config.json

@@ -70,6 +70,12 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "food-chain",
+      "difficulty": 1,
+      "topics": [
+      ]
     },
       {
       "slug": "wordy",

data/tracks/typescript/exercises/food-chain/food-chain.example.ts

@@ -0,0 +1,54 @@
+const animals = ["fly", "spider", "bird", "cat", "dog", "goat", "cow", "horse"]
+
+export default class FoodChain {
+
+    public static verses(start = 1, end = 8): string {
+        if (end < start) {throw new Error("end should be smaller than the start")}
+        let verses = ""
+
+        for ( ; start <= end; start += 1) {
+            verses += FoodChain.verse(start)
+            if (start !== end) {
+                verses += "\n"
+            }
+        }
+        return verses
+    }
+
+    public static verse(num: number): string {
+        let result = ""
+
+        let index = num - 1
+        result += `I know an old lady who swallowed a ${animals[index]}.\n`
+
+        switch (num) {
+        case 2: result += "It wriggled and jiggled and tickled inside her.\n"
+            break
+        case 3: result += "How absurd to swallow a bird!\n"
+            break
+        case 4: result += "Imagine that, to swallow a cat!\n"
+            break
+        case 5: result += "What a hog, to swallow a dog!\n"
+            break
+        case 6: result += "Just opened her throat and swallowed a goat!\n"
+            break
+        case 7: result += "I don't know how she swallowed a cow!\n"
+            break
+        case 8: result += "She's dead, of course!\n"
+            return result
+        default: break
+        }
+
+        while ( index >= 1 ) {
+            result += `She swallowed the ${animals[index]} to catch the ${animals[index - 1]}`
+            if ( index === 2 ) {
+                result += " that wriggled and jiggled and tickled inside her"
+            }
+            result += ".\n"
+            index -= 1
+        }
+        result += "I don't know why she swallowed the fly. Perhaps she'll die."
+
+        return result + "\n"
+    }
+}