trackler 2.0.8.18 → 2.0.8.19

data/tracks/delphi/config.json

@@ -156,6 +156,14 @@
         "Classes"
       ]
     },
+    {
+      "slug": "minesweeper",
+      "difficulty": 5,
+      "topics": [
+        "Parsing",
+        "Transforming"
+      ]
+    },   
     {
       "slug": "bowling",
       "difficulty": 6,

data/tracks/delphi/exercises/minesweeper/MineSweeper.dpr

@@ -0,0 +1,60 @@
+program MineSweeper;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uMineSweeperTest in 'uMineSweeperTest.pas',
+  uMineSweeper in 'uMineSweeper.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := False; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.

data/tracks/delphi/exercises/minesweeper/uMineSweeperExample.pas

@@ -0,0 +1,70 @@
+unit uMineSweeper;
+
+interface
+
+type
+  TMineSweeper = class
+  private
+    class function GetCountForSquare(board: array of string; x, y: integer): integer; static;
+  public
+    class function Annotate(aInput: string): string; static;
+  end;
+
+implementation
+uses System.Generics.Collections, System.StrUtils, System.SysUtils;
+
+class function TMineSweeper.Annotate(aInput: string): string;
+var lResults: TList<string>;
+    Board: TArray<string>;
+    lwrkResult: string;
+    i, j: integer;
+    numMines: integer;
+begin
+  result := '';
+  lResults := TList<string>.Create;
+  Board := aInput.Split(['\n'],none);
+  if length(Board) > 0 then
+  begin
+    for i := 0 to length(Board) - 1 do
+    begin
+      lwrkResult := '';
+      for j := 1 to length(Board[0]) do
+      begin
+        if board[i,j] = '*' then
+          lwrkResult := lwrkResult + '*'
+        else
+        begin
+          numMines := GetCountForSquare(Board, i, j);
+          lwrkResult := lwrkResult +  ifthen(numMines = 0, ' ', numMines.ToString);
+        end;
+      end;
+      lResults.Add(lwrkResult);
+    end;
+    result := result.Join('\n',lResults.ToArray);
+  end;
+end;
+
+class function TMineSweeper.GetCountForSquare(board: array of string; x, y: integer): integer;
+var i, j: integer;
+begin
+  result := 0;
+  for i := -1 to 1 do
+    for j := -1 to 1 do
+      try
+        {$IFOPT R-}
+          {$DEFINE CKRANGEOFF}
+          {$R+}
+        {$ENDIF}
+        if board[x + i, y + j] = '*' then
+          inc(result);
+        {$IFDEF CKRANGEOFF}
+          {$UNDEF CKRANGEOFF}
+          {$R-}
+        {$ENDIF}
+      except
+        on ERangeError do
+          continue;
+      end;
+end;
+
+end.

data/tracks/delphi/exercises/minesweeper/uMineSweeperTest.pas

@@ -0,0 +1,270 @@
+unit uMineSweeperTest;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+type
+
+  [TestFixture]
+  MineSweeperTest = class(TObject)
+  private
+    class function FormatInput(aInput: array of string): string; static;
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure No_rows;
+
+    [Test]
+    [Ignore]
+    procedure No_columns;
+
+    [Test]
+    [Ignore]
+    procedure No_mines;
+
+    [Test]
+    [Ignore]
+    procedure Board_with_only_mines;
+
+    [Test]
+    [Ignore]
+    procedure Mine_surrounded_by_spaces;
+
+    [Test]
+    [Ignore]
+    procedure Space_surrounded_by_mines;
+
+    [Test]
+    [Ignore]
+    procedure Horizontal_line;
+
+    [Test]
+    [Ignore]
+    procedure Horizontal_line_mines_at_edges;
+
+    [Test]
+    [Ignore]
+    procedure Vertical_line;
+
+    [Test]
+    [Ignore]
+    procedure Vertical_line_mines_at_edges;
+
+    [Test]
+    [Ignore]
+    procedure Cross;
+
+    [Test]
+    [Ignore]
+    procedure Large_board;
+  end;
+
+implementation
+uses System.SysUtils, uMineSweeper;
+
+
+{ MineSweeperTest }
+
+procedure MineSweeperTest.Board_with_only_mines;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 3);
+  input[0] := '***';
+  input[1] := '***';
+  input[2] := '***';
+
+  SetLength(expected, 3);
+  expected[0] := '***';
+  expected[1] := '***';
+  expected[2] := '***';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Cross;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 5);
+  input[0] := '  *  ';
+  input[1] := '  *  ';
+  input[2] := '*****';
+  input[3] := '  *  ';
+  input[4] := '  *  ';
+
+  SetLength(expected, 5);
+  expected[0] := ' 2*2 ';
+  expected[1] := '25*52';
+  expected[2] := '*****';
+  expected[3] := '25*52';
+  expected[4] := ' 2*2 ';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Horizontal_line;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 1);
+  input[0] := ' * * ';
+
+  SetLength(expected, 1);
+  expected[0] := '1*2*1';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Horizontal_line_mines_at_edges;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 1);
+  input[0] := '*   *';
+
+  SetLength(expected, 1);
+  expected[0] := '*1 1*';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Large_board;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 6);
+  input[0] := ' *  * ';
+  input[1] := '  *   ';
+  input[2] := '    * ';
+  input[3] := '   * *';
+  input[4] := ' *  * ';
+  input[5] := '      ';
+
+  SetLength(expected, 6);
+  expected[0] := '1*22*1';
+  expected[1] := '12*322';
+  expected[2] := ' 123*2';
+  expected[3] := '112*4*';
+  expected[4] := '1*22*2';
+  expected[5] := '111111';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Mine_surrounded_by_spaces;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 3);
+  input[0] := '   ';
+  input[1] := ' * ';
+  input[2] := '   ';
+
+  SetLength(expected, 3);
+  expected[0] := '111';
+  expected[1] := '1*1';
+  expected[2] := '111';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.No_columns;
+var input: array of string;
+begin
+  SetLength(input, 1);
+  input[0] := '';
+  Assert.AreEqual('', TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.No_mines;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 3);
+  input[0] := '   ';
+  input[1] := '   ';
+  input[2] := '   ';
+
+  SetLength(expected, 3);
+  expected[0] := '   ';
+  expected[1] := '   ';
+  expected[2] := '   ';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.No_rows;
+begin
+  Assert.AreEqual('', TMineSweeper.Annotate(''));
+end;
+
+procedure MineSweeperTest.Space_surrounded_by_mines;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 3);
+  input[0] := '***';
+  input[1] := '* *';
+  input[2] := '***';
+
+  SetLength(expected, 3);
+  expected[0] := '***';
+  expected[1] := '*8*';
+  expected[2] := '***';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Vertical_line;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 5);
+  input[0] := ' ';
+  input[1] := '*';
+  input[2] := ' ';
+  input[3] := '*';
+  input[4] := ' ';
+
+  SetLength(expected, 5);
+  expected[0] := '1';
+  expected[1] := '*';
+  expected[2] := '2';
+  expected[3] := '*';
+  expected[4] := '1';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+procedure MineSweeperTest.Vertical_line_mines_at_edges;
+var input,
+    expected: array of string;
+begin
+  SetLength(input, 5);
+  input[0] := '*';
+  input[1] := ' ';
+  input[2] := ' ';
+  input[3] := ' ';
+  input[4] := '*';
+
+  SetLength(expected, 5);
+  expected[0] := '*';
+  expected[1] := '1';
+  expected[2] := ' ';
+  expected[3] := '1';
+  expected[4] := '*';
+
+  Assert.AreEqual(FormatInput(expected), TMineSweeper.Annotate(FormatInput(input)));
+end;
+
+class function MineSweeperTest.FormatInput(aInput: array of string): string;
+begin
+  result := '';
+  result := result.Join('\n',aInput);
+end;
+
+Initialization
+  TDUnitX.RegisterTestFixture(MineSweeperTest);
+end.

data/tracks/dlang/config.json

@@ -24,84 +24,139 @@
   ],
   "exercises": [
     {
-      "slug": "hello-world" ,
+      "slug": "hello-world",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+        "language basics"
+      ]
     },
     {
       "slug": "gigasecond" ,
       "difficulty": 1,
-      "topics": []
+      "topics": [
+        "language basics",
+        "time"
+      ]
     },
     {
-      "slug": "rna-transcription" ,
+      "slug": "rna-transcription",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "error handling",
+        "control-flow (foreach)"
+      ]
     },
     {
-      "slug": "raindrops" ,
+      "slug": "raindrops",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+        "language basics",
+        "control-flow (if-statements)"
+      ]
     },
     {
-      "slug": "bob" ,
+      "slug": "bob",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "control-flow (if-statements)"
+      ]
     },
     {
-      "slug": "etl" ,
+      "slug": "etl",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "control-flow (foreach)",
+        "associative arrays"
+      ]
     },
     {
-      "slug": "hamming" ,
+      "slug": "hamming",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "error handling",
+        "control-flow (foreach)"
+      ]
     },
     {
-      "slug": "nucleotide-count" ,
+      "slug": "nucleotide-count",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+        "classes",
+        "parsing",
+        "associative arrays"
+      ]
     },
     {
-      "slug": "robot-name" ,
+      "slug": "robot-name",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+        "classes",
+        "random numbers"
+      ]
     },
     {
-      "slug": "difference-of-squares" ,
+      "slug": "difference-of-squares",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "control-flow (foreach)",
+        "template metaprogramming",
+        "functional",
+        "algorithms"
+      ]
     },
     {
-      "slug": "roman-numerals" ,
+      "slug": "roman-numerals",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "conversions",
+        "functional"
+      ]
     },
     {
-      "slug": "series" ,
+      "slug": "series",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "arrays"
+      ]
     },
     {
-      "slug": "triangle" ,
+      "slug": "triangle",
       "difficulty": 2,
-      "topics": []
+      "topics": [
+        "language basics",
+        "control-flow (if-statements)"
+      ]
     },
     {
-      "slug": "crypto-square" ,
+      "slug": "crypto-square",
       "difficulty": 3,
-      "topics": []
+      "topics": [
+        "string manipulation",
+        "classes",
+        "algorithms"
+      ]
     },
     {
-      "slug": "circular-buffer" ,
+      "slug": "circular-buffer",
       "difficulty": 4,
-      "topics": []
+      "topics": [
+        "class templates",
+        "data-structures"
+      ]
     },
     {
-      "slug": "pangram" ,
+      "slug": "pangram",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+        "language basics",
+        "string manipulation",
+        "control-flow"
+      ]
     }
   ],
   "deprecated": [