trackler 2.0.6.11 → 2.0.6.12

data/tracks/pascal/config.json

@@ -36,26 +36,27 @@
       ]
     },
     {
-      "slug": "bowling",
-      "difficulty": 6,
+      "slug": "bank-account",
+      "difficulty": 2,
       "topics": [
-        "Algorithms",
-        "Control-flow (loops)"
+        "Classes"
       ]
     },
     {
-      "slug": "allergies",
-      "difficulty": 4,
+      "slug": "nucleotide-count",
+      "difficulty": 2,
       "topics": [
-        "Bitwise operations",
-        "Filtering"
+        "Dictionaries",
+        "Strings"
       ]
     },
     {
-      "slug": "bank-account",
+      "slug": "etl",
       "difficulty": 2,
       "topics": [
-        "Classes"
+        "Dictionaries",
+        "Lists",
+        "Transforming"
       ]
     },
     {
@@ -74,10 +75,6 @@
         "Transforming"
       ]
     },
-    {
-	  "slug": "book-store",
-	  "difficulty": 6
-	},
     {
       "slug": "perfect-numbers",
       "difficulty": 3,
@@ -85,23 +82,6 @@
         "Integers"
       ]
     },
-    {
-      "slug": "nucleotide-count",
-      "difficulty": 2,
-      "topics": [
-        "Dictionaries",
-        "Strings"
-      ]
-    },
-    {
-      "slug": "etl",
-      "difficulty": 2,
-      "topics": [
-        "Dictionaries",
-        "Lists",
-        "Transforming"
-      ]
-    },
     {
       "slug": "binary-search",
       "difficulty": 3,
@@ -120,11 +100,11 @@
       ]
     },
     {
-      "slug": "circular-buffer",
-      "difficulty": 5,
+      "slug": "allergies",
+      "difficulty": 4,
       "topics": [
-        "Queues",
-        "Classes"
+        "Bitwise operations",
+        "Filtering"
       ]
     },
     {
@@ -135,7 +115,27 @@
         "Arrays",
         "Tuples"
       ]
-    }
+    },
+    {
+      "slug": "circular-buffer",
+      "difficulty": 5,
+      "topics": [
+        "Queues",
+        "Classes"
+      ]
+    },
+    {
+      "slug": "bowling",
+      "difficulty": 6,
+      "topics": [
+        "Algorithms",
+        "Control-flow (loops)"
+      ]
+    },
+    {
+	  "slug": "book-store",
+	  "difficulty": 6
+	}
   ],
   "ignored": [
     "bin",

data/tracks/pascal/exercises/bob/uBobTests.pas

@@ -10,7 +10,6 @@ type
   BobTests = class(TObject)
   public
     [Test]
-    [Ignore]
     procedure Stating_something;
 
     [Test]

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

@@ -10,7 +10,6 @@ type
   HammingTests = class(TObject) 
   public
     [Test]
-    [Ignore]
     procedure test_identical_strands;
 
     [Test]

data/tracks/pascal/exercises/leap/uLeapTests.pas

@@ -10,7 +10,6 @@ type
   YearTest = class(TObject)
   public
     [Test]
-    [Ignore]
     procedure test_leap_year;
 
     [Test]

data/tracks/pascal/exercises/saddle-points/uSaddlePointsExample.pas

@@ -1,3 +1,14 @@
+//========================================================================
+// For this example solution I utilized Stefen Glienke's
+// open-source code library titled Spring4D.  Latest
+// version is available here: https://bitbucket.org/sglienke/spring4d
+// Spring4D is not absolutely necessary, but it does greatly help
+// facilitate a much simpler solution.
+//
+// Spring4D does include a Tuple record type that I have purposely
+// not used in favor of my own, simple, TTuple that I declared in the
+// test runner, in order to remove Spring4D dependency for test execution 
+//========================================================================
 unit uSaddlePoints;
 
 interface

data/tracks/pascal/exercises/saddle-points/uSaddlePointsTests.pas

@@ -1,3 +1,12 @@
+//******************************************************************
+// Hint: You will be using TTuple in your solution.  TTuple is
+// declared in this unit.  It will be necessary for you to add
+// a uses statement in the interface section of uSaddlePoints.pas.
+//
+// For more guidance as you work on this exercise, see
+// GETTING_STARTED.md.
+//******************************************************************
+
 unit uSaddlePointsTests;
 
 interface
@@ -52,7 +61,6 @@ begin
   fValue2 := Value2;
 end;
 
-
 procedure TSaddlePointTests.Readme_example;
 var SaddlePoints: ISaddlePoints;
     values: TArray<TArray<integer>>;

data/tracks/perl6/exercises/atbash-cipher/cipher.t

@@ -5,7 +5,7 @@ use JSON::Tiny;
 
 use lib ( my $dir = IO::Path.new($?FILE).parent ).path;
 
-my $module_name = %*ENV<EXERCISM>.so ?? 'Example' !! 'Allergies';
+my $module_name = %*ENV<EXERCISM>.so ?? 'Example' !! 'Cipher';
 my @potential_module = <p6 pm6 pm>.map:  $module_name ~ '.' ~ *; 
 
 my $module = first { $dir.child($_).e }, |@potential_module

data/tracks/php/config.json

@@ -315,6 +315,13 @@
       "Floating-point numbers",
       "Algorithms"
     ]
+  },
+  {
+    "slug": "robot-simulator",
+    "difficulty": 3,
+    "topics": [
+      "OOP"
+    ]
   }
   ]
 }

data/tracks/php/exercises/robot-simulator/example.php

@@ -0,0 +1,148 @@
+<?php
+
+class Robot
+{
+    const DIRECTION_NORTH = 'north';
+    const DIRECTION_EAST = 'east';
+    const DIRECTION_SOUTH = 'south';
+    const DIRECTION_WEST = 'west';
+
+    /**
+     *
+     * @var int[]
+     */
+    protected $position;
+
+    /**
+     *
+     * @var string
+     */
+    protected $direction;
+
+
+    public function __construct(array $position, string $direction)
+    {
+        $this->position = $position;
+        $this->direction = $direction;
+    }
+
+
+    /**
+     * Make protected properties read-only.
+     * __get() is slow, but it's ok for the given task.
+     *
+     * @param string $name
+     * @return mixed
+     */
+    public function __get($name)
+    {
+        return property_exists(self::class, $name) ? $this->$name : null;
+    }
+
+
+    /**
+     * Turn the Robot clockwise
+     * @return Robot
+     */
+    public function turnRight()
+    {
+        $this->direction = self::listDirectionsClockwize()[$this->direction];
+        return $this;
+    }
+
+
+    /**
+     * Turn the Robot counterclockwise
+     * @return Robot
+     */
+    public function turnLeft()
+    {
+        $this->direction = self::listDirectionsCounterClockwize()[$this->direction];
+        return $this;
+    }
+
+
+    /**
+     * Advance the Robot one step forward
+     * @return Robot
+     */
+    public function advance()
+    {
+        switch ($this->direction) {
+            case self::DIRECTION_NORTH:
+                $this->position[1]++;
+                break;
+
+            case self::DIRECTION_EAST:
+                $this->position[0]++;
+                break;
+
+            case self::DIRECTION_SOUTH:
+                $this->position[1]--;
+                break;
+
+            case self::DIRECTION_WEST:
+                $this->position[0]--;
+                break;
+        }
+        return $this;
+    }
+
+
+    /**
+     * Move the Robot according to instructions: R = Turn Right, L = Turn Left and A = Advance
+     */
+    public function instructions($instructions)
+    {
+        if (!preg_match('/^[LAR]+$/', $instructions)) {
+            throw new InvalidArgumentException('Malformed instructions');
+        }
+
+        foreach ($this->mapInsructionsToActions($instructions) as $action) {
+            $this->$action();
+        }
+        return $this;
+    }
+
+
+    /**
+     * List all possible clockwise turn combinations
+     * @return array
+     */
+    public static function listDirectionsClockwize()
+    {
+        return [
+            self::DIRECTION_NORTH => self::DIRECTION_EAST,
+            self::DIRECTION_EAST => self::DIRECTION_SOUTH,
+            self::DIRECTION_SOUTH => self::DIRECTION_WEST,
+            self::DIRECTION_WEST => self::DIRECTION_NORTH,
+        ];
+    }
+
+
+    /**
+     * List all possible counterclockwise turn combinations
+     * @return array
+     */
+    public static function listDirectionsCounterClockwize()
+    {
+        return array_flip(self::listDirectionsClockwize());
+    }
+
+
+    /**
+     * Translate instructions string to actions
+     * @param string $stringInstructions
+     * @return string[]
+     */
+    protected function mapInsructionsToActions($stringInstructions)
+    {
+        return array_map(function ($x) {
+            return [
+                'L' => 'turnLeft',
+                'R' => 'turnRight',
+                'A' => 'advance',
+            ][$x];
+        }, str_split($stringInstructions));
+    }
+}

data/tracks/php/exercises/robot-simulator/robot-simulator_test.php

@@ -0,0 +1,168 @@
+<?php
+
+include_once 'robot-simulator.php';
+
+class RobotSimulatorTest extends PHPUnit_Framework_TestCase
+{
+
+
+    /**
+     * A robot is created with a position and a direction
+     */
+    public function testCreate()
+    {
+        // Robots are created with a position and direction
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_NORTH, $robot->direction);
+
+        // Negative positions are allowed
+        $robot = new Robot([-1, -1], Robot::DIRECTION_SOUTH);
+        $this->assertEquals([-1, -1], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_SOUTH, $robot->direction);
+    }
+
+
+    /**
+     * Rotate the robot's direction 90 degrees clockwise
+     */
+    public function testTurnRight()
+    {
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+
+        // Change the direction from north to east
+        $robot->turnRight();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_EAST, $robot->direction);
+
+        // Change the direction from east to south
+        $robot->turnRight();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_SOUTH, $robot->direction);
+
+        // Change the direction from south to west
+        $robot->turnRight();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_WEST, $robot->direction);
+
+        // Change the direction from west to north
+        $robot->turnRight();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_NORTH, $robot->direction);
+    }
+
+    /**
+     * Rotate the robot's direction 90 degrees counterclockwise
+     */
+    public function testTurnLeft()
+    {
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+
+        // Change the direction from north to west
+        $robot->turnLeft();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_WEST, $robot->direction);
+
+        // Change the direction from west to south
+        $robot->turnLeft();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_SOUTH, $robot->direction);
+
+        // Change the direction from south to east
+        $robot->turnLeft();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_EAST, $robot->direction);
+
+        // Change the direction from east to north
+        $robot->turnLeft();
+        $this->assertEquals([0, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_NORTH, $robot->direction);
+    }
+
+
+    /**
+     * Move the robot forward 1 space in the direction it is pointing
+     */
+    public function testAdvance()
+    {
+        // Increases the y coordinate by one when facing north
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+        $robot->advance();
+        $this->assertEquals([0, 1], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_NORTH, $robot->direction);
+
+        // Decreases the y coordinate by one when facing south
+        $robot = new Robot([0, 0], Robot::DIRECTION_SOUTH);
+        $robot->advance();
+        $this->assertEquals([0, -1], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_SOUTH, $robot->direction);
+
+        // Increases the x coordinate by one when facing east
+        $robot = new Robot([0, 0], Robot::DIRECTION_EAST);
+        $robot->advance();
+        $this->assertEquals([1, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_EAST, $robot->direction);
+
+        // Decreases the x coordinate by one when facing west
+        $robot = new Robot([0, 0], Robot::DIRECTION_WEST);
+        $robot->advance();
+        $this->assertEquals([-1, 0], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_WEST, $robot->direction);
+    }
+
+
+    /**
+     * Where R = Turn Right, L = Turn Left and A = Advance,
+     * the robot can follow a series of instructions
+     * and end up with the correct position and direction
+     */
+    public function testInstructions()
+    {
+        // Instructions to move west and north
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+        $robot->instructions('LAAARALA');
+        $this->assertEquals([-4, 1], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_WEST, $robot->direction);
+
+        // Instructions to move west and south
+        $robot = new Robot([2, -7], Robot::DIRECTION_EAST);
+        $robot->instructions('RRAAAAALA');
+        $this->assertEquals([-3, -8], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_SOUTH, $robot->direction);
+
+        // Instructions to move east and north
+        $robot = new Robot([8, 4], Robot::DIRECTION_SOUTH);
+        $robot->instructions('LAAARRRALLLL');
+        $this->assertEquals([11, 5], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_NORTH, $robot->direction);
+    }
+
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testMalformedInstructions()
+    {
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+        $robot->instructions('LARX');
+    }
+
+
+    /**
+     * Optional instructions chaining
+     */
+    public function testInstructionsChaining()
+    {
+        $robot = new Robot([0, 0], Robot::DIRECTION_NORTH);
+        $robot->turnLeft()
+            ->advance()
+            ->advance()
+            ->advance()
+            ->turnRight()
+            ->advance()
+            ->turnLeft()
+            ->advance();
+        $this->assertEquals([-4, 1], $robot->position);
+        $this->assertEquals(Robot::DIRECTION_WEST, $robot->direction);
+    }
+}

data/tracks/pony/config.json

@@ -10,58 +10,67 @@
   ],
   "exercises": [
     {
-      "difficulty": 1,
       "slug": "hello-world",
+      "difficulty": 1,
       "topics": [
         "strings",
         "default arguments"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "difference-of-squares",
+      "difficulty": 1,
       "topics": [
         "iterators"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "bob",
+      "difficulty": 1,
       "topics": [
         "strings"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "hamming",
+      "difficulty": 1,
       "topics": [
         "errors"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "leap",
+      "difficulty": 1,
       "topics": [
         "math",
         "booleans"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "anagram",
+      "difficulty": 1,
       "topics": [
         "reference capabilities",
         "strings"
       ]
     },
     {
-      "difficulty": 1,
       "slug": "rna-transcription",
+      "difficulty": 1,
       "topics": [
         "strings",
         "errors",
         "iterators"
       ]
+    },
+    {
+      "slug": "roman-numerals",
+      "difficulty": 2,
+      "topics": [
+        "strings",
+        "errors",
+        "math"
+      ]
     }
   ]
 }

data/tracks/pony/exercises/roman-numerals/example.pony

@@ -0,0 +1,35 @@
+use "collections"
+
+primitive RomanNumerals
+  fun apply(n: USize): String ? =>
+    if n == 0 then
+      return ""
+    elseif n >= 4000 then
+      error
+    end
+
+    let numerals: Array[(USize, String)] = [
+      (1000, "M"),
+      (900, "CM"),
+      (500, "D"),
+      (400, "CD"),
+      (100, "C"),
+      (90, "XC"),
+      (50, "L"),
+      (40, "XL"),
+      (10, "X"),
+      (9, "IX"),
+      (5, "V"),
+      (4, "IV"),
+      (1, "I")
+    ]
+
+    let str = recover String end
+    var n' = n
+    for (arabic, roman) in numerals.values() do
+      while n' >= arabic do
+        str.append(roman)
+        n' = n' - arabic
+      end
+    end
+    str

data/tracks/pony/exercises/roman-numerals/test.pony

@@ -0,0 +1,45 @@
+use "ponytest"
+
+actor Main is TestList
+  new create(env: Env) =>
+    PonyTest(env, this)
+
+  fun tag tests(test: PonyTest) =>
+    test(_TestRomanNumerals)
+
+class iso _TestRomanNumerals is UnitTest
+  fun name(): String => "roman-numerals/RomanNumerals"
+
+  fun apply(h: TestHelper) =>
+    let tests: Array[(USize, String)] = [
+      (0, ""),
+      (1, "I"),
+      (2, "II"),
+      (3, "III"),
+      (4, "IV"),
+      (5, "V"),
+      (6, "VI"),
+      (9, "IX"),
+      (27, "XXVII"),
+      (48, "XLVIII"),
+      (59, "LIX"),
+      (93, "XCIII"),
+      (141, "CXLI"),
+      (163, "CLXIII"),
+      (402, "CDII"),
+      (575, "DLXXV"),
+      (911, "CMXI"),
+      (1024, "MXXIV"),
+      (3000, "MMM")
+    ]
+
+    for test in tests.values() do
+      try
+        h.assert_eq[String](RomanNumerals(test._1), test._2)
+      else
+        h.fail()
+      end
+    end
+
+    h.assert_error({() ? => RomanNumerals(-1)})
+    h.assert_error({() ? => RomanNumerals(4000)})

data/tracks/python/requirements-travis.txt

@@ -1,3 +1,3 @@
 flake8>=3.2,<3.2.99
 pep8>=1.7,<1.7.99
-pyflakes>=1.3,<1.3.99
+pyflakes>=1.5,<1.5.99

data/tracks/ruby/.rubocop.yml

@@ -1559,7 +1559,7 @@ Style/SpaceAfterColon:
 Style/SpaceAfterComma:
   Description: Use spaces after commas.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#spaces-operators
-  Enabled: false
+  Enabled: true
 
 # Supports --auto-correct
 Style/SpaceAfterControlKeyword: