trackler 2.2.1.100 → 2.2.1.101

data/tracks/go/exercises/two-bucket/.meta/hints.md

@@ -0,0 +1,16 @@
+## Implementation
+
+In package twobucket, implement a Go func, Solve, with
+the following signature:
+
+```
+func Solve(sizeBucketOne,
+	sizeBucketTwo,
+	goalAmount int,
+	startBucket string) (goalBucket string, numSteps, otherBucketLevel int, e error)
+```
+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.

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

@@ -0,0 +1,72 @@
+# Two Bucket
+
+Given two buckets of different size, demonstrate how to measure an exact number of liters by strategically transferring liters of fluid between the buckets.
+
+Since this mathematical problem is fairly subject to interpretation / individual approach, the tests have been written specifically to expect one overarching solution.
+
+To help, the tests provide you with which bucket to fill first. That means, when starting with the larger bucket full, you are NOT allowed at any point to have the smaller bucket full and the larger bucket empty (aka, the opposite starting point); that would defeat the purpose of comparing both approaches!
+
+Your program will take as input:
+- the size of bucket one
+- the size of bucket two
+- the desired number of liters to reach
+- which bucket to fill first, either bucket one or bucket two
+
+Your program should determine:
+- the total number of "moves" it should take to reach the desired number of liters, including the first fill
+- which bucket should end up with the desired number of liters (let's say this is bucket A) - either bucket one or bucket two
+- how many liters are left in the other bucket (bucket B)
+
+Note: any time a change is made to either or both buckets counts as one (1) move.
+
+Example:
+Bucket one can hold up to 7 liters, and bucket two can hold up to 11 liters. Let's say bucket one, at a given step, is holding 7 liters, and bucket two is holding 8 liters (7,8). If you empty bucket one and make no change to bucket two, leaving you with 0 liters and 8 liters respectively (0,8), that counts as one "move". Instead, if you had poured from bucket one into bucket two until bucket two was full, leaving you with 4 liters in bucket one and 11 liters in bucket two (4,11), that would count as only one "move" as well.
+
+To conclude, the only valid moves are:
+- pouring from one bucket to another
+- emptying one bucket and doing nothing to the other
+- filling one bucket and doing nothing to the other
+
+Written with <3 at [Fullstack Academy](http://www.fullstackacademy.com/) by [Lindsay](http://lindsaylevine.com).
+
+## Implementation
+
+In package twobucket, implement a Go func, Solve, with
+the following signature:
+
+```
+func Solve(sizeBucketOne,
+	sizeBucketTwo,
+	goalAmount int,
+	startBucket string) (goalBucket string, numSteps, otherBucketLevel int, e error)
+```
+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.
+
+
+## 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
+
+Water Pouring Problem [http://demonstrations.wolfram.com/WaterPouringProblem/](http://demonstrations.wolfram.com/WaterPouringProblem/)
+
+## 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/cases_test.go

@@ -0,0 +1,44 @@
+package twobucket
+
+// Source: exercism/problem-specifications
+// Commit: edbc86b two-bucket: apply lowerCamelCase rule to variables
+// Problem Specifications Version: 1.4.0
+
+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{
+	{
+		"Measure using bucket one of size 3 and bucket two of size 5 - start with bucket one",
+		3, 5, 1, "one", "one", 4, 5, false,
+	},
+	{
+		"Measure using bucket one of size 3 and bucket two of size 5 - start with bucket two",
+		3, 5, 1, "two", "two", 8, 3, false,
+	},
+	{
+		"Measure using bucket one of size 7 and bucket two of size 11 - start with bucket one",
+		7, 11, 2, "one", "one", 14, 11, false,
+	},
+	{
+		"Measure using bucket one of size 7 and bucket two of size 11 - start with bucket two",
+		7, 11, 2, "two", "two", 18, 7, false,
+	},
+	{
+		"Measure one step using bucket one of size 1 and bucket two of size 3 - start with bucket two",
+		1, 3, 3, "two", "two", 1, 0, false,
+	},
+	{
+		"Measure using bucket one of size 2 and bucket two of size 3 - start with bucket one and end with bucket two",
+		2, 3, 3, "one", "two", 2, 2, false,
+	},
+}

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

@@ -0,0 +1,198 @@
+package twobucket
+
+import (
+	"errors"
+)
+
+type bucket int
+
+const (
+	bOne bucket = iota
+	bTwo
+)
+
+type step int
+
+const (
+	none step = iota
+	emptyOne
+	emptyTwo
+	fillOne
+	fillTwo
+	pourOneToTwo
+	pourTwoToOne
+)
+
+type problem struct {
+	capacity [2]int
+	goal     int
+	start    bucket
+}
+
+type state struct {
+	level        [2]int
+	previousStep step
+	numSteps     int
+}
+
+const (
+	FirstBucketName  = "one"
+	SecondBucketName = "two"
+)
+
+// Solve uses given bucket sizes, the goal amount, and starting bucket to
+// solve the two-bucket problem to measure exactly the goal mount,
+// returning the goal bucket name "one" or "two",
+// the required number of steps, and the fill-level of the other bucket.
+func Solve(sizeBucketOne,
+	sizeBucketTwo,
+	goalAmount int,
+	startBucket string) (goalBucket string, numSteps, otherBucketLevel int, e error) {
+
+	if e = validateParameters(sizeBucketOne, sizeBucketTwo, goalAmount, startBucket); e != nil {
+		return "", 0, 0, e
+	}
+
+	p := problem{
+		capacity: [2]int{sizeBucketOne, sizeBucketTwo},
+		goal:     goalAmount,
+	}
+	var s state
+	if startBucket == FirstBucketName {
+		p.start = bOne
+		performStep(p, &s, fillOne)
+	} else {
+		p.start = bTwo
+		performStep(p, &s, fillTwo)
+	}
+	// Initial step might be a solution.
+	if !isSolution(p, s) {
+		s = findGoal(p, s)
+	}
+	if s.level[bOne] == p.goal {
+		return FirstBucketName, s.numSteps, s.level[bTwo], nil
+	}
+	return SecondBucketName, s.numSteps, s.level[bOne], nil
+}
+
+func validateParameters(sizeBucketOne, sizeBucketTwo, goalAmount int, startBucket string) error {
+	if sizeBucketOne <= 0 {
+		return errors.New("sizeBucketOne invalid")
+	}
+	if sizeBucketTwo <= 0 {
+		return errors.New("sizeBucketTwo invalid")
+	}
+	if goalAmount <= 0 {
+		return errors.New("goalAmount invalid")
+	}
+	if startBucket != FirstBucketName && startBucket != SecondBucketName {
+		return errors.New("startBucket invalid")
+	}
+	return nil
+}
+
+func isSolution(p problem, s state) bool {
+	return s.level[bOne] == p.goal || s.level[bTwo] == p.goal
+}
+
+func findGoal(p problem, s state) (g state) {
+	searchList := make([]state, 1)
+	searchList[0] = s
+
+	// Use breadth-first search to find the goal, tracking any previously visited states.
+	visited := map[[2]int]bool{}
+
+	// Mark as already visited two invalid bucket levels: 0,0 and the reverse starting position.
+	visited[[2]int{0, 0}] = true
+	if p.start == bOne {
+		visited[[2]int{0, p.capacity[bTwo]}] = true
+	} else {
+		visited[[2]int{p.capacity[bOne], 0}] = true
+	}
+
+	for {
+		// Pop one item from the searchList each pass.
+		current := searchList[0]
+		searchList = searchList[1:]
+
+		for _, x := range getPossibleSteps(p, current) {
+			next := current
+			performStep(p, &next, x)
+			if isSolution(p, next) {
+				return next
+			}
+			if !visited[next.level] {
+				searchList = append(searchList, next)
+				visited[next.level] = true
+			}
+		}
+	}
+}
+
+func performStep(p problem, s *state, x step) {
+	switch x {
+	case emptyOne:
+		s.level[bOne] = 0
+	case emptyTwo:
+		s.level[bTwo] = 0
+	case fillOne:
+		s.level[bOne] = p.capacity[bOne]
+	case fillTwo:
+		s.level[bTwo] = p.capacity[bTwo]
+	case pourOneToTwo:
+		pour(p, s, bOne, bTwo)
+	case pourTwoToOne:
+		pour(p, s, bTwo, bOne)
+	}
+	s.numSteps++
+	s.previousStep = x
+}
+
+// pour from bucket a to b.
+func pour(p problem, s *state, a, b bucket) {
+	amount := p.capacity[b] - s.level[b]
+	if amount > s.level[a] {
+		amount = s.level[a]
+	}
+	s.level[b] += amount
+	s.level[a] -= amount
+}
+
+func getPossibleSteps(p problem, s state) (list []step) {
+	for x := emptyOne; x <= pourTwoToOne; x++ {
+		if canPeformStep(p, s, x) {
+			list = append(list, x)
+		}
+	}
+	return list
+}
+
+func canPeformStep(p problem, s state, x step) bool {
+	switch x {
+	case emptyOne:
+		if s.previousStep == fillOne || s.previousStep == pourOneToTwo {
+			return false
+		}
+		return s.level[bOne] != 0
+	case emptyTwo:
+		if s.previousStep == fillTwo || s.previousStep == pourTwoToOne {
+			return false
+		}
+		return s.level[bTwo] != 0
+	case fillOne:
+		if s.previousStep == emptyOne || s.level[bOne] == p.capacity[bOne] {
+			return false
+		}
+		return true
+	case fillTwo:
+		if s.previousStep == emptyTwo || s.level[bTwo] == p.capacity[bTwo] {
+			return false
+		}
+		return true
+	case pourOneToTwo:
+		return s.level[bOne] != 0 && s.level[bTwo] < p.capacity[bTwo]
+	case pourTwoToOne:
+		return s.level[bTwo] != 0 && s.level[bOne] < p.capacity[bOne]
+	}
+	return false
+}

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

@@ -0,0 +1,61 @@
+package twobucket
+
+import "testing"
+
+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)
+	}
+}
+
+func BenchmarkSolve(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			Solve(tc.bucketOne, tc.bucketTwo, tc.goal, tc.startBucket)
+		}
+	}
+}
+
+var errorTestCases = []bucketTestCase{
+	{
+		"Invalid first bucket size",
+		0, 5, 5, "one", "one", 1, 0, true,
+	},
+	{
+		"Invalid second bucket size",
+		3, 0, 3, "one", "one", 1, 0, true,
+	},
+	{
+		"Invalid goal amount",
+		1, 1, 0, "one", "one", 0, 1, true,
+	},
+	{
+		"Invalid start bucket name",
+		3, 5, 1, "three", "one", 4, 5, true,
+	},
+}

data/tracks/idris/.travis.yml

@@ -19,7 +19,8 @@ install:
   - bin/fetch-exercism-infra.sh
   - stack --resolver $RESOLVER setup
   - "[[ $(which idris) != '' ]] || travis_wait 60 stack --resolver $RESOLVER install idris"
+  - bin/fetch-idris-testing.sh
 
 script:
-  - bin/configlet .
-  - bin/solve_exercises.sh
+  - bin/configlet lint .
+  - bin/solve_exercises.sh

data/tracks/idris/bin/fetch-idris-testing.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -x
+
+mkdir -p build
+git clone https://github.com/yurrriq/idris-testing.git build/idris-testing
+
+pushd build/idris-testing
+make lib
+make install
+popd

data/tracks/idris/bin/solve_exercises.sh

@@ -29,7 +29,7 @@ for exercise in $exercises; do
 
     ${exercism_command} fetch idris ${exercise} # TODO: track name!
     exercise_implementation=$(ls ${exercism_home}/idris/${exercise}/src/*.idr)
-    exercise_example=${xtrack_home}/exercises/${exercise}/src/example.idr
+    exercise_example=${xtrack_home}/exercises/${exercise}/src/Example.idr
     cp ${exercise_example} ${exercise_implementation}
 
     pushd ${exercism_home}/idris/${exercise}
@@ -56,4 +56,4 @@ for i in ${red[@]}; do
     echo " * ${i}"
 done
 
-exit $exit_code
+exit $exit_code

data/tracks/idris/config.json

@@ -7,6 +7,17 @@
 
   ],
   "exercises": [
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "rna-transcription",
+      "topics" : [
+        "pattern_matching",
+        "vectors"
+      ],
+      "unlocked_by": null,
+      "uuid": "3640da6c-4f1d-483c-8990-de225fcb0b03"
+    },
     {
       "core": false,
       "difficulty": 1,