trackler 2.2.1.100 → 2.2.1.101

data/tracks/go/config.json

@@ -1223,6 +1223,18 @@
       "unlocked_by": "flatten-array",
       "uuid": "6b313720-104a-46c2-8290-4b4af121101f "
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "two-bucket",
+      "topics": [
+        "algorithms",
+        "conditionals",
+        "searching"
+      ],
+      "unlocked_by": "binary-search",
+      "uuid": "549bf4a0-b8eb-4f66-8990-7df6cdfaee0c"
+    },
     {
       "core": false,
       "difficulty": 4,

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

@@ -29,19 +29,32 @@ type testGroup struct {
 	Description string
 	Cases       []json.RawMessage `property:"RAW"`
 	CreateCases []struct {
-		Description  string
-		Hour, Minute int
-		Expected     string
+		Description string
+		Input       struct {
+			Hour, Minute int
+		}
+		Expected string
 	} `property:"create"`
 	AddCases []struct {
-		Description       string
-		Hour, Minute, Add int
-		Expected          string
+		Description string
+		Input       struct {
+			Hour, Minute, Value int
+		}
+		Expected string
 	} `property:"add"`
+	SubtractCases []struct {
+		Description string
+		Input       struct {
+			Hour, Minute, Value int
+		}
+		Expected string
+	} `property:"subtract"`
 	EqCases []struct {
-		Description    string
-		Clock1, Clock2 struct{ Hour, Minute int }
-		Expected       bool
+		Description string
+		Input       struct {
+			Clock1, Clock2 struct{ Hour, Minute int }
+		}
+		Expected bool
 	} `property:"equal"`
 }
 
@@ -62,7 +75,7 @@ var tmpl = `package clock
 			want string
 		}{
 			{{- range .CreateCases }}
-				{ {{.Hour}}, {{.Minute}}, {{.Expected | printf "%#v"}}}, // {{.Description}}
+				{ {{.Input.Hour}}, {{.Input.Minute}}, {{.Expected | printf "%#v"}}}, // {{.Description}}
 			{{- end }}
 		}
 	{{- end }}
@@ -73,7 +86,18 @@ var tmpl = `package clock
 			want string
 		}{
 			{{- range .AddCases }}
-				{ {{.Hour}}, {{.Minute}}, {{.Add}}, {{.Expected | printf "%#v"}}}, // {{.Description}}
+				{ {{.Input.Hour}}, {{.Input.Minute}}, {{.Input.Value}}, {{.Expected | printf "%#v"}}}, // {{.Description}}
+			{{- end }}
+		}
+	{{- end }}
+
+	{{- if .SubtractCases }}
+		var {{ .GroupShortName }}Tests = []struct {
+			h, m, a int
+			want string
+		}{
+			{{- range .SubtractCases }}
+				{ {{.Input.Hour}}, {{.Input.Minute}}, {{.Input.Value}}, {{.Expected | printf "%#v"}}}, // {{.Description}}
 			{{- end }}
 		}
 	{{- end }}
@@ -87,8 +111,8 @@ var tmpl = `package clock
 			{{- range .EqCases }}
 				// {{.Description}}
 				{
-					hm{ {{.Clock1.Hour}}, {{.Clock1.Minute}}},
-					hm{ {{.Clock2.Hour}}, {{.Clock2.Minute}}},
+					hm{ {{.Input.Clock1.Hour}}, {{.Input.Clock1.Minute}}},
+					hm{ {{.Input.Clock2.Hour}}, {{.Input.Clock2.Minute}}},
 					{{.Expected}},
 				},
 			{{- end }}

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

@@ -1,8 +1,8 @@
 package clock
 
 // Source: exercism/problem-specifications
-// Commit: 54c3b74 Cleanup canonical-data for clock
-// Problem Specifications Version: 1.0.1
+// Commit: 8b96944 clock: remove obsolete sentence from comment
+// Problem Specifications Version: 2.2.1
 
 // Create a new clock with an initial time
 var timeTests = []struct {
@@ -50,14 +50,14 @@ var subtractTests = []struct {
 	h, m, a int
 	want    string
 }{
-	{10, 3, -3, "10:00"},    // subtract minutes
-	{10, 3, -30, "09:33"},   // subtract to previous hour
-	{10, 3, -70, "08:53"},   // subtract more than an hour
-	{0, 3, -4, "23:59"},     // subtract across midnight
-	{0, 0, -160, "21:20"},   // subtract more than two hours
-	{6, 15, -160, "03:35"},  // subtract more than two hours with borrow
-	{5, 32, -1500, "04:32"}, // subtract more than one day (1500 min = 25 hrs)
-	{2, 20, -3000, "00:20"}, // subtract more than two days
+	{10, 3, 3, "10:00"},    // subtract minutes
+	{10, 3, 30, "09:33"},   // subtract to previous hour
+	{10, 3, 70, "08:53"},   // subtract more than an hour
+	{0, 3, 4, "23:59"},     // subtract across midnight
+	{0, 0, 160, "21:20"},   // subtract more than two hours
+	{6, 15, 160, "03:35"},  // subtract more than two hours with borrow
+	{5, 32, 1500, "04:32"}, // subtract more than one day (1500 min = 25 hrs)
+	{2, 20, 3000, "00:20"}, // subtract more than two days
 }
 
 // Compare two clocks for equality

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

@@ -44,13 +44,17 @@ func TestAddMinutes(t *testing.T) {
 				a.h, a.m, a.a, got, a.want)
 		}
 	}
+	t.Log(len(addTests), "test cases")
+}
+
+func TestSubtractMinutes(t *testing.T) {
 	for _, a := range subtractTests {
-		if got := New(a.h, a.m).Add(a.a); got.String() != a.want {
+		if got := New(a.h, a.m).Subtract(a.a); got.String() != a.want {
 			t.Fatalf("New(%d, %d).Add(%d) = %q, want %q",
 				a.h, a.m, a.a, got, a.want)
 		}
 	}
-	t.Log(len(addTests), "test cases")
+	t.Log(len(subtractTests), "test cases")
 }
 
 func TestCompareClocks(t *testing.T) {
@@ -81,6 +85,16 @@ func BenchmarkAddMinutes(b *testing.B) {
 	}
 }
 
+func BenchmarkSubtractMinutes(b *testing.B) {
+	c := New(12, 0)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, a := range subtractTests {
+			c.Subtract(a.a)
+		}
+	}
+}
+
 func BenchmarkCreateClocks(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, n := range timeTests {

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

@@ -16,6 +16,10 @@ func (c Clock) Add(m int) Clock {
 	return New(0, int(c)+m)
 }
 
+func (c Clock) Subtract(m int) Clock {
+	return New(0, int(c)-m)
+}
+
 func (c Clock) String() string {
 	return fmt.Sprintf("%02d:%02d", c/60, c%60)
 }

data/tracks/go/exercises/clock/example_clock_test.go

@@ -10,7 +10,7 @@ func ExampleClock_new() {
 	// Output: 10:30
 }
 
-func ExampleClock_Add_add() {
+func ExampleClock_Add() {
 	// create a clock
 	clock := New(10, 30)
 
@@ -21,12 +21,12 @@ func ExampleClock_Add_add() {
 	// Output: 11:00
 }
 
-func ExampleClock_Add_subtract() {
+func ExampleClock_Subtract() {
 	// create a clock
 	clock := New(10, 30)
 
 	// subtract an hour and a half from it
-	clock = clock.Add(-90)
+	clock = clock.Subtract(90)
 	fmt.Println(clock.String())
 
 	// Output: 09:00

data/tracks/go/exercises/parallel-letter-frequency/.meta/hints.md

@@ -0,0 +1,33 @@
+## Concurrency vs Parallelism
+
+Go supports concurrency via "[goroutines](https://golangbot.com/goroutines/)"
+which are started with the `go` keyword. It is a simple, lightweight and elegant
+way to provide concurrency support and is one of the greatest strengths of the
+language.
+
+You may notice that while this exercise is called _Parallel_ letter frequency
+you don't see the term "Parallel" used very often in Go. Gophers prefer to use
+the term **Concurrent** to describe the management of multiple independent
+goroutines ("processes" or "threads" in other language contexts). Although
+these terms are often used interchangeably Gophers like to be technically
+correct and use "concurrent" when discussing the seemingly simultaneous
+executions of goroutines.
+
+While we can plan for our programs to run in parallel, and at times they may
+appear to run in parallel, without strict knowledge of the execution context of
+our code all we can guarantee is that processes will run concurrently. In other
+words they may be executing sequentially faster than we can distinguish but not
+strictly simultaneously.
+
+For more take a look at The Go Blog's post: [Concurrency is not parallelism](https://blog.golang.org/concurrency-is-not-parallelism).
+
+## Concurrency Resources
+
+If you are new to the concurrency features in Go here are some resources to get
+you started. We recommend looking over these before starting this exercise:
+
+* [Concurrency in the Golang Book](https://www.golang-book.com/books/intro/10)
+* [A Tour of Go's concurrency section](https://tour.golang.org/concurrency/1)
+* [Go's sync.Map](https://medium.com/@deckarep/the-new-kid-in-town-gos-sync-map-de24a6bf7c2c)
+
+For a really deep dive you can try the book [Concurrency in Go](http://shop.oreilly.com/product/0636920046189.do) by [@kat-co](https://github.com/kat-co).

data/tracks/go/exercises/parallel-letter-frequency/README.md

@@ -7,6 +7,41 @@ sequentially. A common example is counting the frequency of letters.
 Create a function that returns the total frequency of each letter in a
 list of texts and that employs parallelism.
 
+## Concurrency vs Parallelism
+
+Go supports concurrency via "[goroutines](https://golangbot.com/goroutines/)"
+which are started with the `go` keyword. It is a simple, lightweight and elegant
+way to provide concurrency support and is one of the greatest strengths of the
+language.
+
+You may notice that while this exercise is called _Parallel_ letter frequency
+you don't see the term "Parallel" used very often in Go. Gophers prefer to use
+the term **Concurrent** to describe the management of multiple independent
+goroutines ("processes" or "threads" in other language contexts). Although
+these terms are often used interchangeably Gophers like to be technically
+correct and use "concurrent" when discussing the seemingly simultaneous
+executions of goroutines.
+
+While we can plan for our programs to run in parallel, and at times they may
+appear to run in parallel, without strict knowledge of the execution context of
+our code all we can guarantee is that processes will run concurrently. In other
+words they may be executing sequentially faster than we can distinguish but not
+strictly simultaneously.
+
+For more take a look at The Go Blog's post: [Concurrency is not parallelism](https://blog.golang.org/concurrency-is-not-parallelism).
+
+## Concurrency Resources
+
+If you are new to the concurrency features in Go here are some resources to get
+you started. We recommend looking over these before starting this exercise:
+
+* [Concurrency in the Golang Book](https://www.golang-book.com/books/intro/10)
+* [A Tour of Go's concurrency section](https://tour.golang.org/concurrency/1)
+* [Go's sync.Map](https://medium.com/@deckarep/the-new-kid-in-town-gos-sync-map-de24a6bf7c2c)
+
+For a really deep dive you can try the book [Concurrency in Go](http://shop.oreilly.com/product/0636920046189.do) by [@kat-co](https://github.com/kat-co).
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/exercises/raindrops/.meta/hints.md

@@ -1,7 +1,10 @@
 ## No Stub
 
-This is the first exercise in the Go track that doesn't have a stub file; a pre-existing
-`raindrops.go` file to get you started on your solution.
+This may be the first Go track exercise you encounter without a stub: a
+pre-existing `raindrops.go` file for your solution. You may not see stubs in
+the future and should begin to get comfortable with creating your own Go files
+for your solutions.
 
-You won't see any stub files in the future and should start getting comfortable
-creating your own Go files for your solutions.
+One way to figure out what the function signature(s) you would need is to look
+at the corresponding \*\_test.go file. It will show you what the package level
+functions(s) should be that the test will use to verify the solution.

data/tracks/go/exercises/raindrops/README.md

@@ -17,6 +17,18 @@ Convert a number to a string, the contents of which depend on the number's facto
 - 34 has four factors: 1, 2, 17, and 34.
   - In raindrop-speak, this would be "34".
 
+## No Stub
+
+This may be the first Go track exercise you encounter without a stub: a
+pre-existing `raindrops.go` file for your solution. You may not see stubs in
+the future and should begin to get comfortable with creating your own Go files
+for your solutions.
+
+One way to figure out what the function signature(s) you would need is to look
+at the corresponding \*\_test.go file. It will show you what the package level
+functions(s) should be that the test will use to verify the solution.
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/exercises/roman-numerals/.meta/gen.go

@@ -21,7 +21,9 @@ func main() {
 // The JSON structure we expect to be able to unmarshal into
 type js struct {
 	Cases []struct {
-		Number   int
+		Input struct {
+			Number int
+		}
 		Expected string
 	}
 }
@@ -38,6 +40,6 @@ type romanNumeralTest struct {
 }
 
 var romanNumeralTests = []romanNumeralTest {
-{{range .J.Cases}}{ {{.Number}}, "{{.Expected}}", false},
+{{range .J.Cases}}{ {{.Input.Number}}, "{{.Expected}}", false},
 {{end}}}
 `

data/tracks/go/exercises/roman-numerals/cases_test.go

@@ -1,8 +1,8 @@
 package romannumerals
 
 // Source: exercism/problem-specifications
-// Commit: 070e8d5 roman-numerals: Fix canonical-data.json formatting
-// Problem Specifications Version: 1.0.0
+// Commit: 3c78ac4 Add test case for input value 49 to test double-normalization
+// Problem Specifications Version: 1.2.0
 
 type romanNumeralTest struct {
 	arabic   int
@@ -20,6 +20,7 @@ var romanNumeralTests = []romanNumeralTest{
 	{9, "IX", false},
 	{27, "XXVII", false},
 	{48, "XLVIII", false},
+	{49, "XLIX", false},
 	{59, "LIX", false},
 	{93, "XCIII", false},
 	{141, "CXLI", false},

data/tracks/go/exercises/space-age/.meta/hints.md

@@ -0,0 +1,10 @@
+## No Stub
+
+This may be the first Go track exercise you encounter without a stub: a
+pre-existing `space_age.go` file for your solution. You may not see stubs in
+the future and should begin to get comfortable with creating your own Go files
+for your solutions.
+
+One way to figure out what the function signature(s) you would need is to look
+at the corresponding \*\_test.go file. It will show you what the package level
+functions(s) should be that the test will use to verify the solution.

data/tracks/go/exercises/space-age/README.md

@@ -12,11 +12,24 @@ Given an age in seconds, calculate how old someone would be on:
    - Neptune: orbital period 164.79132 Earth years
 
 So if you were told someone were 1,000,000,000 seconds old, you should
-be able to say that they're 31.69 Earth-years old.
+be able to say that they're 31.69 Earth-years old. Round all ages to
+the nearest hundredth of a year.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
 
+## No Stub
+
+This may be the first Go track exercise you encounter without a stub: a
+pre-existing `space_age.go` file for your solution. You may not see stubs in
+the future and should begin to get comfortable with creating your own Go files
+for your solutions.
+
+One way to figure out what the function signature(s) you would need is to look
+at the corresponding \*\_test.go file. It will show you what the package level
+functions(s) should be that the test will use to verify the solution.
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/exercises/twelve-days/README.md

@@ -28,10 +28,6 @@ On the eleventh day of Christmas my true love gave to me, eleven Pipers Piping,
 On the twelfth day of Christmas my true love gave to me, twelve Drummers Drumming, eleven Pipers Piping, ten Lords-a-Leaping, nine Ladies Dancing, eight Maids-a-Milking, seven Swans-a-Swimming, six Geese-a-Laying, five Gold Rings, four Calling Birds, three French Hens, two Turtle Doves, and a Partridge in a Pear Tree.
 ```
 
-## No Stub
-This is the first Go track exercise you encounter without a stub: a pre-existing "twelve-days.go" file for your solution. You may not see stubs in the future and should begin to get comfortable with creating your own Go files for your solutions.
-
-
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.
@@ -51,7 +47,8 @@ you're having trouble, please visit the exercism.io [Go language page](http://ex
 
 ## Source
 
-Wikipedia [http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song)](http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song))
+Wikipedia [http://en.wikipedia.org/wiki/The*Twelve_Days_of_Christmas*(song)](<http://en.wikipedia.org/wiki/The_Twelve_Days_of_Christmas_(song)>)
 
 ## 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/two-bucket/.meta/gen.go

@@ -0,0 +1,62 @@
+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("two-bucket", &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
+		Input       struct {
+			BucketOne   int
+			BucketTwo   int
+			Goal        int
+			StartBucket string
+		}
+		Expected struct {
+			GoalBucket  string
+			Moves       int
+			OtherBucket int
+		}
+	}
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package twobucket
+
+{{.Header}}
+
+type bucketTestCase struct {
+	description     string
+	bucketOne	int
+	bucketTwo	int
+	goal		int
+	startBucket	string
+	goalBucket	string
+	moves		int
+	otherBucket	int
+	errorExpected   bool // always false for generated test cases.
+}
+
+var testCases = []bucketTestCase {
+{{range .J.Cases}}{
+	"{{.Description}}",
+	{{.Input.BucketOne}}, {{.Input.BucketTwo}}, {{.Input.Goal}}, "{{.Input.StartBucket}}", "{{.Expected.GoalBucket}}", {{.Expected.Moves}}, {{.Expected.OtherBucket}}, false,
+},
+{{end}}}
+`