trackler 2.2.1.77 → 2.2.1.78

data/tracks/go/exercises/book-store/.meta/gen.go

@@ -31,8 +31,10 @@ type TestGroup struct {
 
 type OneCase struct {
 	Description string
-	Basket      []int
-	Expected    float64
+	Input       struct {
+		Basket []int
+	}
+	Expected float64
 }
 
 // template applied to above data structure generates the Go test cases
@@ -47,7 +49,7 @@ var testCases = []struct {
 }{{range .J.Groups}}{
 {{range .Cases}} {
 	description: "{{.Description}}",
-	basket:      {{printf "%#v" .Basket}},
+	basket:      {{printf "%#v" .Input.Basket}},
 	expected:    {{printf "%.2f" .Expected}},
 },
 {{end}}}{{end}}

data/tracks/go/exercises/book-store/cases_test.go

@@ -1,8 +1,8 @@
 package bookstore
 
 // Source: exercism/problem-specifications
-// Commit: a636903 Update description per @insti comments
-// Problem Specifications Version: 1.1.0
+// Commit: 78006a2 move "targetgrouping" to "comments"
+// Problem Specifications Version: 1.2.0
 
 var testCases = []struct {
 	description string

data/tracks/go/exercises/connect/example.go

@@ -43,11 +43,11 @@ func newBoard(lines []string) (board, error) {
 	if len(lines) < 1 {
 		return board{}, errors.New("No lines given")
 	}
-	height := int(len(lines))
+	height := len(lines)
 	if len(lines[0]) < 1 {
 		return board{}, errors.New("First line is empty string")
 	}
-	width := int(len(lines[0]))
+	width := len(lines[0])
 	// This trick for 2D arrays comes from Effective Go
 	fields := make([][]int8, height)
 	fieldsBacker := make([]int8, height*width)
@@ -65,12 +65,11 @@ func newBoard(lines []string) (board, error) {
 			// No need for default, zero value already means no stone
 		}
 	}
-	board := board{
+	return board{
 		height: height,
 		width:  width,
 		fields: fields,
-	}
-	return board, nil
+	}, nil
 }
 
 // Whether there is a stone of the given color at the given location.

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

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"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("dominoes", &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
+	Comments []string
+	Cases    []OneCase
+}
+
+type Dominoe [2]int
+
+func (d Dominoe) String() string {
+	return fmt.Sprintf("Dominoe{%d, %d}", d[0], d[1])
+}
+
+// template applied to above data structure generates the Go test cases
+
+type OneCase struct {
+	Description string
+	Dominoes    []Dominoe `json:"input"`
+	Expected    bool
+}
+
+//func (c OneCase)
+// Template to generate list of test cases.
+var tmpl = `package dominoes
+
+{{.Header}}
+
+var testCases = []struct {
+	description    string
+	dominoes  []Dominoe
+	valid          bool     // true => can chain, false => cannot chain
+}{ {{range .J.Cases}}
+{
+	{{printf "%q"  .Description}},
+	[]Dominoe{ {{range .Dominoes}} {{printf "%v" .}}, {{end}} },
+	{{printf "%v"  .Expected}},
+}, {{end}}
+}
+`

data/tracks/go/exercises/dominoes/.meta/hints.md

@@ -0,0 +1,29 @@
+## Implementation
+
+Define a single Go func, MakeChain, which accepts a slice
+of dominoes and attempts to construct a legal chain of dominoes.
+
+MakeChain should have the following signature:
+
+```
+type Dominoe [2]int
+
+func MakeChain(input []Dominoe) (chain []Dominoe, ok bool)
+```
+
+The 'ok' bool result indicates whether the given input dominoe list
+could be arranged in a legal chain. An empty input list is considered legal,
+and a single dominoe whose sides are the same is also considered legal.
+
+The 'chain' result is a slice of zero or more dominoes
+arranged in an order which shows the legal chain.
+It is acceptable (and expected) that dominoes in 'input' may need
+to be rotated so that each side matches their adjacent dominoe in the chain.
+Dominoes at the beginning and the end of the chain must also match their outer side.
+
+If the given input slice of dominoes cannot be arranged in a legal chain
+MakeChain may return nil for the chain result, but must return false for the ok result.
+
+Since there may be more than one legal chain arrangement for a given input list,
+when ok is true, the test program will check the chain for validity only.
+

data/tracks/go/exercises/dominoes/README.md

@@ -0,0 +1,67 @@
+# Dominoes
+
+Make a chain of dominoes.
+
+Compute a way to order a given set of dominoes in such a way that they form a
+correct domino chain (the dots on one half of a stone match the dots on the
+neighbouring half of an adjacent stone) and that dots on the halfs of the stones
+which don't have a neighbour (the first and last stone) match each other.
+
+For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something
+like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same.
+
+For stones `[1|2]`, `[4|1]` and `[2|3]` the resulting chain is not valid: `[4|1] [1|2] [2|3]`'s first and last numbers are not the same. 4 != 3
+
+Some test cases may use duplicate stones in a chain solution, assume that multiple Domino sets are being used.
+
+## Implementation
+
+Define a single Go func, MakeChain, which accepts a slice
+of dominoes and attempts to construct a legal chain of dominoes.
+
+MakeChain should have the following signature:
+
+```
+type Dominoe [2]int
+
+func MakeChain(input []Dominoe) (chain []Dominoe, ok bool)
+```
+
+The 'ok' bool result indicates whether the given input dominoe list
+could be arranged in a legal chain. An empty input list is considered legal,
+and a single dominoe whose sides are the same is also considered legal.
+
+The 'chain' result is a slice of zero or more dominoes
+arranged in an order which shows the legal chain.
+It is acceptable (and expected) that dominoes in 'input' may need
+to be rotated so that each side matches their adjacent dominoe in the chain.
+Dominoes at the beginning and the end of the chain must also match their outer side.
+
+If the given input slice of dominoes cannot be arranged in a legal chain
+MakeChain may return nil for the chain result, but must return false for the ok result.
+
+Since there may be more than one legal chain arrangement for a given input list,
+when ok is true, the test program will check the chain for validity only.
+
+
+
+## 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).
+
+
+## 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/dominoes/cases_test.go

@@ -0,0 +1,72 @@
+package dominoes
+
+// Source: exercism/problem-specifications
+// Commit: b4ceaf4 Update dominoes canonical-data expected key (#823)
+// Problem Specifications Version: 2.0.0
+
+var testCases = []struct {
+	description string
+	dominoes    []Dominoe
+	valid       bool // true => can chain, false => cannot chain
+}{
+	{
+		"empty input = empty output",
+		[]Dominoe{},
+		true,
+	},
+	{
+		"singleton input = singleton output",
+		[]Dominoe{Dominoe{1, 1}},
+		true,
+	},
+	{
+		"singleton that can't be chained",
+		[]Dominoe{Dominoe{1, 2}},
+		false,
+	},
+	{
+		"three elements",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{3, 1}, Dominoe{2, 3}},
+		true,
+	},
+	{
+		"can reverse dominoes",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{1, 3}, Dominoe{2, 3}},
+		true,
+	},
+	{
+		"can't be chained",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{4, 1}, Dominoe{2, 3}},
+		false,
+	},
+	{
+		"disconnected - simple",
+		[]Dominoe{Dominoe{1, 1}, Dominoe{2, 2}},
+		false,
+	},
+	{
+		"disconnected - double loop",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{2, 1}, Dominoe{3, 4}, Dominoe{4, 3}},
+		false,
+	},
+	{
+		"disconnected - single isolated",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{2, 3}, Dominoe{3, 1}, Dominoe{4, 4}},
+		false,
+	},
+	{
+		"need backtrack",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{2, 3}, Dominoe{3, 1}, Dominoe{2, 4}, Dominoe{2, 4}},
+		true,
+	},
+	{
+		"separate loops",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{2, 3}, Dominoe{3, 1}, Dominoe{1, 1}, Dominoe{2, 2}, Dominoe{3, 3}},
+		true,
+	},
+	{
+		"nine elements",
+		[]Dominoe{Dominoe{1, 2}, Dominoe{5, 3}, Dominoe{3, 1}, Dominoe{1, 2}, Dominoe{2, 4}, Dominoe{1, 6}, Dominoe{2, 3}, Dominoe{3, 4}, Dominoe{5, 6}},
+		true,
+	},
+}

data/tracks/go/exercises/dominoes/dominoes_test.go

@@ -0,0 +1,106 @@
+package dominoes
+
+import (
+	"errors"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestMakeChain(t *testing.T) {
+	for _, test := range testCases {
+		c, ok := MakeChain(test.dominoes)
+		if ok != test.valid {
+			t.Fatalf("FAIL: %s\nMakeChain(%v)\nExpected 'ok' result: %t Actual 'ok': %t",
+				test.description, test.dominoes, test.valid, ok)
+		}
+		if ok {
+			// There can be a variety of "valid" chains. Verify the chain is valid.
+			if err := verifyChain(test.dominoes, c); err != nil {
+				t.Fatalf("FAIL: %s\nVerifying chain failed with error: %v\ninput: %v\nchain: %v",
+					test.description, err, test.dominoes, c)
+			}
+		}
+		t.Logf("PASS: %s", test.description)
+	}
+}
+
+var (
+	errWrongLengthChain          = errors.New("wrong length chain")
+	errChainIsNotLegalAdj        = errors.New("chain is not legal - adjacent mismatch")
+	errChainIsNotLegalEnd        = errors.New("chain is not legal - ends mismatch")
+	errChainSetNotSameAsInputSet = errors.New("chain dominoes not same as input")
+)
+
+func verifyChain(input []Dominoe, chain []Dominoe) error {
+	if len(input) != len(chain) {
+		return errWrongLengthChain
+	}
+
+	switch len(input) {
+	case 0:
+		return nil
+	case 1:
+		if input[0] != chain[0] {
+			return errChainSetNotSameAsInputSet
+		}
+		return nil
+	}
+
+	// Check adjacent pairs.
+	for i := 0; i < len(chain)-1; i++ {
+		if chain[i][1] != chain[i+1][0] {
+			return errChainIsNotLegalAdj
+		}
+	}
+	// Check end dominoes.
+	if chain[0][0] != chain[len(chain)-1][1] {
+		return errChainIsNotLegalEnd
+	}
+
+	// Make copies of input and chain.
+	cinput := copyDominoes(input)
+	cchain := copyDominoes(chain)
+
+	sortDominoes(cinput)
+	sortDominoes(cchain)
+
+	// Compare for equality (same set in input and chain).
+	if !reflect.DeepEqual(cinput, cchain) {
+		return errChainSetNotSameAsInputSet
+	}
+	return nil
+}
+
+func copyDominoes(d []Dominoe) (c []Dominoe) {
+	c = make([]Dominoe, len(d))
+	// Put each dominoe in "canonical position" [a,b] where a <= b.
+	for i := range d {
+		c[i] = d[i]
+		if c[i][0] > c[i][1] {
+			c[i][0], c[i][1] = c[i][1], c[i][0]
+		}
+	}
+	return c
+}
+
+func sortDominoes(d []Dominoe) {
+	sort.Slice(d,
+		func(i, j int) bool {
+			if d[i][0] < d[j][0] {
+				return true
+			}
+			if d[i][0] > d[j][0] {
+				return false
+			}
+			return d[i][1] < d[j][1]
+		})
+}
+
+func BenchmarkMakeChain(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range testCases {
+			MakeChain(test.dominoes)
+		}
+	}
+}

data/tracks/go/exercises/dominoes/example.go

@@ -0,0 +1,146 @@
+package dominoes
+
+type Dominoe [2]int
+
+// MakeChain returns a chain and true if the dominoes in input
+// can be arranged in a legal chain; otherwise it returns nil, false.
+func MakeChain(input []Dominoe) (chain []Dominoe, ok bool) {
+	switch len(input) {
+	case 0:
+		return []Dominoe{}, true
+	case 1:
+		// A single is legal if the ends match.
+		if input[0][0] == input[0][1] {
+			return input, true
+		}
+		return nil, false
+	}
+	chain, ok = buildDominoeChain(input)
+	if !ok {
+		return nil, false
+	}
+	return chain, true
+}
+
+// buildDominoeChain looks for a matching dominoe chain using the 2 or more dominoes in d.
+func buildDominoeChain(d []Dominoe) ([]Dominoe, bool) {
+	permuteList := dominoePermutations(d, len(d))
+	for _, p := range permuteList {
+		chain, ok := arrangeChain(p)
+		if ok {
+			return chain, true
+		}
+	}
+	return nil, false
+}
+
+// arrangeChain uses the dominoes positionally in d[] attempting to make a matching chain;
+// reversing of sides of any dominoe is permitted, but the order of dominoes in d remains
+// the same left to right.
+func arrangeChain(d []Dominoe) (chain []Dominoe, ok bool) {
+	// A good chain will match length of d, so preallocate the chain.
+	chain = make([]Dominoe, len(d))
+	n := 0
+	// Put first dominoe into the chain for starting point.
+	chain[n] = d[0]
+	// Loop through the remaining dominoes in d, attempting to add them into the chain,
+	// allowing a reverse of either single one in chain or the new dominoe t at each step.
+	for i := 1; i < len(d); i++ {
+		t := d[i]
+		last := chain[n]
+		if n == 0 && last[0] == t[0] {
+			// reverse first and only item in chain to match t, and add t to chain.
+			chain[n] = reverseDominoe(last)
+			chain[n+1] = t
+		} else if n == 0 && last[0] == t[1] {
+			// reverse only item in chain and t to match, and add reversed t to chain.
+			chain[n] = reverseDominoe(last)
+			chain[n+1] = reverseDominoe(t)
+		} else if last[1] == t[0] {
+			// add t as-is into chain.
+			chain[n+1] = t
+		} else if last[1] == t[1] {
+			// reverse t to match last one in chain, and add reversed t to chain.
+			chain[n+1] = reverseDominoe(t)
+		} else {
+			// no match for this chain configuration of d, even with swapping.
+			return nil, false
+		}
+		// chain is now filled in with one more dominoe.
+		n++
+	}
+	// Both ends of the chain must also match.
+	if chain[0][0] != chain[len(chain)-1][1] {
+		return nil, false
+	}
+	return chain, true
+}
+
+// reverseDominoe returns given Dominoe x, with its sides reversed/rotated.
+func reverseDominoe(x Dominoe) Dominoe {
+	return Dominoe{x[1], x[0]}
+}
+
+// dominoePermutations returns a slice containing the r length permutations of the elements in iterable.
+// The implementation is modeled after the Python itertools.permutations().
+func dominoePermutations(iterable []Dominoe, r int) (perms [][]Dominoe) {
+	pool := iterable
+	n := len(pool)
+
+	if r > n {
+		return
+	}
+
+	indices := make([]int, n)
+	for i := range indices {
+		indices[i] = i
+	}
+
+	cycles := make([]int, r)
+	for i := range cycles {
+		cycles[i] = n - i
+	}
+
+	result := make([]Dominoe, r)
+	for i, el := range indices[:r] {
+		result[i] = pool[el]
+	}
+
+	p := make([]Dominoe, len(result))
+	copy(p, result)
+	perms = append(perms, p)
+
+	for n > 0 {
+		i := r - 1
+		for ; i >= 0; i-- {
+			cycles[i]--
+			if cycles[i] == 0 {
+				index := indices[i]
+				for j := i; j < n-1; j++ {
+					indices[j] = indices[j+1]
+				}
+				indices[n-1] = index
+				cycles[i] = n - i
+			} else {
+				j := cycles[i]
+				indices[i], indices[n-j] = indices[n-j], indices[i]
+
+				for k := i; k < r; k++ {
+					result[k] = pool[indices[k]]
+				}
+
+				p = make([]Dominoe, len(result))
+				copy(p, result)
+				perms = append(perms, p)
+
+				break
+			}
+		}
+
+		if i < 0 {
+			return
+		}
+
+	}
+	return
+}