trackler 2.2.1.56 → 2.2.1.57

data/tracks/go/exercises/book-store/example.go

@@ -0,0 +1,52 @@
+package bookstore
+
+import (
+	"math"
+)
+
+const bookPrice = 8
+
+var discountTiers = [...]float64{0, 0.05, 0.1, 0.2, 0.25}
+
+// Cost implements the book store exercise.
+func Cost(books []int) float64 {
+	return cost(books, 0)
+}
+
+func cost(books []int, priceSoFar float64) float64 {
+	if len(books) == 0 {
+		return priceSoFar
+	}
+
+	distinctBooks, remainingBooks := getDistinctBooks(books)
+	minPrice := math.MaxFloat32
+
+	for i := 1; i <= len(distinctBooks); i++ {
+		newRemainingBooks := make([]int, len(remainingBooks))
+		copy(newRemainingBooks, remainingBooks)
+		newRemainingBooks = append(newRemainingBooks, distinctBooks[i:]...)
+
+		price := cost(newRemainingBooks, priceSoFar+groupCost(i))
+		minPrice = math.Min(minPrice, price)
+	}
+
+	return minPrice
+}
+
+func getDistinctBooks(books []int) (distinct []int, remaining []int) {
+	exists := make(map[int]bool)
+	for _, book := range books {
+		if exists[book] {
+			remaining = append(remaining, book)
+		} else {
+			distinct = append(distinct, book)
+			exists[book] = true
+		}
+	}
+
+	return
+}
+
+func groupCost(groupSize int) float64 {
+	return float64(bookPrice*groupSize) * (1.00 - discountTiers[groupSize-1])
+}

data/tracks/go/exercises/bowling/bowling_test.go

@@ -2,20 +2,12 @@ package bowling
 
 import "testing"
 
-const targetTestVersion = 1
-
 const previousRollErrorMessage = `FAIL: %s
 	Unexpected error occurred: %q
 	while applying the previous rolls for the
 	test case: %v
 	The error was returned from Roll(%d) for previousRolls[%d].`
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func applyPreviousRolls(g *Game, rolls []int) (int, int, error) {
 	for index, pins := range rolls {
 		var err error

data/tracks/go/exercises/bowling/cases_test.go

@@ -1,8 +1,8 @@
 package bowling
 
-// Source: exercism/x-common
+// Source: exercism/problem-specifications
 // Commit: 26e345e [Bowling] Fix case descriptions (#832)
-// x-common version: 1.0.1
+// Problem Specifications Version: 1.0.1
 
 var scoreTestCases = []struct {
 	description   string

data/tracks/go/exercises/bowling/example.go

@@ -3,8 +3,6 @@ package bowling
 
 import "errors"
 
-const testVersion = 1
-
 var (
 	ErrNegativeRollIsInvalid        = errors.New("Negative roll is invalid")
 	ErrPinCountExceedsPinsOnTheLane = errors.New("Pin count exceeds pins on the lane")

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

@@ -4,14 +4,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 5
-
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestBracket(t *testing.T) {
 	for _, tt := range testCases {
 		actual, err := Bracket(tt.input)

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

@@ -1,8 +1,8 @@
 package brackets
 
-// Source: exercism/x-common
+// Source: exercism/problem-specifications
 // Commit: 855c591 bracket-push: add test case (#747)
-// x-common version: 1.1.0
+// Problem Specifications Version: 1.1.0
 
 type bracketTest struct {
 	input    string

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

@@ -1,8 +1,5 @@
 package brackets
 
-// testVersion shows the version of the exercise.
-const testVersion = 5
-
 type bracketKind int
 
 const (

data/tracks/go/exercises/change/cases_test.go

@@ -1,8 +1,8 @@
 package change
 
-// Source: exercism/x-common
-// Commit: 3d8b5b3 change: Fix canonical-data.json formatting
-// x-common version: 1.0.0
+// Source: exercism/problem-specifications
+// Commit: 52cf1cf Add test for incorrect greedy algorithm
+// Problem Specifications Version: 1.1.0
 
 var testCases = []struct {
 	description    string
@@ -53,6 +53,13 @@ var testCases = []struct {
 		true,
 		[]int{2, 2, 2, 5, 10},
 	},
+	{
+		"another possible change without unit coins available",
+		[]int{4, 5},
+		27,
+		true,
+		[]int{4, 4, 4, 5, 5, 5},
+	},
 	{
 		"no coins make 0 change",
 		[]int{1, 5, 10, 21, 25},

data/tracks/go/exercises/change/change_test.go

@@ -5,14 +5,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 1
-
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestChange(t *testing.T) {
 	for _, tc := range testCases {
 		actual, err := Change(tc.coins, tc.target)
@@ -22,7 +14,7 @@ func TestChange(t *testing.T) {
 					tc.description, tc.coins, tc.target, tc.expectedChange, err.Error())
 			} else {
 				if !reflect.DeepEqual(actual, tc.expectedChange) {
-					t.Fatalf("%s : Change(%v, %d): expected %v, actual %v",
+					t.Fatalf("%s : Change(%v, %d): expected %#v, actual %#v",
 						tc.description, tc.coins, tc.target, tc.expectedChange, actual)
 				} else {
 					t.Logf("PASS: %s", tc.description)

data/tracks/go/exercises/change/example.go

@@ -6,8 +6,6 @@ import (
 	"sort"
 )
 
-const testVersion = 1
-
 var (
 	ErrNoSolutionFound = errors.New("No solution")
 	ErrNegativeTarget  = errors.New("Negative Target")

data/tracks/go/exercises/circular-buffer/circular_buffer_test.go

@@ -19,8 +19,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 4
-
 // Here is one way you can have a test case verify that the expected
 // interfaces are implemented.
 
@@ -88,12 +86,6 @@ func (tb testBuffer) overwrite(c byte) {
 
 // tests.  separate functions so log will have descriptive test name.
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
-
 func TestReadEmptyBuffer(t *testing.T) {
 	tb := nb(1, t)
 	tb.readFail()

data/tracks/go/exercises/circular-buffer/example.go

@@ -8,8 +8,6 @@ import (
 	"errors"
 )
 
-const testVersion = 4
-
 // Buffer implements a circular buffer supporting both overflow-checked writes
 // and unconditional, possibly overwriting, writes.
 type Buffer struct {

data/tracks/go/exercises/clock/cases_test.go

@@ -1,8 +1,8 @@
 package clock
 
-// Source: exercism/x-common
+// Source: exercism/problem-specifications
 // Commit: 54c3b74 Cleanup canonical-data for clock
-// x-common version: 1.0.1
+// Problem Specifications Version: 1.0.1
 
 // Create a new clock with an initial time
 var timeTests = []struct {

data/tracks/go/exercises/clock/clock_test.go

@@ -5,8 +5,9 @@ import (
 	"testing"
 )
 
-// Clock type API:
+// Clock API:
 //
+// type Clock                      // define the clock type
 // New(hour, minute int) Clock     // a "constructor"
 // (Clock) String() string         // a "stringer"
 // (Clock) Add(minutes int) Clock
@@ -27,14 +28,6 @@ import (
 // For some useful guidelines on when to use a value receiver or a pointer
 // receiver see: https://github.com/golang/go/wiki/CodeReviewComments#receiver-type
 
-const targetTestVersion = 4
-
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestCreateClock(t *testing.T) {
 	for _, n := range timeTests {
 		if got := New(n.h, n.m); got.String() != n.want {

data/tracks/go/exercises/clock/example.go

@@ -2,8 +2,6 @@ package clock
 
 import "fmt"
 
-const testVersion = 4
-
 type Clock int
 
 func New(h, m int) Clock {

data/tracks/go/exercises/collatz-conjecture/README.md

@@ -0,0 +1,51 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Further information
+
+For more detailed information about the Go track, including how to get help if
+you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Collatz_conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/collatz-conjecture/collatz_conjecture_test.go

@@ -0,0 +1,77 @@
+package collatzconjecture
+
+import (
+	"testing"
+)
+
+var testCases = []struct {
+	description string
+	input       int
+	expectError bool
+	expected    int
+}{
+	{
+		description: "zero steps for one",
+		input:       1,
+		expectError: false,
+		expected:    0,
+	},
+	{
+		description: "divide if even",
+		input:       16,
+		expectError: false,
+		expected:    4,
+	},
+	{
+		description: "even and old steps",
+		input:       12,
+		expectError: false,
+		expected:    9,
+	},
+	{
+		description: "large number of even and odd steps",
+		input:       1000000,
+		expectError: false,
+		expected:    152,
+	},
+	{
+		description: "zero is an error",
+		input:       0,
+		expectError: true,
+	},
+	{
+		description: "negative value is an error",
+		input:       -15,
+		expectError: true,
+	},
+}
+
+func TestCollatzConjecture(t *testing.T) {
+	for _, testCase := range testCases {
+		steps, err := CollatzConjecture(testCase.input)
+		if testCase.expectError {
+			if err == nil {
+				t.Fatalf("FAIL: %s\n\tCollatzConjecture(%v) expected an error, got %v",
+					testCase.description, testCase.input, steps)
+			}
+		} else {
+			if err != nil {
+				t.Fatalf("FAIL: %s\n\tCollatzConjecture(%v) returns unexpected error %s",
+					testCase.description, testCase.input, err.Error())
+			}
+			if steps != testCase.expected {
+				t.Fatalf("FAIL: %s\n\tCollatzConjecture(%v) expected %v, got %v",
+					testCase.description, testCase.input, testCase.expected, steps)
+			}
+		}
+		t.Logf("PASS: %s", testCase.description)
+	}
+}
+
+func BenchmarkCollatzConjecture(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, testCase := range testCases {
+			CollatzConjecture(testCase.input)
+		}
+	}
+}

data/tracks/go/exercises/collatz-conjecture/example.go

@@ -0,0 +1,24 @@
+package collatzconjecture
+
+import (
+	"errors"
+)
+
+// CollatzConjecture is an example implementation of the collatz conjecture exercise.
+func CollatzConjecture(n int) (int, error) {
+	if n <= 0 {
+		return -1, errors.New("Only positive numbers are allowed")
+	}
+
+	steps := 0
+	for n != 1 {
+		if n%2 == 0 {
+			n = n / 2
+		} else {
+			n = 3*n + 1
+		}
+		steps++
+	}
+
+	return steps, nil
+}

data/tracks/go/exercises/connect/cases_test.go

@@ -1,8 +1,8 @@
 package connect
 
-// Source: exercism/x-common
+// Source: exercism/problem-specifications
 // Commit: 327db7f connect: Fix canonical-data.json formatting
-// x-common version: 1.0.0
+// Problem Specifications Version: 1.0.0
 
 var testCases = []struct {
 	description string