trackler 2.2.1.179 → 2.2.1.180

data/tracks/elixir/docs/ABOUT.md

@@ -11,8 +11,16 @@ Elixir actually compiles down to [bytecode](https://en.wikipedia.org/wiki/Byteco
 
 There is no "conversion cost" for calling Erlang, meaning you can run Erlang code right next to Elixir code.
 
-Being a functional language, everything in Elixir is an expression. Elixir has "First Class Documentation" meaning comments  can be attached to a function, making it easier to retrieve. Regular expressions are also given first class treatment, removing awkward escaping within strings.
+Being a functional language, everything in Elixir is an expression.
 
-Elixir's asynchronous communication implementation allows the code to be lightweight, yet incorporate high-volume concurrency. Programmers use Elixir to handle thousands of requests and responses *concurrently* on a single server node. It has been used successfully for microservices that need to consume and serve a multitude of APIs rapidly.
+Elixir has "First Class Documentation" meaning comments  can be attached to a function, making it easier to retrieve.
+
+Regular expressions are also given first class treatment, removing awkward escaping within strings.
+
+Elixir's asynchronous communication implementation allows the code to be lightweight, yet incorporate high-volume concurrency.
+
+Programmers use Elixir to handle thousands of requests and responses *concurrently* on a single server node.
+
+It has been used successfully for microservices that need to consume and serve a multitude of APIs rapidly.
 
 The [Phoenix framework](http://www.phoenixframework.org/) helps structure Elixir applications for the web.

data/tracks/fortran/config.json

@@ -9,6 +9,7 @@
       "slug": "hello-world",
       "uuid": "b71d9258-78ef-4986-b9ed-ebf93b72d399",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": []

data/tracks/gnu-apl/config.json

@@ -9,6 +9,7 @@
       "slug": "hello-world",
       "uuid": "81121f0c-1218-4d88-bb6c-fd9df3bc0b8d",
       "core": true,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [

data/tracks/go/config.json

@@ -1328,6 +1328,19 @@
         "strings"
       ]
     },
+    {
+      "slug": "list-ops",
+      "uuid": "13d25b60-e8e1-42da-a54f-ce020a2b86e9",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+          "recursion",
+          "type_conversion",
+          "lists",
+          "functional_programming"
+      ]
+    },
     {
       "slug": "binary",
       "uuid": "bf2dcbc4-266f-4cad-9cd7-76d446360a5d",

data/tracks/go/exercises/list-ops/README.md

@@ -0,0 +1,27 @@
+# List Ops
+
+Implement basic list operations.
+
+In functional languages list operations like `length`, `map`, and
+`reduce` are very common. Implement a series of basic list operations,
+without using existing functions.
+
+## 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` and `--benchmem`
+flags:
+
+    go test -v --bench . --benchmem
+
+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).
+
+## 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/list-ops/example.go

@@ -0,0 +1,99 @@
+package listops
+
+// IntList is an abstraction of a list of integers
+type IntList []int
+type predFunc func(int) bool
+type binFunc func(int, int) int
+type unaryFunc func(int) int
+
+// Foldl folds (reduces) the given list from the left with a function
+func (s IntList) Foldl(fn binFunc, initial int) int {
+	if len(s) == 0 {
+		return initial
+	}
+	x, xs := s[0], s[1:]
+	return xs.Foldl(fn, fn(initial, x))
+}
+
+// Foldr folds (reduces) the given list from the right with a function
+func (s IntList) Foldr(fn binFunc, initial int) int {
+	flippedFunc := func(x, y int) int { return fn(y, x) }
+	// Note: This relies on s being finite
+	return s.Reverse().Foldl(flippedFunc, initial)
+}
+
+// Filter list returning only values that satisfy the filter function
+func (s IntList) Filter(fn predFunc) IntList {
+	filtered := make([]int, 0, len(s))
+	var filterAcc func(predFunc, IntList, IntList) IntList
+	filterAcc = func(fn predFunc, acc IntList, lst IntList) IntList {
+		if len(lst) == 0 {
+			return acc
+		}
+		x, xs := lst[0], lst[1:]
+		if fn(x) {
+			acc = append(acc, x)
+		}
+		return filterAcc(fn, acc, xs)
+	}
+	return filterAcc(fn, filtered, s)
+}
+
+// Length returns the length of a list
+func (s IntList) Length() int {
+	// for fun, let's do this with recursion
+	var lengthAcc func(IntList, int) int
+	var isEmpty func(IntList) bool
+	// yeah, this is kind of cheaty, but it's hard to determine if a slice is
+	// empty without using len, so walling it off
+	isEmpty = func(l IntList) bool {
+		return len(l) == 0
+	}
+	lengthAcc = func(lst IntList, acc int) int {
+		if isEmpty(lst) {
+			return acc
+		}
+		return lengthAcc(lst[1:], acc+1)
+	}
+	return lengthAcc(s, 0)
+}
+
+// Map returns a list of elements whose values equal the list value transformed by the mapping function
+func (s IntList) Map(fn unaryFunc) IntList {
+	newSlice := make([]int, len(s))
+	for idx, elt := range s {
+		newSlice[idx] = fn(elt)
+	}
+	return newSlice
+}
+
+// Reverse reverses the list
+func (s IntList) Reverse() IntList {
+	last := len(s) - 1
+	newSlice := make([]int, len(s))
+	for idx, elt := range s {
+		newSlice[last-idx] = elt
+	}
+	return newSlice
+}
+
+// Append adds the elements of the argument list to the receiver
+func (s IntList) Append(lst IntList) IntList {
+	offset := len(s)
+	newSlice := make([]int, offset+len(lst))
+	copy(newSlice, s)
+	for idx, elt := range lst {
+		newSlice[offset+idx] = elt
+	}
+	return newSlice
+}
+
+// Concat concatenates a list of lists
+func (s IntList) Concat(lists []IntList) IntList {
+	newSlice := make([]int, len(s))
+	copy(newSlice, s)
+	for _, l := range lists {
+		newSlice = append(newSlice, l...)
+	}
+	return newSlice
+}

data/tracks/go/exercises/list-ops/listops_test.go

@@ -0,0 +1,291 @@
+package listops
+
+import "reflect"
+import "testing"
+
+var foldTestCases = []struct {
+	name     string
+	property string
+	fn       binFunc
+	initial  int
+	list     IntList
+	want     int
+}{
+	{
+		name:     "empty list",
+		property: "foldl",
+		fn:       func(x, y int) int { return x * y },
+		initial:  2,
+		want:     2,
+		list:     []int{},
+	},
+	{
+		name:     "direction independent function applied to non-empty list",
+		property: "foldl",
+		fn:       func(x, y int) int { return x + y },
+		initial:  5,
+		want:     15,
+		list:     []int{1, 2, 3, 4},
+	},
+	{
+		name:     "direction dependent function applied to non-empty list",
+		property: "foldl",
+		fn:       func(x, y int) int { return x / y },
+		initial:  5,
+		want:     0,
+		list:     []int{2, 5},
+	},
+	{
+		name:     "empty list",
+		property: "foldr",
+		fn:       func(x, y int) int { return x * y },
+		initial:  2,
+		want:     2,
+		list:     []int{},
+	},
+	{
+		name:     "direction dependent function applied to non-empty list",
+		property: "foldr",
+		fn:       func(x, y int) int { return x + y },
+		initial:  5,
+		want:     15,
+		list:     []int{1, 2, 3, 4},
+	},
+	{
+		name:     "direction dependent function applied to non-empty list",
+		property: "foldr",
+		fn:       func(x, y int) int { return x / y },
+		initial:  5,
+		want:     2,
+		list:     []int{2, 5},
+	},
+}
+
+func TestFold(t *testing.T) {
+	var got int
+	for _, tt := range foldTestCases {
+		if tt.property == "foldr" {
+			got = tt.list.Foldr(tt.fn, tt.initial)
+		} else {
+			got = tt.list.Foldl(tt.fn, tt.initial)
+		}
+		if got != tt.want {
+			t.Fatalf("FAIL: %s: %q -- expected: %d, actual: %d", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+
+}
+
+var filterTestCases = []struct {
+	name     string
+	property string
+	fn       predFunc
+	list     []int
+	want     []int
+}{
+	{
+		name:     "empty list",
+		property: "filter",
+		fn:       func(n int) bool { return n%2 == 1 },
+		list:     []int{},
+		want:     []int{},
+	},
+	{
+		name:     "non-empty list",
+		property: "filter",
+		fn:       func(n int) bool { return n%2 == 1 },
+		list:     []int{1, 2, 3, 4, 5},
+		want:     []int{1, 3, 5},
+	},
+}
+
+func TestFilterMethod(t *testing.T) {
+	for _, tt := range filterTestCases {
+		in := IntList(tt.list)
+		got := in.Filter(tt.fn)
+		if !reflect.DeepEqual(IntList(tt.want), got) {
+			t.Fatalf("FAIL: %s: %q -- expected: %v, actual: %v", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+}
+
+var lengthTestCases = []struct {
+	name     string
+	property string
+	list     IntList
+	want     int
+}{
+	{
+		name:     "empty list",
+		property: "length",
+		list:     []int{},
+		want:     0,
+	},
+	{
+		name:     "non-empty list",
+		property: "length",
+		list:     []int{1, 2, 3, 4},
+		want:     4,
+	},
+}
+
+func TestLengthMethod(t *testing.T) {
+	for _, tt := range lengthTestCases {
+		got := tt.list.Length()
+		if tt.want != got {
+			t.Fatalf("FAIL: %s: %q -- expected: %d, actual: %d", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+}
+
+var mapTestCases = []struct {
+	name     string
+	property string
+	list     IntList
+	fn       unaryFunc
+	want     IntList
+}{
+	{
+		name:     "empty list",
+		property: "map",
+		list:     []int{},
+		fn:       func(x int) int { return x + 1 },
+		want:     []int{},
+	},
+	{
+		name:     "non-empty list",
+		property: "map",
+		list:     []int{1, 3, 5, 7},
+		fn:       func(x int) int { return x + 1 },
+		want:     []int{2, 4, 6, 8},
+	},
+}
+
+func TestMapMethod(t *testing.T) {
+	for _, tt := range mapTestCases {
+		got := tt.list.Map(tt.fn)
+		if !reflect.DeepEqual(tt.want, got) {
+			t.Fatalf("FAIL: %s: %q -- expected: %v, actual: %v", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+}
+
+var reverseTestCases = []struct {
+	name     string
+	property string
+	list     IntList
+	want     IntList
+}{
+	{
+		name:     "empty list",
+		property: "reverse",
+		list:     []int{},
+		want:     []int{},
+	},
+	{
+		name:     "non-empty list",
+		property: "reverse",
+		list:     []int{1, 3, 5, 7},
+		want:     []int{7, 5, 3, 1},
+	},
+}
+
+func TestReverseMethod(t *testing.T) {
+	for _, tt := range reverseTestCases {
+		got := tt.list.Reverse()
+		if !reflect.DeepEqual(tt.want, got) {
+			t.Fatalf("FAIL: %s: %q -- expected: %v, actual: %v", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+}
+
+var appendTestCases = []struct {
+	name       string
+	property   string
+	list       IntList
+	appendThis IntList
+	want       IntList
+}{
+	{
+		name:       "empty list",
+		property:   "append",
+		list:       []int{},
+		appendThis: []int{},
+		want:       []int{},
+	},
+	{
+		name:       "empty list to list",
+		property:   "append",
+		list:       []int{},
+		appendThis: []int{1, 2, 3, 4},
+		want:       []int{1, 2, 3, 4},
+	},
+	{
+		name:       "non-empty lists",
+		property:   "append",
+		list:       []int{1, 2},
+		appendThis: []int{2, 3, 4, 5},
+		want:       []int{1, 2, 2, 3, 4, 5},
+	},
+}
+
+func TestAppendMethod(t *testing.T) {
+	for _, tt := range appendTestCases {
+		got := tt.list.Append(tt.appendThis)
+		if !reflect.DeepEqual(tt.want, got) {
+			t.Fatalf("FAIL: %s: %q -- expected: %v, actual: %v", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+
+	}
+}
+
+var concatTestCases = []struct {
+	name     string
+	property string
+	list     IntList
+	args     []IntList
+	want     IntList
+}{
+	{
+		name:     "empty list",
+		property: "concat",
+		list:     []int{},
+		args:     []IntList{},
+		want:     []int{},
+	},
+	{
+		name:     "list of lists",
+		property: "concat",
+		list:     []int{1, 2},
+		args:     []IntList{[]int{3}, []int{}, []int{4, 5, 6}},
+		want:     []int{1, 2, 3, 4, 5, 6},
+	},
+}
+
+func TestConcatMethod(t *testing.T) {
+	for _, tt := range concatTestCases {
+		got := tt.list.Concat(tt.args)
+		if !reflect.DeepEqual(tt.want, got) {
+			t.Fatalf("FAIL: %s: %q -- expected: %v, actual: %v", tt.property, tt.name, tt.want, got)
+		} else {
+			t.Logf("PASS: %s: %s", tt.property, tt.name)
+		}
+	}
+}