trackler 2.2.1.92 → 2.2.1.93

data/tracks/go/exercises/bracket-push/cases_test.go

@@ -1,8 +1,8 @@
 package brackets
 
 // Source: exercism/problem-specifications
-// Commit: 855c591 bracket-push: add test case (#747)
-// Problem Specifications Version: 1.1.0
+// Commit: 5c16d05 bracket-push: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
 
 type bracketTest struct {
 	input    string

data/tracks/go/exercises/dominoes/.meta/gen.go

@@ -37,8 +37,11 @@ func (d Dominoe) String() string {
 
 type OneCase struct {
 	Description string
-	Dominoes    []Dominoe `json:"input"`
-	Expected    bool
+	Comments    []string
+	Input       struct {
+		Dominoes []Dominoe
+	}
+	Expected bool
 }
 
 //func (c OneCase)
@@ -54,7 +57,8 @@ var testCases = []struct {
 }{ {{range .J.Cases}}
 {
 	{{printf "%q"  .Description}},
-	[]Dominoe{ {{range .Dominoes}} {{printf "%v" .}}, {{end}} },
+	{{range .Comments}}//{{.}}
+	{{end}}[]Dominoe{ {{range .Input.Dominoes}} {{printf "%v" .}}, {{end}} },
 	{{printf "%v"  .Expected}},
 }, {{end}}
 }

data/tracks/go/exercises/dominoes/cases_test.go

@@ -1,8 +1,8 @@
 package dominoes
 
 // Source: exercism/problem-specifications
-// Commit: b4ceaf4 Update dominoes canonical-data expected key (#823)
-// Problem Specifications Version: 2.0.0
+// Commit: b5bc74d dominoes: Apply new "input" policy
+// Problem Specifications Version: 2.1.0
 
 var testCases = []struct {
 	description string
@@ -41,6 +41,11 @@ var testCases = []struct {
 	},
 	{
 		"disconnected - simple",
+		//This meets the requirement of being possibly-Euclidean.
+		//All vertices have even degree.
+		//Nevertheless, there is no chain here, as there's no way to get from 1 to 2.
+		//This test (and the two following) prevent solutions from using the even-degree test as the sole criterion,
+		//as that is not a sufficient condition.
 		[]Dominoe{Dominoe{1, 1}, Dominoe{2, 2}},
 		false,
 	},
@@ -56,6 +61,11 @@ var testCases = []struct {
 	},
 	{
 		"need backtrack",
+		//Some solutions may make a chain out of (1, 2), (2, 3), (3, 1)
+		//then decide that since there are no more dominoes containing a 1,
+		//there is no chain possible.
+		//There is indeed a chain here, so this test checks for this line of reasoning.
+		//You need to place the (2, 4) after the (1, 2) rather than the (2, 3).
 		[]Dominoe{Dominoe{1, 2}, Dominoe{2, 3}, Dominoe{3, 1}, Dominoe{2, 4}, Dominoe{2, 4}},
 		true,
 	},

data/tracks/go/exercises/nucleotide-count/.meta/gen.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"log"
+	"sort"
+	"strconv"
+	"strings"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("nucleotide-count", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	exercise string
+	version  string
+	Cases    []struct {
+		Description string
+		Cases       []OneCase
+	}
+}
+
+// OneCase represents each test case
+type OneCase struct {
+	Description string
+	Property    string
+	Input       struct {
+		Strand string
+	}
+	Expected map[string]interface{}
+}
+
+// ErrorExpected returns true if an error should be raised
+func (c OneCase) ErrorExpected() bool {
+	_, exists := c.Expected["error"]
+	return exists
+}
+
+// SortedMapString collects key:values for a map in sorted order
+func (c OneCase) SortedMapString() string {
+	strs := make([]string, 0, len(c.Expected))
+	for k, v := range c.Expected {
+		switch t := v.(type) {
+		case float64:
+			strs = append(strs, `'`+k+`': `+strconv.FormatFloat(t, 'f', -1, 64))
+		default:
+			log.Fatalf("unexpected type %T for %v", t, v)
+		}
+
+	}
+	sort.Strings(strs)
+	return strings.Join(strs, ",")
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package dna
+
+{{.Header}}
+
+{{range .J.Cases}}// {{.Description}}
+var testCases = []struct {
+	description   string
+	strand        string
+	expected      Histogram
+	errorExpected bool
+}{
+{{range .Cases}}{
+	description:	{{printf "%q"  .Description}},
+	strand:		{{printf "%#v"  .Input.Strand}},
+	{{if .ErrorExpected}}errorExpected:	true,
+	{{else}}expected:       Histogram{ {{.SortedMapString}} },
+	{{- end}}
+},
+{{end}}{{end}}
+}
+`

data/tracks/go/exercises/nucleotide-count/.meta/hints.md

@@ -0,0 +1,20 @@
+## Implementation
+
+You should define a custom type 'DNA' with a function 'Counts' that outputs two values: 
+
+- a frequency count for the given DNA strand
+- an error (if there are invalid nucleotides)
+
+Which is a good type for a DNA strand ? 
+
+Which is the best Go types to represent the output values ?
+
+Take a look at the test cases to get a hint about what could be the possible inputs.
+
+
+## note about the tests
+You may be wondering about the `cases_test.go` file. We explain it in the
+[leap exercise][leap-exercise-readme].
+
+[leap-exercise-readme]: https://github.com/exercism/go/blob/master/exercises/leap/README.md
+

data/tracks/go/exercises/nucleotide-count/cases_test.go

@@ -0,0 +1,39 @@
+package dna
+
+// Source: exercism/problem-specifications
+// Commit: 879a096 nucleotide-count: Apply new "input" policy
+// Problem Specifications Version: 1.3.0
+
+// count all nucleotides in a strand
+var testCases = []struct {
+	description   string
+	strand        string
+	expected      Histogram
+	errorExpected bool
+}{
+	{
+		description: "empty strand",
+		strand:      "",
+		expected:    Histogram{'A': 0, 'C': 0, 'G': 0, 'T': 0},
+	},
+	{
+		description: "can count one nucleotide in single-character input",
+		strand:      "G",
+		expected:    Histogram{'A': 0, 'C': 0, 'G': 1, 'T': 0},
+	},
+	{
+		description: "strand with repeated nucleotide",
+		strand:      "GGGGGGG",
+		expected:    Histogram{'A': 0, 'C': 0, 'G': 7, 'T': 0},
+	},
+	{
+		description: "strand with multiple nucleotides",
+		strand:      "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC",
+		expected:    Histogram{'A': 20, 'C': 12, 'G': 17, 'T': 21},
+	},
+	{
+		description:   "strand with invalid nucleotides",
+		strand:        "AGXXACT",
+		errorExpected: true,
+	},
+}

data/tracks/go/exercises/nucleotide-count/example.go

@@ -5,35 +5,25 @@ import (
 	"strings"
 )
 
-// Histogram is a mapping from nucleotide to its count in given DNA
-type Histogram map[byte]int
-
 // DNA is a list of nucleotides
 type DNA string
+type Histogram map[byte]int
 
 const validNucleotides = "ACGT"
 
-// Count counts number of occurrences of given nucleotide in given DNA
-func (dna DNA) Count(nucleotide byte) (count int, err error) {
-	if !strings.Contains(validNucleotides, string(nucleotide)) {
-		return 0, errors.New("dna: invalid nucleotide " + string(nucleotide))
-	}
-
-	return strings.Count(string(dna), string(nucleotide)), nil
-}
-
 // Counts generates a histogram of valid nucleotides in given DNA.
 // Returns error if DNA contains invalid nucleotide.
 func (dna DNA) Counts() (Histogram, error) {
 	var total int
-	h := Histogram{}
+	result := make(Histogram)
+
 	for i := range validNucleotides {
 		nucleotide := validNucleotides[i]
-		h[nucleotide], _ = dna.Count(nucleotide)
-		total += h[nucleotide]
+		result[nucleotide] = strings.Count(string(dna), string(nucleotide))
+		total += result[nucleotide]
 	}
 	if total != len(dna) {
 		return nil, errors.New("dna: contains invalid nucleotide")
 	}
-	return h, nil
+	return result, nil
 }

data/tracks/go/exercises/nucleotide-count/nucleotide_count_test.go

@@ -5,99 +5,22 @@ import (
 	"testing"
 )
 
-var tallyTests = []struct {
-	strand     DNA
-	nucleotide byte
-	expected   int
-}{
-	{"", 'A', 0},
-	{"ACT", 'G', 0},
-	{"CCCCC", 'C', 5},
-	{"GGGGGTAACCCGG", 'T', 1},
-}
-
-func TestNucleotideCounts(t *testing.T) {
-	for _, tt := range tallyTests {
-		if count, err := tt.strand.Count(tt.nucleotide); err != nil {
-			t.Fatal(err)
-		} else if count != tt.expected {
-			t.Fatalf("Got \"%v\", expected \"%v\"", count, tt.expected)
-		}
-	}
-}
-
-func TestHasErrorForInvalidNucleotides(t *testing.T) {
-	dna := DNA("GATTACA")
-	if _, err := dna.Count('X'); err == nil {
-		t.Fatalf("X is an invalid nucleotide, but no error was raised")
-	}
-}
-
-// In most cases, this test is pointless.
-// Very occasionally it matters.
-// Just roll with it.
-func TestCountingDoesntChangeCount(t *testing.T) {
-	dna := DNA("CGATTGGG")
-	dna.Count('T')
-	count1, err := dna.Count('T')
-	if err != nil {
-		t.Fatal(err)
-	}
-	count2, err := dna.Count('T')
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count1 != count2 || count2 != 2 {
-		t.Fatalf("Got %v, expected %v", []int{count1, count2}, []int{2, 2})
-	}
-}
-
-type histogramTest struct {
-	strand   DNA
-	expected Histogram
-	err      bool
-}
-
-var histogramTests = []histogramTest{
-	{
-		"",
-		Histogram{'A': 0, 'C': 0, 'T': 0, 'G': 0},
-		false,
-	},
-	{
-		"GGGGGGGG",
-		Histogram{'A': 0, 'C': 0, 'T': 0, 'G': 8},
-		false,
-	},
-	{
-		"AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC",
-		Histogram{'A': 20, 'C': 12, 'T': 21, 'G': 17},
-		false,
-	},
-	{
-		"GGXXX",
-		nil,
-		true,
-	},
-}
-
-func TestSequenceHistograms(t *testing.T) {
-	for _, tt := range histogramTests {
-		counts, err := tt.strand.Counts()
-		if tt.err && err == nil {
-			t.Fatalf("DNA{ %q }: expected error but didn't get one.", tt.strand)
-		} else if !tt.err && err != nil {
-			t.Fatalf("DNA{ %q }: expected no error but got error %s", tt.strand, err.Error())
-		} else if !tt.err && !reflect.DeepEqual(counts, tt.expected) {
-			t.Fatalf("DNA{ %q }: Got %v, expected %v", tt.strand, counts, tt.expected)
-		}
-	}
-}
-
-func BenchmarkSequenceHistograms(b *testing.B) {
-	for _, tt := range histogramTests {
-		for i := 0; i < b.N; i++ {
-			tt.strand.Counts()
+func TestCounts(t *testing.T) {
+	for _, tc := range testCases {
+		dna := DNA(tc.strand)
+		s, err := dna.Counts()
+		if tc.errorExpected {
+			if err == nil {
+				t.Fatalf("FAIL: %s\nCounts(%q)\nExpected error\nActual: %#v",
+					tc.description, tc.strand, s)
+			}
+		} else if err != nil {
+			t.Fatalf("FAIL: %s\nCounts(%q)\nExpected: %#v\nGot error: %q",
+				tc.description, tc.strand, tc.expected, err)
+		} else if !reflect.DeepEqual(s, tc.expected) {
+			t.Fatalf("FAIL: %s\nCounts(%q)\nExpected: %#v\nActual: %#v",
+				tc.description, tc.strand, tc.expected, s)
 		}
+		t.Logf("PASS: %s", tc.description)
 	}
 }

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

@@ -22,9 +22,11 @@ func main() {
 type js struct {
 	Cases []struct {
 		Description string
-		Factors     []int
-		Limit       int
-		Expected    int
+		Input       struct {
+			Factors []int
+			Limit   int
+		}
+		Expected int
 	}
 }
 
@@ -38,6 +40,6 @@ var varTests = []struct {
 	limit        int
 	sum          int
 }{
-{{range .J.Cases}}{ {{.Factors | printf "%#v"}}, {{.Limit}}, {{.Expected}}}, // {{.Description}}
+{{range .J.Cases}}{ {{.Input.Factors | printf "%#v"}}, {{.Input.Limit}}, {{.Expected}}}, // {{.Description}}
 {{end}}}
 `

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

@@ -1,8 +1,8 @@
 package summultiples
 
 // Source: exercism/problem-specifications
-// Commit: df076b2 sum-of-multiples: Add up to 7 test case (#896)
-// Problem Specifications Version: 1.1.0
+// Commit: fb5b0a1 sum-of-multiples: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
 
 var varTests = []struct {
 	divisors []int

data/tracks/haskell/README.md

@@ -71,14 +71,13 @@ The [track anatomy documentation](https://github.com/exercism/docs/blob/master/l
 ├── config.json
 ├── docs
 │ ├── ABOUT.md
+  ├── EXERCISE_README_INSERT.md
 │ ├── INSTALLATION.md
 │ ├── LEARNING.md
 │ ├── RESOURCES.md
 │ └── TESTS.md
 └── exercises
-  ├── TRACK_HINTS.md
   └── accumulate
-  │ ├── HINTS.md
   │ ├── package.yaml
   │ ├── stack.yaml
   │ ├── examples
@@ -88,8 +87,10 @@ The [track anatomy documentation](https://github.com/exercism/docs/blob/master/l
   │ │     └── Accumuĺate.hs
   │ ├── src
   │ │ └── Accumuĺate.hs
-  │ └── test
-  │   └── Tests.hs
+  │ ├── test
+  │ │ └── Tests.hs
+  │ └── .meta
+  │   └── hints.md
   └── allergies
   │ ├── ...
   └── ...
@@ -103,11 +104,11 @@ Each exercise has the following structure:
 resolver for all the exercises.
 - `package.yaml` is a file in the [hpack](https://github.com/sol/hpack#readme)
 format that has all dependencies and build instructions for an exercise.
-- `HINTS.md` is an optional file containing instructions and/or hints. It is used together with the respective `description.md` for the exercise from [problem-specifications](https://github.com/exercism/problem-specifications) to build the `README.md` file.
 - `src/ModuleName.hs` is a [stub solution](#stub-solution).
 - `examples/success-<name>/package.yaml` contains library dependencies for the [example solution](#example-solution). `<name>` is a unique name for the example - usually "standard" (as in `success-standard`), but it can be some other name in case of multiple example solutions.
 - `examples/success-<name>/src/ModuleName.hs` is the source code of the sample solution.
 - `test/Tests.hs` is the [test suite](#test-suite).
+- `.meta/hints.md` is an optional file containing instructions and/or hints. It is used together with the respective `description.md` for the exercise from [problem-specifications](https://github.com/exercism/problem-specifications) to build the `README.md` file.
 
 ### Writing an issue
 To report a bug you should [create an issue](https://help.github.com/articles/creating-an-issue/) on the [exercism/haskell repo](https://github.com/exercism/haskell/issues).