trackler 2.0.8.38 → 2.0.8.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcc166e36a7b734f6e7c78d015a93311bb78eb39
-  data.tar.gz: f7439a7ec5b911ba95a279186d799368c895db5e
+  metadata.gz: f16f5a4fa0fdde0642c976d3e020bdf84d359613
+  data.tar.gz: 940657bebb2d0ea237f01459d6beeab37766ee9b
 SHA512:
-  metadata.gz: bee112127f3bd191392aadd16e0a8b7d6f7b245debddf91f48b8066ec12d79b3890e78d8a5149807e9ce1a38f4356942a99ee43a28ce769aac5bad86c4b358a5
-  data.tar.gz: a73867dadaf36325e0e92a64bc6638541f105fffd3b60e30bb8534beb86cd3f37df6821bd1c1b7edbc5b38cec31075ba7285c1e6b4a4e309bf6c04e85bf71b5e
+  metadata.gz: f67845a691fb409f1c1453bca11cd939f37647ba716bac4a6ccd8d15cb7d0d50f43098c3448491adfc7724d5ef1c1922e96c6c98b1eefc60368e9786dd26fe87
+  data.tar.gz: 59000762c30e40be13816d4d7413ceff5ca4529b98fb912874a12a7a7a9ea272c003019bf7047769f16e73d19dde9e2912c91f15790735f2aa45099bf53630e3

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.38"
+  VERSION = "2.0.8.39"
 end

data/tracks/csharp/exercises/list-ops/HINTS.md

@@ -1,2 +1,2 @@
 ## Hints
-The `Foldl` andf `Foldr` methods are "fold" functions, which is a concept well-known in the functional programming world, but less so in the object-oriented one. If you'd like more background information, check out this[fold](https://en.wikipedia.org/wiki/Fold_(higher-order_function)) page.
+The `Foldl` and `Foldr` methods are "fold" functions, which is a concept well-known in the functional programming world, but less so in the object-oriented one. If you'd like more background information, check out this [fold](https://en.wikipedia.org/wiki/Fold_(higher-order_function)) page.

data/tracks/csharp/exercises/nucleotide-count/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires the use of a Dictionary. For more information see 
+[this page.](https://msdn.microsoft.com/en-us/library/s4ys34ea(v=vs.110).aspx)

data/tracks/go/config.json

@@ -505,6 +505,14 @@
         "Arrays",
         "Algorithms"
       ]
+    },
+    {
+      "difficulty": 1,
+      "slug": "bowling",
+      "topics": [
+        "Control-flow (conditionals)",
+        "Arrays"
+      ]
     }
   ]
 }

data/tracks/go/exercises/bowling/bowling_test.go

@@ -0,0 +1,77 @@
+package bowling
+
+import "testing"
+
+const targetTestVersion = 1
+
+const previousRollErrorMessage = `FAIL: %s
+	Unexpected error occurred: %q
+	while applying the previous rolls for the
+	test case: %v
+	The error was returned from Roll(%d) for previousRolls[%d].`
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
+func applyPreviousRolls(g *Game, rolls []int) (int, int, error) {
+	for index, pins := range rolls {
+		var err error
+		if err = g.Roll(pins); err != nil {
+			return index, pins, err
+		}
+	}
+	return 0, 0, nil
+}
+
+func TestScore(t *testing.T) {
+	for _, tc := range scoreTestCases {
+		g := NewGame()
+		index, pins, err := applyPreviousRolls(g, tc.previousRolls)
+		if err != nil {
+			t.Fatalf(previousRollErrorMessage,
+				tc.description, err, tc.previousRolls, pins, index)
+		}
+		score, err := g.Score()
+		if tc.valid {
+			var _ error = err
+			if err != nil {
+				t.Fatalf("FAIL: %s : Score() after Previous Rolls: %#v expected %d, got error %s",
+					tc.description, tc.previousRolls, tc.score, err)
+			} else {
+				if score != tc.score {
+					t.Fatalf("%s : Score() after Previous Rolls: %#v expected %d, got %d",
+						tc.description, tc.previousRolls, tc.score, score)
+				}
+			}
+		} else if err == nil {
+			t.Fatalf("FAIL: %s : Score() after Previous Rolls: %#v expected an error, got score %d\n\tExplanation: %s",
+				tc.description, tc.previousRolls, score, tc.explainText)
+		}
+		t.Logf("PASS: %s", tc.description)
+	}
+}
+
+func TestRoll(t *testing.T) {
+	for _, tc := range rollTestCases {
+		g := NewGame()
+		index, pins, err := applyPreviousRolls(g, tc.previousRolls)
+		if err != nil {
+			t.Fatalf(previousRollErrorMessage,
+				tc.description, err, tc.previousRolls, pins, index)
+		}
+		err = g.Roll(tc.roll)
+		if tc.valid && err != nil {
+			var _ error = err
+			t.Fatalf("FAIL: %s : Roll(%d) after Previous Rolls: %#v got unexpected error \"%s\".",
+				tc.description, tc.roll, tc.previousRolls, err)
+
+		} else if !tc.valid && err == nil {
+			t.Fatalf("FAIL: %s : Roll(%d) after Previous Rolls: %#v expected an error.\n\tExplanation: %s",
+				tc.description, tc.roll, tc.previousRolls, tc.explainText)
+		}
+		t.Logf("PASS: %s", tc.description)
+	}
+}

data/tracks/go/exercises/bowling/cases_test.go

@@ -0,0 +1,225 @@
+package bowling
+
+// Source: exercism/x-common
+// Commit: 3cf5eb9 bowling: Make canonical-data.json compliant
+// x-common version: 1.0.0
+
+var scoreTestCases = []struct {
+	description   string
+	previousRolls []int  // bowling rolls to do before the Score() test
+	valid         bool   // true => no error, false => error expected
+	score         int    // when .valid == true, the expected score value
+	explainText   string // when .valid == false, error explanation text
+}{
+	{
+		"should be able to score a game with all zeros",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		0,
+		"",
+	},
+	{
+		"should be able to score a game with no strikes or spares",
+		[]int{3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6},
+		true,
+		90,
+		"",
+	},
+	{
+		"a spare followed by zeros is worth ten points",
+		[]int{6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		10,
+		"",
+	},
+	{
+		"points scored in the roll after a spare are counted twice",
+		[]int{6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		16,
+		"",
+	},
+	{
+		"consecutive spares each get a one roll bonus",
+		[]int{5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		31,
+		"",
+	},
+	{
+		"a spare in the last frame gets a one roll bonus that is counted once",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7},
+		true,
+		17,
+		"",
+	},
+	{
+		"a strike earns ten points in a frame with a single roll",
+		[]int{10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		10,
+		"",
+	},
+	{
+		"points scored in the two rolls after a strike are counted twice as a bonus",
+		[]int{10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		26,
+		"",
+	},
+	{
+		"consecutive strikes each get the two roll bonus",
+		[]int{10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		true,
+		81,
+		"",
+	},
+	{
+		"a strike in the last frame gets a two roll bonus that is counted once",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1},
+		true,
+		18,
+		"",
+	},
+	{
+		"rolling a spare with the two roll bonus does not get a bonus roll",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3},
+		true,
+		20,
+		"",
+	},
+	{
+		"strikes with the two roll bonus do not get bonus rolls",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10},
+		true,
+		30,
+		"",
+	},
+	{
+		"a strike with the one roll bonus after a spare in the last frame does not get a bonus",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10},
+		true,
+		20,
+		"",
+	},
+	{
+		"all strikes is a perfect game",
+		[]int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+		true,
+		300,
+		"",
+	},
+
+	{
+		"two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6},
+		true,
+		26,
+		"",
+	},
+
+	{
+		"an unstarted game can not be scored",
+		[]int{},
+		false,
+		0,
+		"Score cannot be taken until the end of the game",
+	},
+	{
+		"an incomplete game can not be scored",
+		[]int{0, 0},
+		false,
+		0,
+		"Score cannot be taken until the end of the game",
+	},
+
+	{
+		"bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10},
+		false,
+		0,
+		"Score cannot be taken until the end of the game",
+	},
+	{
+		"both bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10},
+		false,
+		0,
+		"Score cannot be taken until the end of the game",
+	},
+	{
+		"bonus roll for a spare in the last frame must be rolled before score can be calculated",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3},
+		false,
+		0,
+		"Score cannot be taken until the end of the game",
+	},
+}
+
+var rollTestCases = []struct {
+	description   string
+	previousRolls []int  // bowling rolls to do before the Roll(roll) test
+	valid         bool   // true => no error, false => error expected
+	roll          int    // pin count for the test roll
+	explainText   string // when .valid == false, error explanation text
+}{
+
+	{
+		"rolls can not score negative points",
+		[]int{},
+		false,
+		-1,
+		"Negative roll is invalid",
+	},
+	{
+		"a roll can not score more than 10 points",
+		[]int{},
+		false,
+		11,
+		"Pin count exceeds pins on the lane",
+	},
+	{
+		"two rolls in a frame can not score more than 10 points",
+		[]int{5},
+		false,
+		6,
+		"Pin count exceeds pins on the lane",
+	},
+	{
+		"bonus roll after a strike in the last frame can not score more than 10 points",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10},
+		false,
+		11,
+		"Pin count exceeds pins on the lane",
+	},
+	{
+		"two bonus rolls after a strike in the last frame can not score more than 10 points",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5},
+		false,
+		6,
+		"Pin count exceeds pins on the lane",
+	},
+
+	{
+		"the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6},
+		false,
+		10,
+		"Pin count exceeds pins on the lane",
+	},
+	{
+		"second bonus roll after a strike in the last frame can not score than 10 points",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10},
+		false,
+		11,
+		"Pin count exceeds pins on the lane",
+	},
+
+	{
+		"cannot roll if game already has ten frames",
+		[]int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		false,
+		0,
+		"Cannot roll after game is over",
+	},
+}

data/tracks/go/exercises/bowling/example.go

@@ -0,0 +1,133 @@
+// Package bowling implements scoring for the game of bowling.
+package bowling
+
+import "errors"
+
+const testVersion = 1
+
+var (
+	ErrNegativeRollIsInvalid        = errors.New("Negative roll is invalid")
+	ErrPinCountExceedsPinsOnTheLane = errors.New("Pin count exceeds pins on the lane")
+	ErrPrematureScore               = errors.New("Score cannot be taken until the end of the game")
+	ErrCannotRollAfterGameOver      = errors.New("Cannot roll after game is over")
+)
+
+const (
+	pinsPerFrame      = 10
+	framesPerGame     = 10
+	maxRollsPerFrame  = 2
+	maxRollsLastFrame = 3
+	maxRolls          = (maxRollsPerFrame * (framesPerGame - 1)) + maxRollsLastFrame
+)
+
+// Game records the data to track a game's progress.
+type Game struct {
+	rolls       [maxRolls]int // storage for the rolls
+	nRolls      int           // counts the rolls accumulated.
+	nFrames     int           // counts completed frames, up to framesPerGame.
+	rFrameStart int           // tracks the starting roll of each frame.
+}
+
+// NewGame returns a fresh zero-valued game struct.
+func NewGame() *Game {
+	return &Game{}
+}
+
+// Roll records one roll for a bowling frame with 'pins' knocked down.
+// An error is possible depending on pin value and previous rolls.
+func (g *Game) Roll(pins int) error {
+	// Validate pin count on roll.
+	if pins > pinsPerFrame {
+		return ErrPinCountExceedsPinsOnTheLane
+	}
+	if pins < 0 {
+		return ErrNegativeRollIsInvalid
+	}
+	if g.completedFrames() == framesPerGame {
+		return ErrCannotRollAfterGameOver
+	}
+	// Record the roll.
+	g.rolls[g.nRolls] = pins
+	g.nRolls++
+	if pins == pinsPerFrame && g.completedFrames() < framesPerGame-1 {
+		// Frames before last one can be strikes with no problems.
+		g.completeTheFrame()
+		return nil
+	}
+	if g.rollsThisFrame() == maxRollsPerFrame {
+		// Have counted normal max rolls on a frame.
+		if g.rawFrameScore(g.rFrameStart) > pinsPerFrame {
+			// Unless we have completed all but last frame, cannot count > pinsPerFrame.
+			if g.completedFrames() != framesPerGame-1 || !g.isStrike(g.rFrameStart) {
+				return ErrPinCountExceedsPinsOnTheLane
+			}
+		}
+		if g.completedFrames() < framesPerGame-1 {
+			// Completed frames before last one with maxRollsPerFrame.
+			g.completeTheFrame()
+			return nil
+		}
+		// For last frame, is it complete now ?
+		if g.rawFrameScore(g.rFrameStart) < pinsPerFrame {
+			// Yes, complete.
+			g.completeTheFrame()
+		}
+	} else if g.rollsThisFrame() == maxRollsLastFrame {
+		// Extra roll on the last frame.
+		if g.isStrike(g.rFrameStart) {
+			// First was a strike.
+			if !g.isStrike(g.rFrameStart + 1) {
+				// Second was NOT a strike, so last 2 rolls cannot exceed pinsPerFrame.
+				if g.strikeBonus(g.rFrameStart) > pinsPerFrame {
+					return ErrPinCountExceedsPinsOnTheLane
+				}
+			}
+			if b := g.strikeBonus(g.rFrameStart); b > pinsPerFrame && b < 2*pinsPerFrame {
+				// Unless one of the bonuses was a strike, bonus frames too high.
+				if !g.isStrike(g.rFrameStart+1) && !g.isStrike(g.rFrameStart+2) {
+					return ErrPinCountExceedsPinsOnTheLane
+				}
+			}
+		} else if !g.isSpare(g.rFrameStart) {
+			// Attempt to make extra roll in last frame without strike or spare.
+			return ErrCannotRollAfterGameOver
+		}
+		// Completed last frame.
+		g.completeTheFrame()
+	}
+
+	return nil
+}
+
+// Score returns the score of the game with a potential error.
+func (g *Game) Score() (int, error) {
+	if g.completedFrames() != framesPerGame {
+		return 0, ErrPrematureScore
+	}
+
+	score := 0
+	frameStart := 0
+
+	for frame := 0; frame < framesPerGame; frame++ {
+		if g.isStrike(frameStart) {
+			score += pinsPerFrame + g.strikeBonus(frameStart)
+			frameStart++
+		} else if g.isSpare(frameStart) {
+			score += pinsPerFrame + g.spareBonus(frameStart)
+			frameStart += maxRollsPerFrame
+		} else {
+			score += g.rawFrameScore(frameStart)
+			frameStart += maxRollsPerFrame
+		}
+	}
+	return score, nil
+}
+
+func (g *Game) rollsThisFrame() int     { return g.nRolls - g.rFrameStart }
+func (g *Game) completeTheFrame()       { g.nFrames++; g.rFrameStart = g.nRolls }
+func (g *Game) completedFrames() int    { return g.nFrames }
+func (g *Game) isStrike(f int) bool     { return g.rolls[f] == pinsPerFrame }
+func (g *Game) rawFrameScore(f int) int { return g.rolls[f] + g.rolls[f+1] }
+func (g *Game) spareBonus(f int) int    { return g.rolls[f+2] }
+func (g *Game) strikeBonus(f int) int   { return g.rolls[f+1] + g.rolls[f+2] }
+func (g *Game) isSpare(f int) bool      { return (g.rolls[f] + g.rolls[f+1]) == pinsPerFrame }