trackler 2.2.1.102 → 2.2.1.103

data/tracks/gnu-apl/config/exercise_readme.go.tmpl

@@ -4,9 +4,6 @@
 {{- with .Hints }}
 {{ . }}
 {{ end }}
-{{- with .TrackInsert }}
-{{ . }}
-{{ end }}
 {{- with .Spec.Credits -}}
 ## Source
 

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

@@ -0,0 +1,36 @@
+# Armstrong Numbers
+
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 2`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+## 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/Narcissistic_number](https://en.wikipedia.org/wiki/Narcissistic_number)
+
+## 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/hints.md

@@ -11,6 +11,26 @@ func Solve(sizeBucketOne,
 ```
 Solve returns four values: the resulting goal bucket("one" or two"),
 the number of moves/steps to achieve the goal amount,
-the liters left in the other bucket,
-and an error value. The returned error value should be nil for valid parameters,
-or an error for invalid parameters.
+the liters left in the other bucket, and an error value.
+The returned error value should be nil when the parameters are valid.
+Return an error for any invalid parameter.
+Solve should also return an error when a solution cannot be found,
+but this error relates only to the bonus exercise below, so you may
+ignore that error case for your initial solution.
+
+### Bonus exercise
+
+Once you get `go test` passing, try `go test -tags bonus`.  This uses a *build
+tag* to enable tests that were not previously enabled. Build tags control which
+files should be included in the package. You can read more about those at [the
+Go documentation](https://golang.org/pkg/go/build/#hdr-Build_Constraints).
+
+The exercise limits `go test` to only build the tests referenced in the
+`two_bucket_test.go` file. The bonus test cases are found in the file
+`bonus_test.go`. Enable those tests as described above.
+
+To get the bonus tests to pass, the Solve func must detect when
+a solution cannot be found and return an error.
+A solution cannot be found when input test case bucket sizes
+are not ones which allow the three operations to succeed in creating the goal amount,
+which occurs when the two bucket sizes are not relatively prime to one another.

data/tracks/go/exercises/two-bucket/README.md

@@ -42,9 +42,29 @@ func Solve(sizeBucketOne,
 ```
 Solve returns four values: the resulting goal bucket("one" or two"),
 the number of moves/steps to achieve the goal amount,
-the liters left in the other bucket,
-and an error value. The returned error value should be nil for valid parameters,
-or an error for invalid parameters.
+the liters left in the other bucket, and an error value.
+The returned error value should be nil when the parameters are valid.
+Return an error for any invalid parameter.
+Solve should also return an error when a solution cannot be found,
+but this error relates only to the bonus exercise below, so you may
+ignore that error case for your initial solution.
+
+### Bonus exercise
+
+Once you get `go test` passing, try `go test -tags bonus`.  This uses a *build
+tag* to enable tests that were not previously enabled. Build tags control which
+files should be included in the package. You can read more about those at [the
+Go documentation](https://golang.org/pkg/go/build/#hdr-Build_Constraints).
+
+The exercise limits `go test` to only build the tests referenced in the
+`two_bucket_test.go` file. The bonus test cases are found in the file
+`bonus_test.go`. Enable those tests as described above.
+
+To get the bonus tests to pass, the Solve func must detect when
+a solution cannot be found and return an error.
+A solution cannot be found when input test case bucket sizes
+are not ones which allow the three operations to succeed in creating the goal amount,
+which occurs when the two bucket sizes are not relatively prime to one another.
 
 
 ## Running the tests

data/tracks/go/exercises/two-bucket/bonus_test.go

@@ -0,0 +1,22 @@
+// +build bonus
+
+package twobucket
+
+import "testing"
+
+var noSolutionCases = []bucketTestCase{
+	{
+		"No solution case 1",
+		2, 4, 1, "two", "", 0, 0, true,
+	},
+	{
+		"No solution case 2",
+		3, 6, 1, "one", "", 0, 0, true,
+	},
+}
+
+func TestSolve_bonus(t *testing.T) {
+	for _, tc := range noSolutionCases {
+		runTestCase(t, tc)
+	}
+}

data/tracks/go/exercises/two-bucket/example.go

@@ -69,10 +69,13 @@ func Solve(sizeBucketOne,
 	if !isSolution(p, s) {
 		s = findGoal(p, s)
 	}
-	if s.level[bOne] == p.goal {
+	switch {
+	case s.level[bOne] == p.goal:
 		return FirstBucketName, s.numSteps, s.level[bTwo], nil
+	case s.level[bTwo] == p.goal:
+		return SecondBucketName, s.numSteps, s.level[bOne], nil
 	}
-	return SecondBucketName, s.numSteps, s.level[bOne], nil
+	return "", 0, 0, errors.New("no solution")
 }
 
 func validateParameters(sizeBucketOne, sizeBucketTwo, goalAmount int, startBucket string) error {
@@ -110,7 +113,7 @@ func findGoal(p problem, s state) (g state) {
 		visited[[2]int{p.capacity[bOne], 0}] = true
 	}
 
-	for {
+	for len(searchList) != 0 {
 		// Pop one item from the searchList each pass.
 		current := searchList[0]
 		searchList = searchList[1:]
@@ -127,6 +130,7 @@ func findGoal(p problem, s state) (g state) {
 			}
 		}
 	}
+	return state{}
 }
 
 func performStep(p problem, s *state, x step) {
@@ -160,14 +164,14 @@ func pour(p problem, s *state, a, b bucket) {
 
 func getPossibleSteps(p problem, s state) (list []step) {
 	for x := emptyOne; x <= pourTwoToOne; x++ {
-		if canPeformStep(p, s, x) {
+		if canPerformStep(p, s, x) {
 			list = append(list, x)
 		}
 	}
 	return list
 }
 
-func canPeformStep(p problem, s state, x step) bool {
+func canPerformStep(p problem, s state, x step) bool {
 	switch x {
 	case emptyOne:
 		if s.previousStep == fillOne || s.previousStep == pourOneToTwo {

data/tracks/go/exercises/two-bucket/two_bucket_test.go

@@ -2,40 +2,44 @@ package twobucket
 
 import "testing"
 
+func runTestCase(t *testing.T, tc bucketTestCase) {
+	g, m, other, e := Solve(tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket)
+	var _ error = e
+	if e == nil {
+		if tc.errorExpected {
+			t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected error\nActual: %q, %d, %d",
+				tc.description,
+				tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
+				g, m, other)
+		}
+		if g != tc.goalBucket || m != tc.moves || other != tc.otherBucket {
+			t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected: %q, %d, %d\nActual: %q, %d, %d",
+				tc.description,
+				tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
+				tc.goalBucket, tc.moves, tc.otherBucket,
+				g, m, other)
+		}
+	} else if e != nil {
+		if !tc.errorExpected {
+			t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected: %q, %d, %d\nGot Error %q",
+				tc.description,
+				tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
+				tc.goalBucket, tc.moves, tc.otherBucket,
+				e)
+		}
+	}
+	t.Logf("PASS: %s", tc.description)
+}
+
 func TestSolve(t *testing.T) {
 	for _, tc := range append(testCases, errorTestCases...) {
-		g, m, other, e := Solve(tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket)
-		var _ error = e
-		if e == nil {
-			if tc.errorExpected {
-				t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected error\nActual: %q, %d, %d",
-					tc.description,
-					tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
-					g, m, other)
-			}
-			if g != tc.goalBucket || m != tc.moves || other != tc.otherBucket {
-				t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected: %q, %d, %d\nActual: %q, %d, %d",
-					tc.description,
-					tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
-					tc.goalBucket, tc.moves, tc.otherBucket,
-					g, m, other)
-			}
-		} else if e != nil {
-			if !tc.errorExpected {
-				t.Fatalf("FAIL: %s\nSolve(%d, %d, %d, %q)\nExpected: %q, %d, %d\nnGot Error %q",
-					tc.description,
-					tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket,
-					tc.goalBucket, tc.moves, tc.otherBucket,
-					e)
-			}
-		}
-		t.Logf("PASS: %s", tc.description)
+		runTestCase(t, tc)
 	}
 }
 
 func BenchmarkSolve(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		for _, tc := range testCases {
+		for _, tc := range append(testCases, errorTestCases...) {
 			Solve(tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket)
 		}
 	}

data/tracks/haxe/config/exercise_readme.go.tmpl

@@ -4,9 +4,6 @@
 {{- with .Hints }}
 {{ . }}
 {{ end }}
-{{- with .TrackInsert }}
-{{ . }}
-{{ end }}
 {{- with .Spec.Credits -}}
 ## Source
 

data/tracks/haxe/exercises/leap/README.md

@@ -0,0 +1,33 @@
+# Leap
+
+Given a year, report if it is a leap year.
+
+The tricky thing here is that a leap year in the Gregorian calendar occurs:
+
+```text
+on every year that is evenly divisible by 4
+  except every year that is evenly divisible by 100
+    unless the year is also evenly divisible by 400
+```
+
+For example, 1997 is not a leap year, but 1996 is.  1900 is not a leap
+year, but 2000 is.
+
+If your language provides a method in the standard library that does
+this look-up, pretend it doesn't exist and implement it yourself.
+
+## Notes
+
+Though our exercise adopts some very simple rules, there is more to
+learn!
+
+For a delightful, four minute explanation of the whole leap year
+phenomenon, go watch [this youtube video][video].
+
+[video]: http://www.youtube.com/watch?v=xX96xng7sAE
+## Source
+
+JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/protein-translation/README.md

@@ -20,11 +20,11 @@ All subsequent codons after are ignored, like this:
 
 RNA: `"AUGUUUUCUUAAAUG"` =>
 
-Codons: `"AUG", "UUU", "UCU", "UAG", "AUG"` =>
+Codons: `"AUG", "UUU", "UCU", "UAA", "AUG"` =>
 
 Protein: `"Methionine", "Phenylalanine", "Serine"`
 
-Note the stop codon terminates the translation and the final methionine is not translated into the protein sequence.
+Note the stop codon `"UAA"` terminates the translation and the final methionine is not translated into the protein sequence.
 
 Below are the codons and resulting Amino Acids needed for the exercise.
 

data/tracks/lfe/exercises/bob/.meta/description.md

@@ -0,0 +1,10 @@
+Bob is a lackadaisical teenager. In conversation, his responses are very limited.
+
+Bob answers 'Sure.' if you ask him a question.
+
+He answers 'Whoa, chill out!' if you yell at him.
+
+He says 'Fine. Be that way!' if you address him without actually saying
+anything.
+
+He answers 'Whatever.' to anything else.

data/tracks/nim/config/exercise_readme.go.tmpl

@@ -4,9 +4,6 @@
 {{- with .Hints }}
 {{ . }}
 {{ end }}
-{{- with .TrackInsert }}
-{{ . }}
-{{ end }}
 {{- with .Spec.Credits -}}
 ## Source
 

data/tracks/objective-c/exercises/collatz-conjecture/README.md

@@ -0,0 +1,50 @@
+# 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.
+
+## Setup
+
+There are two different methods of getting set up to run the tests with Objective-C:
+
+- Create an Xcode project with a test target which will run the tests.
+- Use the ruby gem `objc` as a test runner utility.
+
+Both are described in more detail here: http://exercism.io/languages/objective-c
+
+
+### Submitting Exercises
+
+When submitting an exercise, make sure your solution file is in the same directory as the test code.
+
+For example, if you're submitting `Bob.m` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/objective-c/bob/Bob.m`.
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/objective-c/exercises/grains/README.md

@@ -0,0 +1,50 @@
+# Grains
+
+Calculate the number of grains of wheat on a chessboard given that the number
+on each square doubles.
+
+There once was a wise servant who saved the life of a prince. The king
+promised to pay whatever the servant could dream up. Knowing that the
+king loved chess, the servant told the king he would like to have grains
+of wheat. One grain on the first square of a chess board. Two grains on
+the next. Four on the third, and so on.
+
+There are 64 squares on a chessboard.
+
+Write code that shows:
+- how many grains were on each square, and
+- the total number of grains
+
+## For bonus points
+
+Did you get the tests passing and the code clean? If you want to, these
+are some additional things you could try:
+
+- Optimize for speed.
+- Optimize for readability.
+
+Then please share your thoughts in a comment on the submission. Did this
+experiment make the code better? Worse? Did you learn anything from it?
+
+## Setup
+
+There are two different methods of getting set up to run the tests with Objective-C:
+
+- Create an Xcode project with a test target which will run the tests.
+- Use the ruby gem `objc` as a test runner utility.
+
+Both are described in more detail here: http://exercism.io/languages/objective-c
+
+
+### Submitting Exercises
+
+When submitting an exercise, make sure your solution file is in the same directory as the test code.
+
+For example, if you're submitting `Bob.m` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/objective-c/bob/Bob.m`.
+
+## Source
+
+JavaRanch Cattle Drive, exercise 6 [http://www.javaranch.com/grains.jsp](http://www.javaranch.com/grains.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/objective-c/exercises/nth-prime/README.md

@@ -0,0 +1,32 @@
+# Nth Prime
+
+Given a number n, determine what the nth prime is.
+
+By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that
+the 6th prime is 13.
+
+If your language provides methods in the standard library to deal with prime
+numbers, pretend they don't exist and implement them yourself.
+
+## Setup
+
+There are two different methods of getting set up to run the tests with Objective-C:
+
+- Create an Xcode project with a test target which will run the tests.
+- Use the ruby gem `objc` as a test runner utility.
+
+Both are described in more detail here: http://exercism.io/languages/objective-c
+
+
+### Submitting Exercises
+
+When submitting an exercise, make sure your solution file is in the same directory as the test code.
+
+For example, if you're submitting `Bob.m` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/objective-c/bob/Bob.m`.
+
+## Source
+
+A variation on Problem 7 at Project Euler [http://projecteuler.net/problem=7](http://projecteuler.net/problem=7)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.