trackler 2.1.0.26 → 2.1.0.27

data/tracks/go/exercises/poker/example.go

@@ -7,7 +7,7 @@ import (
 	"unicode/utf8"
 )
 
-const testVersion = 4
+const testVersion = 5
 
 const (
 	Jack  = 11
@@ -168,6 +168,15 @@ func evalHand(counts []rankCount, cards []card) handValue {
 			discrs = append(discrs, card.rank)
 		}
 		sort.Sort(sort.Reverse(sort.IntSlice(discrs)))
+	} else if (kind == straight || kind == straightFlush) &&
+		counts[0].rank == Ace && counts[1].rank == 5 {
+		// For a straight with an Ace through 5,
+		// adjust down the discrs value of the Ace to be 1.
+		for i := 1; i < len(cards); i++ {
+			discrs = append(discrs, counts[i].rank)
+		}
+		// Ace becomes a 1 in a low straight with Ace.
+		discrs = append(discrs, 1)
 	} else {
 		for _, rc := range counts {
 			discrs = append(discrs, rc.rank)

data/tracks/go/exercises/poker/poker_test.go

@@ -10,230 +10,7 @@ import (
 // Also define a testVersion with a value that matches
 // the targetTestVersion here.
 
-const targetTestVersion = 4
-
-var validTestCases = []struct {
-	name  string
-	hands []string
-	best  []string
-}{
-	{
-		name:  "single hand is always best",
-		hands: []string{"3♡ 10♢ 7♧ 8♤ A♢"},
-		best:  []string{"3♡ 10♢ 7♧ 8♤ A♢"},
-	},
-	{
-		name:  "highest card",
-		hands: []string{"3♢ 2♢ 5♤ 6♤ 9♡", "3♡ 2♡ 5♧ 6♢ 10♡"},
-		best:  []string{"3♡ 2♡ 5♧ 6♢ 10♡"},
-	},
-	{
-		name:  "highest card with mostly same cards",
-		hands: []string{"4♢ 2♢ 5♤ 6♤ 9♡", "4♡ 3♤ 5♧ 6♢ 9♢"},
-		best:  []string{"4♡ 3♤ 5♧ 6♢ 9♢"},
-	},
-	{
-		name:  "pair beats lower",
-		hands: []string{"4♢ 3♤ 4♤ J♤ K♤", "A♡ K♡ J♢ 10♧ 9♡"},
-		best:  []string{"4♢ 3♤ 4♤ J♤ K♤"},
-	},
-	{
-		name:  "best pair",
-		hands: []string{"4♡ 2♡ 5♧ 4♢ 10♡", "3♢ 3♡ 5♤ 6♤ 9♡"},
-		best:  []string{"4♡ 2♡ 5♧ 4♢ 10♡"},
-	},
-	{
-		name:  "best pair with same pair and highest cards",
-		hands: []string{"4♡ 2♡ 5♧ 4♢ 10♡", "4♤ 4♧ 5♡ 10♢ 3♡"},
-		best:  []string{"4♤ 4♧ 5♡ 10♢ 3♡"},
-	},
-	{
-		name: "two pair beats lower",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ K♤",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"2♢ 8♡ 5♢ 2♡ 8♧"},
-	},
-	{
-		name: "best two pair",
-		hands: []string{
-			"4♢ J♧ 4♤ J♤ K♤",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"4♢ J♧ 4♤ J♤ K♤"},
-	},
-	{
-		name: "best two pair with equal highest pair",
-		hands: []string{
-			"4♢ J♧ 4♤ J♤ K♤",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"3♢ J♡ 5♢ 3♡ J♢",
-		},
-		best: []string{"4♢ J♧ 4♤ J♤ K♤"},
-	},
-	{
-		name: "best two pair with equal pairs",
-		hands: []string{
-			"4♢ J♧ 4♤ J♤ 2♤",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"4♧ J♡ 5♢ 4♡ J♢",
-		},
-		best: []string{"4♧ J♡ 5♢ 4♡ J♢"},
-	},
-	{
-		name: "three of a kind beats lower",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ K♤",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 8♡ 3♡ 3♧ 9♧",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"3♢ 8♡ 3♡ 3♧ 9♧"},
-	},
-	{
-		name: "best three of a kind",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ 4♡",
-			"A♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 8♡ 3♡ 3♧ 9♧",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"4♢ 3♤ 4♤ J♤ 4♡"},
-	},
-	{
-		name: "straight beats lower",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ K♤",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 8♡ 3♡ 3♧ 9♧",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"Q♡ K♡ J♢ 10♧ 9♡"},
-	},
-	{
-		name: "straight includes ace as one",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ K♤",
-			"2♤ 3♡ A♤ 5♤ 4♤",
-			"3♢ 8♡ 3♡ 3♧ 9♧",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"2♤ 3♡ A♤ 5♤ 4♤"},
-	},
-	{
-		name: "best straight",
-		hands: []string{
-			"4♢ 3♤ 4♤ J♤ K♤",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"A♢ K♧ 10♢ J♢ Q♢",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"A♢ K♧ 10♢ J♢ Q♢"},
-	},
-	{
-		name: "flush beats lower",
-		hands: []string{
-			"4♤ 3♤ 8♤ J♤ K♤",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 8♡ 3♡ 3♧ 9♧",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"4♤ 3♤ 8♤ J♤ K♤"},
-	},
-	{
-		name: "best flush",
-		hands: []string{
-			"4♤ 3♤ 8♤ J♤ K♤",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 8♢ A♢ 4♢ 7♢",
-			"2♢ 8♡ 5♢ 2♡ 8♧",
-		},
-		best: []string{"3♢ 8♢ A♢ 4♢ 7♢"},
-	},
-	{
-		name: "full house beats lower",
-		hands: []string{
-			"4♤ 3♤ 8♤ J♤ K♤",
-			"2♢ 8♡ 8♢ 2♡ 8♧",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ A♡ 3♡ 3♧ A♧",
-		},
-		best: []string{"2♢ 8♡ 8♢ 2♡ 8♧"},
-	},
-	{
-		name: "best full house",
-		hands: []string{
-			"4♤ 3♤ 8♤ J♤ K♤",
-			"2♢ 8♡ 8♢ 2♡ 8♧",
-			"5♡ 5♢ A♧ 5♧ A♢",
-			"3♢ A♡ 3♡ 3♧ A♧",
-		},
-		best: []string{"2♢ 8♡ 8♢ 2♡ 8♧"},
-	},
-	{
-		name: "four of a kind beats lower",
-		hands: []string{
-			"4♤ 5♤ 8♤ J♤ K♤",
-			"2♢ 8♡ 8♢ 2♡ 8♧",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 3♡ 3♤ 3♧ A♧",
-		},
-		best: []string{"3♢ 3♡ 3♤ 3♧ A♧"},
-	},
-	{
-		name: "best four of a kind",
-		hands: []string{
-			"4♤ 5♤ 8♤ J♤ K♤",
-			"2♢ 2♧ 8♢ 2♡ 2♤",
-			"Q♡ K♡ J♢ 10♧ 9♡",
-			"3♢ 3♡ 3♤ 3♧ A♧",
-		},
-		best: []string{"3♢ 3♡ 3♤ 3♧ A♧"},
-	},
-	{
-		name: "straight flush beats lower",
-		hands: []string{
-			"4♤ 5♢ 8♤ J♤ K♤",
-			"2♢ 8♡ 8♢ 2♡ 8♧",
-			"Q♡ K♡ 8♡ 10♡ 9♡",
-			"3♢ 3♡ 3♤ 3♧ A♧",
-			"2♤ 3♤ A♤ 5♤ 4♤",
-		},
-		best: []string{"2♤ 3♤ A♤ 5♤ 4♤"},
-	},
-	{
-		name: "best straight flush is royal flush",
-		hands: []string{
-			"4♤ 5♤ 8♤ J♤ K♤",
-			"2♢ 8♡ 8♢ 2♡ 8♧",
-			"Q♡ K♡ J♡ 10♡ 9♡",
-			"Q♢ K♢ J♢ 10♢ A♢",
-		},
-		best: []string{"Q♢ K♢ J♢ 10♢ A♢"},
-	},
-	{
-		name:  "tie for best pair",
-		hands: []string{"4♡ 2♡ 5♧ 4♢ 10♡", "4♧ 10♢ 5♤ 2♤ 4♤"},
-		best:  []string{"4♡ 2♡ 5♧ 4♢ 10♡", "4♧ 10♢ 5♤ 2♤ 4♤"},
-	},
-	{
-		name: "tie of three",
-		hands: []string{
-			"A♡ 2♡ 3♡ 4♡ 5♡",
-			"A♤ 2♤ 3♤ 4♤ 5♤",
-			"5♧ 4♧ 3♧ 2♧ A♧",
-			"A♢ 2♢ 6♢ 4♢ 5♢",
-		},
-		best: []string{
-			"A♡ 2♡ 3♡ 4♡ 5♡",
-			"A♤ 2♤ 3♤ 4♤ 5♤",
-			"5♧ 4♧ 3♧ 2♧ A♧",
-		},
-	},
-}
+const targetTestVersion = 5
 
 var invalidTestCases = []struct {
 	name string

data/tracks/go/exercises/sum-of-multiples/.meta/gen.go

@@ -0,0 +1,43 @@
+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("sum-of-multiples", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Cases []struct {
+		Description string
+		Factors     []int
+		Limit       int
+		Expected    int
+	}
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package summultiples
+
+{{.Header}}
+
+var varTests = []struct {
+	divisors     []int
+	limit        int
+	sum          int
+}{
+{{range .J.Cases}}{ {{.Factors | printf "%#v"}}, {{.Limit}}, {{.Expected}}}, // {{.Description}}
+{{end}}}
+`

data/tracks/go/exercises/sum-of-multiples/cases_test.go

@@ -0,0 +1,24 @@
+package summultiples
+
+// Source: exercism/x-common
+// Commit: 72b1496 sum-of-multiples: Fix canonical-data.json formatting
+// x-common version: 1.0.0
+
+var varTests = []struct {
+	divisors []int
+	limit    int
+	sum      int
+}{
+	{[]int{3, 5}, 1, 0},             // multiples of 3 or 5 up to 1
+	{[]int{3, 5}, 4, 3},             // multiples of 3 or 5 up to 4
+	{[]int{3, 5}, 10, 23},           // multiples of 3 or 5 up to 10
+	{[]int{3, 5}, 100, 2318},        // multiples of 3 or 5 up to 100
+	{[]int{3, 5}, 1000, 233168},     // multiples of 3 or 5 up to 1000
+	{[]int{7, 13, 17}, 20, 51},      // multiples of 7, 13 or 17 up to 20
+	{[]int{4, 6}, 15, 30},           // multiples of 4 or 6 up to 15
+	{[]int{5, 6, 8}, 150, 4419},     // multiples of 5, 6 or 8 up to 150
+	{[]int{5, 25}, 51, 275},         // multiples of 5 or 25 up to 51
+	{[]int{43, 47}, 10000, 2203160}, // multiples of 43 or 47 up to 10000
+	{[]int{1}, 100, 4950},           // multiples of 1 up to 100
+	{[]int{}, 10000, 0},             // multiples of an empty list up to 10000
+}

data/tracks/go/exercises/sum-of-multiples/example.go

@@ -1,6 +1,6 @@
 package summultiples
 
-const testVersion = 1
+const testVersion = 2
 
 // SumMultiples returns the sum of the multiples of the given divisors
 // up to, but not including, the given limit.

data/tracks/go/exercises/sum-of-multiples/sum_of_multiples_test.go

@@ -2,24 +2,7 @@ package summultiples
 
 import "testing"
 
-const targetTestVersion = 1
-
-var varTests = []struct {
-	divisors []int
-	limit    int
-	sum      int
-}{
-	{[]int{3, 5}, 1, 0},
-	{[]int{3, 5}, 4, 3},
-	{[]int{3, 5}, 10, 23},
-	{[]int{3, 5}, 100, 2318},
-	{[]int{3, 5}, 1000, 233168},
-	{[]int{7, 13, 17}, 20, 51},
-	{[]int{43, 47}, 10000, 2203160},
-	{[]int{5, 10, 12}, 10000, 13331672},
-	{[]int{1, 1}, 10000, 49995000},
-	{[]int{}, 10000, 0},
-}
+const targetTestVersion = 2
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {

data/tracks/groovy/exercises/robot-name/RobotSpec.groovy

@@ -0,0 +1,38 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class RobotSpec extends Specification {
+
+    def 'generates a name'() {
+        expect: new Robot().name =~ /^[a-zA-Z]{2}\d{3}$/
+    }
+
+    @Ignore
+    def 'generates the same name when called again'() {
+        given:
+            def robot = new Robot()
+        expect:
+            robot.name == robot.name
+    }
+
+    @Ignore
+    def 'different robots generate different names'() {
+        given:
+            def robot = new Robot()
+            def other_robot = new Robot()
+        expect:
+            robot.name != other_robot.name
+    }
+
+    @Ignore
+    def 'can be reset to generate another name'() {
+        given:
+            def robot = new Robot()
+            def name_before_reset = robot.name
+            robot.reset()
+            def name_after_reset = robot.name
+        expect:
+            name_before_reset != name_after_reset
+    }
+
+}

data/tracks/kotlin/config.json

@@ -252,6 +252,16 @@
       "slug": "all-your-base",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "collatz-conjecture",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "diamond",
+      "topics": []
+    },
     {
       "difficulty": 2,
       "slug": "bank-account",

data/tracks/kotlin/exercises/collatz-conjecture/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"]
+  }
+}