trackler 2.2.1.49 → 2.2.1.50

data/tracks/common-lisp/exercises/sublist/example.lisp

@@ -0,0 +1,24 @@
+(defpackage #:sublist
+  (:use #:common-lisp)
+  (:export #:sublist))
+
+(in-package #:sublist)
+
+(defun is-prefix-of (xs ys)
+  (cond ((null xs)                 T)
+        ((null ys)                 NIL)
+        ((equal (car xs) (car ys)) (is-prefix-of (cdr xs) (cdr ys)))
+        (T                         NIL)))
+
+(defun sublist-of (xs ys)
+  (if (and xs (null ys))
+    nil
+    (or (is-prefix-of xs ys) (sublist-of xs (cdr ys)))))
+
+(defun sublist (xs ys)
+  (let ((sub   (sublist-of xs ys))
+        (super (sublist-of ys xs)))
+    (cond ((and sub super) "equal")
+          (sub             "sublist")
+          (super           "superlist")
+          (T               "unequal"))))

data/tracks/common-lisp/exercises/sublist/sublist-test.lisp

@@ -0,0 +1,87 @@
+(ql:quickload "lisp-unit")
+#-xlisp-test (load "sublist")
+
+(defpackage #:sublist-test
+  (:use #:common-lisp #:lisp-unit))
+
+(in-package #:sublist-test)
+
+
+;; Equal lists tests:
+(define-test empty-lists
+  (assert-equal "equal" (sublist:sublist (list)
+                                         (list))))
+
+(define-test list-equals-itself
+  (assert-equal "equal" (sublist:sublist (list 1 2 3)
+                                         (list 1 2 3))))
+
+
+;; Unequal lists tests:
+(define-test different-lists
+  (assert-equal "unequal" (sublist:sublist (list 1 2 3)
+                                           (list 2 3 4))))
+
+(define-test first-list-missing-element-from-second-list
+  (assert-equal "unequal" (sublist:sublist (list 1 3)
+                                           (list 1 2 3))))
+
+(define-test second-list-missing-element-from-first-list
+  (assert-equal "unequal" (sublist:sublist (list 1 2 3)
+                                           (list 1 3))))
+
+(define-test order-matters-to-a-lists
+  (assert-equal "unequal" (sublist:sublist (list 1 2 3)
+                                           (list 3 2 1))))
+
+(define-test same-digits-different-numbers
+  (assert-equal "unequal" (sublist:sublist (list 1 0 1)
+                                           (list 10 1))))
+
+;; Sublist lists tests:
+(define-test empty-list-within-non-empty-list
+  (assert-equal "sublist" (sublist:sublist (list)
+                                           (list 1 2 3))))
+
+(define-test false-start
+  (assert-equal "sublist" (sublist:sublist (list 1 2 5)
+                                           (list 0 1 2 3 1 2 5 6))))
+
+(define-test consecutive
+  (assert-equal "sublist" (sublist:sublist (list 1 1 2)
+                                           (list 0 1 1 1 2 1 2))))
+
+(define-test sublist-at-start
+  (assert-equal "sublist" (sublist:sublist (list 0 1 2)
+                                           (list 0 1 2 3 4 5))))
+
+(define-test sublist-in-middle
+  (assert-equal "sublist" (sublist:sublist (list 2 3 4)
+                                           (list 0 1 2 3 4 5))))
+
+(define-test sublist-at-end
+  (assert-equal "sublist" (sublist:sublist (list 3 4 5)
+                                           (list 0 1 2 3 4 5))))
+
+
+;; Superlist lists tests:
+(define-test not-empty-list-contains-empty-list
+  (assert-equal "superlist" (sublist:sublist (list 1 2 3)
+                                             (list))))
+
+(define-test at-start-of-superlist
+  (assert-equal "superlist" (sublist:sublist (list 0 1 2 3 4 5)
+                                             (list 0 1 2))))
+
+(define-test in-middle-of-superlist
+  (assert-equal "superlist" (sublist:sublist (list 0 1 2 3 4 5)
+                                             (list 2 3))))
+
+(define-test at-end-superlist
+  (assert-equal "superlist" (sublist:sublist (list 0 1 2 3 4 5)
+                                             (list 3 4 5))))
+
+#-xlisp-test
+(let ((*print-errors* t)
+      (*print-failures* t))
+  (run-tests :all))

data/tracks/common-lisp/exercises/sublist/sublist.lisp

@@ -0,0 +1,8 @@
+(defpackage #:sublist
+  (:use #:common-lisp)
+  (:export #:sublist))
+
+(in-package #:sublist)
+
+(defun sublist (list1 list2)
+  "what is list1 of list2 (sublist, superlist, equal or unequal)")

data/tracks/common-lisp/exercises/triangle/README.md

@@ -2,23 +2,26 @@
 
 Determine if a triangle is equilateral, isosceles, or scalene.
 
-An _equilateral_ triangle has all three sides the same length.<br/>
+An _equilateral_ triangle has all three sides the same length.
+
 An _isosceles_ triangle has at least two sides the same length. (It is sometimes
 specified as having exactly two sides the same length, but for the purposes of
-this exercise we'll say at least two.)<br/>
+this exercise we'll say at least two.)
+
 A _scalene_ triangle has all sides of different lengths.
 
 ## Note
 
-For a shape to be a triangle at all, all sides have to be of length > 0, and 
-the sum of the lengths of any two sides must be greater than or equal to the 
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
 length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
 
 ## Dig Deeper
 
-The case where the sum of the lengths of two sides _equals_ that of the 
-third is known as a _degenerate_ triangle - it has zero area and looks like 
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
 a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
 ## Setup
 
 Check out [Exercism Help](http://exercism.io/languages/lisp) for instructions to

data/tracks/common-lisp/exercises/trinary/README.md

@@ -11,7 +11,7 @@ Trinary numbers contain three symbols: 0, 1, and 2.
 The last place in a trinary number is the 1's place. The second to last
 is the 3's place, the third to last is the 9's place, etc.
 
-```bash
+```shell
 # "102012"
     1       0       2       0       1       2    # the number
 1*3^5 + 0*3^4 + 2*3^3 + 0*3^2 + 1*3^1 + 2*3^0    # the value

data/tracks/common-lisp/exercises/word-count/README.md

@@ -4,14 +4,13 @@ Given a phrase, count the occurrences of each word in that phrase.
 
 For example for the input `"olly olly in come free"`
 
-```plain
+```text
 olly: 2
 in: 1
 come: 1
 free: 1
 ```
 
-
 ## Setup
 
 Check out [Exercism Help](http://exercism.io/languages/lisp) for instructions to

data/tracks/ecmascript/config.json

@@ -236,6 +236,20 @@
         "Recursion"
       ]
     },
+    {
+      "uuid": "207af8f6-0ffe-e380-d521-7e054bd4e959257c77d",
+      "slug": "two-fer",
+      "core": false,
+      "unlocked_by": "hello-world",
+      "difficulty": 1,
+      "topics": [
+        "Booleans",
+        "Strings",
+        "Logic",
+        "Optional values",
+        "Text formatting"
+      ]
+    },
     {
       "uuid": "d773c4ef-c09e-40e4-a7fe-01456cb4a12a",
       "slug": "hamming",
@@ -980,6 +994,22 @@
         "Exception handling"
       ]
     },
+    {
+      "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": "dbf26ef1-62ff-4cb1-8ac7-09b022df3b2f"
+    },
     {
       "uuid": "6a1eee0e-f8d4-446d-9c52-f31c3700af1b",
       "slug": "diamond",

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

@@ -0,0 +1,80 @@
+# Bowling
+
+Score a bowling game.
+
+Bowling is 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
+
+A game consists of 10 frames. A frame is composed of one or two balls thrown, with 10 pins standing at the start of the frame. 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 after the second throw.
+
+* A spare is where all ten pins are knocked down after the second throw. The total value of a spare is 10 plus the number of pins knocked down in the next throw.
+
+* A strike is where all ten pins are knocked down after 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 another strike, then the first strike's value cannot be totalled until the next throw.
+
+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 the player throws a strike or a spare, then they get one extra throw called 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.
+
+## Setup
+
+Go through the setup instructions for ECMAScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/ecmascript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ npm install
+```
+
+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.
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ npm test
+```
+
+In the test suites all tests but the first have been skipped.
+
+Once you get a test passing, you can enable the next one by
+changing `xtest` to `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/ecmascript/exercises/bowling/bowling.spec.js

@@ -0,0 +1,159 @@
+import Bowling from './bowling';
+
+describe('Bowling', () => {
+  describe('Check game can be scored correctly.', () => {
+    test('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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);
+    });
+
+    xtest('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.', () => {
+    xtest('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(); }).toThrow(
+        new Error('Pins must have a value from 0 to 10'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Pins must have a value from 0 to 10'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Pin count exceeds pins on the lane'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Pin count exceeds pins on the lane'),
+      );
+    });
+
+    xtest('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);
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Pin count exceeds pins on the lane'),
+      );
+    });
+
+    xtest('an unstarted game can not be scored', () => {
+      const rolls = [];
+      expect(() => { new Bowling(rolls).score(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'),
+      );
+    });
+
+    xtest('an incomplete game can not be scored', () => {
+      const rolls = [0, 0];
+      expect(() => { new Bowling(rolls).score(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Should not be able to roll after game is over'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'),
+      );
+    });
+
+    xtest('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(); }).toThrow(
+        new Error('Score cannot be taken until the end of the game'),
+      );
+    });
+  });
+});