trackler 2.2.1.86 → 2.2.1.87

data/tracks/go/exercises/atbash-cipher/.meta/gen.go

@@ -32,8 +32,10 @@ type js struct {
 		Cases       []struct {
 			Description string
 			Property    string
-			Phrase      string
-			Expected    string
+			Input       struct {
+				Phrase string
+			}
+			Expected string
 		}
 	}
 }
@@ -50,9 +52,9 @@ type atbashTest struct {
 
 var tests = []atbashTest {
 {{range .J.Cases}} {{range .Cases}}{
-	{{if isEncode .Property}} s: {{printf "%q" .Phrase }},
+	{{if isEncode .Property}} s: {{printf "%q" .Input.Phrase }},
 		expected: {{printf "%q" .Expected }}, {{else}} s: {{printf "%q" .Expected }},
-		expected:  {{printf "%q" .Phrase }}, {{- end}}
+		expected:  {{printf "%q" .Input.Phrase }}, {{- end}}
 },
 {{end}}{{end}}
 }

data/tracks/go/exercises/atbash-cipher/cases_test.go

@@ -1,8 +1,8 @@
 package atbash
 
 // Source: exercism/problem-specifications
-// Commit: bb4f220 atbash-cipher: Fix canonical-data.json formatting
-// Problem Specifications Version: 1.0.0
+// Commit: dda678b atbash-cipher: Apply new "input" policy
+// Problem Specifications Version: 1.1.0
 
 type atbashTest struct {
 	s        string

data/tracks/go/exercises/change/.meta/gen.go

@@ -31,9 +31,11 @@ type js struct {
 type OneCase struct {
 	Description string
 	Property    string
-	Coins       []int
-	Target      int
-	Expected    interface{}
+	Input       struct {
+		Coins  []int
+		Target int
+	}
+	Expected interface{}
 }
 
 func (c OneCase) Valid() bool {
@@ -83,8 +85,8 @@ var testCases = []struct {
 }{
 {{range .J.Cases}}{
 	{{printf "%q"  .Description}},
-	{{printf "%#v" .Coins}},
-	{{printf "%d"  .Target}},
+	{{printf "%#v" .Input.Coins}},
+	{{printf "%d"  .Input.Target}},
 	{{printf "%v"  .Valid}},
 	{{printf "%#v" .IntSlice}},
 },

data/tracks/go/exercises/change/cases_test.go

@@ -1,8 +1,8 @@
 package change
 
 // Source: exercism/problem-specifications
-// Commit: 52cf1cf Add test for incorrect greedy algorithm
-// Problem Specifications Version: 1.1.0
+// Commit: 044d09a change: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
 
 var testCases = []struct {
 	description    string

data/tracks/go/exercises/collatz-conjecture/.meta/gen.go

@@ -20,8 +20,10 @@ func main() {
 
 type OneCase struct {
 	Description string
-	Number      int
-	Expected    interface{}
+	Input       struct {
+		Number int
+	}
+	Expected interface{}
 }
 
 // The JSON structure we expect to be able to unmarshal into
@@ -63,7 +65,7 @@ var testCases = []struct {
 }{
 {{range .J.Cases}}{
 	description:	"{{.Description}}",
-	input:		{{.Number}},
+	input:		{{.Input.Number}},
 {{if .Valid}} expected:	{{.Answer}},
 {{- else}} expectError: true,
 {{- end}}

data/tracks/go/exercises/collatz-conjecture/cases_test.go

@@ -1,8 +1,8 @@
 package collatzconjecture
 
 // Source: exercism/problem-specifications
-// Commit: 25c4479 Collatz-conjecture: remove trailing space in test name (#839)
-// Problem Specifications Version: 1.1.1
+// Commit: 7bb0a64 collatz-conjecture: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
 
 var testCases = []struct {
 	description string

data/tracks/go/exercises/connect/.meta/gen.go

@@ -22,8 +22,10 @@ func main() {
 type js struct {
 	Cases []struct {
 		Description string
-		Board       []string
-		Expected    string
+		Input       struct {
+			Board []string
+		}
+		Expected string
 	}
 }
 
@@ -39,7 +41,7 @@ var testCases = []struct {
 }{
 	{{range .J.Cases}}{
 		description: {{printf "%q" .Description}},
-		board: []string{ {{range $line := .Board}}{{printf "\n    %q," $line}}{{end}}},
+		board: []string{ {{range $line := .Input.Board}}{{printf "\n    %q," $line}}{{end}}},
 		expected: {{printf "%q" .Expected}},
 },
 {{end}}}

data/tracks/go/exercises/connect/cases_test.go

@@ -1,8 +1,8 @@
 package connect
 
 // Source: exercism/problem-specifications
-// Commit: 327db7f connect: Fix canonical-data.json formatting
-// Problem Specifications Version: 1.0.0
+// Commit: a02d64d connect: Apply new "input" policy
+// Problem Specifications Version: 1.1.0
 
 var testCases = []struct {
 	description string

data/tracks/go/exercises/flatten-array/.meta/gen.go

@@ -29,8 +29,10 @@ type js struct {
 type oneCase struct {
 	Description string
 	Property    string
-	Input       interface{}
-	Expected    []interface{}
+	Input       struct {
+		Array interface{}
+	}
+	Expected []interface{}
 }
 
 // Template to generate test cases.
@@ -45,7 +47,7 @@ var testCases = []struct {
 }{ {{range .J.Cases}}
 {
 	description:	{{printf "%q"  .Description}},
-	input:		{{printf "%#v"  .Input}},
+	input:		{{printf "%#v"  .Input.Array}},
 	expected:	{{printf "%#v"  .Expected}},
 },{{end}}
 }

data/tracks/go/exercises/flatten-array/cases_test.go

@@ -1,8 +1,8 @@
 package flatten
 
 // Source: exercism/problem-specifications
-// Commit: d7a3c09 flatten-array: Add test case for no nesting (#744)
-// Problem Specifications Version: 1.1.0
+// Commit: 0290376 flatten-array: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
 
 var testCases = []struct {
 	description string

data/tracks/go/exercises/meetup/.meta/gen.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"log"
 	"strings"
 	"text/template"
@@ -22,14 +23,24 @@ func main() {
 
 // The JSON structure we expect to be able to unmarshal into
 type js struct {
-	Cases []struct {
-		Description string
-		Year        int
-		Month       int
-		Week        string
-		Dayofweek   string
-		Dayofmonth  int
+	Cases []OneCase
+}
+
+type OneCase struct {
+	Description string
+	Input       struct {
+		Year      int
+		Month     int
+		Week      string
+		Dayofweek string
 	}
+	DateString string `json:"expected"`
+}
+
+func (c OneCase) ExpectedDay() int {
+	var y, m, d int
+	fmt.Sscanf(c.DateString, "%4d-%2d-%2d", &y, &m, &d)
+	return d
 }
 
 // template applied to above data structure generates the Go test cases
@@ -46,6 +57,6 @@ var testCases = []struct {
 	weekday time.Weekday
 	expDay  int
 }{
-{{range .J.Cases}}{ {{.Year}}, {{.Month}}, {{week .Week}}, time.{{.Dayofweek}}, {{.Dayofmonth}}}, // {{.Description}}
+{{range .J.Cases}}{ {{.Input.Year}}, {{.Input.Month}}, {{week .Input.Week}}, time.{{.Input.Dayofweek}}, {{.ExpectedDay}}}, // {{.Description}}
 {{end}}}
 `

data/tracks/go/exercises/meetup/cases_test.go

@@ -1,8 +1,8 @@
 package meetup
 
 // Source: exercism/problem-specifications
-// Commit: fe9630e meetup: Fix canonical-data.json formatting
-// Problem Specifications Version: 1.0.0
+// Commit: 56cdfa5 meetup: Update json for new input policy
+// Problem Specifications Version: 1.1.0
 
 import "time"
 

data/tracks/go/exercises/simple-linked-list/README.md

@@ -0,0 +1,47 @@
+# Simple Linked List
+
+Write a simple linked list implementation that uses Elements and a List.
+
+The linked list is a fundamental data structure in computer science,
+often used in the implementation of other data structures. They're
+pervasive in functional programming languages, such as Clojure, Erlang,
+or Haskell, but far less common in imperative languages such as Ruby or
+Python.
+
+The simplest kind of linked list is a singly linked list. Each element in the
+list contains data and a "next" field pointing to the next element in the list
+of elements.
+
+This variant of linked lists is often used to represent sequences or
+push-down stacks (also called a LIFO stack; Last In, First Out).
+
+As a first take, lets create a singly linked list to contain the range (1..10),
+and provide functions to reverse a linked list and convert to and from arrays.
+
+When implementing this in a language with built-in linked lists,
+implement your own abstract data type.
+
+## 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
+
+Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists.
+[http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000](http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000)
+
+## 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/simple-linked-list/example.go

@@ -0,0 +1,74 @@
+package linkedlist
+
+import "errors"
+
+type element struct {
+	data int
+	next *element
+}
+
+type List struct {
+	head *element
+	size int
+}
+
+func New(array []int) *List {
+	var res List
+	for _, elem := range array {
+		res.Push(elem)
+	}
+	return &res
+}
+
+func (list *List) Size() int {
+	return list.size
+}
+
+func (list *List) Push(elem int) {
+	newNode := element{elem, nil}
+	if list.head == nil {
+		list.head = &newNode
+	} else {
+		node := list.head
+		for node.next != nil {
+			node = node.next
+		}
+		node.next = &newNode
+	}
+	list.size++
+}
+
+func (list *List) Pop() (int, error) {
+	var elem int
+	if list.size == 0 {
+		return 0, errors.New("Cannot call pop on empty list")
+	} else if list.size == 1 {
+		elem = list.head.data
+		list.head = nil
+	} else {
+		node := list.head
+		for node.next.next != nil {
+			node = node.next
+		}
+		elem = node.next.data
+		node.next = nil
+	}
+	list.size--
+	return elem, nil
+}
+
+func (list *List) Array() []int {
+	res := []int{}
+	for node := list.head; node != nil; node = node.next {
+		res = append(res, node.data)
+	}
+	return res
+}
+
+func (list *List) Reverse() *List {
+	array, size := list.Array(), list.size
+	for i := 0; i < size/2; i++ {
+		array[i], array[size-1-i] = array[size-1-i], array[i]
+	}
+	return New(array)
+}

data/tracks/go/exercises/simple-linked-list/linked_list_test.go

@@ -0,0 +1,210 @@
+// API:
+//
+// type Element struct {
+//  data int
+//  next *Element
+// }
+//
+// type List struct {
+//  head *Element
+//  size int
+// }
+//
+// func New([]int) *List
+// func (*List) Size() int
+// func (*List) Push(int)
+// func (*List) Pop() (int, error)
+// func (*List) Array() []int
+// func (*List) Reverse() *List
+
+package linkedlist
+
+import (
+	"reflect"
+	"testing"
+)
+
+var array1To10 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+
+func TestEmptyListHasSizeZero(t *testing.T) {
+	list := New([]int{})
+	if size := list.Size(); size != 0 {
+		t.Fatalf("Size of empty list: %d, expected: %d", size, 0)
+	}
+	list = New(nil)
+	if size := list.Size(); size != 0 {
+		t.Fatalf("Size of empty list: %d, expected: %d", size, 0)
+	}
+}
+
+func TestSingletonListHasSizeOne(t *testing.T) {
+	list := New([]int{1})
+	if size := list.Size(); size != 1 {
+		t.Fatalf("Size of singleton list: %d, expected: %d", size, 1)
+	}
+}
+
+func TestNonEmptyListHasCorrectSize(t *testing.T) {
+	list := New([]int{1, 2, 3})
+	if size := list.Size(); size != 3 {
+		t.Fatalf("Size of list from [1, 2, 3]: %d, expected: %d", size, 3)
+	}
+}
+
+func TestEmptyListToEmptyArray(t *testing.T) {
+	list := New([]int{})
+	if array := list.Array(); len(array) != 0 {
+		t.Fatalf("Test empty list to array: %v, want empty array", array)
+	}
+	list = New(nil)
+	if array := list.Array(); len(array) != 0 {
+		t.Fatalf("Test empty list to array: %v, want empty array", array)
+	}
+}
+
+func TestNonEmptyListToArray(t *testing.T) {
+	expected := []int{1, 2, 3}
+	list := New(expected)
+	array := list.Array()
+	if !reflect.DeepEqual(array, expected) {
+		t.Fatalf("Test non empty list to array: %v, want %v", array, expected)
+	}
+}
+
+func TestPopFromEmptyList(t *testing.T) {
+	list := New([]int{})
+	if _, err := list.Pop(); err == nil {
+		t.Fatalf("Pop from empty list: expected error but there was not")
+	}
+	list = New(nil)
+	if _, err := list.Pop(); err == nil {
+		t.Fatalf("Pop from empty list: expected error but there was not")
+	}
+}
+
+func TestPopFromNonEmptyList(t *testing.T) {
+	list := New([]int{1, 2, 3})
+	elem, err := list.Pop()
+	if err != nil {
+		t.Fatalf("Pop from non empty list: unexpected error %v", err)
+	}
+	if elem != 3 {
+		t.Fatalf("Pop from non empty list: %d, want %d", elem, 3)
+	}
+	actual := list.Array()
+	expected := []int{1, 2}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Pop from non empty list: %v, want %v", actual, expected)
+	}
+}
+
+func TestPushToEmptyList(t *testing.T) {
+	list := New([]int{})
+	list.Push(1)
+	actual := list.Array()
+	expected := []int{1}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Push to empty list: %v, want %v", actual, expected)
+	}
+	list = New(nil)
+	list.Push(1)
+	actual = list.Array()
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Push to empty list: %v, want %v", actual, expected)
+	}
+}
+
+func TestPushToNonEmptyList(t *testing.T) {
+	list := New([]int{1, 2, 3})
+	list.Push(4)
+	actual := list.Array()
+	expected := []int{1, 2, 3, 4}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Push to non empty list: %v, want %v", actual, expected)
+	}
+}
+
+func TestPushAndPop(t *testing.T) {
+	list := New([]int{1, 2, 3})
+	list.Pop()
+	list.Push(4)
+	list.Push(5)
+	list.Pop()
+	list.Push(6)
+	actual := list.Array()
+	expected := []int{1, 2, 4, 6}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Test push and pop: %v, want %v", actual, expected)
+	}
+}
+
+func TestReverseEmptyList(t *testing.T) {
+	list := New([]int{})
+	if reversed := list.Reverse().Array(); len(reversed) != 0 {
+		t.Fatalf("Reverse empty list: %v, want empty list", reversed)
+	}
+	list = New(nil)
+	if reversed := list.Reverse().Array(); len(reversed) != 0 {
+		t.Fatalf("Reverse empty list: %v, want empty list", reversed)
+	}
+}
+
+func TestReverseNonEmptyList(t *testing.T) {
+	list := New([]int{1, 2, 3})
+	actual := list.Reverse().Array()
+	expected := []int{3, 2, 1}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("Reverse non empty list: %v, want %v", actual, expected)
+	}
+}
+
+func BenchmarkNewList(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = New(array1To10)
+	}
+}
+
+func BenchmarkListSize(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		list := New(array1To10)
+		b.StartTimer()
+		_ = list.Size()
+	}
+}
+
+func BenchmarkListPush(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		list := New(array1To10)
+		b.StartTimer()
+		list.Push(11)
+	}
+}
+
+func BenchmarkListPop(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		list := New(array1To10)
+		b.StartTimer()
+		_, _ = list.Pop()
+	}
+}
+
+func BenchmarkListToArray(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		list := New(array1To10)
+		b.StartTimer()
+		_ = list.Array()
+	}
+}
+
+func BenchmarkListReverse(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		list := New(array1To10)
+		b.StartTimer()
+		_ = list.Reverse()
+	}
+}