trackler 2.2.1.45 → 2.2.1.46

data/tracks/dart/exercises/anagram/README.md

@@ -6,6 +6,16 @@ Given `"listen"` and a list of candidates like `"enlists" "google"
 "inlets" "banana"` the program should return a list containing
 `"inlets"`.
 
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 Inspired by the Extreme Startup game [https://github.com/rchatley/extreme_startup](https://github.com/rchatley/extreme_startup)

data/tracks/dart/exercises/bob/README.md

@@ -10,6 +10,17 @@ He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 
 He answers 'Whatever.' to anything else.
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)

data/tracks/dart/exercises/difference-of-squares/README.md

@@ -11,6 +11,17 @@ The sum of the squares of the first ten natural numbers is
 Hence the difference between the square of the sum of the first
 ten natural numbers and the sum of the squares of the first ten
 natural numbers is 3025 - 385 = 2640.
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 Problem 6 at Project Euler [http://projecteuler.net/problem=6](http://projecteuler.net/problem=6)

data/tracks/dart/exercises/gigasecond/README.md

@@ -3,6 +3,17 @@
 Calculate the moment when someone has lived for 10^9 seconds.
 
 A gigasecond is 10^9 (1,000,000,000) seconds.
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 Chapter 9 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=09](http://pine.fm/LearnToProgram/?Chapter=09)

data/tracks/dart/exercises/gigasecond/test/gigasecond_test.dart

@@ -1,39 +1,62 @@
 import "package:test/test.dart";
 import "package:gigasecond/gigasecond.dart";
 
+DateTime birthDate;
+DateTime expectedDate;
+Gigasecond gigasecond;
+
 void main() {
-  group("Gigasecond", () {
-    test("tells a gigasecond anniversary since midnight", () {
-      final birthDate = new DateTime.utc(2015, DateTime.SEPTEMBER, 14);
-      final expectedDate = new DateTime.utc(2047, DateTime.MAY, 23, 1, 46, 40);
-      final gigasecond = new Gigasecond(birthDate);
-
-      expect(gigasecond.date(), equals(expectedDate));
-    });
-
-    test("tells the anniversary is next day when you are born at night", () {
-      final birthDate = new DateTime.utc(2015, DateTime.SEPTEMBER, 14, 23, 59, 59);
-      final expectedDate = new DateTime.utc(2047, DateTime.MAY, 24, 1, 46, 39);
-      final gigasecond = new Gigasecond(birthDate);
-
-      expect(gigasecond.date(), equals(expectedDate));
-    }, skip: true);
-
-    test("even works before 1970 (beginning of Unix epoch)", () {
-      final birthDate = new DateTime.utc(1959, DateTime.JULY, 19, 5, 13, 45);
-      final expectedDate = new DateTime.utc(1991, DateTime.MARCH, 27, 7, 0, 25);
-      final gigasecond = new Gigasecond(birthDate);
-
-      expect(gigasecond.date(), equals(expectedDate));
-    }, skip: true);
-
-    test("make sure calling \"date\" doesn\"t mutate value", () {
-      final birthDate = new DateTime.utc(1959, DateTime.JULY, 19, 5, 13, 45);
-      final expectedDate = new DateTime.utc(1991, DateTime.MARCH, 27, 7, 0, 25);
-      final gigasecond = new Gigasecond(birthDate);
-
-      gigasecond.date();
-      expect(gigasecond.date(), equals(expectedDate));
-    }, skip: true);
+  group("Gigasecond", gigasecondTests);
+}
+
+void gigasecondTests() {
+  // The setUp() function is used to share code between tests. It is executed
+  // before every test in a group or test suite.
+  setUp(() {
+    birthDate = new DateTime.utc(2015, DateTime.SEPTEMBER, 14);
+  });
+
+  group("since midnight tests", sinceMidnightTests);
+  group("at night tests", atNightTests);
+  group("unixEpoch tests", unixEpochTests);
+}
+
+void sinceMidnightTests() {
+  setUp(() {
+    gigasecond = new Gigasecond(birthDate);
+    expectedDate = new DateTime.utc(2047, DateTime.MAY, 23, 1, 46, 40);
+  });
+
+  test("tells a gigasecond anniversary since midnight", () {
+    expect(gigasecond.date(), equals(expectedDate));
+  });
+
+  test("make sure calling \"date()\" doesn't mutate value", () {
+    gigasecond.date();
+    expect(gigasecond.date(), equals(expectedDate));
+  });
+}
+
+void atNightTests() {
+  setUp(() {
+    birthDate = birthDate.add(new Duration(hours: 23, minutes: 59, seconds: 59));
+    gigasecond = new Gigasecond(birthDate);
+    expectedDate = new DateTime.utc(2047, DateTime.MAY, 24, 1, 46, 39);
+  });
+
+  test("tells the anniversary is next day when you are born at night", () {
+    expect(gigasecond.date(), equals(expectedDate));
+  });
+}
+
+void unixEpochTests() {
+  setUp(() {
+    birthDate = new DateTime.utc(1959, DateTime.JULY, 19, 5, 13, 45);
+    gigasecond = new Gigasecond(birthDate);
+    expectedDate = new DateTime.utc(1991, DateTime.MARCH, 27, 7, 0, 25);
+  });
+
+  test("even works before 1970 (beginning of Unix epoch)", () {
+    expect(gigasecond.date(), equals(expectedDate));
   });
 }

data/tracks/dart/exercises/hamming/README.md

@@ -34,6 +34,17 @@ The Hamming distance between these two DNA strands is 7.
 The Hamming distance is only defined for sequences of equal length. This means
 that based on the definition, each language could deal with getting sequences
 of equal length differently.
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)

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

@@ -4,9 +4,9 @@ class Hamming {
       throw new ArgumentError("DNA strands must be of equal length.");
     }
 
-    var diff = 0;
+    int diff = 0;
 
-    for (var i = 0; i < a.length; i++) {
+    for (int i = 0; i < a.length; i++) {
       if (a[i] != b[i]) {
         diff++;
       }

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

@@ -1,54 +1,71 @@
 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();
 
   group("Hamming", () {
-    test("no difference between identical strands", () {
-      final res = hamming.compute("A", "A");
-
-      expect(res, equals(0));
+    test("empty strands", () {
+      expect(hamming.compute("", ""), equals(0));
     });
 
-    test("complete hamming distance for single nucleotide strand", () {
-      final res = hamming.compute("A", "G");
+    test("identical strands", () {
+      expect(hamming.compute("A", "A"), equals(0));
+    }, skip: true);
 
-      expect(res, equals(1));
+    test("long identical strands", () {
+      expect(hamming.compute("GGACTGA", "GGACTGA"), equals(0));
     }, skip: true);
 
-    test("complete hamming distance for small strand", () {
-      final res = hamming.compute("AG", "CT");
+    test("complete distance in single nucleotide strands", () {
+      expect(hamming.compute("A", "G"), equals(1));
+    }, skip: true);
 
-      expect(res, equals(2));
+    test("complete distance in small strands", () {
+      expect(hamming.compute("AG", "CT"), equals(2));
     }, skip: true);
 
-    test("small hamming distance", () {
-      final res = hamming.compute("AT", "CT");
+    test("small distance in small strands", () {
+      expect(hamming.compute("AT", "CT"), equals(1));
+    }, skip: true);
 
-      expect(res, equals(1));
+    test("small distance", () {
+      expect(hamming.compute("GGACG", "GGTCG"), equals(1));
     }, skip: true);
 
-    test("small hamming distance in longer strand", () {
-      final res = hamming.compute("GGACG", "GGTCG");
+    test("small distance in long strands", () {
+      expect(hamming.compute("ACCAGGG", "ACTATGG"), equals(2));
+    }, skip: true);
 
-      expect(res, equals(1));
+    test("non-unique character in first strand", () {
+      expect(hamming.compute("AAG", "AAA"), equals(1));
     }, skip: true);
 
-    test("large hamming distance", () {
-      final res = hamming.compute("GATACA", "GCATAA");
+    test("non-unique character in second strand", () {
+      expect(hamming.compute("AAA", "AAG"), equals(1));
+    }, skip: true);
+
+    test("same nucleotides in different positions", () {
+      expect(hamming.compute("TAG", "GAT"), equals(2));
+    }, skip: true);
 
-      expect(res, equals(4));
+    test("large distance", () {
+      expect(hamming.compute("GATACA", "GCATAA"), equals(4));
     }, skip: true);
 
-    test("hamming distance in very long strand", () {
-      final res = hamming.compute("GGACGGATTCTG", "AGGACGGATTCT");
+    test("large distance in off-by-one strand", () {
+      expect(hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), equals(9));
+    }, skip: true);
 
-      expect(res, equals(9));
+    test("disallow first strand longer", () {
+      expect(() => hamming.compute("AATG", "AAA"), throwsArgumentError);
     }, skip: true);
 
-    test("throws error when strands are not equal length", () {
-      expect(() => hamming.compute("GGACGGATTCTG", "AGGAC"), throwsArgumentError);
+    test("disallow second strand longer", () {
+      expect(() => hamming.compute("ATA", "AGTG"), throwsArgumentError);
     }, skip: true);
   });
 }

data/tracks/dart/exercises/hello-world/README.md

@@ -13,6 +13,17 @@ The objectives are simple:
 - Submit your solution and check it at the website.
 
 If everything goes well, you will be ready to fetch your first real exercise.
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)

data/tracks/dart/exercises/leap/README.md

@@ -4,7 +4,7 @@ Given a year, report if it is a leap year.
 
 The tricky thing here is that a leap year in the Gregorian calendar occurs:
 
-```plain
+```text
 on every year that is evenly divisible by 4
   except every year that is evenly divisible by 100
     unless the year is also evenly divisible by 400
@@ -25,6 +25,17 @@ For a delightful, four minute explanation of the whole leap year
 phenomenon, go watch [this youtube video][video].
 
 [video]: http://www.youtube.com/watch?v=xX96xng7sAE
+
+
+To run the tests:
+
+```sh
+$ pub run test
+```
+
+For more detailed info about the Dart track see the [help page](http://exercism.io/languages/dart).
+
+
 ## Source
 
 JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)

data/tracks/dart/exercises/phone-number/README.md

@@ -0,0 +1,56 @@
+# Phone Number
+Clean up user-entered phone numbers so that they can be sent SMS messages.
+
+The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: `1`.
+
+NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as *area code*, followed by a seven-digit local number. The first three digits of the local number represent the *exchange code*, followed by the unique four-digit number which is the *subscriber number*.
+
+The format is usually represented as
+
+```text
+(NXX)-NXX-XXXX
+```
+
+where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
+
+Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+
+For example, the inputs
+- `+1 (613)-995-0253`
+- `613-995-0253`
+- `1 613 995 0253`
+- `613.995.0253`
+
+should all produce the output
+
+`6139950253`
+
+**Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
+
+# Tip
+A function with a *return type* can only return data of that *type* and `null`.
+However the function caller is only expecting one data type.
+
+Example:
+```dart
+String hello(int a){
+    if ( a == 0){
+        return "a";
+    } else {
+        return null;
+    }
+}
+```
+To make it more clear that this function can also return `null` or more data types, use `dynamic`.
+```dart
+dynamic hello(int a){
+    if ( a == 0){
+        return "a";
+    } else {
+        return null;
+    }
+}
+```
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/dart/exercises/phone-number/lib/example.dart

@@ -0,0 +1,45 @@
+class PhoneNumber {
+  /// Returns `String` for a valid number, `null` for invalid.
+  dynamic cleanNumber(String phoneNumber) {
+    /// initialize an empty string.
+    String onlyDigits = "";
+
+    /// find all digits.
+    Iterable<Match> findDigits = new RegExp(r'\d+').allMatches(phoneNumber);
+    findDigits.forEach((match) {
+      onlyDigits += match.group(0);
+
+      /// remove all digits **for an edge case**.
+      phoneNumber = phoneNumber.replaceAll(match.group(0), "");
+    });
+
+    /// Only these special characters are allowed.
+    /// **"." "(" ")" "-" "+" ** and space,
+    /// remove these characters.
+    phoneNumber = phoneNumber.replaceAll(new RegExp(r"^[\-\.\(\)\+\s+]*$"), "");
+
+    /// "123-@:!-7890" is invalid, however **"123-@:!-789012"** is valid
+    /// by the current logic since the regex grabs all the digits
+    /// but "123-@:!-78901256" should be considered as invalid.
+    /// hence if anything else still exists its an invalid number.
+    if (phoneNumber.length > 0) return null;
+
+    /// remove leading country code **1** to make it easy to process.
+    if (onlyDigits.startsWith("1")) {
+      onlyDigits = onlyDigits.substring(1);
+    }
+
+    if (onlyDigits.length < 10 || onlyDigits.length > 10) return null;
+
+    /// after removing the country code if it exists,
+    /// first and fourth digits can only range from **2-9**
+    /// i.e. Area code and Exchange code.
+    RegExp codeRange = new RegExp(r'^[2-9]$');
+    if (codeRange.hasMatch(onlyDigits[0]) && codeRange.hasMatch(onlyDigits[3])) {
+      return onlyDigits;
+    }
+
+    /// if a condition isn't accounted for.
+    return null;
+  }
+}

data/tracks/dart/exercises/phone-number/lib/phone_number.dart

@@ -0,0 +1,3 @@
+class PhoneNumber {
+  // Put your code here.
+}