trackler 2.0.0.1 → 2.0.0.2

data/tracks/fsharp/exercises/bowling/BowlingTest.fs

@@ -4,56 +4,171 @@ open NUnit.Framework
 
 open Bowling
 
-let rollMany pins count game =
-    List.replicate count pins
-    |> List.fold (fun acc item -> roll item acc) game
-
-let rollSpare game = 
-    game
-    |> roll 5
-    |> roll 5
-
-let rollStrike game = game |> roll 10
+let rollMany rolls game = List.fold (fun game pins -> roll pins game) game rolls
 
 [<Test>]
-let ``Gutter game`` () =
-    let result = newGame |> rollMany 0 20
-    Assert.That(score result, Is.EqualTo(0))
-
+let ``Should be able to score a game with all zeros`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 0))
+    
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``All ones game`` () =
-    let result = newGame |> rollMany 1 20
-    Assert.That(score result, Is.EqualTo(20))
-
+let ``Should be able to score a game with no strikes or spares`` () =
+    let rolls = [3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6; 3; 6]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 90))
+    
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``One spare game`` () =
-    let result = 
-        newGame
-        |> rollSpare
-        |> roll 3
-        |> rollMany 0 17
-
-    Assert.That(score result, Is.EqualTo(16))
-
+let ``A spare followed by zeros is worth ten points`` () =
+    let rolls = [6; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 10))
+    
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``One strike game`` () =
-    let result = 
-        newGame
-        |> rollStrike
-        |> roll 3
-        |> roll 4
-        |> rollMany 0 16
-
-    Assert.That(score result, Is.EqualTo(24))
-
+let ``Points scored in the roll after a spare are counted twice`` () =
+    let rolls = [6; 4; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 16))
+    
 [<Test>]
 [<Ignore("Remove to run test")>]
-let ``Perfect game`` () =
-    let result = newGame |> rollMany 10 12
-
-    Assert.That(score result, Is.EqualTo(300))
-  
-
+let ``Consecutive spares each get a one roll bonus`` () =
+    let rolls = [5; 5; 3; 7; 4; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 31))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A spare in the last frame gets a one roll bonus that is counted once`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 7]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 17))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A strike earns ten points in frame with a single roll`` () =
+    let rolls = [10; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 10))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Points scored in the two rolls after a strike are counted twice as a bonus`` () =
+    let rolls = [10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 26))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Consecutive strikes each get the two roll bonus`` () =
+    let rolls = [10; 10; 10; 5; 3; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 81))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A strike in the last frame gets a two roll bonus that is counted once`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 1]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 18))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Rolling a spare with the two roll bonus does not get a bonus roll`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 7; 3]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 20))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Strikes with the two roll bonus do not get bonus rolls`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10; 10]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 30))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A strike with the one roll bonus after a spare in the last frame does not get a bonus`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3; 10]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 20))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``All strikes is a perfect game`` () =
+    let rolls = [10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10; 10]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(Some 300))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Rolls can not score negative points`` () =
+    let rolls = [-1; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A roll can not score more than 10 points`` () =
+    let rolls = [11; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Two rolls in a frame can not score more than 10 points`` () =
+    let rolls = [5; 6; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Two bonus rolls after a strike in the last frame can not score more than 10 points`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 5; 6]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``An unstarted game can not be scored`` () =
+    let rolls = []
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``An incomplete game can not be scored`` () =
+    let rolls = [0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A game with more than ten frames can not be scored`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Bonus rolls for a strike in the last frame must be rolled before score can be calculated`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Both bonus rolls for a strike in the last frame must be rolled before score can be calculated`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 10; 10]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))
+    
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Bonus roll for a spare in the last frame must be rolled before score can be calculated`` () =
+    let rolls = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 7; 3]
+    let game = rollMany rolls newGame
+    Assert.That(score game, Is.EqualTo(None))

data/tracks/fsharp/exercises/bowling/Example.fs

@@ -1,29 +1,58 @@
 module Bowling
 
+let map2 f opt1 opt2 = 
+    match opt1, opt2 with
+    | Some x, Some y -> Some (f x y)
+    | _ -> None
+
 let numberOfFrames = 10
 let maximumFrameScore = 10
-
-let roll pins game = game @ [pins]
-
-let score game =    
-
-    let roll index = List.item index game
-
-    let isStrike frameIndex = roll frameIndex = maximumFrameScore
-    let isSpare frameIndex = roll frameIndex + roll (frameIndex + 1) = maximumFrameScore
-
-    let strikeBonus frameIndex = roll (frameIndex + 1) + roll (frameIndex + 2) 
-    let spareBonus frameIndex = roll (frameIndex + 2) 
-
-    let sumOfBallsInFrame frameIndex = roll frameIndex + roll (frameIndex + 1)
+let minimumFrameScore = 0
+
+let newGame = Some []
+
+let validatePins pins = 
+    if pins < minimumFrameScore || pins > maximumFrameScore then 
+        None 
+    else 
+        Some pins
+
+let isStrike pins = pins = maximumFrameScore
+let isSpare pins1 pins2 = pins1 + pins2 = maximumFrameScore
+
+let roll pins rolls = map2 (fun rolls pins -> rolls @ [pins]) rolls (validatePins pins)
+
+let rec scoreRolls totalScore frame rolls = 
+    let isLastFrame = frame = numberOfFrames
+    let gameFinished = frame = numberOfFrames + 1
+
+    let scoreStrike remainder = 
+        match remainder with
+        | x::y::zs when isLastFrame ->
+            if x + y > 10 && x <> 10 then None
+            else scoreRolls (totalScore + 10 + x + y) (frame + 1) zs
+        | x::y::zs ->
+            scoreRolls (totalScore + 10 + x + y) (frame + 1) (x::y::zs)
+        | _ ->
+            None
+
+    let scoreSpare x y remainder = 
+        match remainder with 
+        | z::zs->
+            scoreRolls (totalScore + x + y + z) (frame + 1) (if isLastFrame then zs else z::zs)
+        | _ ->
+            None
+            
+    let scoreNormal x y remainder =
+        match validatePins (x + y) with
+        | Some z -> scoreRolls (totalScore + z) (frame + 1) remainder
+        | None -> None
+
+    match rolls with
+    | [] -> if gameFinished then Some totalScore else None
+    | x::xs when isStrike x -> scoreStrike xs        
+    | x::y::ys when isSpare x y -> scoreSpare x y ys        
+    | x::y::zs -> scoreNormal x y zs       
+    | _ -> None
     
-    let folder (score, frameIndex) _ = 
-        if isStrike frameIndex then (score + 10 + strikeBonus frameIndex, frameIndex + 1)
-        elif isSpare frameIndex then (score + 10 + spareBonus frameIndex, frameIndex + 2)
-        else (score + sumOfBallsInFrame frameIndex, frameIndex + 2)
-
-    [1..numberOfFrames]
-    |> List.fold folder (0, 0)
-    |> fst
-
-let newGame = []
+let score = Option.bind (scoreRolls 0 1)

data/tracks/go/config.json

@@ -211,6 +211,11 @@
       "slug": "robot-name",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "diamond",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "react",

data/tracks/go/exercises/diamond/diamond_test.go

@@ -0,0 +1,227 @@
+package diamond
+
+import (
+	"math/rand"
+	"reflect"
+	"strings"
+	"testing"
+	"testing/quick"
+	"time"
+)
+
+var config = &quick.Config{Rand: rand.New(rand.NewSource(time.Now().UnixNano()))}
+
+type correctChar byte
+
+func (c correctChar) Generate(rand *rand.Rand, _ int) reflect.Value {
+	return reflect.ValueOf(correctChar('A' + rand.Intn('Z'-'A'+1)))
+}
+
+func checkCorrect(requirement func(byte, []string) bool, keepSeparator bool, t *testing.T) {
+	assertion := func(char correctChar) bool {
+		d, err := Gen(byte(char))
+		if err != nil {
+			return false
+		}
+		separator := strings.Split
+		if keepSeparator {
+			separator = strings.SplitAfter
+		}
+		rows := separator(d, "\n")
+		if len(rows) < 2 {
+			return false
+		}
+		return requirement(byte(char), rows[:len(rows)-1])
+	}
+	if err := quick.Check(assertion, config); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestFirstRowContainsOneA(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		return len(rows) > 0 && strings.Count(rows[0], "A") == 1
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestLastRowContainsOneA(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		return len(rows) > 0 && strings.Count(rows[len(rows)-1], "A") == 1
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestAllRowsIdenticalLettersExceptFirstAndLast(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		for i, row := range rows {
+			r := strings.TrimSpace(row)
+			if r[0] != r[len(r)-1] {
+				return false
+			}
+			if len(r) < 2 && i != 0 && i != len(rows)-1 {
+				return false
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestAllRowsHaveSameTrailingSpaces(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		for _, row := range rows {
+			if len(row) == 0 {
+				return false
+			}
+			for i, j := 0, len(row)-1; i < j && row[i] == ' '; i, j = i+1, j-1 {
+				if row[j] != ' ' {
+					return false
+				}
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestDiamondIsHorizontallySymmetric(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		for _, row := range rows {
+			l := len(row)
+			for i := l/2 - 1; i >= 0; i-- {
+				if row[i] != row[l-1-i] {
+					return false
+				}
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestDiamondIsVerticallySymmetric(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		for i, j := 0, len(rows)-1; i < j; i, j = i+1, j-1 {
+			if rows[i] != rows[j] {
+				return false
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, true, t)
+}
+
+func TestDiamondIsSquare(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		if int(char-'A')*2+1 != len(rows) {
+			return false
+		}
+		for _, row := range rows {
+			if len(row) != len(rows) {
+				return false
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestDiamondHasItsShape(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		var n int
+		for i, row := range rows {
+			s := len(strings.TrimSpace(row))
+			if i > len(rows)/2 && n <= s {
+				return false
+			} else if i <= len(rows)/2 && n >= s {
+				return false
+			}
+			n = s
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestTopHalfHasAscendingLetters(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		var start byte = 'A' - 1
+		for i := 0; i <= len(rows)/2; i++ {
+			s := strings.TrimLeft(rows[i], " ")
+			if s == "" || s[0] <= start {
+				return false
+			}
+			start = s[0]
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestBottomHalfHasDescendingLetters(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		var start byte = 'A' - 1
+		for i := len(rows) - 1; i > len(rows)/2; i-- {
+			s := strings.TrimLeft(rows[i], " ")
+			if s == "" || s[0] <= start {
+				return false
+			}
+			start = s[0]
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+func TestDiamondFourCornersAreTriangle(t *testing.T) {
+	requirement := func(char byte, rows []string) bool {
+		notSpace := func(r rune) bool { return r <= 'Z' && r >= 'A' }
+		var n int
+		for i, row := range rows {
+			s := strings.IndexFunc(row, notSpace)
+			e := len(row) - strings.LastIndexFunc(row, notSpace) - 1
+			if s != e {
+				return false
+			} else if i == 0 {
+				n = s
+			} else {
+				if i > len(rows)/2 && n >= s {
+					return false
+				} else if i <= len(rows)/2 && n <= s {
+					return false
+				}
+				n = s
+			}
+		}
+		return true
+	}
+	checkCorrect(requirement, false, t)
+}
+
+type wrongChar byte
+
+func (c wrongChar) Generate(rand *rand.Rand, _ int) reflect.Value {
+	b := rand.Intn(256)
+	for ; b >= 'A' && b <= 'Z'; b = rand.Intn(256) {
+	}
+	return reflect.ValueOf(wrongChar(b))
+}
+
+func TestCharOutOfRangeShouldGiveError(t *testing.T) {
+	assertion := func(char wrongChar) bool {
+		_, err := Gen(byte(char))
+		return err != nil
+	}
+	if err := quick.Check(assertion, config); err != nil {
+		t.Error(err)
+	}
+}
+
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}

data/tracks/go/exercises/diamond/example.go

@@ -0,0 +1,47 @@
+package diamond
+
+import (
+	"errors"
+	"strings"
+)
+
+const testVersion = 1
+
+const startIndex = 'A'
+
+// Gen builds a diamond
+func Gen(char byte) (string, error) {
+	if char > 'Z' || char < 'A' {
+		return "", errors.New(string(char) + " isn't supported, only between (A, Z)")
+	}
+	return gen(char), nil
+}
+
+func gen(char byte) string {
+	var output []string
+	currentIndex := int(char - startIndex)
+	for i := 0; i <= currentIndex; i++ {
+		output = append(output, getLine(currentIndex, i))
+	}
+	for i := currentIndex - 1; i > -1; i-- {
+		output = append(output, getLine(currentIndex, i))
+	}
+	return strings.Join(output, "\n") + "\n"
+}
+
+func getLine(currentStart, current int) string {
+	diff := currentStart - current
+	return spaces(diff) + alphabets(current) + spaces(diff)
+}
+
+func alphabets(current int) string {
+	if current == 0 {
+		return "A"
+	}
+	c := current + startIndex
+	return string(c) + spaces(current*2-1) + string(c)
+}
+
+func spaces(n int) string {
+	return strings.Repeat(" ", n)
+}

data/tracks/go/exercises/food-chain/example.go

@@ -1,6 +1,6 @@
 package foodchain
 
-const testVersion = 2
+const testVersion = 3
 
 var verse = []struct{ eaten, comment string }{
 	{"", ""},

data/tracks/go/exercises/food-chain/food_chain_test.go

@@ -1,11 +1,12 @@
 package foodchain
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 )
 
-const targetTestVersion = 2
+const targetTestVersion = 3
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
@@ -67,24 +68,47 @@ I don't know why she swallowed the fly. Perhaps she'll die.`,
 She's dead, of course!`,
 }
 
+// diff compares two multi-line strings and returns a helpful comment
+func diff(got, want string) string {
+	g := strings.Split(got, "\n")
+	w := strings.Split(want, "\n")
+	for i := 0; ; i++ {
+		switch {
+		case i < len(g) && i < len(w):
+			if g[i] == w[i] {
+				continue
+			}
+			return fmt.Sprintf("-- first difference in line %d:\n"+
+				"-- got : %q\n-- want: %q\n", i+1, g[i], w[i])
+		case i < len(g):
+			return fmt.Sprintf("-- got %d extra lines after line %d:\n"+
+				"-- first extra line: %q\n", len(g)-len(w), i, g[i])
+		case i < len(w):
+			return fmt.Sprintf("-- got %d correct lines, want %d more lines:\n"+
+				"-- want next: %q\n", i, len(w)-i, w[i])
+		default:
+			return "no differences found"
+		}
+	}
+}
+
 func TestVerse(t *testing.T) {
 	for v := 1; v <= 8; v++ {
 		if ret := Verse(v); ret != ref[v] {
-			t.Fatalf("Verse(%d) =\n%s\n  want:\n%s", v, ret, ref[v])
+			t.Fatalf("Verse(%d) =\n%s\n  want:\n%s\n%s", v, ret, ref[v], diff(ret, ref[v]))
 		}
 	}
 }
 
 func TestVerses(t *testing.T) {
-	if ret, want := Verses(1, 2), ref[1]+"\n\n"+ref[2]; ret != want {
-		t.Fatalf("Verses(1, 2) =\n%s\n  want:\n%s", ret, want)
+	if ret, want := Verses(1, 3), strings.Join(ref[1:4], "\n\n"); ret != want {
+		t.Fatalf("Verses(1, 3) =\n%s\n  want:\n%s\n%s", ret, want, diff(ret, want))
 	}
-
 }
 
 func TestSong(t *testing.T) {
 	if ret, want := Song(), strings.Join(ref[1:], "\n\n"); ret != want {
-		t.Fatalf("Song() =\n%s\n  want:\n%s", ret, want)
+		t.Fatalf("Song() =\n%s\n  want:\n%s\n%s", ret, want, diff(ret, want))
 	}
 }