trackler 2.2.1.64 → 2.2.1.65

data/tracks/go/exercises/perfect-numbers/.meta/gen.go

@@ -0,0 +1,88 @@
+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("perfect-numbers", &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
+	}
+}
+
+// Test cases
+type oneCase struct {
+	Description string
+	Property    string
+	Input       int64
+	Expected    interface{}
+}
+
+func (c oneCase) Valid() bool {
+	valid, _ := determineExpected(c.Expected)
+	return valid
+}
+
+func (c oneCase) ExpectedClassification() string {
+	_, e := determineExpected(c.Expected)
+	switch e {
+	case "perfect":
+		return "ClassificationPerfect"
+	case "abundant":
+		return "ClassificationAbundant"
+	case "deficient":
+		return "ClassificationDeficient"
+	}
+	return e
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether a test case is valid(bool) and has a classification or expects an error,
+// returning valid and classification.
+func determineExpected(expected interface{}) (bool, string) {
+	exp, ok := expected.(string)
+	if ok {
+		return ok, exp
+	}
+	return false, ""
+}
+
+// Template to generate test cases.
+var tmpl = `package perfect
+
+{{.Header}}
+
+var classificationTestCases = []struct {
+	description	string
+	input		int64
+	ok		bool
+	expected	Classification
+}{ {{range .J.Cases}} {{range .Cases}}
+{
+	description:	"{{.Description}}",
+	input:		{{.Input}},
+{{if .Valid}} ok: true,
+	expected: {{.ExpectedClassification}},
+{{- else}} ok: false,
+{{- end}}
+},{{end}}{{end}}
+}
+`

data/tracks/go/exercises/perfect-numbers/.meta/hints.md

@@ -0,0 +1,19 @@
+## Implementation
+
+Define
+```type Classification```
+for containing the classification values for natural numbers.
+You may choose any representation for this type.
+
+Define three Classification constants named
+```
+	ClassificationDeficient
+	ClassificationPerfect
+	ClassificationAbundant
+```
+
+Implement a function named Classify which accepts
+an int64 input and returns a Classification and an error value.
+
+Create an error named ErrOnlyPositive
+which is returned when the input is not a positive integer.

data/tracks/go/exercises/perfect-numbers/README.md

@@ -5,7 +5,7 @@ Nicomachus' (60 - 120 CE) classification scheme for natural numbers.
 
 The Greek mathematician [Nicomachus](https://en.wikipedia.org/wiki/Nicomachus) devised a classification scheme for natural numbers, identifying each as belonging uniquely to the categories of **perfect**, **abundant**, or **deficient** based on their [aliquot sum](https://en.wikipedia.org/wiki/Aliquot_sum). The aliquot sum is defined as the sum of the factors of a number not including the number itself. For example, the aliquot sum of 15 is (1 + 3 + 5) = 9
 
-- **Perfect**: aliquot sum = number 
+- **Perfect**: aliquot sum = number
   - 6 is a perfect number because (1 + 2 + 3) = 6
   - 28 is a perfect number because (1 + 2 + 4 + 7 + 14) = 28
 - **Abundant**: aliquot sum > number
@@ -14,9 +14,30 @@ The Greek mathematician [Nicomachus](https://en.wikipedia.org/wiki/Nicomachus) d
 - **Deficient**: aliquot sum < number
   - 8 is a deficient number because (1 + 2 + 4) = 7
   - Prime numbers are deficient
-  
+
 Implement a way to determine whether a given number is **perfect**. Depending on your language track, you may also need to implement a way to determine whether a given number is **abundant** or **deficient**.
 
+## Implementation
+
+Define
+```type Classification```
+for containing the classification values for natural numbers.
+You may choose any representation for this type.
+
+Define three Classification constants named
+```
+	ClassificationDeficient
+	ClassificationPerfect
+	ClassificationAbundant
+```
+
+Implement a function named Classify which accepts
+an int64 input and returns a Classification and an error value.
+
+Create an error named ErrOnlyPositive
+which is returned when the input is not a positive integer.
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

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

@@ -0,0 +1,89 @@
+package perfect
+
+// Source: exercism/problem-specifications
+// Commit: 924bb7a perfect-numbers: fix misleading test description
+// Problem Specifications Version: 1.0.1
+
+var classificationTestCases = []struct {
+	description string
+	input       int64
+	ok          bool
+	expected    Classification
+}{
+	{
+		description: "Smallest perfect number is classified correctly",
+		input:       6,
+		ok:          true,
+		expected:    ClassificationPerfect,
+	},
+	{
+		description: "Medium perfect number is classified correctly",
+		input:       28,
+		ok:          true,
+		expected:    ClassificationPerfect,
+	},
+	{
+		description: "Large perfect number is classified correctly",
+		input:       33550336,
+		ok:          true,
+		expected:    ClassificationPerfect,
+	},
+	{
+		description: "Smallest abundant number is classified correctly",
+		input:       12,
+		ok:          true,
+		expected:    ClassificationAbundant,
+	},
+	{
+		description: "Medium abundant number is classified correctly",
+		input:       30,
+		ok:          true,
+		expected:    ClassificationAbundant,
+	},
+	{
+		description: "Large abundant number is classified correctly",
+		input:       33550335,
+		ok:          true,
+		expected:    ClassificationAbundant,
+	},
+	{
+		description: "Smallest prime deficient number is classified correctly",
+		input:       2,
+		ok:          true,
+		expected:    ClassificationDeficient,
+	},
+	{
+		description: "Smallest non-prime deficient number is classified correctly",
+		input:       4,
+		ok:          true,
+		expected:    ClassificationDeficient,
+	},
+	{
+		description: "Medium deficient number is classified correctly",
+		input:       32,
+		ok:          true,
+		expected:    ClassificationDeficient,
+	},
+	{
+		description: "Large deficient number is classified correctly",
+		input:       33550337,
+		ok:          true,
+		expected:    ClassificationDeficient,
+	},
+	{
+		description: "Edge case (no factors other than itself) is classified correctly",
+		input:       1,
+		ok:          true,
+		expected:    ClassificationDeficient,
+	},
+	{
+		description: "Zero is rejected (not a natural number)",
+		input:       0,
+		ok:          false,
+	},
+	{
+		description: "Negative integer is rejected (not a natural number)",
+		input:       -1,
+		ok:          false,
+	},
+}

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

@@ -18,12 +18,12 @@ var (
 )
 
 // Classify finds the category of given natural number
-func Classify(n uint64) (Classification, error) {
-	if n == 0 {
+func Classify(n int64) (Classification, error) {
+	if n <= 0 {
 		return "", ErrOnlyPositive
 	}
-	var sum uint64
-	for i := uint64(1); i < n; i++ {
+	var sum int64
+	for i := int64(1); i < n; i++ {
 		if n%i == 0 {
 			if sum = sum + i; sum > n {
 				return ClassificationAbundant, nil

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

@@ -4,32 +4,27 @@ 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},
-}
-
 func TestGivesPositiveRequiredError(t *testing.T) {
 	if _, err := Classify(0); err != ErrOnlyPositive {
-		t.Errorf("Expected error %q but got %q", ErrOnlyPositive, err)
+		t.Fatalf("FAIL GivesPositiveRequiredError Expected error %q but got %q", ErrOnlyPositive, err)
 	}
+	t.Logf("PASS GivesPositiveRequiredError")
 }
 
 func TestClassifiesCorrectly(t *testing.T) {
 	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 {
-			t.Errorf("%d: Expected %q, got %q", c.input, c.expected, cat)
+		cat, err := Classify(c.input)
+		switch {
+		case err != nil:
+			if c.ok {
+				t.Fatalf("FAIL %s\nClassify(%d)\nExpected no error but got error %q", c.description, c.input, err)
+			}
+		case !c.ok:
+			t.Fatalf("FAIL %s\nClassify(%d)\nExpected error but got %q", c.description, c.input, cat)
+		case cat != c.expected:
+			t.Fatalf("FAIL %s\nClassify(%d)\nExpected %q, got %q", c.description, c.input, c.expected, cat)
 		}
+		t.Logf("PASS %s", c.description)
 	}
 }
 

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

data/tracks/go/exercises/wordy/cases_test.go

@@ -0,0 +1,111 @@
+package wordy
+
+// Source: exercism/problem-specifications
+// Commit: 5b8ad58 wordy: Fix canonical-data.json formatting
+// Problem Specifications Version: 1.0.0
+
+type wordyTest struct {
+	description string
+	question    string
+	ok          bool
+	answer      int
+}
+
+var tests = []wordyTest{
+	{
+		"addition",
+		"What is 1 plus 1?",
+		true,
+		2,
+	},
+	{
+		"more addition",
+		"What is 53 plus 2?",
+		true,
+		55,
+	},
+	{
+		"addition with negative numbers",
+		"What is -1 plus -10?",
+		true,
+		-11,
+	},
+	{
+		"large addition",
+		"What is 123 plus 45678?",
+		true,
+		45801,
+	},
+	{
+		"subtraction",
+		"What is 4 minus -12?",
+		true,
+		16,
+	},
+	{
+		"multiplication",
+		"What is -3 multiplied by 25?",
+		true,
+		-75,
+	},
+	{
+		"division",
+		"What is 33 divided by -3?",
+		true,
+		-11,
+	},
+	{
+		"multiple additions",
+		"What is 1 plus 1 plus 1?",
+		true,
+		3,
+	},
+	{
+		"addition and subtraction",
+		"What is 1 plus 5 minus -2?",
+		true,
+		8,
+	},
+	{
+		"multiple subtraction",
+		"What is 20 minus 4 minus 13?",
+		true,
+		3,
+	},
+	{
+		"subtraction then addition",
+		"What is 17 minus 6 plus 3?",
+		true,
+		14,
+	},
+	{
+		"multiple multiplication",
+		"What is 2 multiplied by -2 multiplied by 3?",
+		true,
+		-12,
+	},
+	{
+		"addition and multiplication",
+		"What is -3 plus 7 multiplied by -2?",
+		true,
+		-8,
+	},
+	{
+		"multiple division",
+		"What is -12 divided by 2 divided by -3?",
+		true,
+		2,
+	},
+	{
+		"unknown operation",
+		"What is 52 cubed?",
+		false,
+		0,
+	},
+	{
+		"Non math question",
+		"Who is the President of the United States?",
+		false,
+		0,
+	},
+}