trackler 2.2.1.115 → 2.2.1.116

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a973bc08e042be7c0a98c8daa57f0f81d5ff009c
-  data.tar.gz: f0ed6e91cf8aec9a4b45324e38f482cbf46e3c03
+  metadata.gz: 0aae28d0f054933886687244d59d5cac2b1e40e2
+  data.tar.gz: 224c04be34690e5137ab56043c4b023631dce533
 SHA512:
-  metadata.gz: 52b97d29dcfe66c8569302a2a89532164f00c37353749cb3181e6a99f88430fffae43afaf825f2e4a7399a2a437af37d1dd4e66046031bed5490e83a6a35a3b2
-  data.tar.gz: ebbb7a299f91d23a101d0a7b9a6794fac451addfc67a2e983916b5e54b641372aa5426290e6b4f92dbc9077cd62b2a39aae0b1f089650d25711d192cd3cb4b4c
+  metadata.gz: a93c8b0204daf3f7460f2af8f9ce338c46f93a0637eefe73b19b74c74a710c8b3bd407cf4678298bf81051aeb047ae8898ed1511fca6c6f7a73303f04c68a5a0
+  data.tar.gz: 21785aa9e8b63124a89b4535d889da17fc0b265cd2ac1b3ed98c561849f051035d0938bda4eac0224cb49d68b3c0eb877ccb7fb5ad191272ba49ee7ecdb491fc

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.115"
+  VERSION = "2.2.1.116"
 end

data/problem-specifications/exercises/yacht/canonical-data.json

@@ -0,0 +1,251 @@
+{
+    "exercise":"yacht",
+    "version":"1.0.0",
+    "comments":[
+        "The dice are represented always as a list of exactly five integers",
+        "with values between 1 and 6 inclusive. The category is an string.",
+        "the categories are 'ones' to 'sixes',",
+        "Then 'full house',",
+        "     'four of a kind'",
+        "     'little straight' 1-5",
+        "     'big straight' 2-6",
+        "     'choice', sometimes called Chance",
+        "     'yacht', or five of a kind"
+   ],
+    "cases":[
+        {
+            "description":"Yacht",
+            "property":"score",
+            "input":{
+                "dice":[5, 5, 5, 5, 5],
+                "category":"yacht"
+            },
+            "expected":50
+        },
+        {
+            "description":"Not Yacht",
+            "property":"score",
+            "input":{
+                "dice":[1, 3, 3, 2, 5],
+                "category":"yacht"
+            },
+            "expected":0
+        },
+        {
+            "description":"Ones",
+            "property":"score",
+            "input":{
+                "dice":[1, 1, 1, 3, 5],
+                "category":"ones"
+            },
+            "expected":3
+        },
+        {
+            "description":"Ones, out of order",
+            "property":"score",
+            "input":{
+                "dice":[3, 1, 1, 5, 1],
+                "category":"ones"
+            },
+            "expected":3
+        },
+        {
+            "description":"No ones",
+            "property":"score",
+            "input":{
+                "dice":[4, 3, 6, 5, 5],
+                "category":"ones"
+            },
+            "expected":0
+        },
+        {
+            "description":"Twos",
+            "property":"score",
+            "input":{
+                "dice":[2, 3, 4, 5, 6],
+                "category":"twos"
+            },
+            "expected":2
+        },
+        {
+            "description":"Fours",
+            "property":"score",
+            "input":{
+                "dice":[1, 4, 1, 4, 1],
+                "category":"fours"
+            },
+            "expected":8
+        },
+        {
+            "description":"Yacht counted as threes",
+            "property":"score",
+            "input":{
+                "dice":[3, 3, 3, 3, 3],
+                "category":"threes"
+            },
+            "expected":15
+        },
+        {
+            "description":"Yacht of 3s counted as fives",
+            "property":"score",
+            "input":{
+                "dice":[3, 3, 3, 3, 3],
+                "category":"fives"
+            },
+            "expected":0
+        },
+        {
+            "description":"Sixes",
+            "property":"score",
+            "input":{
+                "dice":[2, 3, 4, 5 ,6],
+                "category":"sixes"
+            },
+            "expected":6
+        },
+        {
+            "description":"Full house two small, three big",
+            "property":"score",
+            "input":{
+                "dice":[2, 2, 4, 4, 4],
+                "category":"full house"
+            },
+            "expected":16
+        },
+        {
+            "description":"Full house three small, two big",
+            "property":"score",
+            "input":{
+                "dice":[5, 3, 3, 5, 3],
+                "category":"full house"
+            },
+            "expected":19
+        },
+        {
+            "description":"Two pair is not a full house",
+            "property":"score",
+            "input":{
+                "dice":[2, 2, 4, 4, 5],
+                "category":"full house"
+            },
+            "expected":0
+        },
+        {
+            "description":"Yacht is not a full house",
+            "property":"score",
+            "input":{
+                "dice":[2, 2, 2, 2, 2],
+                "category":"full house"
+            },
+            "expected":0
+        },
+        {
+            "description":"Four of a Kind",
+            "property":"score",
+            "input":{
+                "dice":[6, 6, 4, 6, 6],
+                "category":"four of a kind"
+            },
+            "expected":24
+        },
+        {
+            "description":"Yacht can be scored as Four of a Kind",
+            "property":"score",
+            "input":{
+                "dice":[3, 3, 3, 3, 3],
+                "category":"four of a kind"
+            },
+            "expected":12
+        },
+        {
+            "description":"Full house is not Four of a Kind",
+            "property":"score",
+            "input":{
+                "dice":[3, 3, 3, 5, 5],
+                "category":"four of a kind"
+            },
+            "expected":0
+        },
+        {
+            "description":"Little Straight",
+            "property":"score",
+            "input":{
+                "dice":[3, 5, 4, 1, 2],
+                "category":"little straight"
+            },
+            "expected":30
+        },
+        {
+            "description":"Little Straight as Big Straight",
+            "property":"score",
+            "input":{
+                "dice":[1, 2, 3, 4, 5],
+                "category":"big straight"
+            },
+            "expected":0
+        },
+        {
+            "description":"Four in order but not a little straight",
+            "property":"score",
+            "input":{
+                "dice":[1, 1, 2, 3, 4],
+                "category":"little straight"
+            },
+            "expected":0
+        },
+        {
+            "description":"No pairs but not a little straight",
+            "property":"score",
+            "input":{
+                "dice":[1, 2, 3, 4, 6],
+                "category":"little straight"
+            },
+            "expected":0
+        },
+        {
+            "description":"Minimum is 1, maximum is 5, but not a little straight",
+            "property":"score",
+            "input":{
+                "dice":[1, 1, 3, 4, 5],
+                "category":"little straight"
+            },
+            "expected":0
+        },
+        {
+            "description":"Big Straight",
+            "property":"score",
+            "input":{
+                "dice":[4, 6, 2, 5, 3],
+                "category":"big straight"
+            },
+            "expected":30
+        },
+        {
+            "description":"Big Straight as little straight",
+            "property":"score",
+            "input":{
+                "dice":[6, 5, 4, 3, 2],
+                "category":"little straight"
+            },
+            "expected":0
+        },
+        {
+            "description":"Choice",
+            "property":"score",
+            "input":{
+                "dice":[3, 3, 5, 6, 6],
+                "category":"choice"
+            },
+            "expected":23
+        },
+        {
+            "description":"Yacht as choice",
+            "property":"score",
+            "input":{
+                "dice":[2, 2, 2, 2, 2],
+                "category":"choice"
+            },
+            "expected":10
+        }
+    ]
+}

data/problem-specifications/exercises/yacht/description.md

@@ -0,0 +1,34 @@
+# Score a single throw of dice in *Yacht*
+
+The dice game [Yacht](https://en.wikipedia.org/wiki/Yacht_(dice_game)) is from
+the same family as Poker Dice, Generala and particularly Yahtzee, of which it
+is a precursor. In the game, five dice are rolled and the result can be entered
+in any of twelve categories. The score of a throw of the dice depends on
+category chosen.
+
+## Scores in Yacht
+
+    Category    Score                   Example
+    Ones            1 × number of ones      1 1 1 4 5 scores 3
+    Twos            2 × number of twos      2 2 3 4 5 scores 4
+    Threes          3 × number of threes    3 3 3 3 3 scores 15
+    Fours           4 × number of fours     1 2 3 3 5 scores 0
+    Fives           5 × number of fives     5 1 5 2 5 scores 15
+    Sixes           6 × number of sixes     2 3 4 5 6 scores 6
+    Full House      Total of the dice       3 3 3 5 5 scores 19
+    Four of a Kind  Total of the four dice  4 4 4 4 6 scores 16
+    Little Straight 30 points               1 2 3 4 5 scores 30 
+    Big Straight    30 points               2 3 4 5 6 scores 30
+    Choice          Sum of the dice         2 3 3 4 6 scores 18
+    Yacht           50 points               4 4 4 4 4 scores 50
+
+If the dice do not satisfy the requirements of a category, the score is zero.
+If, for example, *Four Of A Kind* is entered in the *Yacht* category, zero
+points are scored. A *Yacht* scores zero if entered in the *Full House* category.
+
+## Task 
+Given a list of values for five dice and a category, your solution should return
+the score of the dice for that category. If the dice do not satisfy the requirements
+of the category your solution should return 0. You can assume that five values
+will always be presented, and the value of each will be between one and six
+inclusively. You should not assume that the dice are ordered.

data/problem-specifications/exercises/yacht/metadata.yml

@@ -0,0 +1,5 @@
+---
+blurb: "Score a single throw of dice in the game Yacht"
+source: "James Kilfiger, using wikipedia"
+source_url: "https://en.wikipedia.org/wiki/Yacht_(dice_game)"
+

data/tracks/c/docs/C_STYLE_GUIDE.md

@@ -118,10 +118,7 @@ Like most C source files, a test file begins with includes.
 // any other includes here
 ```
 
-The includes are then followed by any helper functions that are used by the test functions.
-The names of such helper functions should not use the `test_` prefix.
-
-Next, there are the `setUp()` and `tearDown()` functions. 
+The includes are then followed by the `setUp()` and `tearDown()` functions. 
 So far, no exercise uses these (the function bodies are empty) yet they must remain in place to allow the test files to compile correctly across all platforms.
 
 ```c
@@ -134,6 +131,9 @@ void tearDown(void)
 }
 ```
 
+Next are any helper functions that are used by the test functions.
+The names of such helper functions should not use the `test_` prefix.
+
 Next are the test functions themselves. 
 The names of these functions use a `test_` prefix.
 Excepting the first, each test function should have `TEST_IGNORE();` as its first statement. 

data/tracks/csharp/config.json

@@ -923,7 +923,7 @@
         "algorithms",
         "matrices"
       ],
-      "unlocked_by": "matrix",
+      "unlocked_by": "kindergarten-garden",
       "uuid": "bae1f3a4-b63d-4efd-921a-133b3d5e379c"
     },
     {

data/tracks/dart/.travis.yml

@@ -13,9 +13,7 @@ cache:
     - $HOME/.pub-cache
 
 before_script:
-  - bin/check_formatting
+  - pub run bin/check_formatting.dart
 
 script:
-  - bin/fetch-configlet
-  - bin/configlet lint .
-  - pub run test test/
+  - pub run bin/presubmit.dart

data/tracks/dart/CONTRIBUTING.md

@@ -31,12 +31,8 @@ Please keep the following in mind:
     * Sensitive information (email address, real names, etc)
 
 - Please run the following commands before submitting your PR:
-    * `pub run test` - All the tests for Dart exercises can be run from the top level of the repo with this command
-    * `bin/fetch-configlet` - Downloads the latest version of configlet and stores it in the bin/ directory
-    * `bin/configlet lint --track-id dart .` - Checks the config.json for formatting issues
-    * `bin/configlet fmt .` - Formats the config.json
-    * `bin/check_formatting` - Checks All the Dart files for formatting issues
-    * `pub run dart_style:format -l 120 -w .` - Formats all the Dart files
+    * `pub run bin/check_formatting.dart` - Checks the config.json and all Dart files for formatting issues
+    * `pub run bin/presubmit.dart` - Runs the test for Dart exercises, and formats config.json and all Dart files
 
 - Once a Pull Request is approved, the contributing branch will be rebased onto the latest version of our master branch.
 

data/tracks/dart/bin/check_formatting.dart

@@ -0,0 +1,17 @@
+import 'dart:async';
+import 'package:exercism_dart/src/utils.dart';
+
+Future<Null> main() async {
+  final CommonUtils utils = new CommonUtils();
+
+  if (utils.fetchConfiglet() == 0) {
+    print('Checking config.json formatting...');
+    await utils.runCmdIfExecutable('bin/configlet', ['lint', '--track-id', 'dart', '.']);
+  }
+
+  print('Checking all Dart files formatting...');
+  await utils.runCmd('pub', ['run', 'dart_style:format', '-l', '120', '-n', '.']);
+
+  await utils.terminate();
+  print('Done!');
+}

data/tracks/dart/bin/presubmit.dart

@@ -0,0 +1,20 @@
+import 'dart:async';
+import 'package:exercism_dart/src/utils.dart';
+
+Future<Null> main() async {
+  final CommonUtils utils = new CommonUtils();
+
+  if (utils.fetchConfiglet() == 0) {
+    print('Formatting config.json...');
+    await utils.runCmdIfExecutable('bin/configlet', ['fmt', '.']);
+  }
+
+  print('Formatting all Dart files...');
+  await utils.runCmd('pub', ['run', 'dart_style:format', '-l', '120', '-w', '.']);
+
+  print('Running tests...');
+  await utils.runCmd('pub', ['run', 'test']);
+
+  await utils.terminate();
+  print('Done!');
+}

data/tracks/dart/config.json

@@ -142,4 +142,4 @@
   "foregone": [],
   "language": "Dart",
   "test_pattern": "_test\\.dart$"
-}
+}

data/tracks/dart/exercises/hamming/lib/example.dart

@@ -1,5 +1,5 @@
 class Hamming {
-  int compute(String a, String b) {
+  int distance(String a, String b) {
     if (a.length != b.length) {
       throw new ArgumentError("DNA strands must be of equal length.");
     }

data/tracks/dart/exercises/hamming/test/hamming_test.dart

@@ -1,71 +1,84 @@
-import "package:test/test.dart";
-import "package:hamming/hamming.dart";
+import 'package:test/test.dart';
+import 'package:hamming/hamming.dart';
 
 /// Test cases match one-to-one with those described
 /// in the problem specification found here:
 /// https://github.com/exercism/problem-specifications/blob/master/exercises/hamming/canonical-data.json
 void main() {
-  final hamming = new Hamming();
+  final Hamming hamming = new Hamming();
 
-  group("Hamming", () {
+  group('Hamming', () {
     test("empty strands", () {
-      expect(hamming.compute("", ""), equals(0));
-    });
+      final int result = hamming.distance("", "");
+      expect(result, equals(0));
+    }, skip: false);
 
     test("identical strands", () {
-      expect(hamming.compute("A", "A"), equals(0));
+      final int result = hamming.distance("A", "A");
+      expect(result, equals(0));
     }, skip: true);
 
     test("long identical strands", () {
-      expect(hamming.compute("GGACTGA", "GGACTGA"), equals(0));
+      final int result = hamming.distance("GGACTGA", "GGACTGA");
+      expect(result, equals(0));
     }, skip: true);
 
     test("complete distance in single nucleotide strands", () {
-      expect(hamming.compute("A", "G"), equals(1));
+      final int result = hamming.distance("A", "G");
+      expect(result, equals(1));
     }, skip: true);
 
     test("complete distance in small strands", () {
-      expect(hamming.compute("AG", "CT"), equals(2));
+      final int result = hamming.distance("AG", "CT");
+      expect(result, equals(2));
     }, skip: true);
 
     test("small distance in small strands", () {
-      expect(hamming.compute("AT", "CT"), equals(1));
+      final int result = hamming.distance("AT", "CT");
+      expect(result, equals(1));
     }, skip: true);
 
     test("small distance", () {
-      expect(hamming.compute("GGACG", "GGTCG"), equals(1));
+      final int result = hamming.distance("GGACG", "GGTCG");
+      expect(result, equals(1));
     }, skip: true);
 
     test("small distance in long strands", () {
-      expect(hamming.compute("ACCAGGG", "ACTATGG"), equals(2));
+      final int result = hamming.distance("ACCAGGG", "ACTATGG");
+      expect(result, equals(2));
     }, skip: true);
 
     test("non-unique character in first strand", () {
-      expect(hamming.compute("AAG", "AAA"), equals(1));
+      final int result = hamming.distance("AAG", "AAA");
+      expect(result, equals(1));
     }, skip: true);
 
     test("non-unique character in second strand", () {
-      expect(hamming.compute("AAA", "AAG"), equals(1));
+      final int result = hamming.distance("AAA", "AAG");
+      expect(result, equals(1));
     }, skip: true);
 
     test("same nucleotides in different positions", () {
-      expect(hamming.compute("TAG", "GAT"), equals(2));
+      final int result = hamming.distance("TAG", "GAT");
+      expect(result, equals(2));
     }, skip: true);
 
     test("large distance", () {
-      expect(hamming.compute("GATACA", "GCATAA"), equals(4));
+      final int result = hamming.distance("GATACA", "GCATAA");
+      expect(result, equals(4));
     }, skip: true);
 
     test("large distance in off-by-one strand", () {
-      expect(hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), equals(9));
+      final int result = hamming.distance("GGACGGATTCTG", "AGGACGGATTCT");
+      expect(result, equals(9));
     }, skip: true);
 
     test("disallow first strand longer", () {
-      expect(() => hamming.compute("AATG", "AAA"), throwsArgumentError);
+      expect(() => hamming.distance("AATG", "AAA"), throwsArgumentError);
     }, skip: true);
 
     test("disallow second strand longer", () {
-      expect(() => hamming.compute("ATA", "AGTG"), throwsArgumentError);
+      expect(() => hamming.distance("ATA", "AGTG"), throwsArgumentError);
     }, skip: true);
   });
 }