trackler 2.2.1.71 → 2.2.1.72

data/tracks/go/exercises/nth-prime/.meta/gen.go

@@ -0,0 +1,76 @@
+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("nth-prime", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+type OneCase struct {
+	Description string
+	Input       int
+	Expected    interface{}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Cases []OneCase
+}
+
+func (c OneCase) HasPrimeAnswer() bool {
+	hasPrimeAnswer, _ := determineExpected(c.Expected)
+	return hasPrimeAnswer
+}
+
+func (c OneCase) PrimeAnswer() int {
+	_, answer := determineExpected(c.Expected)
+	return answer
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether a test case has a Prime answer or expects an error,
+// returning true and the answer, or false and zero.
+func determineExpected(expected interface{}) (bool, int) {
+	value, ok := expected.(float64)
+	if ok {
+		return true, int(value)
+	}
+	return false, 0
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package prime
+
+{{.Header}}
+
+var tests = []struct {
+	description string
+	n   int
+	p   int
+	ok  bool
+}{
+{{range .J.Cases}}{
+	"{{.Description}}",
+	{{.Input}},
+{{- if .HasPrimeAnswer}}
+	{{.PrimeAnswer}},
+	true,
+{{- else}}
+	0,
+	false,
+{{- end}}
+},
+{{end}}}
+`

data/tracks/go/exercises/nth-prime/cases_test.go

@@ -0,0 +1,43 @@
+package prime
+
+// Source: exercism/problem-specifications
+// Commit: e82cbcd nth-prime: Use object instead of bool for invalid value (#969)
+// Problem Specifications Version: 2.0.0
+
+var tests = []struct {
+	description string
+	n           int
+	p           int
+	ok          bool
+}{
+	{
+		"first prime",
+		1,
+		2,
+		true,
+	},
+	{
+		"second prime",
+		2,
+		3,
+		true,
+	},
+	{
+		"sixth prime",
+		6,
+		13,
+		true,
+	},
+	{
+		"big prime",
+		10001,
+		104743,
+		true,
+	},
+	{
+		"there is no zeroth prime",
+		0,
+		0,
+		false,
+	},
+}

data/tracks/go/exercises/nth-prime/nth_prime_test.go

@@ -2,33 +2,19 @@ package prime
 
 import "testing"
 
-var tests = []struct {
-	n  int
-	p  int
-	ok bool
-}{
-	{1, 2, true},
-	{2, 3, true},
-	{3, 5, true},
-	{4, 7, true},
-	{5, 11, true},
-	{6, 13, true},
-	{10001, 104743, true},
-	{0, 0, false},
-}
-
 func TestNth(t *testing.T) {
 	for _, test := range tests {
 		switch p, ok := Nth(test.n); {
 		case !ok:
 			if test.ok {
-				t.Fatalf("Nth(%d) returned !ok.  Expecting ok.", test.n)
+				t.Fatalf("FAIL %s\nNth(%d) returned !ok.  Expecting ok.", test.description, test.n)
 			}
 		case !test.ok:
-			t.Fatalf("Nth(%d) = %d, ok = %t.  Expecting !ok.", test.n, p, ok)
+			t.Fatalf("FAIL %s\nNth(%d) = %d, ok = %t.  Expecting !ok.", test.description, test.n, p, ok)
 		case p != test.p:
-			t.Fatalf("Nth(%d) = %d, want %d.", test.n, p, test.p)
+			t.Fatalf("FAIL %s\nNth(%d) = %d, want %d.", test.description, test.n, p, test.p)
 		}
+		t.Logf("PASS %s", test.description)
 	}
 }
 

data/tracks/go/exercises/prime-factors/.meta/gen.go

@@ -0,0 +1,54 @@
+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("prime-factors", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Groups []TestGroup `json:"cases"`
+}
+
+type TestGroup struct {
+	Description string
+	Cases       []OneCase
+}
+
+type OneCase struct {
+	Description string
+	Input       int64
+	Expected    []int64
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package prime
+
+{{.Header}}
+
+var tests = []struct {
+	description string
+	input int64
+	expected []int64
+}{
+{{range .J.Groups}}
+{{range .Cases}} {
+	"{{.Description}}",
+	{{.Input}},
+	{{printf "%#v" .Expected}},
+},
+{{end}}{{end}}}
+`

data/tracks/go/exercises/prime-factors/cases_test.go

@@ -0,0 +1,48 @@
+package prime
+
+// Source: exercism/problem-specifications
+// Commit: bf5bb2b prime-factors: Fix canonical-data.json formatting
+// Problem Specifications Version: 1.0.0
+
+var tests = []struct {
+	description string
+	input       int64
+	expected    []int64
+}{
+
+	{
+		"no factors",
+		1,
+		[]int64{},
+	},
+	{
+		"prime number",
+		2,
+		[]int64{2},
+	},
+	{
+		"square of a prime",
+		9,
+		[]int64{3, 3},
+	},
+	{
+		"cube of a prime",
+		8,
+		[]int64{2, 2, 2},
+	},
+	{
+		"product of primes and non-primes",
+		12,
+		[]int64{2, 2, 3},
+	},
+	{
+		"product of primes",
+		901255,
+		[]int64{5, 17, 23, 461},
+	},
+	{
+		"factors include a large prime",
+		93819012551,
+		[]int64{11, 9539, 894119},
+	},
+}

data/tracks/go/exercises/prime-factors/prime_factors_test.go

@@ -7,30 +7,15 @@ import (
 	"testing"
 )
 
-var tests = []struct {
-	input    int64
-	expected []int64
-}{
-	{1, []int64{}},
-	{2, []int64{2}},
-	{3, []int64{3}},
-	{4, []int64{2, 2}},
-	{6, []int64{2, 3}},
-	{8, []int64{2, 2, 2}},
-	{9, []int64{3, 3}},
-	{27, []int64{3, 3, 3}},
-	{625, []int64{5, 5, 5, 5}},
-	{901255, []int64{5, 17, 23, 461}},
-	{93819012551, []int64{11, 9539, 894119}},
-}
-
 func TestPrimeFactors(t *testing.T) {
 	for _, test := range tests {
 		actual := Factors(test.input)
 		if !reflect.DeepEqual(actual, test.expected) {
-			t.Errorf("prime.Factors(%d) = %#v; expected %#v",
-				test.input, actual, test.expected)
+			t.Fatalf("FAIL %s\nFactors(%d) = %#v;\nexpected %#v",
+				test.description, test.input,
+				actual, test.expected)
 		}
+		t.Logf("PASS %s", test.description)
 	}
 }
 

data/tracks/groovy/config.json

@@ -180,9 +180,21 @@
       ],
       "unlocked_by": null,
       "uuid": "aa34b8a4-6958-42d4-b0ca-d846811afef1"
+    },
+    {
+      "core": true,
+      "difficulty": 6,
+      "slug": "linked-list",
+      "topics": [
+        "algorithms",
+        "generics",
+        "lists"
+      ],
+      "unlocked_by": null,
+      "uuid": "6a5e6d90-e0f3-43e7-8088-a4137bf2b125"
     }
   ],
   "foregone": [],
   "language": "Groovy",
   "test_pattern": "(Spec)[.]groovy"
-}
+}

data/tracks/groovy/exercises/linked-list/DoubleLinkedList.groovy

@@ -0,0 +1,19 @@
+class DoubleLinkedList<T> {
+
+    void push(T value) {
+        throw new UnsupportedOperationException('Method implementation is missing')
+    }
+
+    T pop() {
+        throw new UnsupportedOperationException('Method implementation is missing')
+    }
+
+    T shift() {
+        throw new UnsupportedOperationException('Method implementation is missing')
+    }
+
+    void unshift(T value) {
+        throw new UnsupportedOperationException('Method implementation is missing')
+    }
+
+}

data/tracks/groovy/exercises/linked-list/DoubleLinkedListSpec.groovy

@@ -0,0 +1,79 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class DoubleLinkedListSpec extends Specification {
+
+    def 'can push and pop'() {
+        DoubleLinkedList<Integer> list = new DoubleLinkedList<>()
+        when:
+            list.push(10)
+            list.push(20)
+        then:
+            list.pop() == 20
+        and:
+            list.pop() == 10
+    }
+
+    @Ignore
+    def 'can push and shift'() {
+        DoubleLinkedList<String> list = new DoubleLinkedList<>()
+        when:
+            list.push("10")
+            list.push("20")
+        then:
+            list.shift() == "10"
+        and:
+            list.shift() == "20"
+    }
+
+    @Ignore
+    def 'can unshift an shift'() {
+        DoubleLinkedList<Character> list = new DoubleLinkedList<>()
+        when:
+            list.unshift('1')
+            list.unshift('2')
+        then:
+            list.shift() == '2'
+        and:
+            list.shift() == '1'
+    }
+
+    @Ignore
+    def 'can unshift and pop'() {
+        DoubleLinkedList<Integer> list = new DoubleLinkedList<>()
+        when:
+            list.unshift(10)
+            list.unshift(20)
+        then:
+            list.pop() == 10
+        and:
+            list.pop() == 20
+    }
+
+    @Ignore
+    def 'complete example'() {
+        DoubleLinkedList<String> list = new DoubleLinkedList<>()
+        when:
+            list.push("ten")
+            list.push("twenty")
+
+        then:
+            list.pop() == "twenty"
+
+        when:
+            list.push("thirty")
+
+        then:
+            list.shift() == "ten"
+
+        when:
+            list.unshift("forty")
+            list.push("fifty")
+
+        then:
+            list.shift() == "forty"
+            list.pop() == "fifty"
+            list.shift() == "thirty"
+
+    }
+}

data/tracks/groovy/exercises/linked-list/Example.groovy

@@ -0,0 +1,57 @@
+class DoubleLinkedList<T> {
+
+    Element<T> head
+
+    void push(T value) {
+        if(!head) {
+            head = new Element<>(value, null, null)
+            head.next = head
+            head.prev = head
+            return
+        }
+
+        def oldTail = head.prev
+        def tail = new Element<>(value, oldTail, head)
+        oldTail.next = tail
+        head.prev = tail
+    }
+
+    T pop() {
+        head = head.prev
+        shift()
+    }
+
+    T shift() {
+        T value = head.value
+
+        def newHead = head.next
+        def newTail = head.prev
+
+        if(newHead.is(head)) {
+            head = null
+        } else {
+            newHead.prev = newTail
+            newTail.next = newHead
+            head = newHead
+        }
+
+        value
+    }
+
+    void unshift(T value) {
+        push(value)
+        head = head.prev
+    }
+
+    private static final class Element<T> {
+        final T value
+        Element<T> prev
+        Element<T> next
+
+        Element(T value, Element<T> prev, Element<T> next) {
+            this.value = value
+            this.prev = prev
+            this.next = next
+        }
+    }
+}