trackler 2.1.0.53 → 2.1.0.54

data/tracks/delphi/exercises/wordy/uWordyExample.pas

@@ -0,0 +1,130 @@
+unit uWordy;
+
+interface
+uses System.SysUtils, RegularExpressions, System.Generics.Collections;
+
+type
+  EInvalidProblem = Class(Exception);
+
+  TWordy = Class
+  private
+    type
+      TParsedProblem = record
+        X: integer;
+        Operation1: string;
+        Y: integer;
+        Operation2: string;
+        Z: integer;
+        constructor create(parsedGroups: TGroupCollection);
+      end;
+    class var Operations: TDictionary<string, TFunc<integer, integer, integer>>;
+    class var VariableAndOperatorGroupsRegex: TRegex;
+    class procedure buildOperations;
+    class procedure buildVariableAndOperatorGroupsRegex;
+    class function ParseProblem(aProblem: string): TParsedProblem;
+  public
+    class function Answer(aQuestion: string): integer;
+  end;
+
+implementation
+uses Math;
+
+{ TWordy }
+
+class function TWordy.Answer(aQuestion: string): integer;
+var ParsedProblem: TParsedProblem;
+    Operation: TFunc<integer, integer, integer>;
+    firstPass: integer;
+begin
+  if not assigned(Operations) then
+  begin
+    buildOperations;
+    buildVariableAndOperatorGroupsRegex;
+  end;
+
+  ParsedProblem := ParseProblem(aQuestion);
+  Operation := Operations[ParsedProblem.Operation1];
+  firstPass := Operation(ParsedProblem.X, ParsedProblem.Y);
+  if ParsedProblem.Operation2.IsEmpty then
+    result := firstPass
+  else
+  begin
+    Operation := Operations[ParsedProblem.Operation2];
+    result := Operation(firstPass, ParsedProblem.Z);
+  end;
+end;
+
+class procedure TWordy.BuildOperations;
+begin
+  Operations := TDictionary<string, TFunc<integer, integer, integer>>.Create;
+  Operations.Add('plus',
+    function(X: integer; Y: integer): integer
+    begin
+      result := X + Y;
+    end);
+
+  Operations.Add('minus',
+    function(X: integer; Y: integer): integer
+    begin
+      result := X - Y;
+    end);
+
+  Operations.Add('multiplied by',
+    function(X: integer; Y: integer): integer
+    begin
+      result := X * Y;
+    end);
+
+  Operations.Add('divided by',
+    function(X: integer; Y: integer): integer
+    begin
+      result := X div Y;
+    end);
+end;
+
+class procedure TWordy.buildVariableAndOperatorGroupsRegex;
+begin
+  VariableAndOperatorGroupsRegex := TRegex.Create(format('%0:s %1:s %0:s\s*%1:s*\s*%0:s*',
+    ['(-?\d+)','(plus|minus|multiplied by|divided by)']));
+end;
+
+class function TWordy.ParseProblem(aProblem: string): TParsedProblem;
+var Match: TMatch;
+begin
+  Match := VariableAndOperatorGroupsRegex.Match(aProblem);
+  if Match.Groups.Count = 0 then
+    raise EInvalidProblem.Create('Invalid Problem');
+
+  result := TParsedProblem.create(Match.Groups);
+end;
+
+{ TWordy.TParsedProblem }
+
+constructor TWordy.TParsedProblem.create(parsedGroups: TGroupCollection);
+var i: integer;
+    parsedItems: TList<string>;
+    parsedItemsArray: TArray<string>;
+begin
+  parsedItems := TList<string>.Create;
+  for i := 1 to parsedGroups.Count - 1 do
+  begin
+    if parsedGroups[i].Success then
+      parsedItems.Add(parsedGroups[i].Value)
+    else
+      parsedItems.Add('');
+  end;
+
+  parsedItemsArray := parsedItems.ToArray;
+  Setlength(parsedItemsArray, 5);
+
+  X := parsedItemsArray[0].ToInteger;
+  Operation1 := parsedItemsArray[1];
+  Y := parsedItemsArray[2].ToInteger;
+  Operation2 := parsedItemsArray[3];
+  if parsedItemsArray[4] <> '' then
+    Z := parsedItemsArray[4].ToInteger
+  else
+    Z := 0;
+end;
+
+end.

data/tracks/delphi/exercises/wordy/uWordyTests.pas

@@ -0,0 +1,184 @@
+unit uWordyTests;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+type
+
+  [TestFixture]
+  WordyTests = class(TObject)
+  public
+//   [Ignore('Comment the "[Ignore]" statement to run the test')]
+   [TestCase('addition', 'What is 1 plus 1?,2')]
+   procedure Addition(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('more addition', 'What is 53 plus 2?,55')]
+   procedure More_Addition(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('addition with negative numbers', 'What is -1 plus -10?,-11')]
+   procedure Addition_with_negative_numbers(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('large addition', 'What is 123 plus 45678?,45801')]
+   procedure Large_addition(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('subtraction', 'What is 4 minus -12?,16')]
+   procedure Subtraction(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('multiplication', 'What is -3 multiplied by 25?,-75')]
+   procedure Multiplication(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('division', 'What is 33 divided by -3?,-11')]
+   procedure Division(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('multiple additions', 'What is 1 plus 1 plus 1?,3')]
+   procedure Multiple_additions(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('addition and subtraction', 'What is 1 plus 5 minus -2?,8')]
+   procedure Addition_and_subtraction(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('multiple subtraction', 'What is 20 minus 4 minus 13?,3')]
+   procedure Multiple_subtraction(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('subtraction then addition', 'What is 17 minus 6 plus 3?,14')]
+   procedure Subtraction_then_addition(const aInput: string; const aExpected: integer);
+
+   [Ignore]
+   [TestCase('multiple multiplication', 'What is 2 multiplied by -2 multiplied by 3?,-12')]
+   procedure Multiple_multiplication(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('addition and multiplication', 'What is -3 plus 7 multiplied by -2?,-8')]
+   procedure Addition_and_multiplication(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('multiple division', 'What is -12 divided by 2 divided by -3?,2')]
+   procedure Multiple_division(const aInput: string; aExpected: integer);
+
+   [Ignore]
+   [TestCase('unknown operation', 'What is 52 cubed?,Invalid Problem')]
+   procedure Unknown_operation(const aInput: string; aExpected: string);
+
+   [Ignore]
+   [TestCase('Non math question', 'Who is the President of the United States?,Invalid Problem')]
+   procedure Non_math_question(const aInput: string; aExpected: string);
+  end;
+
+implementation
+uses uWordy;
+
+procedure WordyTests.Addition(const aInput: string; const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Addition_and_multiplication(const aInput: string;
+  aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Addition_and_subtraction(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Addition_with_negative_numbers(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Division(const aInput: string; aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Large_addition(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.More_Addition(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Multiple_additions(const aInput: string;
+  aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Multiple_division(const aInput: string;
+  aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Multiple_multiplication(const aInput: string;
+  aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Multiple_subtraction(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Multiplication(const aInput: string; aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Subtraction(const aInput: string; aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Subtraction_then_addition(const aInput: string;
+  const aExpected: integer);
+begin
+  Assert.AreEqual(aExpected, TWordy.Answer(aInput));
+end;
+
+procedure WordyTests.Unknown_operation(const aInput: string; aExpected: string);
+var MyProc: TTestLocalMethod;
+begin
+  MyProc := procedure
+            begin
+              TWordy.Answer(aInput);
+            end;
+
+  Assert.WillRaiseWithMessage(MyProc, EInvalidProblem, aExpected);
+end;
+
+procedure WordyTests.Non_math_question(const aInput: string; aExpected: string);
+var MyProc: TTestLocalMethod;
+begin
+  MyProc := procedure
+            begin
+              TWordy.Answer(aInput);
+            end;
+
+  Assert.WillRaiseWithMessage(MyProc, EInvalidProblem, aExpected);
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(WordyTests);
+end.

data/tracks/ecmascript/.travis.yml

@@ -5,5 +5,5 @@ node_js:
 sudo: false
 script:
 - bin/fetch-configlet
-- bin/configlet .
+- bin/configlet lint .
 - make test

data/tracks/ecmascript/Makefile

@@ -27,7 +27,7 @@ test-assignment:
 	@cp exercises/grains/lib/big-integer.$(FILEEXT) $(OUTDIR)
 	@cp exercises/$(ASSIGNMENT)/$(TSTFILE) $(OUTDIR)
 	@cp exercises/$(ASSIGNMENT)/$(EXAMPLE) $(OUTDIR)/$(subst _,-,$(ASSIGNMENT)).$(FILEEXT)
-	@sed 's/xit/it/g' exercises/$(ASSIGNMENT)/$(TSTFILE) > $(OUTDIR)/temp.$(TSTFILE)
+	@sed 's/xtest/test/g' exercises/$(ASSIGNMENT)/$(TSTFILE) > $(OUTDIR)/temp.$(TSTFILE)
 	@node_modules/.bin/jest $(OUTDIR)/temp.*.spec.js
 	@rm $(OUTDIR)/*
 	@rmdir $(OUTDIR)

data/tracks/ecmascript/README.md

@@ -1,5 +1,5 @@
 # xECMAScript
-[![Build Status](https://travis-ci.org/exercism/xecmascript.svg?branch=master)](https://travis-ci.org/exercism/xecmascript)
+[![Build Status](https://travis-ci.org/exercism/ecmascript.svg?branch=master)](https://travis-ci.org/exercism/ecmascript)
 [![Join the chat at https://gitter.im/exercism/xecmascript](https://badges.gitter.im/exercism/xecmascript.svg)](https://gitter.im/exercism/xecmascript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Exercism exercises in ECMAScript 6

data/tracks/ecmascript/config.json

@@ -145,6 +145,13 @@
 
       ]
     },
+    {
+      "slug": "diffie-hellman",
+      "difficulty": 3,
+      "topics": [
+        "Cryptography"
+      ]
+    },
     {
       "slug": "acronym",
       "difficulty": 1,

data/tracks/ecmascript/docs/EXERCISE_README_INSERT.md

@@ -21,8 +21,8 @@ Execute the tests with:
 $ npm test
 ```
 
-In many test suites all but the first test have been skipped.
+In the test suites all tests but the first have been skipped.
 
-Once you get a test passing, you can unskip the next one by
-changing `xit` to `it`.
+Once you get a test passing, you can enable the next one by
+changing `xtest` to `test`.
 

data/tracks/ecmascript/docs/TESTS.md

@@ -27,10 +27,9 @@ $ npm run watch
 
 ## Making Your First ECMAScript 2015 Module
 
-Usually, tests on this track will load your implementation importing it as a
-ECMAScript 2015 module: `import Bob from './bob.js';`. To make it work, you just
-needs to export your implementation from the file the tests are looking for
-your module, `bob.js`:
+Usually, tests on this track will load your implementation by importing it as an
+ECMAScript 2015 module: `import Bob from './bob.js';`. You just
+need to export your implementation from the referenced file, `bob.js`:
 
 ```javascript
 export default class Bob {

data/tracks/ecmascript/exercises/accumulate/accumulate.spec.js

@@ -2,30 +2,30 @@ import accumulate from './accumulate';
 
 describe('accumulate()', () => {
 
-  it('accumulation empty', () => {
+  test('accumulation empty', () => {
     const accumulator =  (e) => e * e;
     expect(accumulate([], accumulator)).toEqual([]);
   });
 
-  xit('accumulate squares', () => {
+  xtest('accumulate squares', () => {
     const accumulator = number => number * number;
     const result = accumulate([1, 2, 3], accumulator);
     expect(result).toEqual([1, 4, 9]);
   });
 
-  xit('accumulate upcases', () => {
+  xtest('accumulate upcases', () => {
     const accumulator =  word => word.toUpperCase();
     const result = accumulate('hello world'.split(/\s/), accumulator);
     expect(result).toEqual(['HELLO', 'WORLD']);
   });
 
-  xit('accumulate reversed strings', () => {
+  xtest('accumulate reversed strings', () => {
     const accumulator = word => word.split('').reverse().join('');
     const result = accumulate('the quick brown fox etc'.split(/\s/), accumulator);
     expect(result).toEqual(['eht', 'kciuq', 'nworb', 'xof', 'cte']);
   });
 
-  xit('accumulate recursively', () => {
+  xtest('accumulate recursively', () => {
     const result = accumulate('a b c'.split(/\s/), char => {
       return accumulate('1 2 3'.split(/\s/), digit => {
         return char + digit;

data/tracks/ecmascript/exercises/accumulate/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/acronym/acronym.spec.js

@@ -1,27 +1,27 @@
 import Acronyms from './acronym';
 
 describe('Acronyms are produced from', ()=>{
-  it('title cased phrases', () => {
+  test('title cased phrases', () => {
     expect(Acronyms.parse('Portable Network Graphics')).toEqual('PNG');
   });
 
-  xit('other title cased phrases', () => {
+  xtest('other title cased phrases', () => {
     expect(Acronyms.parse('Ruby on Rails')).toEqual('ROR');
   });
 
-  xit('inconsistently cased phrases', ()=>{
+  xtest('inconsistently cased phrases', ()=>{
     expect(Acronyms.parse('HyperText Markup Language')).toEqual('HTML');
   });
 
-  xit('phrases with punctuation', () => {
+  xtest('phrases with punctuation', () => {
     expect(Acronyms.parse('First In, First Out')).toEqual('FIFO');
   });
 
-  xit('other phrases with punctuation', () => {
+  xtest('other phrases with punctuation', () => {
     expect(Acronyms.parse('PHP: Hypertext Preprocessor')).toEqual('PHP');
   });
 
-  xit('phrases with punctuation and sentence casing', () => {
+  xtest('phrases with punctuation and sentence casing', () => {
     expect(Acronyms.parse('Complementary metal-oxide semiconductor')).toEqual('CMOS');
   });
 });