trackler 2.2.1.71 → 2.2.1.72

data/tracks/ecmascript/exercises/rectangles/package.json

@@ -61,8 +61,7 @@
     "extends": "airbnb",
     "rules": {
       "import/no-unresolved": "off",
-      "import/extensions": "off",
-      "no-plusplus": "off"
+      "import/extensions": "off"
     }
   },
   "licenses": [

data/tracks/ecmascript/exercises/rotational-cipher/package.json

@@ -61,8 +61,7 @@
     "extends": "airbnb",
     "rules": {
       "import/no-unresolved": "off",
-      "import/extensions": "off",
-      "no-plusplus": "off"
+      "import/extensions": "off"
     }
   },
   "licenses": [

data/tracks/ecmascript/exercises/spiral-matrix/package.json

@@ -61,8 +61,7 @@
     "extends": "airbnb",
     "rules": {
       "import/no-unresolved": "off",
-      "import/extensions": "off",
-      "no-plusplus": "off"
+      "import/extensions": "off"
     }
   },
   "licenses": [

data/tracks/ecmascript/exercises/transpose/package.json

@@ -9,7 +9,7 @@
     "url": "https://github.com/exercism/xecmascript"
   },
   "devDependencies": {
-    "babel-jest": "^20.0.3",
+    "babel-jest": "^21.2.0",
     "babel-plugin-transform-builtin-extend": "^1.1.2",
     "babel-preset-env": "^1.4.0",
     "eslint": "^3.19.0",
@@ -17,7 +17,7 @@
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsx-a11y": "^5.0.1",
     "eslint-plugin-react": "^7.0.1",
-    "jest": "^20.0.4"
+    "jest": "^21.2.1"
   },
   "jest": {
     "modulePathIgnorePatterns": [

data/tracks/erlang/docs/ABOUT.md

@@ -2,4 +2,4 @@ Erlang is a programming language used to build massively scalable soft real-time
 Some of its uses are in telecoms, banking, e-commerce, computer telephony and instant messaging.
 Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance.
 
-The above description is a quote taken directly from the 'Getting Started' section of [the Erlang homepage](www.erlang.org).
+The above description is a quote taken directly from the 'Getting Started' section of [the Erlang homepage](https://www.erlang.org).

data/tracks/go/exercises/binary-search/.meta/gen.go

@@ -0,0 +1,55 @@
+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("binary-search", &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    []oneCase
+}
+
+// Test cases
+type oneCase struct {
+	Description string
+	Property    string
+	Array       []int
+	Value       int
+	Expected    int
+}
+
+// Template to generate test cases.
+var tmpl = `package binarysearch
+
+{{.Header}}
+
+var testCases = []struct {
+	description	string
+	slice		[]int
+	key		int
+	x	int
+}{ {{range .J.Cases}}
+{
+	description:	{{printf "%q"  .Description}},
+	slice:		{{printf "%#v"  .Array}},
+	key:		{{printf "%d"  .Value}},
+	x:	{{printf "%d"  .Expected}},
+},{{end}}
+}
+`

data/tracks/go/exercises/binary-search/binary_search_test.go

@@ -1,193 +1,52 @@
-// Go has binary search in the standard library.  Let's reimplement
-// sort.SearchInts with the same API as documented in the standard library
-// at http://golang.org/pkg/sort/#Search.  Note that there are some differences
-// with the exercise README.
-//
-// * If there are duplicate values of the key you are searching for, you can't
-// just stop at the first one you find; you must find the first occurrence in
-// the slice.
-//
-// * There is no special "not found" indication.  If the search key is not
-// present, SearchInts returns the index of the first value greater than the
-// search key.  If the key is greater than all values in the slice, SearchInts
-// returns the length of the slice.
-//
-// * You can assume the slice is sorted in increasing order.  There is no need
-// to check that it is sorted.  (That would wreck the performance.)
-//
-// Try it on your own without peeking at the standard library code.
-
 package binarysearch
 
 import (
+	"fmt"
 	"math/rand"
-	"sort"
 	"testing"
 )
 
-var testData = []struct {
-	ref   string
-	slice []int
-	key   int
-	x     int // expected result
-}{
-	{"6 found at index 3",
-		[]int{1, 3, 4, 6, 8, 9, 11},
-		6, 3},
-	{"9 found at index 5",
-		[]int{1, 3, 4, 6, 8, 9, 11},
-		9, 5},
-	{"3 found at index 1",
-		[]int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144},
-		3, 1},
-	{"55 found at index 7",
-		[]int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144},
-		55, 7},
-	{"21 found at index 5",
-		[]int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377},
-		21, 5},
-	{"34 found at index 6",
-		[]int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377},
-		34, 6},
-
-	{"1 found at beginning of slice",
-		[]int{1, 3, 6},
-		1, 0},
-	{"6 found at end of slice",
-		[]int{1, 3, 6},
-		6, 2},
-	{"2 > 1 at index 0, < 3 at index 1",
-		[]int{1, 3, 6},
-		2, 1},
-	{"2 < all values",
-		[]int{11, 13, 16},
-		2, 0},
-	{"21 > all 3 values",
-		[]int{11, 13, 16},
-		21, 3},
-	{"1 found at beginning of slice",
-		[]int{1, 1, 1, 1, 1, 3, 6}, // duplicates
-		1, 0},
-	{"3 found at index 1",
-		[]int{1, 3, 3, 3, 3, 3, 6},
-		3, 1},
-	{"6 found at index 4",
-		[]int{1, 3, 3, 3, 6, 6, 6},
-		6, 4},
-	{"-2 > -3 at index 1, < -1 at index 2",
-		[]int{-6, -3, -1}, // negatives
-		-2, 2},
-	{"0 > -7 at index 4, < 1 at index 5",
-		[]int{-19, -17, -15, -12, -7, 1, 14, 35, 69, 124},
-		0, 5},
-	{"slice has no values",
-		nil, 0, 0},
-}
-
 func TestSearchInts(t *testing.T) {
-	for _, test := range testData {
-		if !sort.IntsAreSorted(test.slice) {
-			t.Skip("Invalid test data")
-		}
+	for _, test := range testCases {
 		if x := SearchInts(test.slice, test.key); x != test.x {
-			t.Fatalf("SearchInts(%v, %d) = %d, want %d",
-				test.slice, test.key, x, test.x)
-		}
-	}
-}
-
-// Did you get it?  Did you cut and paste from the standard library?
-// Whatever.  Now show you can work it.
-//
-// The test program will supply slices and keys and you will write a function
-// that searches and returns one of the following messages:
-//
-//   k found at beginning of slice.
-//   k found at end of slice.
-//   k found at index fx.
-//   k < all values.
-//   k > all n values.
-//   k > lv at lx, < gv at gx.
-//   slice has no values.
-//
-// In your messages, substitute appropritate values for k, lv, and gv;
-// substitute indexes for fx, lx, and gx; substitute a number for n.
-//
-// In the function Message you will demonstrate a number of different ways
-// to test the result of SearchInts.  Note that you would probably never need
-// all of these different tests in a real program.  The point of the exercise
-// is just to show that it is possible to identify a number of different
-// conditions from the return value.
-func TestMessage(t *testing.T) {
-	for _, test := range testData {
-		if !sort.IntsAreSorted(test.slice) {
-			t.Skip("Invalid test data")
-		}
-		if res := Message(test.slice, test.key); res != test.ref {
-			t.Fatalf("Message(%v, %d) =\n%q\nwant:\n%q",
-				test.slice, test.key, res, test.ref)
+			t.Fatalf("FAIL: %s\nSearchInts(%#v, %d) = %d, want %d",
+				test.description, test.slice, test.key, x, test.x)
 		}
+		t.Logf("SUCCESS: %s", test.description)
 	}
 }
 
 // Benchmarks also test searching larger random slices
 
-func Benchmark1e2(b *testing.B) {
-	s := make([]int, 1e2)
-	for i := range s {
-		s[i] = rand.Intn(len(s))
-	}
-	sort.Ints(s)
-	k := rand.Intn(len(s))
-	ref := sort.SearchInts(s, k)
-	res := SearchInts(s, k)
-	if ref != res {
-		b.Fatalf(
-			"Search of %d values gave different answer than sort.SearchInts",
-			len(s))
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		SearchInts(s, k)
-	}
+type query struct {
+	slice []int
+	x     int
 }
 
-func Benchmark1e4(b *testing.B) {
-	s := make([]int, 1e4)
-	for i := range s {
-		s[i] = rand.Intn(len(s))
+func newQuery(n int) (query, error) {
+	q := query{slice: make([]int, n)}
+	for i := 0; i < n; i++ {
+		q.slice[i] = i
 	}
-	sort.Ints(s)
-	k := rand.Intn(len(s))
-	ref := sort.SearchInts(s, k)
-	res := SearchInts(s, k)
-	if ref != res {
-		b.Fatalf(
-			"Search of %d values gave different answer than sort.SearchInts",
-			len(s))
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		SearchInts(s, k)
+	q.x = rand.Intn(n)
+	if res := SearchInts(q.slice, q.x); res != q.x {
+		return q, fmt.Errorf("Search of %d values gave different answer", n)
 	}
+	return q, nil
 }
 
-func Benchmark1e6(b *testing.B) {
-	s := make([]int, 1e6)
-	for i := range s {
-		s[i] = rand.Intn(len(s))
-	}
-	sort.Ints(s)
-	k := rand.Intn(len(s))
-	ref := sort.SearchInts(s, k)
-	res := SearchInts(s, k)
-	if ref != res {
-		b.Fatalf(
-			"Search of %d values gave different answer than sort.SearchInts",
-			len(s))
+func runBenchmark(n int, b *testing.B) {
+	q, err := newQuery(n)
+	if err != nil {
+		b.Fatal(err)
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		SearchInts(s, k)
+		SearchInts(q.slice, q.x)
 	}
 }
+
+func Benchmark1e2(b *testing.B) { runBenchmark(1e2, b) }
+func Benchmark1e4(b *testing.B) { runBenchmark(1e4, b) }
+func Benchmark1e6(b *testing.B) { runBenchmark(1e6, b) }
+func Benchmark1e8(b *testing.B) { runBenchmark(1e8, b) }

data/tracks/go/exercises/binary-search/cases_test.go

@@ -0,0 +1,73 @@
+package binarysearch
+
+// Source: exercism/problem-specifications
+// Commit: 8acd78c Replace x-common with problem-specifications
+// Problem Specifications Version: 1.0.0
+
+var testCases = []struct {
+	description string
+	slice       []int
+	key         int
+	x           int
+}{
+	{
+		description: "finds a value in an array with one element",
+		slice:       []int{6},
+		key:         6,
+		x:           0,
+	},
+	{
+		description: "finds a value in the middle of an array",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         6,
+		x:           3,
+	},
+	{
+		description: "finds a value at the beginning of an array",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         1,
+		x:           0,
+	},
+	{
+		description: "finds a value at the end of an array",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         11,
+		x:           6,
+	},
+	{
+		description: "finds a value in an array of odd length",
+		slice:       []int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634},
+		key:         144,
+		x:           9,
+	},
+	{
+		description: "finds a value in an array of even length",
+		slice:       []int{1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377},
+		key:         21,
+		x:           5,
+	},
+	{
+		description: "identifies that a value is not included in the array",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         7,
+		x:           -1,
+	},
+	{
+		description: "a value smaller than the array's smallest value is not included",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         0,
+		x:           -1,
+	},
+	{
+		description: "a value larger than the array's largest value is not included",
+		slice:       []int{1, 3, 4, 6, 8, 9, 11},
+		key:         13,
+		x:           -1,
+	},
+	{
+		description: "nothing is included in an empty array",
+		slice:       []int{},
+		key:         1,
+		x:           -1,
+	},
+}

data/tracks/go/exercises/binary-search/example.go

@@ -1,38 +1,16 @@
 package binarysearch
 
-import "fmt"
-
-func SearchInts(s []int, k int) (i int) {
-	for j := len(s); i < j; {
+// SearchInts search given key in the given slice
+// upon finding returns its index, otherwise -1
+func SearchInts(s []int, k int) int {
+	for i, j := 0, len(s)-1; i <= j; {
 		if h := (i + j) / 2; s[h] < k {
 			i = h + 1
+		} else if s[h] > k {
+			j = h - 1
 		} else {
-			j = h
+			return h
 		}
 	}
-	return
-}
-
-func Message(s []int, k int) string {
-	x := SearchInts(s, k)
-	switch {
-	case x == len(s):
-		if x == 0 {
-			return "slice has no values"
-		}
-		return fmt.Sprintf("%d > all %d values", k, x)
-	case s[x] != k:
-		if x == 0 {
-			return fmt.Sprintf("%d < all values", k)
-		}
-		return fmt.Sprintf("%d > %d at index %d, < %d at index %d",
-			k, s[x-1], x-1, s[x], x)
-	}
-	switch x {
-	case 0:
-		return fmt.Sprintf("%d found at beginning of slice", k)
-	case len(s) - 1:
-		return fmt.Sprintf("%d found at end of slice", k)
-	}
-	return fmt.Sprintf("%d found at index %d", k, x)
+	return -1
 }