trackler 2.2.1.61 → 2.2.1.62

data/tracks/perl6/exercises/pangram/Example.pm6

@@ -1,4 +1,4 @@
-unit module Pangram:ver<1>;
+unit module Pangram:ver<2>;
 
 sub is-pangram (Str:D $string --> Bool:D) is export {
   $string.lc.comb ⊇ ‘a’..‘z’

data/tracks/perl6/exercises/pangram/Pangram.pm6

@@ -1,4 +1,4 @@
-unit module Pangram:ver<1>;
+unit module Pangram:ver<2>;
 
 sub is-pangram ($string) is export {
 }

data/tracks/perl6/exercises/pangram/example.yaml

@@ -1,17 +1,23 @@
 exercise: Pangram
-version: 1
+version: 2
 plan: 12
 imports: '&is-pangram'
-tests: |
-  for $c-data<cases>.values -> %case-set {
-    is is-pangram(.<input>), |.<expected description> for %case-set<cases>.values;
+tests: |-
+  for $c-data<cases>».<cases>».Array.flat {
+    given is-pangram .<input> -> $result {
+      subtest .<description>, {
+        plan 2;
+        isa-ok $result, Bool;
+        is-deeply $result, .<expected>, 'Result matches expected';
+      }
+    }
   }
 
 unit: module
-example: |
+example: |-
   sub is-pangram (Str:D $string --> Bool:D) is export {
     $string.lc.comb ⊇ ‘a’..‘z’
   }
-stub: |
+stub: |-
   sub is-pangram ($string) is export {
   }

data/tracks/perl6/exercises/pangram/pangram.t

@@ -5,7 +5,7 @@ use lib my $dir = $?FILE.IO.dirname;
 use JSON::Fast;
 
 my Str:D $exercise := 'Pangram';
-my Version:D $version = v1;
+my Version:D $version = v2;
 my Str $module //= $exercise;
 plan 12;
 
@@ -22,8 +22,14 @@ if ::($exercise).^ver !~~ $version {
 require ::($module) <&is-pangram>;
 
 my $c-data = from-json $=pod.pop.contents;
-for $c-data<cases>.values -> %case-set {
-  is is-pangram(.<input>), |.<expected description> for %case-set<cases>.values;
+for $c-data<cases>».<cases>».Array.flat {
+  given is-pangram .<input> -> $result {
+    subtest .<description>, {
+      plan 2;
+      isa-ok $result, Bool;
+      is-deeply $result, .<expected>, 'Result matches expected';
+    }
+  }
 }
 
 =head2 Canonical Data

data/tracks/python/config.json

@@ -54,6 +54,20 @@
         "logic"
       ]
     },
+    {
+      "uuid": "7126f86c-0e7f-7080-b4cb-3c8457dfcadcfe7e446",
+      "slug": "parallel-letter-frequency",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 5,
+      "topics": [
+        "threading",
+        "parallellism",
+        "loops",
+        "queues",
+        "strings"
+      ]
+    },
     {
       "uuid": "ca7c5ef1-5135-4fb4-8e68-669ef0f2a51a",
       "slug": "rna-transcription",
@@ -1021,6 +1035,17 @@
         "text_formatting"
       ]
     },
+    {
+      "uuid": "f5503274-ac23-11e7-abc4-cec278b6b50a",
+      "slug": "connect",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "parsing",
+        "transforming"
+      ]
+    },
     {
       "uuid": "33f689ee-1d9c-4908-a71c-f84bff3510df",
       "slug": "collatz-conjecture",
@@ -1031,6 +1056,19 @@
         "loops"
       ]
     },
+    {
+      "uuid": "d4ddeb18-ac22-11e7-abc4-cec278b6b50a",
+      "slug": "go-counting",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "parsing",
+        "tuples",
+        "optional_values",
+        "classes"
+      ]
+    },
     {
       "uuid": "7f4d5743-7ab8-42ca-b393-767f7e9a4e97",
       "slug": "complex-numbers",

data/tracks/python/exercises/complex-numbers/complex_numbers_test.py

@@ -5,61 +5,46 @@ import math
 from complex_numbers import ComplexNumber
 
 
-class ComplexNumbersTest(unittest.TestCase):
-
-    def test_real_part_of_a_purely_real_number(self):
-        input_number = ComplexNumber(1, 0)
-        self.assertEqual(input_number.real, 1)
-
-    def test_real_part_of_a_purely_imaginary_number(self):
-        input_number = ComplexNumber(0, 1)
-        self.assertEqual(input_number.real, 0)
-
-    def test_real_part_of_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 2)
-        self.assertEqual(input_number.real, 1)
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
-    def test_imaginary_part_of_a_purely_real_number(self):
-        input_number = ComplexNumber(1, 0)
-        self.assertEqual(input_number.imaginary, 0)
 
-    def test_imaginary_part_of_a_purely_imaginary_number(self):
-        input_number = ComplexNumber(0, 1)
-        self.assertEqual(input_number.imaginary, 1)
-
-    def test_maginary_part_of_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 2)
-        self.assertEqual(input_number.imaginary, 2)
+class ComplexNumbersTest(unittest.TestCase):
 
     def test_add_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
-        second_input = ComplexNumber(3, 0)
-        self.assertEqual(first_input.add(second_input).real, 4)
+        second_input = ComplexNumber(2, 0)
+        self.assertEqual(first_input.add(second_input).real, 3)
         self.assertEqual(first_input.add(second_input).imaginary, 0)
 
     def test_add_purely_imaginary_numbers(self):
         first_input = ComplexNumber(0, 1)
-        second_input = ComplexNumber(0, 3)
+        second_input = ComplexNumber(0, 2)
         self.assertEqual(first_input.add(second_input).real, 0)
-        self.assertEqual(first_input.add(second_input).imaginary, 4)
+        self.assertEqual(first_input.add(second_input).imaginary, 3)
 
     def test_add_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(4, 6)
-        self.assertEqual(first_input.add(second_input).real, 5)
-        self.assertEqual(first_input.add(second_input).imaginary, 8)
+        second_input = ComplexNumber(3, 4)
+        self.assertEqual(first_input.add(second_input).real, 4)
+        self.assertEqual(first_input.add(second_input).imaginary, 6)
 
     def test_subtract_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
-        second_input = ComplexNumber(-1, 0)
-        self.assertEqual(first_input.sub(second_input).real, 2)
+        second_input = ComplexNumber(2, 0)
+        self.assertEqual(first_input.sub(second_input).real, -1)
         self.assertEqual(first_input.sub(second_input).imaginary, 0)
 
+    def test_subtract_purely_imaginary_numbers(self):
+        first_input = ComplexNumber(0, 1)
+        second_input = ComplexNumber(0, 2)
+        self.assertEqual(first_input.sub(second_input).real, 0)
+        self.assertEqual(first_input.sub(second_input).imaginary, -1)
+
     def test_subtract_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(-2, -2)
-        self.assertEqual(first_input.sub(second_input).real, 3)
-        self.assertEqual(first_input.sub(second_input).imaginary, 4)
+        second_input = ComplexNumber(3, 4)
+        self.assertEqual(first_input.sub(second_input).real, -2)
+        self.assertEqual(first_input.sub(second_input).imaginary, -2)
 
     def test_multiply_purely_real_numbers(self):
         first_input = ComplexNumber(1, 0)
@@ -67,35 +52,41 @@ class ComplexNumbersTest(unittest.TestCase):
         self.assertEqual(first_input.mul(second_input).real, 2)
         self.assertEqual(first_input.mul(second_input).imaginary, 0)
 
+    def test_multiply_purely_imaginary_numbers(self):
+        first_input = ComplexNumber(0, 1)
+        second_input = ComplexNumber(0, 2)
+        self.assertEqual(first_input.mul(second_input).real, -2)
+        self.assertEqual(first_input.mul(second_input).imaginary, 0)
+
     def test_multiply_numbers_with_real_and_imaginary_part(self):
         first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(-5, 10)
-        self.assertEqual(first_input.mul(second_input).real, -25)
-        self.assertEqual(first_input.mul(second_input).imaginary, 0)
+        second_input = ComplexNumber(3, 4)
+        self.assertEqual(first_input.mul(second_input).real, -5)
+        self.assertEqual(first_input.mul(second_input).imaginary, 10)
 
     def test_divide_purely_real_numbers(self):
         input_number = ComplexNumber(1.0, 0.0)
         expected = ComplexNumber(0.5, 0.0)
         divider = ComplexNumber(2.0, 0.0)
-        self.assertEqual(expected.real, input_number.div(divider).real)
-        self.assertEqual(expected.imaginary,
-                         input_number.div(divider).imaginary)
+        self.assertEqual(input_number.div(divider).real, expected.real)
+        self.assertEqual(input_number.div(divider).imaginary,
+                         expected.imaginary)
 
     def test_divide_purely_imaginary_numbers(self):
         input_number = ComplexNumber(0, 1)
         expected = ComplexNumber(0.5, 0)
         divider = ComplexNumber(0, 2)
-        self.assertEqual(expected.real, input_number.div(divider).real)
-        self.assertEqual(expected.imaginary,
-                         input_number.div(divider).imaginary)
+        self.assertEqual(input_number.div(divider).real, expected.real)
+        self.assertEqual(input_number.div(divider).imaginary,
+                         expected.imaginary)
 
     def test_divide_numbers_with_real_and_imaginary_part(self):
         input_number = ComplexNumber(1, 2)
         expected = ComplexNumber(0.44, 0.08)
         divider = ComplexNumber(3, 4)
-        self.assertEqual(expected.real, input_number.div(divider).real)
-        self.assertEqual(expected.imaginary,
-                         input_number.div(divider).imaginary)
+        self.assertEqual(input_number.div(divider).real, expected.real)
+        self.assertEqual(input_number.div(divider).imaginary,
+                         expected.imaginary)
 
     def test_absolute_value_of_a_positive_purely_real_number(self):
         self.assertEqual(ComplexNumber(5, 0).abs(), 5)
@@ -103,53 +94,77 @@ class ComplexNumbersTest(unittest.TestCase):
     def test_absolute_value_of_a_negative_purely_real_number(self):
         self.assertEqual(ComplexNumber(-5, 0).abs(), 5)
 
-    def test_absolute_value_of_imaginary_number_negative_imaginary_part(self):
-        self.assertEqual(ComplexNumber(0, -5).abs(), 5)
-
     def test_absolute_value_of_imaginary_number_positive_imaginary_part(self):
         self.assertEqual(ComplexNumber(0, 5).abs(), 5)
 
+    def test_absolute_value_of_imaginary_number_negative_imaginary_part(self):
+        self.assertEqual(ComplexNumber(0, -5).abs(), 5)
+
     def test_absolute_value_of_a_number_with_real_and_imaginary_part(self):
         self.assertEqual(ComplexNumber(3, 4).abs(), 5)
 
     def test_conjugate_a_purely_real_number(self):
         input_number = ComplexNumber(5, 0)
         expected = ComplexNumber(5, 0)
-        self.assertEqual(expected.real, input_number.conjugate().real)
-        self.assertEqual(expected.imaginary,
-                         input_number.conjugate().imaginary)
+        self.assertEqual(input_number.conjugate().real, expected.real)
+        self.assertEqual(input_number.conjugate().imaginary,
+                         expected.imaginary)
 
     def test_conjugate_a_purely_imaginary_number(self):
         input_number = ComplexNumber(0, 5)
         expected = ComplexNumber(0, -5)
-        self.assertEqual(expected.real, input_number.conjugate().real)
-        self.assertEqual(expected.imaginary,
-                         input_number.conjugate().imaginary)
+        self.assertEqual(input_number.conjugate().real, expected.real)
+        self.assertEqual(input_number.conjugate().imaginary,
+                         expected.imaginary)
 
-    def conjugate_a_number_with_real_and_imaginary_part(self):
+    def test_conjugate_a_number_with_real_and_imaginary_part(self):
         input_number = ComplexNumber(1, 1)
         expected = ComplexNumber(1, -1)
-        self.assertEqual(expected.real, input_number.conjugate().real)
-        self.assertEqual(expected.imaginary,
-                         input_number.conjugate().imaginary)
+        self.assertEqual(input_number.conjugate().real, expected.real)
+        self.assertEqual(input_number.conjugate().imaginary,
+                         expected.imaginary)
+
+    def test_real_part_of_a_purely_real_number(self):
+        input_number = ComplexNumber(1, 0)
+        self.assertEqual(input_number.real, 1)
+
+    def test_real_part_of_a_purely_imaginary_number(self):
+        input_number = ComplexNumber(0, 1)
+        self.assertEqual(input_number.real, 0)
+
+    def test_real_part_of_a_number_with_real_and_imaginary_part(self):
+        input_number = ComplexNumber(1, 2)
+        self.assertEqual(input_number.real, 1)
+
+    def test_imaginary_part_of_a_purely_real_number(self):
+        input_number = ComplexNumber(1, 0)
+        self.assertEqual(input_number.imaginary, 0)
+
+    def test_imaginary_part_of_a_purely_imaginary_number(self):
+        input_number = ComplexNumber(0, 1)
+        self.assertEqual(input_number.imaginary, 1)
+
+    def test_imaginary_part_of_a_number_with_real_and_imaginary_part(self):
+        input_number = ComplexNumber(1, 2)
+        self.assertEqual(input_number.imaginary, 2)
 
     def test_eulers_identity_formula(self):
         input_number = ComplexNumber(0, math.pi)
         expected = ComplexNumber(-1, 0)
-        self.assertEqual(expected.real, input_number.exp().real)
-        self.assertEqual(expected.imaginary, input_number.exp().imaginary)
+        self.assertEqual(input_number.exp().real, expected.real)
+        self.assertEqual(input_number.exp().imaginary, expected.imaginary)
 
     def test_exponential_of_0(self):
         input_number = ComplexNumber(0, 0)
         expected = ComplexNumber(1, 0)
-        self.assertEqual(expected.real, input_number.exp().real)
-        self.assertEqual(expected.imaginary, input_number.exp().imaginary)
+        self.assertEqual(input_number.exp().real, expected.real)
+        self.assertEqual(input_number.exp().imaginary, expected.imaginary)
 
     def test_exponential_of_a_purely_real_number(self):
         input_number = ComplexNumber(1, 0)
         expected = ComplexNumber(math.e, 0)
-        self.assertEqual(expected.real, input_number.exp().real)
-        self.assertEqual(expected.imaginary, input_number.exp().imaginary)
+        self.assertEqual(input_number.exp().real, expected.real)
+        self.assertEqual(input_number.exp().imaginary, expected.imaginary)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/connect/README.md

@@ -0,0 +1,44 @@
+# Connect
+
+Compute the result for a game of Hex / Polygon.
+
+The abstract boardgame known as
+[Hex](https://en.wikipedia.org/wiki/Hex_%28board_game%29) / Polygon /
+CON-TAC-TIX is quite simple in rules, though complex in practice. Two players
+place stones on a rhombus with hexagonal fields. The player to connect his/her
+stones to the opposite side first wins. The four sides of the rhombus are
+divided between the two players (i.e. one player gets assigned a side and the
+side directly opposite it and the other player gets assigned the two other
+sides).
+
+Your goal is to build a program that given a simple representation of a board
+computes the winner (or lack thereof). Note that all games need not be "fair".
+(For example, players may have mismatched piece counts.)
+
+The boards look like this (with spaces added for readability, which won't be in
+the representation passed to your code):
+
+```
+. O . X .
+ . X X O .
+  O O O X .
+   . X O X O
+    X O O O X
+```
+
+"Player `O`" plays from top to bottom, "Player `X`" plays from left to right. In
+the above example `O` has made a connection from left to right but nobody has
+won since `O` didn't connect top and bottom.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/connect/connect.py

@@ -0,0 +1,7 @@
+
+class ConnectGame:
+    def __init__(self, board):
+        pass
+
+    def get_winner(self):
+        pass

data/tracks/python/exercises/connect/connect_test.py

@@ -0,0 +1,118 @@
+import unittest
+
+import connect
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+
+testcases = [
+    {
+        "description": "an empty board has no winner",
+        "board":
+        """ . . . . .
+             . . . . .
+              . . . . .
+               . . . . .
+                . . . . .""",
+        "winner": ""
+    },
+    {
+        "description": "O can win on a 1x1 board",
+        "board": "O",
+        "winner": "O"
+    },
+    {
+        "description": "X can win on a 1x1 board",
+        "board": "X",
+        "winner": "X"
+    },
+    {
+        "description": "only edges does not make a winner",
+        "board":
+            """ O O O X
+                 X . . X
+                  X . . X
+                   X O O O""",
+        "winner": ""
+    },
+    {
+        "description": "illegal diagonal does not make a winner",
+        "board":
+            """ X O . .
+                 O X X X
+                  O X O .
+                   . O X .
+                    X X O O""",
+        "winner": ""
+    },
+    {
+        "description": "nobody wins crossing adjacent angles",
+        "board":
+            """ X . . .
+                 . X O .
+                  O . X O
+                   . O . X
+                    . . O .""",
+        "winner": ""
+    },
+    {
+        "description": "X wins crossing from left to right",
+        "board":
+            """ . O . .
+                 O X X X
+                  O X O .
+                   X X O X
+                    . O X .""",
+        "winner": "X"
+    },
+    {
+        "description": "X wins using a convoluted path",
+        "board":
+            """ . X X . .
+                 X . X . X
+                  . X . X .
+                   . X X . .
+                    O O O O O""",
+        "winner": "X"
+    },
+    {
+        "description": "O wins crossing from top to bottom",
+        "board":
+            """ . O . .
+                 O X X X
+                  O O O .
+                   X X O X
+                    . O X .""",
+        "winner": "O"
+    },
+    {
+        "description": "X wins using a spiral path",
+        "board":
+            """ O X X X X X X X X
+                 O X O O O O O O O
+                  O X O X X X X X O
+                   O X O X O O O X O
+                    O X O X X X O X O
+                     O X O O O X O X O
+                      O X X X X X O X O
+                       O O O O O O O X O
+                        X X X X X X X X O """,
+        "winner": "X"
+    },
+]
+
+
+class ConnectTest(unittest.TestCase):
+    def test_game(self):
+        for testcase in testcases:
+            game = connect.ConnectGame(testcase["board"])
+            winner = game.get_winner()
+            expected = testcase["winner"] if testcase["winner"] else "None"
+            got = winner if winner else "None"
+            self.assertEqual(winner, testcase["winner"],
+                             "Test failed: %s, expected winner: %s, got: %s"
+                             % (testcase["description"], expected, got))
+
+
+if __name__ == '__main__':
+    unittest.main()