2017-08-15

go/accumulate/README.md

@@ -0,0 +1,53 @@
+# Accumulate
+
+Implement the `accumulate` operation, which, given a collection and an
+operation to perform on each element of the collection, returns a new
+collection containing the result of applying that operation to each element of
+the input collection.
+
+Given the collection of numbers:
+
+- 1, 2, 3, 4, 5
+
+And the operation:
+
+- square a number (`x => x * x`)
+
+Your code should be able to produce the collection of squares:
+
+- 1, 4, 9, 16, 25
+
+Check out the test suite to see the expected function signature.
+
+## Restrictions
+
+Keep your hands off that collect/map/fmap/whatchamacallit functionality
+provided by your standard library!
+Solve this one yourself using other basic tools instead.
+
+Lisp specific: it's perfectly fine to use `MAPCAR` or the equivalent,
+as this is idiomatic Lisp, not a library function.
+
+## 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
+
+Conversation with James Edward Gray II [https://twitter.com/jeg2](https://twitter.com/jeg2)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

go/accumulate/accumulate.go

@@ -0,0 +1,11 @@
+package accumulate
+
+const testVersion = 1
+
+func Accumulate(vals []string, f func(string) string) []string {
+	ret := make([]string, len(vals))
+	for i := range vals {
+		ret[i] = f(vals[i])
+	}
+	return ret
+}

go/accumulate/accumulate_test.go

@@ -0,0 +1,57 @@
+package accumulate
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const targetTestVersion = 1
+
+func echo(c string) string {
+	return c
+}
+
+func capitalize(word string) string {
+	return strings.Title(word)
+}
+
+var tests = []struct {
+	expected    []string
+	given       []string
+	converter   func(string) string
+	description string
+}{
+	{[]string{}, []string{}, echo, "echo"},
+	{[]string{"echo", "echo", "echo", "echo"}, []string{"echo", "echo", "echo", "echo"}, echo, "echo"},
+	{[]string{"First", "Letter", "Only"}, []string{"first", "letter", "only"}, capitalize, "capitalize"},
+	{[]string{"HELLO", "WORLD"}, []string{"hello", "world"}, strings.ToUpper, "strings.ToUpper"},
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
+func TestAccumulate(t *testing.T) {
+	for _, test := range tests {
+		actual := Accumulate(test.given, test.converter)
+		if fmt.Sprintf("%q", actual) != fmt.Sprintf("%q", test.expected) {
+			t.Fatalf("Accumulate(%q, %q): expected %q, actual %q", test.given, test.description, test.expected, actual)
+		}
+	}
+}
+
+func BenchmarkAccumulate(b *testing.B) {
+	b.StopTimer()
+	for _, test := range tests {
+		b.StartTimer()
+
+		for i := 0; i < b.N; i++ {
+			Accumulate(test.given, test.converter)
+		}
+
+		b.StopTimer()
+	}
+}