trackler 2.2.1.134 → 2.2.1.135

data/tracks/ruby/README.md

@@ -324,14 +324,8 @@ converting string indices to integer indices.
 
 ## READMEs
 
-<<<<<<< HEAD
 All exercises must have a README.md file, but should not be created manually. The READMEs
 are constructed using shared metadata, which lives in the [problem-specifications][] repo.
-=======
-Do not add a README or README.md file to the exercise's directory. The READMEs
-are constructed using shared metadata, which lives in the
-[problem-specifications][] repo.
->>>>>>> Whitespace and wrapping, not integral to this PR
 
 Use the `configlet` tool to generate a README from shared metadata:
 

data/tracks/rust/.travis.yml

@@ -8,11 +8,11 @@ script:
 - "./bin/fetch-configlet"
 - "sh ./_test/ensure-readmes-are-updated.sh"
 - "./bin/configlet lint ."
+- "./_test/verify-exercise-difficulties.sh"
 sudo: false
 rust:
   - stable
   - beta
-  - nightly
 env:
   - DENYWARNINGS=
   - DENYWARNINGS=1

data/tracks/rust/_test/verify-exercise-difficulties.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+repo=$(cd "$(dirname "$0")/.." && pwd)
+config=$repo/config.json
+
+es=0
+
+# ensure every exercise has a difficulty
+no_difficulty=$(
+    jq --raw-output '
+        .exercises[] |
+        select((.deprecated | not) and (has("difficulty") | not)) |
+        .slug
+    ' $config
+)
+if [ -n "$no_difficulty" ]; then
+    echo "Exercises without a difficulty in config.json:"
+    echo "$no_difficulty"
+    es=1
+fi
+
+# ensure that all difficulties are one of 1, 4, 7, 10
+invalid_difficulty=$(
+    jq --raw-output '
+        .exercises[] |
+        select(
+            (.deprecated | not) and
+            has("difficulty") and
+            (
+                .difficulty | tostring |
+                in({"1":null,"4":null,"7":null,"10":null}) |
+                not
+            )
+        ) |
+        "\(.slug) (\(.difficulty))"
+    ' $config
+)
+if [ -n "$invalid_difficulty" ]; then
+    echo "Exercises with invalid difficulty (must be in {1, 4, 7, 10})"
+    echo "$invalid_difficulty"
+    es=1
+fi
+
+# ensure difficulties are sorted
+exercise_order=$(jq --raw-output '.exercises[] | select(.deprecated | not) | .slug' $config)
+sorted_order=$(jq --raw-output '.exercises | sort_by(.difficulty) | .[] | select(.deprecated | not) | .slug' $config)
+if [ "$exercise_order" != "$sorted_order" ]; then
+    echo "Exercises are not in sorted order in config.json"
+    es=1
+fi
+
+exit $es

data/tracks/rust/config.json

@@ -200,7 +200,7 @@
       "slug": "saddle-points",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 3,
+      "difficulty": 4,
       "topics": [
         "vectors",
         "iterators"
@@ -211,7 +211,7 @@
       "slug": "isogram",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 3,
+      "difficulty": 4,
       "topics": [
         "chars",
         "iterators",
@@ -772,7 +772,7 @@
       "slug": "poker",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 6,
+      "difficulty": 7,
       "topics": [
         "lifetimes",
         "struct",
@@ -786,7 +786,7 @@
       "slug": "decimal",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 6,
+      "difficulty": 7,
       "topics": [
         "struct",
         "traits",

data/tracks/swift/exercises/space-age/Tests/SpaceAgeTests/SpaceAgeTests.swift

@@ -9,49 +9,49 @@ class SpaceAgeTests: XCTestCase {
 
     func testAgeInEarthYears() {
         let age = SpaceAge(1_000_000_000)
-        XCTAssertEqual(31.69, age.onEarth)
+        XCTAssertEqual(31.69, age.onEarth, accuracy: 0.01)
     }
 
     func testAgeInMercuryYears() {
         let age = SpaceAge(2_134_835_688)
-        XCTAssertEqual(67.65, age.onEarth)
-        XCTAssertEqual(280.88, age.onMercury)
+        XCTAssertEqual(67.65, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(280.88, age.onMercury, accuracy: 0.01)
     }
 
     func testAgeInVenusYears() {
         let age = SpaceAge(189_839_836)
-        XCTAssertEqual(6.02, age.onEarth)
-        XCTAssertEqual(9.78, age.onVenus)
+        XCTAssertEqual(6.02, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(9.78, age.onVenus, accuracy: 0.01)
     }
 
     func testAgeOnMars() {
         let age = SpaceAge(2_329_871_239)
-        XCTAssertEqual(73.83, age.onEarth)
-        XCTAssertEqual(39.25, age.onMars)
+        XCTAssertEqual(73.83, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(39.25, age.onMars, accuracy: 0.01)
     }
 
     func testAgeOnJupiter() {
         let age = SpaceAge(901_876_382)
-        XCTAssertEqual(28.58, age.onEarth)
-        XCTAssertEqual(2.41, age.onJupiter)
+        XCTAssertEqual(28.58, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(2.41, age.onJupiter, accuracy: 0.01)
     }
 
     func testAgeOnSaturn() {
         let age = SpaceAge(3_000_000_000)
-        XCTAssertEqual(95.06, age.onEarth)
-        XCTAssertEqual(3.23, age.onSaturn)
+        XCTAssertEqual(95.06, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(3.23, age.onSaturn, accuracy: 0.01)
     }
 
     func testAgeOnUranus() {
         let age = SpaceAge(3_210_123_456)
-        XCTAssertEqual(101.72, age.onEarth)
-        XCTAssertEqual(1.21, age.onUranus)
+        XCTAssertEqual(101.72, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(1.21, age.onUranus, accuracy: 0.01)
     }
 
     func testAgeOnNeptune() {
         let age = SpaceAge(8_210_123_456)
-        XCTAssertEqual(260.16, age.onEarth)
-        XCTAssertEqual(1.58, age.onNeptune)
+        XCTAssertEqual(260.16, age.onEarth, accuracy: 0.01)
+        XCTAssertEqual(1.58, age.onNeptune, accuracy: 0.01)
     }
 
     static var allTests: [(String, (SpaceAgeTests) -> () throws -> Void)] {

data/tracks/typescript/config.json

@@ -400,6 +400,20 @@
       "unlocked_by": "bob",
       "uuid": "9850a74a-1842-4db0-b3ed-5a53b4f25050"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "rectangles",
+      "topics": [
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "arrays",
+        "matrices",
+        "strings"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "6d81d98f-afde-4aea-85ff-c7baef98fb7e"
+    },
     {
       "core": false,
       "difficulty": 5,
@@ -645,6 +659,21 @@
       "unlocked_by": null,
       "uuid": "f5b00e76-3015-444d-8012-9862990db08c"
     },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "connect",
+      "topics": [
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "games",
+        "parsing",
+        "arrays",
+        "maps"
+      ],
+      "unlocked_by": "grade-school",
+      "uuid": "69cbdc2a-50f4-4e14-b9f4-c1ddee021018"
+    },
     {
       "core": false,
       "difficulty": 8,
@@ -671,6 +700,22 @@
       ],
       "uuid": "26787ded-0aa2-46f6-88dd-13a00cce9236"
     },
+    {
+      "core": false,
+      "difficulty": 8,
+      "slug": "bowling",
+      "topics": [
+        "arrays",
+        "control_flow_conditionals",
+        "control_flow_loops",
+        "exception_handling",
+        "games",
+        "parsing",
+        "text_formatting"
+      ],
+      "unlocked_by": "grade-school",
+      "uuid": "18376dda-8e8d-4cf7-a44a-db71da438e87"
+    },
     {
       "core": false,
       "difficulty": 9,
@@ -1092,4 +1137,4 @@
   "foregone": [],
   "language": "TypeScript",
   "test_pattern": ".*[.]test[.]ts$"
-}
+}

data/tracks/typescript/exercises/bowling/README.md

@@ -0,0 +1,93 @@
+# Bowling
+
+Score a bowling game.
+
+Bowling is a game where players roll a heavy ball to knock down pins
+arranged in a triangle. Write code to keep track of the score
+of a game of bowling.
+
+## Scoring Bowling
+
+The game consists of 10 frames. A frame is composed of one or two ball
+throws with 10 pins standing at frame initialization. There are three
+cases for the tabulation of a frame.
+
+* An open frame is where a score of less than 10 is recorded for the
+  frame. In this case the score for the frame is the number of pins
+  knocked down.
+
+* A spare is where all ten pins are knocked down by the second
+  throw. The total value of a spare is 10 plus the number of pins
+  knocked down in their next throw.
+
+* A strike is where all ten pins are knocked down by the first
+  throw. The total value of a strike is 10 plus the number of pins
+  knocked down in the next two throws. If a strike is immediately
+  followed by a second strike, then the value of the first strike
+  cannot be determined until the ball is thrown one more time.
+
+Here is a three frame example:
+
+| Frame 1         | Frame 2       | Frame 3                |
+| :-------------: |:-------------:| :---------------------:|
+| X (strike)      | 5/ (spare)    | 9 0 (open frame)       |
+
+Frame 1 is (10 + 5 + 5) = 20
+
+Frame 2 is (5 + 5 + 9) = 19
+
+Frame 3 is (9 + 0) = 9
+
+This means the current running total is 48.
+
+The tenth frame in the game is a special case. If someone throws a
+strike or a spare then they get a fill ball. Fill balls exist to
+calculate the total of the 10th frame. Scoring a strike or spare on
+the fill ball does not give the player more fill balls. The total
+value of the 10th frame is the total number of pins knocked down.
+
+For a tenth frame of X1/ (strike and a spare), the total value is 20.
+
+For a tenth frame of XXX (three strikes), the total value is 30.
+
+## Requirements
+
+Write code to keep track of the score of a game of bowling. It should
+support two operations:
+
+* `roll(pins : int)` is called each time the player rolls a ball.  The
+  argument is the number of pins knocked down.
+* `score() : int` is called only at the very end of the game.  It
+  returns the total score for that game.
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+
+
+## Source
+
+The Bowling Game Kata at but UncleBob [http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata](http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/typescript/exercises/bowling/bowling.example.ts

@@ -0,0 +1,77 @@
+export default class Bowling {
+    rolls: number[]
+
+    constructor(rolls: number[]) {
+        this.rolls = rolls
+    }
+
+    score() {
+        const initialState = {
+            frameNumber: 1,
+            rollNumber: 1,
+            pinsRemaining: 10,
+            spareLastFrame: false,
+            strikeLastFrame: false,
+            twoStrikesInARow: false,
+            fillBall: false,
+            score: 0,
+        }
+
+        const finalState = this.rolls.reduce((state, roll) => {
+            if (roll < 0 || roll > 10) {
+                throw new Error('Pins must have a value from 0 to 10')
+            }
+
+            if (roll > state.pinsRemaining) {
+                throw new Error('Pin count exceeds pins on the lane')
+            }
+
+            if (state.frameNumber > 10) {
+                throw new Error('Should not be able to roll after game is over')
+            }
+
+            const finalFrame = state.frameNumber === 10
+            const strike = state.rollNumber === 1 && roll === 10
+            const spare = state.rollNumber === 2 && roll === state.pinsRemaining
+            const frameOver = finalFrame
+                ? (!state.fillBall && !spare && state.rollNumber === 2) || state.rollNumber === 3
+                : strike || spare || state.rollNumber === 2
+
+            let score = state.score + roll
+
+            if (state.strikeLastFrame && state.rollNumber < 3) { score += roll }
+            if (state.spareLastFrame && state.rollNumber === 1) { score += roll }
+            if (state.twoStrikesInARow && state.rollNumber === 1) { score += roll }
+
+            const next = {
+                frameNumber: 0,
+                rollNumber:  0,
+                pinsRemaining:  0,
+                spareLastFrame: false,
+                strikeLastFrame: false,
+                twoStrikesInARow: false,
+                fillBall: false,
+                score: 0
+            }
+
+            next.frameNumber = frameOver ? state.frameNumber + 1 : state.frameNumber
+            next.rollNumber = frameOver ? 1 : state.rollNumber + 1
+            next.pinsRemaining = finalFrame
+                ? ((strike || spare) ? 10 : state.pinsRemaining - roll)
+                : (frameOver ? 10 : state.pinsRemaining - roll)
+            next.spareLastFrame = frameOver ? spare : state.spareLastFrame
+            next.strikeLastFrame = frameOver ? strike : state.strikeLastFrame
+            next.twoStrikesInARow = frameOver ? strike && state.strikeLastFrame : state.twoStrikesInARow
+            next.fillBall = next.fillBall || (finalFrame && (strike || spare))
+            next.score = score
+
+            return next
+        }, initialState)
+
+        if (finalState.frameNumber !== 11) {
+            throw new Error('Score cannot be taken until the end of the game')
+        }
+
+        return finalState.score
+    }
+}

data/tracks/typescript/exercises/bowling/bowling.test.ts

@@ -0,0 +1,137 @@
+import Bowling from './bowling'
+
+describe('Bowling', () => {
+    describe('Check game can be scored correctly.', () => {
+        it('should be able to score a game with all gutterballs', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(0)
+        })
+
+        xit('should be able to score a game with all open frames', () => {
+            const rolls = [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6]
+            expect(new Bowling(rolls).score()).toEqual(90)
+        })
+
+        xit('a spare followed by zeros is worth ten points', () => {
+            const rolls = [6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(10)
+        })
+
+        xit('points scored in the roll after a spare are counted twice', () => {
+            const rolls = [6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(16)
+        })
+
+        xit('consecutive spares each get a one roll bonus', () => {
+            const rolls = [5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(31)
+        })
+
+        xit('should allow fill ball when the last frame is a spare', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7]
+            expect(new Bowling(rolls).score()).toEqual(17)
+        })
+
+        xit('a strike earns ten points in a frame with a single roll', () => {
+            const rolls = [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(10)
+        })
+
+        xit('points scored in the two rolls after a strike are counted twice as a bonus', () => {
+            const rolls = [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(26)
+        })
+
+        xit('should be able to score multiple strikes in a row', () => {
+            const rolls = [10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(new Bowling(rolls).score()).toEqual(81)
+        })
+
+        xit('should allow fill balls when the last frame is a strike', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1]
+            expect(new Bowling(rolls).score()).toEqual(18)
+        })
+
+        xit('rolling a spare with the two roll bonus does not get a bonus roll', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3]
+            expect(new Bowling(rolls).score()).toEqual(20)
+        })
+
+        xit('strikes with the two roll bonus do not get bonus rolls', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10]
+            expect(new Bowling(rolls).score()).toEqual(30)
+        })
+
+        xit('a strike with the one roll bonus after a spare in the last frame does not get a bonus', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10]
+            expect(new Bowling(rolls).score()).toEqual(20)
+        })
+
+        xit('should be able to score a perfect game', () => {
+            const rolls = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
+            expect(new Bowling(rolls).score()).toEqual(300)
+        })
+    })
+
+    describe('Check game rules.', () => {
+        xit('rolls can not score negative points', () => {
+            const rolls = [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Pins must have a value from 0 to 10')
+        })
+
+        xit('a roll can not score more than 10 points', () => {
+            const rolls = [11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Pins must have a value from 0 to 10')
+        })
+
+        xit('two rolls in a frame can not score more than 10 points', () => {
+            const rolls = [5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Pin count exceeds pins on the lane')
+        })
+
+        xit('two bonus rolls after a strike in the last frame can not score more than 10 points', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Pin count exceeds pins on the lane')
+        })
+
+        xit('two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6]
+            expect(new Bowling(rolls).score()).toEqual(26)
+        })
+
+        xit('the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Pin count exceeds pins on the lane')
+        })
+
+        xit('an unstarted game can not be scored', () => {
+            const rolls: number[] = []
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Score cannot be taken until the end of the game')
+        })
+
+        xit('an incomplete game can not be scored', () => {
+            const rolls = [0, 0]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Score cannot be taken until the end of the game')
+        })
+
+        xit('a game with more than ten frames and no last frame spare or strike can not be scored', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Should not be able to roll after game is over')
+        })
+
+        xit('bonus rolls for a strike in the last frame must be rolled before score can be calculated', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Score cannot be taken until the end of the game')
+        })
+
+        xit('both bonus rolls for a strike in the last frame must be rolled before score can be calculated', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Score cannot be taken until the end of the game')
+        })
+
+        xit('bonus roll for a spare in the last frame must be rolled before score can be calculated', () => {
+            const rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3]
+            expect(() => { new Bowling(rolls).score() }).toThrowError('Score cannot be taken until the end of the game')
+        })
+    })
+})