trackler 2.2.1.68 → 2.2.1.69

data/tracks/python/exercises/proverb/proverb_test.py

@@ -3,59 +3,49 @@ import unittest
 from proverb import proverb
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class ProverbTest(unittest.TestCase):
-    def test_a_single_consequence(self):
-        expected = 'For want of a nail the shoe was lost.\n'\
-                   'And all for the want of a nail.'
-        self.assertEqual(proverb(['nail', 'shoe']), expected)
-
-    def test_short_list(self):
-        expected = 'For want of a nail the shoe was lost.\n'\
-                   'For want of a shoe the horse was lost.\n'\
-                   'And all for the want of a nail.'
-        self.assertEqual(proverb(['nail', 'shoe', 'horse']), expected)
-
-    def test_long_list(self):
-        expected = 'For want of a nail the shoe was lost.\n'\
-                   'For want of a shoe the horse was lost.\n'\
-                   'For want of a horse the rider was lost.\n'\
-                   'And all for the want of a nail.'
-        self.assertEqual(proverb(['nail', 'shoe', 'horse', 'rider']), expected)
-
-    def test_new_itens(self):
-        expected = 'For want of a key the value was lost.\n'\
-                   'And all for the want of a key.'
-        self.assertEqual(proverb(['key', 'value']), expected)
-
-    def test_whole_proverb(self):
-        expected = 'For want of a nail the shoe was lost.\n'\
-                   'For want of a shoe the horse was lost.\n'\
-                   'For want of a horse the rider was lost.\n'\
-                   'For want of a rider the message was lost.\n'\
-                   'For want of a message the battle was lost.\n'\
-                   'For want of a battle the kingdom was lost.\n'\
-                   'And all for the want of a nail.'
-        self.assertEqual(
-            proverb([
-                'nail', 'shoe', 'horse', 'rider', 'message', 'battle',
-                'kingdom'
-            ]), expected)
-
-    def test_qualifier(self):
-        expected = 'For want of a nail the shoe was lost.\n'\
-                   'For want of a shoe the horse was lost.\n'\
-                   'For want of a horse the rider was lost.\n'\
-                   'For want of a rider the message was lost.\n'\
-                   'For want of a message the battle was lost.\n'\
-                   'For want of a battle the kingdom was lost.\n'\
-                   'And all for the want of a horseshoe nail.'
-        self.assertEqual(
-            proverb(
-                [
-                    'nail', 'shoe', 'horse', 'rider', 'message', 'battle',
-                    'kingdom'
-                ],
-                qualifier='horseshoe'), expected)
+    def test_zero_pieces(self):
+        self.assertEqual(proverb([]), "")
+
+    def test_one_piece(self):
+        inputs = ["nail"]
+        expected = "And all for the want of a nail."
+        self.assertEqual(proverb(inputs), expected)
+
+    def test_two_pieces(self):
+        inputs = ["nail", "shoe"]
+        expected = "\n".join(["For want of a nail the shoe was lost.",
+                              "And all for the want of a nail."])
+        self.assertEqual(proverb(inputs), expected)
+
+    def test_three_pieces(self):
+        inputs = ["nail", "shoe", "horse"]
+        expected = "\n".join(["For want of a nail the shoe was lost.",
+                              "For want of a shoe the horse was lost.",
+                              "And all for the want of a nail."])
+        self.assertEqual(proverb(inputs), expected)
+
+    def test_full_proverb(self):
+        inputs = ["nail", "shoe", "horse", "rider",
+                  "message", "battle", "kingdom"]
+        expected = "\n".join(["For want of a nail the shoe was lost.",
+                              "For want of a shoe the horse was lost.",
+                              "For want of a horse the rider was lost.",
+                              "For want of a rider the message was lost.",
+                              "For want of a message the battle was lost.",
+                              "For want of a battle the kingdom was lost.",
+                              "And all for the want of a nail."])
+        self.assertEqual(proverb(inputs), expected)
+
+    def test_four_pieces_modernised(self):
+        inputs = ["pin", "gun", "soldier", "battle"]
+        expected = "\n".join(["For want of a pin the gun was lost.",
+                              "For want of a gun the soldier was lost.",
+                              "For want of a soldier the battle was lost.",
+                              "And all for the want of a pin."])
+        self.assertEqual(proverb(inputs), expected)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/say/example.py

@@ -10,9 +10,9 @@ def say(number, recursive=False):
     k, m, b, t = 1e3, 1e6, 1e9, 1e12
 
     if number < 0:
-        raise AttributeError('number is negative')
+        raise ValueError('number is negative')
     if number >= t:
-        raise AttributeError('number is too large: %s' % str(number))
+        raise ValueError('number is too large: %s' % str(number))
 
     if number < 20:
         return small[number] if not recursive else 'and ' + small[number]

data/tracks/python/exercises/say/say_test.py

@@ -64,11 +64,11 @@ class SayTest(unittest.TestCase):
                                 "one hundred and twenty-three"))
 
     def test_number_to_large(self):
-        with self.assertRaises(AttributeError):
+        with self.assertRaises(ValueError):
             say(1e12)
 
     def test_number_negative(self):
-        with self.assertRaises(AttributeError):
+        with self.assertRaises(ValueError):
             say(-1)
 
 

data/tracks/rust/README.md

@@ -96,6 +96,8 @@ Note that:
 
 - If the test suite is appreciably sped up by running in release mode, and there is reason to be confident that the example implementation does not contain any overflow errors, consider adding a file `.meta/test-in-release-mode`. This should contain brief comments explaining the situation.
 
+- If your exercise implements macro-based testing (see [#392](https://github.com/exercism/rust/issues/392#issuecomment-343865993) and [`perfect-numbers.rs`](https://github.com/exercism/rust/blob/master/exercises/perfect-numbers/tests/perfect-numbers.rs)), you will likely run afoul of a CI check which counts the `#[ignore]` lines and compares the result to the number of `#[test]` lines. To fix this, add a file `.meta/ignore-count-ignores` to disable that check for your exercise.
+
 - `README.md` may be [regenerated](https://github.com/exercism/docs/blob/master/maintaining-a-track/regenerating-exercise-readmes.md) from Exercism data. The generator will use the `description.md` from the exercise directory in the [problem-specifications repository](https://github.com/exercism/problem-specifications/tree/master/exercises), then any hints in `.meta/hints.md`, then the [Rust-specific instructions](https://github.com/exercism/rust/blob/master/config/exercise-readme-insert.md). The `## Source` section comes from the `metadata.yml` in the same directory.  Convention is that the description of the source remains text and the link is both name and hyperlink of the markdown link.
 
 - Be sure to add the exercise to an appropriate place in the `config.json` file.  The position in the file determines the order exercises are sent.   Generate a unique UUID for the exercise.  Current difficuly levels in use are 1, 4, 7 and 10.

data/tracks/rust/_test/count-ignores.sh

@@ -3,14 +3,21 @@
 repo=$(cd "$(dirname "$0")/.." && pwd)
 exitcode=0
 
-for t in $repo/exercises/*/tests/*.rs; do
-  tests=$(grep "^\s*\#\[test\]" $t | wc -l | tr -d '[:space:]')
-  ignores=$(grep "^\s*\#\[ignore\]" $t | wc -l | tr -d '[:space:]')
-  want_ignores=$(expr $tests - 1)
-  if [ "$ignores" != "$want_ignores" ]; then
-    echo "\033[1;31m$t: Has $tests tests and $ignores ignores (should be $want_ignores)\033[0m"
-    exitcode=1
-  fi
+for e in $repo/exercises/*; do
+   if [ -f "$e/.meta/ignore-count-ignores" ]; then
+      continue
+   fi
+   if [ -d "$e/tests" ]; then
+      for t in $e/tests/*.rs; do
+        tests=$(grep "^\s*\#\[test\]" $t | wc -l | tr -d '[:space:]')
+        ignores=$(grep "^\s*\#\[ignore\]" $t | wc -l | tr -d '[:space:]')
+        want_ignores=$(expr $tests - 1)
+        if [ "$ignores" != "$want_ignores" ]; then
+          echo "\033[1;31m$t: Has $tests tests and $ignores ignores (should be $want_ignores)\033[0m"
+          exitcode=1
+        fi
+      done
+   fi
 done
 
 exit $exitcode

data/tracks/rust/bin/test-exercise

@@ -72,7 +72,10 @@ fi
 
 # eliminate #[ignore] lines from tests
 for test in "$exercise/tests/*.rs"; do
-    sed -i '/\[ignore\]/d' $test
+   sed -i -e '/#\[ignore\]/{
+      s/#\[ignore\]\s*//
+      /^\s*$/d
+   }' $test
 done
 
 # run tests from within exercise directory

data/tracks/rust/exercises/perfect-numbers/.meta/ignore-count-ignores

@@ -0,0 +1,6 @@
+Perfect numbers has tests generated by macro.
+This breaks the count-ignores.sh script:
+
+```text
+exercises/perfect-numbers/tests/perfect-numbers.rs: Has 2 tests and 11 ignores (should be 1)
+```

data/tracks/rust/exercises/perfect-numbers/tests/perfect-numbers.rs

@@ -2,32 +2,42 @@ extern crate perfect_numbers;
 
 use perfect_numbers::{Classification, classify};
 
+macro_rules! tests {
+    ($property_test_func:ident {
+        $( $(#[$attr:meta])* $test_name:ident( $( $param:expr ),* ); )+
+    }) => {
+        $(
+            $(#[$attr])*
+            #[test]
+            fn $test_name() {
+                $property_test_func($( $param ),* )
+            }
+        )+
+    }
+}
+
+fn test_classification(num: u64, result: Classification) {
+    assert_eq!(classify(num), Ok(result));
+}
+
 #[test]
 fn basic() {
     assert_eq!(classify(0), Err("Number must be positive"));
 }
 
-#[test]
-#[ignore]
-fn test_all() {
-    struct TestClassification {
-        num: u64,
-        result: perfect_numbers::Classification
-    }
-    let test_table: Vec<TestClassification> = vec![
-        TestClassification { num: 6, result: Classification::Perfect },
-        TestClassification { num: 28, result: Classification::Perfect },
-        TestClassification { num: 33550336, result: Classification::Perfect },
-        TestClassification { num: 12, result: Classification::Abundant },
-        TestClassification { num: 30, result: Classification::Abundant },
-        TestClassification { num: 33550335, result: Classification::Abundant },
-        TestClassification { num: 2, result: Classification::Deficient },
-        TestClassification { num: 4, result: Classification::Deficient },
-        TestClassification { num: 32, result: Classification::Deficient },
-        TestClassification { num: 33550337, result: Classification::Deficient },
-        TestClassification { num: 1, result: Classification::Deficient },
-    ];
-    for t in test_table {
-        assert_eq!(classify(t.num), Ok(t.result));
+
+tests! {
+    test_classification {
+        #[ignore] test_1(1, Classification::Deficient);
+        #[ignore] test_2(2, Classification::Deficient);
+        #[ignore] test_4(4, Classification::Deficient);
+        #[ignore] test_6(6, Classification::Perfect);
+        #[ignore] test_12(12, Classification::Abundant);
+        #[ignore] test_28(28, Classification::Perfect);
+        #[ignore] test_30(30, Classification::Abundant);
+        #[ignore] test_32(32, Classification::Deficient);
+        #[ignore] test_33550335(33550335, Classification::Abundant);
+        #[ignore] test_33550336(33550336, Classification::Perfect);
+        #[ignore] test_33550337(33550337, Classification::Deficient);
     }
 }

data/tracks/typescript/config.json

@@ -525,6 +525,22 @@
         "Exception handling",
         "Text formatting"
       ]
+    },
+    {
+        "uuid": "7dd29a19-08f6-8480-2e01-1f7262d8860a",
+        "slug": "two-bucket",
+        "core": false,
+        "unlocked_by": "pangram",
+        "difficulty": 6,
+        "topics": [
+            "algorithms",
+            "arrays",
+            "control-flow-(conditionals)",
+            "control-flow-(loops)",
+            "exception-handling",
+            "games",
+            "parsing"
+        ]
     }
   ],
   "foregone": [],

data/tracks/typescript/exercises/two-bucket/README.md

@@ -0,0 +1,66 @@
+# Two Bucket
+
+Given two buckets of different size, demonstrate how to measure an exact number of liters by strategically transferring liters of fluid between the buckets.
+
+Since this mathematical problem is fairly subject to interpretation / individual approach, the tests have been written specifically to expect one overarching solution.
+
+To help, the tests provide you with which bucket to fill first. That means, when starting with the larger bucket full, you are NOT allowed at any point to have the smaller bucket full and the larger bucket empty (aka, the opposite starting point); that would defeat the purpose of comparing both approaches! 
+
+Your program will take as input:
+- the size of bucket one, passed as a numeric value
+- the size of bucket two, passed as a numeric value
+- the desired number of liters to reach, passed as a numeric value
+- which bucket to fill first, passed as a String (either 'one' or 'two')
+
+Your program should determine:
+- the total number of "moves" it should take to reach the desired number of liters, including the first fill - expects a numeric value
+- which bucket should end up with the desired number of liters (let's say this is bucket A) - expects a String (either 'one' or 'two')
+- how many liters are left in the other bucket (bucket B) - expects a numeric value
+
+Note: any time a change is made to either or both buckets counts as one (1) move. 
+
+Example: 
+Bucket one can hold up to 7 liters, and bucket two can hold up to 11 liters. Let's say bucket one, at a given step, is holding 7 liters, and bucket two is holding 8 liters (7,8). If you empty bucket one and make no change to bucket two, leaving you with 0 liters and 8 liters respectively (0,8), that counts as one "move". Instead, if you had poured from bucket one into bucket two until bucket two was full, leaving you with 4 liters in bucket one and 11 liters in bucket two (4,11), that would count as only one "move" as well.
+
+To conclude, the only valid moves are:
+- pouring from one bucket to another
+- emptying one bucket and doing nothing to the other
+- filling one bucket and doing nothing to the other
+
+Referenced with <3 by VestigeJ most of the work was done by [Lindsay](http://lindsaylevine.com).
+
+## Setup
+
+Go through the setup instructions for Typescript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ npm install
+```
+
+## 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
+
+Water Pouring Problem [http://demonstrations.wolfram.com/WaterPouringProblem/](http://demonstrations.wolfram.com/WaterPouringProblem/)
+
+## 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/two-bucket/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^21.1.5",
+    "@types/node": "^8.0.47",
+    "jest": "^21.2.1",
+    "ts-jest": "^21.1.3",
+    "tslint": "^5.8.0",
+    "typescript": "^2.5.3"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

data/tracks/typescript/exercises/two-bucket/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": { 
+        "target": "es2017",
+        "module": "commonjs",
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "preserveConstEnums": true,
+        "noFallthroughCasesInSwitch":true,
+        "noImplicitThis":true,
+        "noImplicitReturns":true,
+        "sourceMap": true,
+        "noEmitOnError": true,
+        "outDir": "./build"
+    },
+    "compileOnSave": true, 
+    "exclude": [
+        "node_modules"
+    ]
+}

data/tracks/typescript/exercises/two-bucket/tslint.json

@@ -0,0 +1,127 @@
+{
+    "jsRules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            false,
+            "double"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    },
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ],
+        "no-namespace": true, 
+        "prefer-for-of": true,
+        "only-arrow-functions": [true, "allow-declarations"],
+        "no-var-requires": true,
+        "no-any": true,
+        "curly": true,
+        "forin": true,
+        "no-arg": true,
+        "label-position": true,
+        "no-conditional-assignment": true,
+        "no-console": [true, "log", "error"],
+        "no-construct": true,
+        "no-duplicate-variable": true,
+        "no-empty": true,
+        "no-invalid-this": [true, "check-function-in-method"],
+        "no-misused-new": true,
+        "no-null-keyword": true,
+        "no-string-literal": true,
+        "radix": true,
+        "typeof-compare": true,
+        "use-isnan": true,
+        "prefer-const": true,
+        "array-type": [true, "array-simple"],
+        "arrow-parens": true,
+        "new-parens": true,
+        "no-consecutive-blank-lines": [true,1],
+        "no-parameter-properties": true,
+        "no-unnecessary-initializer": true,
+        "object-literal-shorthand": true,
+        "object-literal-key-quotes": [true, "as-needed"]
+    }
+}

data/tracks/typescript/exercises/two-bucket/two-bucket.example.ts

@@ -0,0 +1,97 @@
+
+export enum Bucket {
+  One = "one",
+  Two = "two"
+}
+
+export class TwoBucket {
+    starter: Bucket
+    x: number
+    y: number
+    z: number
+    goalBucket: Bucket
+    otherBucket: number
+
+    constructor(x: number, y: number, z: number, starter: Bucket) {
+      this.starter = starter
+      this.x = x
+      this.y = y
+      this.z = z
+    }
+    reachedGoal(measurements: number[]): boolean {
+      if (measurements[0] === this.z || measurements[1] === this.z) {
+        if (measurements[0] === this.z) {
+          this.goalBucket = Bucket.One
+          this.otherBucket = measurements[1]
+        } else {
+          this.goalBucket = Bucket.Two
+          this.otherBucket = measurements[0]
+        }
+        return true
+      }
+      return false
+    }
+    bigFirst(measurements: number[], moveCount: number, prBool: boolean): number {
+      let j = measurements[0],
+        k = measurements[1]
+      while (!this.reachedGoal(measurements)) {
+        if (k > this.x && j === 0 && moveCount === 0) {
+          j = this.x
+          k = this.y - j
+        } else if (j === this.x) {
+          j = 0
+        } else if (k > this.x && j !== 0 || k > this.x && prBool) {
+          k -= (this.x - j)
+          j = this.x
+        } else if (k > this.x || j === 0) {
+          j = k
+          k -= j
+        } else if (k === 0) {
+          k = this.y
+        }
+        measurements = [j, k]
+        moveCount++
+        prBool = !prBool
+      }
+      return moveCount
+    }
+    smallFirst(measurements: number[], moveCount: number, prBool: boolean): number {
+      let j = measurements[0],
+        k = measurements[1]
+      while (!this.reachedGoal(measurements)) {
+        if (j === this.x && moveCount === 0) {
+          j = 0
+          k = this.x
+        } else if (j === 0) {
+          j = this.x
+        } else if (j === this.x && k < this.y) {
+          const tempK = k
+          k + j > this.y ? k = this.y : k = tempK + j
+          tempK + j > this.y ? j -= (this.y - tempK) : j = 0
+        } else if (k === this.y) {
+          k = 0
+        } else if (k === 0 && j < this.x) {
+          k = j
+          j = 0
+        }
+        measurements = [j, k]
+        moveCount++
+        prBool = !prBool
+      }
+      return moveCount
+    }
+    moves() {
+      let j = 0,
+        k = 0 // j will be running val of bucket one, k = running val of bucket two
+      this.starter === Bucket.One ? j = this.x : k = this.y
+      const measurements = [j, k]
+      let moveCount = 0
+      const prBool = true // pour / receive boolean - need to pour or receive every other turn
+      if (this.starter === Bucket.One) {
+        moveCount = this.smallFirst(measurements, moveCount, prBool)
+      } else {
+        moveCount = this.bigFirst(measurements, moveCount, prBool)
+      }
+      return moveCount + 1 // accounts for first move made before loop (and moveCount starts at zero before loop)
+    }
+  }