trackler 2.2.1.56 → 2.2.1.57

data/tracks/php/exercises/rail-fence-cipher/example.php

@@ -0,0 +1,61 @@
+<?php
+function encode($plainMessage, $rails)
+{
+    $cipherMessage = [];
+    $position = ($rails * 2) - 2;
+    for ($index = 0; $index < strlen($plainMessage); $index++) {
+        for ($step = 0; $step < $rails; $step++) {
+            if (!isset($cipherMessage[$step])) {
+                $cipherMessage[$step] = '';
+            }
+            if ($index % $position == $step || $index % $position == $position-$step) {
+                $cipherMessage[$step] .= $plainMessage[$index];
+            } else {
+                $cipherMessage[$step] .= ".";
+            }
+        }
+    }
+    return implode('', str_replace('.', '', $cipherMessage));
+}
+
+function decode($cipherMessage, $rails)
+{
+    $position = ($rails * 2) - 2;
+    $textLength = strlen($cipherMessage);
+
+    $minLength = floor($textLength / $position);
+    $balance = $textLength % $position;
+    $lengths = [];
+    $strings = [];
+    $totalLengths = 0;
+    //find no of characters in each row
+    for ($rowIndex = 0; $rowIndex < $rails; $rowIndex++) {
+        $lengths[$rowIndex] = $minLength;
+        if ($rowIndex != 0 && $rowIndex != ($rails - 1)) {
+            $lengths[$rowIndex] += $minLength;
+        }
+        if ($balance > $rowIndex) {
+            $lengths[$rowIndex]++;
+        }
+        if ($balance > ($rails + ($rails - $rowIndex) - 2)) {
+            $lengths[$rowIndex]++;
+        }
+        $strings[] = substr($cipherMessage, $totalLengths, $lengths[$rowIndex]);
+        $totalLengths += $lengths[$rowIndex];
+    }
+
+    //convert row of characters to plain message
+    $plainText = '';
+    while (strlen($plainText) < $textLength) {
+        for ($charIndex = 0; $charIndex < $position; $charIndex++) {
+            if (isset($strings[$charIndex])) {
+                $index = $charIndex;
+            } else {
+                $index = $position - $charIndex;
+            }
+            $plainText .= substr($strings[$index], 0, 1);
+            $strings[$index] = substr($strings[$index], 1);
+        }
+    }
+    return $plainText;
+}

data/tracks/php/exercises/rail-fence-cipher/rail-fence-cipher_test.php

@@ -0,0 +1,76 @@
+<?php
+require_once "rail-fence-cipher.php";
+
+class RailFenceCipherTest extends PHPUnit\Framework\TestCase
+{
+
+    /**
+     * Test encode with two rails.
+     */
+    public function testEncodeWithTwoRails()
+    {
+
+        $plainText  = "XOXOXOXOXOXOXOXOXO";
+        $rails = 2;
+        $expected = "XXXXXXXXXOOOOOOOOO";
+        $this->assertEquals(encode($plainText, $rails), $expected);
+    }
+    /**
+     * Test encode with three rails.
+     */
+    public function testEncodeWithThreeRails()
+    {
+        $this->markTestSkipped();
+        $plainText  = "WEAREDISCOVEREDFLEEATONCE";
+        $rails = 3;
+        $expected = "WECRLTEERDSOEEFEAOCAIVDEN";
+        $this->assertEquals(encode($plainText, $rails), $expected);
+    }
+
+    /**
+     * Test encode with ending in the middle.
+     */
+    public function testEncodeWithEndingInTheMiddle()
+    {
+        $this->markTestSkipped();
+        $plainText  = "EXERCISES";
+        $rails = 4;
+        $expected = "ESXIEECSR";
+        $this->assertEquals(encode($plainText, $rails), $expected);
+    }
+
+    /**
+     * Test decode with three rails.
+     */
+    public function testDecodeWithThreeRails()
+    {
+        $this->markTestSkipped();
+        $encryptedText  = "TEITELHDVLSNHDTISEIIEA";
+        $rails = 3;
+        $expected = "THEDEVILISINTHEDETAILS";
+        $this->assertEquals(decode($encryptedText, $rails), $expected);
+    }
+    /**
+     * Test decode with five rails.
+     */
+    public function testDecodeWithFiveRails()
+    {
+        $this->markTestSkipped();
+        $encryptedText  = "EIEXMSMESAORIWSCE";
+        $rails = 5;
+        $expected = "EXERCISMISAWESOME";
+        $this->assertEquals(decode($encryptedText, $rails), $expected);
+    }
+
+    /**
+     * Test decode with six rails.
+     */
+    public function testDecodeWithSixRails()
+    {
+        $this->markTestSkipped();
+        $encryptedText  = "133714114238148966225439541018335470986172518171757571896261";
+        $rails = 6;
+        $expected = "112358132134558914423337761098715972584418167651094617711286";
+        $this->assertEquals(decode($encryptedText, $rails), $expected);
+    }
+}

data/tracks/purescript/.travis.yml

@@ -9,7 +9,7 @@ install:
 
 script:
   - bin/fetch-configlet
-  - bin/configlet lint .
+  - bin/configlet --track-id purescript lint .
   - bin/check-bower.sh
   - bin/test.sh
 

data/tracks/python/config.json

@@ -1115,6 +1115,19 @@
         "exception_handling"
       ]
     },
+    {
+        "uuid": "55c818d6-04a8-2480-de83-9f85fd0d2eafa71935f",
+        "slug": "pov",
+        "core": false,
+        "unlocked_by": null,
+        "difficulty": 9,
+        "topics": [
+            "graphs",
+            "recursion",
+            "searching",
+            "trees"
+        ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",

data/tracks/python/exercises/alphametics/example.py

@@ -1,29 +1,42 @@
-from itertools import combinations, permutations
-
-
-def check_leading_zeros(*numbers):
-    return any(n[0] == '0' for n in numbers)
-
-
-def test_equation(puzzle, substitutions):
-    equation = ''.join(substitutions.get(char) or char for char in puzzle)
-    left, right = equation.split(' == ')
-    left_numbers = left.split(' + ')
-
-    if check_leading_zeros(right, *left_numbers):
-        return False
-
-    return sum(map(int, left_numbers)) == int(right)
-
-
-def solve(puzzle):
-    letters = set(char for char in puzzle if char.isupper())
-    numbers = map(str, range(10))
-
-    for c in combinations(numbers, len(letters)):
-        for p in permutations(c):
-            substitutions = dict(zip(letters, p))
-            if test_equation(puzzle, substitutions):
-                return {k: int(v) for k, v in substitutions.items()}
-
-    return {}  # no solution found
+from itertools import permutations
+from string import ascii_uppercase as acu, digits
+acuset = set(acu)
+dset = set(digits)
+
+
+def solve(an):
+    fullexp = [tuple(map(str.strip, s.split("+")))
+               for s in an.upper().split("==")]
+    digexp = [[w[-1] for w in s] for s in fullexp]
+
+    alphas = set("".join([w for s in fullexp for w in s]))
+    if not alphas <= acuset:
+        raise ValueError
+    leadchars = set([w[0] for s in fullexp for w in s])
+    digchars = set([x for s in digexp for x in s])
+    leadigchars = leadchars & digchars
+    leadigcharslen = len(leadigchars)
+    leadother = leadchars - leadigchars
+    leadotherlen = len(leadother)
+
+    digtuple = tuple(leadigchars) + tuple(set(digchars) - leadigchars)
+    othertuple = tuple(leadother) + tuple(alphas - digchars - leadother)
+    combostg = "".join(digtuple + othertuple)
+    olen = len(othertuple)
+    for digtest in permutations(digits, len(digtuple)):
+        if any(map(lambda x: x == "0", digtest[:leadigcharslen])):
+            continue
+        td = dict(zip(digtuple, digtest))
+        digeval = [[int(td[w]) for w in s] for s in digexp]
+        if (sum(digeval[0]) % 10) == (sum(digeval[1]) % 10):
+            for otest in permutations(dset - set(digtest), olen):
+                if any(map(lambda x: x == "0", otest[:leadotherlen])):
+                    continue
+                b = an
+                for c, v in zip(combostg, "".join(digtest + otest)):
+                    b = b.replace(c, v)
+                fulleval = [[int(w.strip())
+                             for w in s.split("+")] for s in b.split("==")]
+                if sum(fulleval[0]) == sum(fulleval[1]):
+                    return dict(zip(combostg, map(int, digtest + otest)))
+    return {}

data/tracks/python/exercises/crypto-square/crypto_square_test.py

@@ -3,26 +3,33 @@ import unittest
 from crypto_square import encode
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v3.1.0
+
 class CryptoSquareTest(unittest.TestCase):
     def test_empty_string(self):
         self.assertEqual(encode(''), '')
 
-    def test_perfect_square(self):
-        self.assertEqual(encode('ABCD'), 'ac bd')
+    def test_lowercase(self):
+        self.assertEqual(encode('A'), 'a')
+
+    def test_remove_spaces(self):
+        self.assertEqual(encode('  b '), 'b')
+
+    def test_remove_punctuation(self):
+        self.assertEqual(encode('@1,%!'), '1')
 
-    def test_small_imperfect_square(self):
-        self.assertEqual(encode('This is easy!'), 'tis hsy ie sa')
+    def test_9chars_results_3chunks(self):
+        self.assertEqual(encode('This is fun!'), 'tsf hiu isn')
 
-    def test_punctuation_and_numbers(self):
-        msg = "1, 2, 3, Go! Go, for God's sake!"
-        ciph = '1gga 2ook 3fde gos ors'
-        self.assertEqual(encode(msg), ciph)
+    def test_8chars_results_3chunks_ending_space(self):
+        self.assertEqual(encode('Chill out.'), 'clu hlt io ')
 
-    def test_long_string(self):
-        msg = ("If man was meant to stay on the ground, god would have given "
-               "us roots.")
-        ciph = "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau"
-        self.assertEqual(encode(msg), ciph)
+    def test_54chars_results_7chunks_2ending_space(self):
+        self.assertEqual(
+            encode('If man was meant to stay on the ground, '
+                   'god would have given us roots.'),
+            'imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau '
+        )
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/crypto-square/example.py

@@ -12,7 +12,7 @@ def encode(msg):
     square_size = int(ceil(sqrt(len(msg))))
     square = _chunks_of(msg, square_size)
     return ' '.join([''.join(col)
-                     for col in zip_longest(*square, fillvalue='')])
+                     for col in zip_longest(*square, fillvalue=' ')])
 
 
 def _cleanse(s):

data/tracks/python/exercises/kindergarten-garden/kindergarten_garden_test.py

@@ -2,14 +2,26 @@ import unittest
 
 from kindergarten_garden import Garden
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 
 class KindergartenGardenTests(unittest.TestCase):
-    def test_alices_garden(self):
+    def test_garden_with_single_student(self):
         self.assertEqual(
             Garden("RC\nGG").plants("Alice"),
             "Radishes Clover Grass Grass".split())
 
-    def test_bob_and_charlies_gardens(self):
+    def test_different_garden_with_single_student(self):
+        self.assertEqual(
+            Garden("VC\nRC").plants("Alice"),
+            "Violets Clover Radishes Clover".split())
+
+    def test_garden_with_two_students(self):
+        garden = Garden("VVCG\nVVRC")
+        self.assertEqual(
+            garden.plants("Bob"), "Clover Grass Radishes Clover".split())
+
+    def test_multiple_students_for_the_same_garden_with_three_students(self):
         garden = Garden("VVCCGG\nVVCCGG")
         self.assertEqual(garden.plants("Bob"), ["Clover"] * 4)
         self.assertEqual(garden.plants("Charlie"), ["Grass"] * 4)
@@ -26,6 +38,7 @@ class KindergartenGardenTests(unittest.TestCase):
         self.assertEqual(
             garden.plants("Larry"), "Grass Violets Clover Violets".split())
 
+    # Additional tests for this track
     def test_disordered_test(self):
         garden = Garden(
             "VCRRGVRG\nRVGCCGCV",

data/tracks/python/exercises/phone-number/README.md

@@ -14,7 +14,8 @@ The format is usually represented as
 
 where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
 
-Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the 
+country code (1) if present.
 
 For example, the inputs
 - `+1 (613)-995-0253`

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

@@ -0,0 +1,53 @@
+# POV
+
+Reparent a graph on a selected node.
+
+### Tree Reparenting
+
+This exercise is all about re-orientating a graph to see things from a different
+point of view. For example family trees are usually presented from the
+ancestor's perspective:
+
+```text
+    +------0------+
+    |      |      |
+  +-1-+  +-2-+  +-3-+
+  |   |  |   |  |   |
+  4   5  6   7  8   9
+```
+
+But the same information can be presented from the perspective of any other node
+in the graph, by pulling it up to the root and dragging its relationships along
+with it. So the same graph from 6's perspective would look like:
+
+```text
+        6
+        |
+  +-----2-----+
+  |           |
+  7     +-----0-----+
+        |           |
+      +-1-+       +-3-+
+      |   |       |   |
+      4   5       8   9
+```
+
+This lets us more simply describe the paths between two nodes. So for example
+the path from 6-9 (which in the first graph goes up to the root and then down to
+a different leaf node) can be seen to follow the path 6-2-0-3-9
+
+This exercise involves taking an input graph and re-orientating it from the point
+of view of one of the nodes.
+
+## 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/pov/example.py

@@ -0,0 +1,70 @@
+from json import dumps
+
+
+class Tree(object):
+    def __init__(self, label, children=[]):
+        self.label = label
+        self.children = children
+
+    def __dict__(self):
+        return {self.label: [c.__dict__() for c in sorted(self.children)]}
+
+    def __str__(self, indent=None):
+        return dumps(self.__dict__(), indent=indent)
+
+    def __lt__(self, other):
+        return self.label < other.label
+
+    def __eq__(self, other):
+        return self.__dict__() == other.__dict__()
+
+    def __iter__(self):
+        yield self.label
+        for child in self.children:
+            for gchild in child:
+                yield gchild
+
+    def dup(self):
+        return Tree(self.label, [c.dup() for c in self.children])
+
+    def add(self, other):
+        tree = self.dup()
+        tree.children.append(other)
+        return tree
+
+    def remove(self, node):
+        tree = self.dup()
+        for child in list(tree.children):
+            tree.children.remove(child)
+            if child.label == node:
+                break
+            tree.children.append(child.remove(node))
+        return tree
+
+    def fromPov(self, from_node):
+        stack = [self]
+        visited = set()
+        while stack:
+            tree = stack.pop(0)
+            if tree.label in visited:
+                continue
+            visited.add(tree.label)
+            if from_node == tree.label:
+                return tree
+            for child in tree.children:
+                stack.append(child.add(tree.remove(child.label)))
+        raise ValueError()
+
+    def pathTo(self, from_node, to_node):
+        reordered = self.fromPov(from_node)
+        stack = reordered.children
+        path = [from_node]
+        while path[-1] != to_node:
+            try:
+                tree = stack.pop()
+            except IndexError:
+                raise ValueError()
+            if to_node in tree:
+                path.append(tree.label)
+                stack = tree.children
+        return path