trackler 2.2.1.86 → 2.2.1.87

data/tracks/fsharp/exercises/custom-set/Example.fs

@@ -24,6 +24,8 @@ let intersection left right = left.items |> List.filter (fun x -> List.contains
 
 let difference left right = left.items |> List.filter (fun x -> List.contains x right.items |> not) |> fromList
 
+let isEqualTo left right = (size left = size right) && (isEmpty (difference left right))
+
 let isSubsetOf left right = left.items |> List.forall (fun x -> List.contains x right.items)
 
 let isDisjointFrom left right = left.items |> List.exists (fun x -> List.contains x right.items) |> not

data/tracks/fsharp/generators/Generators.fs

@@ -227,6 +227,67 @@ type CollatzConjecture() =
 type CryptoSquare() =
     inherit GeneratorExercise()
 
+type CustomSet() = 
+    inherit GeneratorExercise()
+
+    member __.SutName = "actual"
+
+    override __.TestMethodBodyAssertTemplate _ = "AssertEqual"
+
+    member __.RenderSet canonicalDataCase key =
+        let value = 
+            (canonicalDataCase.Properties.[key] :?> JToken).ToObject<seq<string>>()
+            |> formatList
+        sprintf "CustomSet.fromList %s" value
+
+    override this.RenderSut canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "add" | "intersection" | "difference" | "union" -> 
+            sprintf "%sBool" this.SutName
+        | _ -> this.SutName
+
+    override __.RenderExpected (canonicalDataCase, _, _) =
+        match canonicalDataCase.Property with
+        | "add" | "intersection" | "difference" | "union" -> 
+            "true"
+        | _ -> formatValue canonicalDataCase.Expected
+
+    override this.RenderArrange canonicalDataCase = 
+        let arrangeLines =
+            match canonicalDataCase.Property with
+            | "empty" ->
+                let setValue = this.RenderSet canonicalDataCase "set"
+                [ sprintf "let %s = CustomSet.isEmpty (%s)" this.SutName setValue ]
+            | "add" | "contains" ->
+                let methodName = 
+                    match canonicalDataCase.Property with
+                    | "add" -> "insert"
+                    | s -> s
+                let setVar = sprintf "let setValue = %s" (this.RenderSet canonicalDataCase "set")
+                let valueVar = sprintf "let element = %s" (formatValue canonicalDataCase.Properties.["element"])
+                let resultVar = sprintf "let %s = CustomSet.%s element setValue" this.SutName methodName 
+                [ setVar; valueVar; resultVar ]
+            | "intersection" | "difference" | "union" | "disjoint" | "subset" | "equal" ->
+                let methodName = 
+                    match canonicalDataCase.Property with
+                    | "disjoint" -> "isDisjointFrom"
+                    | "subset" -> "isSubsetOf"
+                    | "equal" -> "isEqualTo"
+                    | s -> s
+                let firstSetVar = sprintf "let set1 = %s" (this.RenderSet canonicalDataCase "set1")
+                let secondSetVar = sprintf "let set2 = %s" (this.RenderSet canonicalDataCase "set2")
+                let resultVar = sprintf "let %s = CustomSet.%s set1 set2" this.SutName methodName
+                [ firstSetVar; secondSetVar; resultVar ]
+            | _ -> 
+                [ "" ]
+
+        match canonicalDataCase.Property with
+        | "add" | "intersection" | "difference" | "union" -> 
+            let expectedSetVar = sprintf "let expectedSet = %s" (this.RenderSet canonicalDataCase "expected")
+            let actualBoolVar = sprintf "let %sBool = CustomSet.isEqualTo %s expectedSet" this.SutName this.SutName
+            arrangeLines @ [ expectedSetVar; actualBoolVar ]
+        | _ -> arrangeLines
+
 type Diamond() =
     inherit CustomExercise()
 

data/tracks/go/config.json

@@ -870,6 +870,17 @@
       "unlocked_by": "clock",
       "uuid": "fcf735fe-a659-40ae-858e-6d1e834a4faf"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "simple-linked-list",
+      "topics": [
+        "arrays",
+        "loops"
+      ],
+      "unlocked_by": "error-handling",
+      "uuid": "408f235e-f1ce-11e7-8c3f-9a214cf093ae"
+    },
     {
       "core": false,
       "difficulty": 5,
@@ -1183,6 +1194,19 @@
       "unlocked_by": "flatten-array",
       "uuid": "2e5c9e76-decd-49db-be4b-353ebeb46b73"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "alphametics",
+      "topics": [
+        "algorithms",
+        "arrays",
+        "mathematics",
+        "searching"
+      ],
+      "unlocked_by": "flatten-array",
+      "uuid": "6b313720-104a-46c2-8290-4b4af121101f "
+    },
     {
       "deprecated": true,
       "slug": "binary",
@@ -1210,8 +1234,7 @@
     }
   ],
   "foregone": [
-    "linked-list",
-    "simple-linked-list"
+    "linked-list"
   ],
   "ignore_pattern": "example(?!.*test)",
   "language": "Go"

data/tracks/go/exercises/acronym/acronym_test.go

@@ -12,3 +12,11 @@ func TestAcronym(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkAcronym(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range stringTestCases {
+			Abbreviate(test.input)
+		}
+	}
+}

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

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"log"
+	"sort"
+	"strings"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("alphametics", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Cases []struct {
+		Description string
+		Cases       []OneCase
+	}
+}
+type OneCase struct {
+	Description string
+	Input       struct {
+		Puzzle string
+	}
+	Expected map[string]int
+}
+
+func (c OneCase) ErrorExpected() bool {
+	return len(c.Expected) == 0
+}
+
+func (c OneCase) SortedMapString() string {
+	strs := make([]string, 0, len(c.Expected))
+	for s, v := range c.Expected {
+		strs = append(strs, `"`+s+`": `+string(v+'0'))
+	}
+	sort.Strings(strs)
+	return strings.Join(strs, ",")
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package alphametics
+
+{{.Header}}
+
+{{range .J.Cases}}// {{.Description}}
+var testCases = []struct {
+	description   string
+	input         string
+	expected      map[string]int
+	errorExpected bool
+}{
+{{range .Cases}}{
+	description:	{{printf "%q" .Description}},
+	input:		{{printf "%q" .Input.Puzzle}},
+	{{if .ErrorExpected}}errorExpected:	true,
+	{{else}}expected:	map[string]int{ {{.SortedMapString}} },
+	{{- end}}
+},
+{{end}}{{end}}
+}
+`

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

@@ -0,0 +1,38 @@
+## Implementation
+
+Define a single Go func, Solve, which accepts a puzzle string which may have zero
+or more + operators, and one == operator; Solve should attempt to solve the alphametics puzzle
+and return a map of all the letter substitutions for both the puzzle and the addition solution.
+
+Use the following signature for func Solve:
+
+```
+func Solve(puzzle string) (map[string]int, error) {
+```
+Solve should return an error if there is no solution to the given puzzle.
+
+An example puzzle and returned solution is:
+```
+Solve("SEND + MORE == MONEY")
+```
+would return
+```
+map[string]int{"M":1, "O":0, "N":6, "E":5, "Y":2, "S":9, "D":7, "R":8}, nil
+```
+
+```text
+  S E N D
+  M O R E +
+-----------
+M O N E Y
+```
+
+Replacing these with valid numbers gives:
+
+```text
+  9 5 6 7
+  1 0 8 5 +
+-----------
+1 0 6 5 2
+```
+

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

@@ -0,0 +1,93 @@
+# Alphametics
+
+Write a function to solve alphametics puzzles.
+
+[Alphametics](https://en.wikipedia.org/wiki/Alphametics) is a puzzle where
+letters in words are replaced with numbers.
+
+For example `SEND + MORE = MONEY`:
+
+```text
+  S E N D
+  M O R E +
+-----------
+M O N E Y
+```
+
+Replacing these with valid numbers gives:
+
+```text
+  9 5 6 7
+  1 0 8 5 +
+-----------
+1 0 6 5 2
+```
+
+This is correct because every letter is replaced by a different number and the
+words, translated into numbers, then make a valid sum.
+
+Each letter must represent a different digit, and the leading digit of
+a multi-digit number must not be zero.
+
+Write a function to solve alphametics puzzles.
+
+## Implementation
+
+Define a single Go func, Solve, which accepts a puzzle string which may have zero
+or more + operators, and one == operator; Solve should attempt to solve the alphametics puzzle
+and return a map of all the letter substitutions for both the puzzle and the addition solution.
+
+Use the following signature for func Solve:
+
+```
+func Solve(puzzle string) (map[string]int, error) {
+```
+Solve should return an error if there is no solution to the given puzzle.
+
+An example puzzle and returned solution is:
+```
+Solve("SEND + MORE == MONEY")
+```
+would return
+```
+map[string]int{"M":1, "O":0, "N":6, "E":5, "Y":2, "S":9, "D":7, "R":8}, nil
+```
+
+```text
+  S E N D
+  M O R E +
+-----------
+M O N E Y
+```
+
+Replacing these with valid numbers gives:
+
+```text
+  9 5 6 7
+  1 0 8 5 +
+-----------
+1 0 6 5 2
+```
+
+
+
+## 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/alphametics/alphametics_test.go

@@ -0,0 +1,33 @@
+package alphametics
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSolve(t *testing.T) {
+	for _, tc := range testCases {
+		s, err := Solve(tc.input)
+		if tc.errorExpected {
+			if err == nil {
+				t.Fatalf("FAIL: %s\nSolve(%q)\nExpected error\nActual: %#v",
+					tc.description, tc.input, s)
+			}
+		} else if err != nil {
+			t.Fatalf("FAIL: %s\nSolve(%q)\nExpected: %#v\nGot error: %q",
+				tc.description, tc.input, tc.expected, err)
+		} else if !reflect.DeepEqual(s, tc.expected) {
+			t.Fatalf("FAIL: %s\nSolve(%q)\nExpected: %#v\nActual: %#v",
+				tc.description, tc.input, tc.expected, s)
+		}
+		t.Logf("PASS: %s", tc.description)
+	}
+}
+
+func BenchmarkSolve(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			Solve(tc.input)
+		}
+	}
+}

data/tracks/go/exercises/alphametics/cases_test.go

@@ -0,0 +1,59 @@
+package alphametics
+
+// Source: exercism/problem-specifications
+// Commit: a86a774 alphametics: apply input policy to final test case
+// Problem Specifications Version: 1.2.0
+
+// Solve the alphametics puzzle
+var testCases = []struct {
+	description   string
+	input         string
+	expected      map[string]int
+	errorExpected bool
+}{
+	{
+		description: "puzzle with three letters",
+		input:       "I + BB == ILL",
+		expected:    map[string]int{"B": 9, "I": 1, "L": 0},
+	},
+	{
+		description:   "solution must have unique value for each letter",
+		input:         "A == B",
+		errorExpected: true,
+	},
+	{
+		description:   "leading zero solution is invalid",
+		input:         "ACA + DD == BD",
+		errorExpected: true,
+	},
+	{
+		description: "puzzle with four letters",
+		input:       "AS + A == MOM",
+		expected:    map[string]int{"A": 9, "M": 1, "O": 0, "S": 2},
+	},
+	{
+		description: "puzzle with six letters",
+		input:       "NO + NO + TOO == LATE",
+		expected:    map[string]int{"A": 0, "E": 2, "L": 1, "N": 7, "O": 4, "T": 9},
+	},
+	{
+		description: "puzzle with seven letters",
+		input:       "HE + SEES + THE == LIGHT",
+		expected:    map[string]int{"E": 4, "G": 2, "H": 5, "I": 0, "L": 1, "S": 9, "T": 7},
+	},
+	{
+		description: "puzzle with eight letters",
+		input:       "SEND + MORE == MONEY",
+		expected:    map[string]int{"D": 7, "E": 5, "M": 1, "N": 6, "O": 0, "R": 8, "S": 9, "Y": 2},
+	},
+	{
+		description: "puzzle with ten letters",
+		input:       "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE",
+		expected:    map[string]int{"A": 5, "D": 3, "E": 4, "F": 7, "G": 8, "N": 0, "O": 2, "R": 1, "S": 6, "T": 9},
+	},
+	{
+		description: "puzzle with ten letters and 199 addends",
+		input:       "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES",
+		expected:    map[string]int{"A": 1, "E": 0, "F": 5, "H": 8, "I": 7, "L": 2, "O": 6, "R": 3, "S": 4, "T": 9},
+	},
+}

data/tracks/go/exercises/alphametics/example.go

@@ -0,0 +1,212 @@
+package alphametics
+
+import (
+	"errors"
+	"strings"
+	"unicode"
+)
+
+var decDigits = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+type problem struct {
+	vDigits      [][]rune
+	maxDigits    int
+	letterValues [26]int
+	lettersUsed  []rune
+	nLetters     int
+}
+
+func Solve(puzzle string) (map[string]int, error) {
+	p := parsePuzzle(puzzle)
+	if p == nil {
+		return nil, errors.New("invalid puzzle")
+	}
+	return p.solvePuzzle()
+}
+
+// parsePuzzle parses the puzzle input into a problem for solving.
+func parsePuzzle(puzzle string) (p *problem) {
+	var valueStrings []string
+	p = new(problem)
+	fields := strings.Fields(puzzle)
+	for _, field := range fields {
+		if field == "+" || field == "==" {
+			continue
+		} else {
+			valueStrings = append(valueStrings, field)
+			if len(field) > p.maxDigits {
+				p.maxDigits = len(field)
+			}
+			for _, r := range field {
+				if !unicode.IsUpper(r) {
+					return nil
+				}
+				v := r - 'A'
+				p.letterValues[v] = -1
+			}
+		}
+	}
+	// Count the letters used.
+	for v := 0; v < len(p.letterValues); v++ {
+		if p.letterValues[v] == -1 {
+			p.nLetters++
+		}
+	}
+	p.vDigits = make([][]rune, len(valueStrings))
+	for i := range valueStrings {
+		p.vDigits[i] = make([]rune, p.maxDigits)
+		for d, r := range valueStrings[i] {
+			j := len(valueStrings[i]) - 1 - d
+			// Each vDigits value is 0 for nothing in this position,
+			// or 1..26 for 'A'..'Z'.
+			p.vDigits[i][j] = r - 'A' + 1
+		}
+	}
+	// Make a list of the letters used, where 0 == 'A'
+	p.lettersUsed = make([]rune, p.nLetters)
+	for n, v := 0, 0; v < len(p.letterValues); v++ {
+		if p.letterValues[v] == -1 {
+			p.lettersUsed[n] = rune(v) // 0 == 'A'
+			n++
+		}
+	}
+	return p
+}
+
+func (p *problem) solvePuzzle() (map[string]int, error) {
+	for _, digValues := range permutations(decDigits, p.nLetters) {
+		if p.isPuzzleSolution(digValues) {
+			// Check leading digit of answer for 0 (invalid solution).
+			r := p.vDigits[len(p.vDigits)-1][p.maxDigits-1]
+			if p.letterValues[r-1] == 0 {
+				continue
+			}
+			return p.puzzleMap(), nil
+		}
+	}
+	return nil, errors.New("no solution")
+}
+
+// isPuzzleSolution returns true if the values work out as a solution.
+func (p *problem) isPuzzleSolution(values []int) bool {
+	// Put the candidate values into the letterValues for the lettersUsed.
+	for i, r := range p.lettersUsed {
+		p.letterValues[r] = values[i]
+	}
+	// For each column up to maxDigits
+	// check that the sum of the digits corresponding to values in vDigits
+	// add up to the digits (modulo 10) of values in last row.
+	carry := 0
+	for d := 0; d < p.maxDigits; d++ {
+		// Get initial sum for the digits for the this column of vDigits
+		r := p.vDigits[0][d]
+		sum := carry
+		if r != 0 {
+			// There's a character in this position.
+			sum += p.letterValues[r-1]
+		}
+		// Sum remaining rows for this column.
+		for n := 1; n < len(p.vDigits)-1; n++ {
+			r = p.vDigits[n][d]
+			if r != 0 {
+				// There's a character in this position.
+				sum += p.letterValues[r-1]
+			}
+		}
+		carry = sum / 10
+		sum = sum % 10
+		// Check the result sum against the answer row digit.
+		r = p.vDigits[len(p.vDigits)-1][d]
+		if r == 0 || sum != p.letterValues[r-1] {
+			return false
+		}
+	}
+	return true
+}
+
+// puzzleMap creates a "by letter" map from the letterValues used.
+func (p *problem) puzzleMap() map[string]int {
+	pm := make(map[string]int, p.nLetters)
+	for _, v := range p.lettersUsed {
+		r := v + 'A'
+		s := string(r)
+		pm[s] = p.letterValues[v]
+	}
+	return pm
+}
+
+// permutations returns a slice containing the r length permutations of the elements in iterable.
+// The implementation is modeled after the Python itertools.permutations().
+func permutations(iterable []int, r int) (perms [][]int) {
+	pool := iterable
+	n := len(pool)
+	nperm := 1
+	for i := n; i > 1; i-- {
+		nperm *= i
+	}
+	if r < n {
+		d := 1
+		for i := (n - r); i > 1; i-- {
+			d *= i
+		}
+		nperm = nperm / d
+	}
+	perms = make([][]int, 0, nperm)
+
+	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([]int, r)
+	for i, el := range indices[:r] {
+		result[i] = pool[el]
+	}
+
+	p := make([]int, 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([]int, len(result))
+				copy(p, result)
+				perms = append(perms, p)
+
+				break
+			}
+		}
+
+		if i < 0 {
+			return
+		}
+
+	}
+	return
+}