trackler 2.1.0.48 → 2.1.0.49

data/tracks/dart/tool/create-exercise

@@ -0,0 +1,124 @@
+#!/usr/bin/env dart
+// vim: set syntax=dart:
+
+import "dart:io";
+import "dart:async";
+import "package:args/args.dart";
+
+/** Constants */
+const ME = "create-exercise";
+
+final parser = new ArgParser()..addSeparator("Usage: $ME <slug>");
+
+/** Helpers */
+List<String> words(String str) {
+  return str
+      .toLowerCase()
+      .replaceAll(new RegExp(r"[^a-z0-9]"), " ")
+      .replaceAll(new RegExp(r"\ +"), " ")
+      .trim()
+      .split(" ");
+}
+
+String upperFirst(String str) {
+  final chars = str.split("");
+  final first = chars.first;
+
+  return first.toUpperCase() + chars.skip(1).join("");
+}
+
+String camelCase(String str, {bool isUpperFirst = false}) {
+  final parts = words(str);
+  final first = parts.first;
+  final rest = parts.skip(1);
+
+  return (isUpperFirst ? upperFirst(first) : first) + rest.map(upperFirst).join("");
+}
+
+String pascalCase(String str) => camelCase(str, isUpperFirst: true);
+
+String snakeCase(String str) => words(str).join("_");
+
+String kebabCase(String str) => words(str).join("-");
+
+/** Templates */
+String exampleTemplate(String name) => """
+class ${pascalCase(name)} {
+
+}
+""";
+
+String mainTemplate(String name) => """
+class ${pascalCase(name)} {
+  // Put your code here
+}
+""";
+
+String testTemplate(String name) => """
+import "package:test/test.dart";
+import "package:${snakeCase(name)}/${snakeCase(name)}.dart";
+
+void main() {
+  final ${camelCase(name)} = new ${pascalCase(name)}();
+
+  group("${pascalCase(name)}", () {
+    test("should work", () {
+      // TODO
+    });
+  });
+}
+""";
+
+String pubTemplate(String name) => """
+name: '${snakeCase(name)}'
+dev_dependencies:
+  test: '0.12.23+1'
+""";
+
+Future main(args) async {
+  final arguments = parser.parse(args);
+  final restArgs = arguments.rest;
+
+  if (restArgs.isEmpty) {
+    stderr.write(parser.usage);
+    exit(1);
+  }
+
+  final name = restArgs.first;
+
+  // Create dir
+  final currentDir = Directory.current;
+  final exerciseDir = new Directory("exercises/${kebabCase(name)}");
+  final filename = snakeCase(name);
+
+  if (await exerciseDir.exists()) {
+    stderr.write("$name already exist");
+    exit(1);
+  }
+
+  await new Directory("${exerciseDir.path}/lib").create(recursive: true);
+  await new Directory("${exerciseDir.path}/test").create(recursive: true);
+
+  // Create files
+  await new File("${exerciseDir.path}/lib/example.dart").writeAsString(exampleTemplate(name));
+  await new File("${exerciseDir.path}/lib/${filename}.dart").writeAsString(mainTemplate(name));
+  await new File("${exerciseDir.path}/test/${filename}_test.dart").writeAsString(testTemplate(name));
+  await new File("${exerciseDir.path}/pubspec.yaml").writeAsString(pubTemplate(name));
+
+  // Install deps
+  Directory.current = exerciseDir;
+
+  final res = await Process.run("pub", ["get"], runInShell: true);
+
+  if (!res.stdout.toString().isEmpty) {
+    stdout.write(res.stdout);
+  }
+
+  if (!res.stderr.toString().isEmpty) {
+    stderr.write(res.stderr);
+  }
+
+  assert(res.exitCode == 0);
+
+  Directory.current = currentDir;
+}

data/tracks/delphi/README.md

@@ -6,5 +6,5 @@ Exercism exercises in Delphi Pascal.
 
 ## Contributing Guide
 
-Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
+Please see the [contributing guide](https://github.com/exercism/problem-specifications/blob/master/CONTRIBUTING.md).
 

data/tracks/delphi/exercises/bank-account/uBankAccountTests.pas

@@ -31,7 +31,7 @@ type
   end;
 
 implementation
-uses System.Classes, System.SyncObjs, uBankAccount;
+uses System.SysUtils, System.Classes, System.SyncObjs, uBankAccount;
 
 const HalfCentTolerance = 0.005;
 
@@ -118,20 +118,22 @@ begin
       procedure
       var j: integer;
       begin
-        for j := 1 to iterations do
-        begin
-          account.UpdateBalance(1);
-          account.UpdateBalance(-1);
+        try
+          for j := 1 to iterations do
+          begin
+            account.UpdateBalance(1);
+            account.UpdateBalance(-1);
+          end;
+        finally
+          dec(activeThreadCount);
+          if activeThreadCount <= 0 then
+            allthreadsDone.SetEvent;
         end;
-
-        dec(activeThreadCount);
-        if activeThreadCount <= 0 then
-          allthreadsDone.SetEvent;
       end)
       .Start;
   end;
 
-  assert.AreEqual(wrSignaled,allthreadsDone.WaitFor(60000));
+  assert.AreEqual(wrSignaled,allthreadsDone.WaitFor(60000), format('%d threads still active',[activeThreadCount]));
   assert.AreEqual(0, account.Balance, HalfCentTolerance);
 end;
 

data/tracks/delphi/exercises/hamming/uHammingExample.pas

@@ -5,20 +5,20 @@ interface
 type
   THamming = class
   public
-    class function compute(s1, s2: string): integer; static;
+    class function Distance(strand1, strand2: string): integer; static;
   end;
 
 implementation
 uses System.SysUtils;
 
-class function THamming.compute(s1, s2: string): integer;
+class function THamming.Distance(strand1, strand2: string): integer;
 var i: integer;
 begin
-  if s1.Length <> s2.Length  then
+  if strand1.Length <> strand2.Length  then
     raise EArgumentException.Create('Arguments are not same length');
   result := 0;
-  for i := Low(s1) to High(s1) do
-    result := result + ord(s1[i] <> s2[i]);
+  for i := Low(strand1) to High(strand1) do
+    result := result + ord(strand1[i] <> strand2[i]);
 end;
 
 end.

data/tracks/delphi/exercises/hamming/uHammingTests.pas

@@ -7,157 +7,155 @@ uses
 type
 
   [TestFixture]
-  HammingTests = class(TObject) 
+  HammingTests = class(TObject)
   public
     [Test]
 //  [Ignore('Comment the "[Ignore]" statement to run the test')]
-    procedure test_identical_strands;
+    procedure empty_strands;
 
     [Test]
     [Ignore]
-    procedure test_long_identical_strands;
+    procedure identical_strands;
 
     [Test]
     [Ignore]
-    procedure test_complete_distance_in_single_nucleotide_strands;
+    procedure long_identical_strands;
 
     [Test]
     [Ignore]
-    procedure test_complete_distance_in_small_strands;
+    procedure complete_distance_in_single_nucleotide_strands;
 
     [Test]
     [Ignore]
-    procedure test_small_distance_in_small_strands;
+    procedure complete_distance_in_small_strands;
 
     [Test]
     [Ignore]
-    procedure test_small_distance;
+    procedure small_distance_in_small_strands;
 
     [Test]
     [Ignore]
-    procedure test_small_distance_in_long_strands;
+    procedure small_distance;
 
     [Test]
     [Ignore]
-    procedure test_non_unique_character_in_first_strand;
+    procedure small_distance_in_long_strands;
 
     [Test]
     [Ignore]
-    procedure test_non_unique_character_in_second_strand;
+    procedure non_unique_character_in_first_strand;
 
     [Test]
     [Ignore]
-    procedure test_same_nucleotides_in_different_positions;
+    procedure non_unique_character_in_second_strand;
 
     [Test]
     [Ignore]
-    procedure test_large_distance;
+    procedure same_nucleotides_in_different_positions;
 
     [Test]
     [Ignore]
-    procedure test_large_distance_in_off_by_one_strand;
+    procedure large_distance;
 
     [Test]
     [Ignore]
-    procedure test_empty_strands;
+    procedure large_distance_in_off_by_one_strand;
 
     [Test]
     [Ignore]
-    procedure test_disallow_first_strand_longer;
+    procedure disallow_first_strand_longer;
 
     [Test]
     [Ignore]
-    procedure test_disallow_second_strand_longer;
+    procedure disallow_second_strand_longer;
   end;
 
 implementation
 uses System.SysUtils, uHamming;
 
-procedure HammingTests.test_identical_strands;
+procedure HammingTests.empty_strands;
 begin
-  assert.AreEqual(0,THamming.compute('A','A'));
+  assert.AreEqual(0,THamming.Distance('',''));
 end;
 
-procedure HammingTests.test_long_identical_strands;
+procedure HammingTests.identical_strands;
 begin
-  assert.AreEqual(0, THamming.compute('GGACTGA', 'GGACTGA'));
+  assert.AreEqual(0,THamming.Distance('A','A'));
 end;
 
-procedure HammingTests.test_complete_distance_in_single_nucleotide_strands;
+procedure HammingTests.long_identical_strands;
 begin
-  assert.AreEqual(1, THamming.compute('A', 'G'));
+  assert.AreEqual(0, THamming.Distance('GGACTGA', 'GGACTGA'));
 end;
 
-procedure HammingTests.test_complete_distance_in_small_strands;
+procedure HammingTests.complete_distance_in_single_nucleotide_strands;
 begin
-  assert.AreEqual( 2, THamming.compute('AG', 'CT'));
+  assert.AreEqual(1, THamming.Distance('A', 'G'));
 end;
 
-procedure HammingTests.test_small_distance_in_small_strands;
+procedure HammingTests.complete_distance_in_small_strands;
 begin
-  assert.AreEqual(1, THamming.compute('AT', 'CT'));
+  assert.AreEqual( 2, THamming.Distance('AG', 'CT'));
 end;
 
-procedure HammingTests.test_small_distance;
+procedure HammingTests.small_distance_in_small_strands;
 begin
-  assert.AreEqual(1, THamming.compute('GGACG', 'GGTCG'));
+  assert.AreEqual(1, THamming.Distance('AT', 'CT'));
 end;
 
-procedure HammingTests.test_small_distance_in_long_strands;
+procedure HammingTests.small_distance;
 begin
-  assert.AreEqual(2, THamming.compute('ACCAGGG', 'ACTATGG'));
+  assert.AreEqual(1, THamming.Distance('GGACG', 'GGTCG'));
 end;
 
-procedure HammingTests.test_non_unique_character_in_first_strand;
+procedure HammingTests.small_distance_in_long_strands;
 begin
-  assert.AreEqual(1, THamming.compute('AGA', 'AGG'));
+  assert.AreEqual(2, THamming.Distance('ACCAGGG', 'ACTATGG'));
 end;
 
-procedure HammingTests.test_non_unique_character_in_second_strand;
+procedure HammingTests.non_unique_character_in_first_strand;
 begin
-  assert.AreEqual(1, THamming.compute('AGG', 'AGA'));
+  assert.AreEqual(1, THamming.Distance('AGA', 'AGG'));
 end;
 
-procedure HammingTests.test_same_nucleotides_in_different_positions;
+procedure HammingTests.non_unique_character_in_second_strand;
 begin
-  assert.AreEqual(2, THamming.compute('TAG', 'GAT'));
+  assert.AreEqual(1, THamming.Distance('AGG', 'AGA'));
 end;
 
-procedure HammingTests.test_large_distance;
+procedure HammingTests.same_nucleotides_in_different_positions;
 begin
-  assert.AreEqual(4, THamming.compute('GATACA', 'GCATAA'));
+  assert.AreEqual(2, THamming.Distance('TAG', 'GAT'));
 end;
 
-procedure HammingTests.test_large_distance_in_off_by_one_strand;
+procedure HammingTests.large_distance;
 begin
-  assert.AreEqual(9, THamming.compute('GGACGGATTCTG', 'AGGACGGATTCT'));
+  assert.AreEqual(4, THamming.Distance('GATACA', 'GCATAA'));
 end;
 
-procedure HammingTests.test_empty_strands;
+procedure HammingTests.large_distance_in_off_by_one_strand;
 begin
-  assert.AreEqual(0, THamming.compute('', ''));
+  assert.AreEqual(9, THamming.Distance('GGACGGATTCTG', 'AGGACGGATTCT'));
 end;
 
-procedure HammingTests.test_disallow_first_strand_longer;
+procedure HammingTests.disallow_first_strand_longer;
 var MyProc: TTestLocalMethod;
 begin
   MyProc := procedure
             begin
-              THamming.compute('AATG', 'AAA');
+              THamming.Distance('AATG', 'AAA');
             end;
   assert.WillRaise(MyProc, EArgumentException);
-  MyProc := nil;
 end;
 
-procedure HammingTests.test_disallow_second_strand_longer;
+procedure HammingTests.disallow_second_strand_longer;
 var MyProc: TTestLocalMethod;
 begin
   MyProc := procedure
             begin
-              THamming.compute('ATA', 'AGTG');
+              THamming.Distance('ATA', 'AGTG');
             end;
   assert.WillRaise(MyProc, EArgumentException);
-  MyProc := nil;
 end;
 
 initialization

data/tracks/ecmascript/.babelrc

@@ -0,0 +1,3 @@
+{
+  "plugins": ["transform-regenerator"]
+}

data/tracks/ecmascript/config.json

@@ -292,6 +292,14 @@
 
       ]
     },
+    {
+      "slug": "flatten-array",
+      "difficulty": 5,
+      "topics": [
+        "Arrays",
+        "Recursion"
+      ]
+    },
     {
       "slug": "largest-series-product",
       "difficulty": 1,
@@ -313,6 +321,15 @@
 
       ]
     },
+    {
+      "slug": "list-ops",
+      "difficulty": 5,
+      "topics": [
+        "Data structures",
+        "Lists",
+        "Loops"
+      ]
+    },
     {
       "slug": "binary-search-tree",
       "difficulty": 1,
@@ -443,7 +460,14 @@
       "slug": "connect",
       "difficulty": 7,
       "topics": [
-
+      ]
+    },
+    {
+      "slug": "alphametics",
+      "difficulty": 7,
+      "topics": [
+        "games",
+        "algorithms"
       ]
     }
   ],