trackler 2.2.1.62 → 2.2.1.63

data/tracks/python/config.json

@@ -55,7 +55,7 @@
       ]
     },
     {
-      "uuid": "7126f86c-0e7f-7080-b4cb-3c8457dfcadcfe7e446",
+      "uuid": "c4754efd-6d67-48bd-994e-4b07a217ffc3",
       "slug": "parallel-letter-frequency",
       "core": false,
       "unlocked_by": null,
@@ -789,7 +789,7 @@
       ]
     },
     {
-      "uuid": "6aacc273-0a33-8180-679e-c12c440c0fcf89e1fb6",
+      "uuid": "aeaed0e4-0973-4035-8bc5-07480849048f",
       "slug": "tree-building",
       "core": false,
       "unlocked_by": null,
@@ -880,12 +880,24 @@
         "recursion"
       ]
     },
+    {
+        "uuid": "4c6edc8a-7bc0-4386-a653-d1091fe49301",
+        "slug": "simple-linked-list",
+        "core": false,
+        "unlocked_by": null,
+        "difficulty": 1,
+        "topics": [
+          "lists",
+          "algorithms",
+          "conditionals"
+        ]
+    },
     {
       "uuid": "ca7a8b16-e5d5-4211-84f0-2f8e35b4a665",
       "slug": "linked-list",
       "core": false,
-      "unlocked_by": null,
-      "difficulty": 1,
+      "unlocked_by": "simple-linked-list",
+      "difficulty": 3,
       "topics": [
         "lists",
         "algorithms",
@@ -1024,7 +1036,7 @@
       ]
     },
     {
-      "uuid": "bacb2184-025f-0980-38d6-34fb419e03a6d3d8b44",
+      "uuid": "4177de10-f767-4306-b45d-5e9c08ef4753",
       "slug": "two-fer",
       "core": false,
       "unlocked_by": null,
@@ -1091,7 +1103,7 @@
       ]
     },
     {
-      "uuid": "8c89f739-05fb-7b80-b5f9-6ad079c750ba8302be8",
+      "uuid": "6f530d0c-d13e-4270-b120-e42c16691a66",
       "slug": "two-bucket",
       "difficulty": 5,
       "topics": [
@@ -1101,7 +1113,7 @@
       ]
     },
     {
-      "uuid": "1818f134-0ed9-e680-9b29-45ffd2b3344b0f841c7",
+      "uuid": "88610b9a-6d3e-4924-a092-6d2f907ed4e2",
       "slug": "markdown",
       "difficulty": 3,
       "topics": [
@@ -1109,7 +1121,7 @@
       ]
     },
     {
-      "uuid": "e348a307-078c-5280-65af-a159283d4e79438b755",
+      "uuid": "14e1dfe3-a45c-40c1-bf61-2e4f0cca5579",
       "slug": "forth",
       "core": false,
       "unlocked_by": null,
@@ -1132,19 +1144,19 @@
       ]
     },
     {
-        "uuid": "4f5f890d-0db4-5480-f79a-21057c37871b15133dc",
-        "slug": "zipper",
-        "core": false,
-        "unlocked_by": null,
-        "difficulty": 8,
-        "topics": [
-            "recursion",
-            "searching",
-            "trees"
-        ]
+      "uuid": "569210ea-71c1-4fd2-941e-6bf0d953019e",
+      "slug": "zipper",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 8,
+      "topics": [
+          "recursion",
+          "searching",
+          "trees"
+      ]
     },
     {
-      "uuid": "3a2a947a-01b3-1e80-e32b-de1756fd88365adf12e",
+      "uuid": "0dac0feb-e1c8-497e-9a1b-e96e0523eea6",
       "slug": "error-handling",
       "core": false,
       "unlocked_by": null,
@@ -1154,7 +1166,7 @@
       ]
     },
     {
-      "uuid": "4354f631-0cf5-9980-75e7-86d1c3da1f0d3f5e619",
+      "uuid": "54995590-65eb-4178-a527-0d7b1526a843",
       "slug": "dominoes",
       "core": false,
       "unlocked_by": null,
@@ -1165,7 +1177,7 @@
       ]
     },
     {
-      "uuid": "55c818d6-04a8-2480-de83-9f85fd0d2eafa71935f",
+      "uuid": "d98b1080-36d4-4357-b12a-685d204856bf",
       "slug": "pov",
       "core": false,
       "unlocked_by": null,
@@ -1178,7 +1190,7 @@
       ]
     },
     {
-      "uuid": "21dacf48-0580-4d80-a6d2-257b07ad3cc47b02454",
+      "uuid": "4c0d0d6b-347e-40ae-9b51-08555fe76cb9",
       "slug": "react",
       "core": false,
       "unlocked_by": null,

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

@@ -1,42 +1,98 @@
 from itertools import permutations
-from string import ascii_uppercase as acu, digits
+from string import ascii_uppercase as acu
 acuset = set(acu)
-dset = set(digits)
+dset = set(range(10))
+nzdset = dset.copy()
+nzdset.remove(0)
 
 
 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]
+    # Break down to words
+    an = an.upper()
+    alphaexp = [tuple(map(str.strip, s.split("+")))
+                for s in an.split("==")]
+    # Sum powers of 10 for letters ready for computation
+    expdict = dict()
+    loexpdict = dict()
+    for si, s in enumerate(alphaexp):
+        esign = 1 - (si << 1)
+        for t in s:
+            lowletter = t[-1]
+            if lowletter not in loexpdict:
+                loexpdict[lowletter] = 0
+            loexpdict[lowletter] += esign
+            for p, letter in enumerate(reversed(t)):
+                if letter not in expdict:
+                    expdict[letter] = 0
+                expdict[letter] += esign * (10 ** p)
 
-    alphas = set("".join([w for s in fullexp for w in s]))
-    if not alphas <= acuset:
+    # Extract all letters and check if they are really letters
+    alldigits = set(expdict.keys())
+    if not alldigits <= 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)))
+
+    # extract high and low digigts
+    hidigits = set([w[0] for s in alphaexp for w in s])
+    lodigits = set([w[-1] for s in alphaexp for w in s])
+
+    # Break down low digits to nonzeros (also high digits) and possible zeros
+    lonzdigits = lodigits & hidigits
+    lorestdigits = lodigits - lonzdigits
+
+    # Main digits, all but not low
+    maindigits = alldigits - lodigits
+
+    # Break down main digit list into nonzeroees and possible zeroes
+    mainnzdigits = maindigits & hidigits
+    mainrestdigits = maindigits - mainnzdigits
+
+    # change sets to tuples to guarantee the stable order
+    t_lorestdigits = tuple(lorestdigits)
+    t_lonzdigits = tuple(lonzdigits)
+    t_lowdigs = t_lorestdigits + t_lonzdigits
+
+    t_mainrestdigits = tuple(mainrestdigits)
+    t_mainnzdigits = tuple(mainnzdigits)
+    t_maindigs = t_mainrestdigits + t_mainnzdigits
+    t_alldigs = t_lowdigs + t_maindigs
+
+    # Check all possible digit permunations with zeros
+    for lorest in permutations(dset, len(lorestdigits)):
+        remnzdigs = nzdset - set(lorest)
+        # Generate addtional non-zero digit permutations
+        for lonz in permutations(remnzdigs, len(lonzdigits)):
+            # Build a dictionary for to test the expression
+            t_digvals = lorest + lonz
+            # Evaluate the expression sides
+            testsum = sum([dig * loexpdict[let]
+                           for let, dig in zip(t_lowdigs, t_digvals)])
+            if testsum % 10 == 0:
+                # Low digit test passed, check the main digits
+                # if there are no other digits that low digits,
+                # test the whole expression and return if OK
+                if len(maindigits) == 0:
+                    testsum = sum([dig * expdict[let]
+                                   for let, dig in zip(t_lowdigs, t_digvals)])
+                    if testsum == 0:
+                        return dict(zip(t_lowdigs, t_digvals))
+                else:
+                    # non-assigned digits
+                    remdigs = dset - set(t_digvals)
+                    # non-assigned without 0
+                    remnzdigs = remdigs - set((0,))
+                    # permutations for the rest of the digits
+                    for mainrest in permutations(remdigs,
+                                                 len(t_mainrestdigits)):
+                        lastnzdigs = remnzdigs - set(mainrest)
+                        # permutations for the non-zero rest of the digits
+                        for mainnz in permutations(lastnzdigs,
+                                                   len(t_mainnzdigits)):
+                            # Evaluate
+                            t_alldigvals = lorest + lonz + mainrest + mainnz
+                            testsum = sum([dig * expdict[let]
+                                           for let, dig in zip(t_alldigs,
+                                                               t_alldigvals)])
+                            if testsum == 0:
+                                return dict(zip(t_alldigs, t_alldigvals))
+
     return {}

data/tracks/python/exercises/ocr-numbers/example.py

@@ -1,10 +1,10 @@
-ROW = 4
-COL = 3
+NUM_ROWS = 4
+NUM_COLS = 3
 
 
 def split_ocr(ocr):
-    return [[ocr[i][COL * j:COL * (j + 1)] for i in range(ROW)]
-            for j in range(len(ocr[0]) // COL)]
+    return [[ocr[i][NUM_COLS * j:NUM_COLS * (j + 1)] for i in range(NUM_ROWS)]
+            for j in range(len(ocr[0]) // NUM_COLS)]
 
 
 ALL = ['    _  _     _  _  _  _  _  _ ',
@@ -16,11 +16,21 @@ OCR_LIST = split_ocr(ALL)
 OCR_LIST = [OCR_LIST[-1]] + OCR_LIST[:9]
 
 
-def number(ocr):
-    if (len(ocr) != ROW or len(ocr[0]) % COL or
-            any(len(r) != len(ocr[0]) for r in ocr)):
+def convert(input_grid):
+    split_indices = (list(range(0, len(input_grid), NUM_ROWS)) +
+                     [len(input_grid)])
+
+    lines = [input_grid[start:end]
+             for start, end in zip(split_indices[:-1], split_indices[1:])]
+
+    return ",".join(convert_one_line(line) for line in lines)
+
+
+def convert_one_line(input_grid):
+    if (len(input_grid) != NUM_ROWS or len(input_grid[0]) % NUM_COLS or
+            any(len(r) != len(input_grid[0]) for r in input_grid)):
         raise ValueError('Wrong grid size.')
-    numbers = split_ocr(ocr)
+    numbers = split_ocr(input_grid)
     digits = ''
     for n in numbers:
         try:
@@ -28,16 +38,3 @@ def number(ocr):
         except ValueError:
             digits += '?'
     return digits
-
-
-def grid(digits):
-    try:
-        if not digits.isdigit():
-            raise ValueError('String should be numeric.')
-    except AttributeError:
-        raise ValueError('Argument should be a string.')
-    ocr = ['' for i in range(ROW)]
-    for d in digits:
-        for r in range(ROW):
-            ocr[r] += OCR_LIST[int(d)][r]
-    return ocr

data/tracks/python/exercises/ocr-numbers/ocr_numbers.py

@@ -1,6 +1,2 @@
-def number(digits):
-    pass
-
-
-def grid(digits):
+def convert(input_grid):
     pass

data/tracks/python/exercises/ocr-numbers/ocr_numbers_test.py

@@ -1,123 +1,141 @@
 """Tests for the ocr-numbers exercise
 
 Implementation note:
-Both ocr.grid and ocr.number should validate their input
-and raise ValueErrors with meaningful error messages
+ocr.convert should validate its input and
+raise ValueErrors with meaningful error messages
 if necessary.
 """
 
 import unittest
 
-from ocr_numbers import grid, number
+from ocr_numbers import convert
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class OcrTest(unittest.TestCase):
-    def test_0(self):
-        self.assertEqual(number([" _ ",
-                                 "| |",
-                                 "|_|",
-                                 "   "]), '0')
-
-    def test_1(self):
-        self.assertEqual(number(["   ",
-                                 "  |",
-                                 "  |",
-                                 "   "]), '1')
-
-    def test_garbage(self):
-        self.assertEqual(number([" _ ",
-                                 " _|",
-                                 "  |",
-                                 "   "]), '?')
-
-    def test_last_line_nonblank(self):
-        self.assertEqual(number(["   ",
-                                 "  |",
-                                 "  |",
-                                 "| |"]), '?')
-
-    def test_unknown_char(self):
-        self.assertEqual(number([" - ",
-                                 " _|",
-                                 " X|",
-                                 "   "]), '?')
-
-    def test_too_short_row(self):
+    def test_recognizes_0(self):
+        self.assertEqual(convert([" _ ",
+                                  "| |",
+                                  "|_|",
+                                  "   "]), '0')
+
+    def test_recognizes_1(self):
+        self.assertEqual(convert(["   ",
+                                  "  |",
+                                  "  |",
+                                  "   "]), '1')
+
+    def test_unreadable(self):
+        self.assertEqual(convert(["   ",
+                                  "  _",
+                                  "  |",
+                                  "   "]), '?')
+
+    def test_line_number_not_multiple_of_four(self):
         with self.assertRaises(ValueError):
-            number(["   ",
-                    " _|",
-                    " |",
-                    "   "])
+            convert([" _ ",
+                     "| |",
+                     "   "])
 
-    def test_insufficient_rows(self):
-        with self.assertRaises(ValueError):
-            number(["   ",
-                    " _|",
-                    " X|"])
-
-    def test_grid0(self):
-        self.assertEqual(grid('0'), [" _ ",
-                                     "| |",
-                                     "|_|",
-                                     "   "])
-
-    def test_grid1(self):
-        self.assertEqual(grid('1'), ["   ",
-                                     "  |",
-                                     "  |",
-                                     "   "])
-
-    def test_0010110(self):
-        self.assertEqual(
-            number([
-                " _  _     _        _ ",
-                "| || |  || |  |  || |",
-                "|_||_|  ||_|  |  ||_|",
-                "                     "
-            ]), '0010110')
-
-    def test_3186547290(self):
-        digits = '3186547290'
-        self.assertEqual(
-            number([
-                " _     _  _  _     _  _  _  _ ",
-                " _|  ||_||_ |_ |_|  | _||_|| |",
-                " _|  ||_||_| _|  |  ||_  _||_|",
-                "                              "
-            ]), digits)
-
-    def test_Lost(self):
-        digits = '4815162342'
-        self.assertEqual(
-            number([
-                "    _     _     _  _  _     _ ",
-                "|_||_|  ||_   ||_  _| _||_| _|",
-                "  ||_|  | _|  ||_||_  _|  ||_ ",
-                "                              "
-            ]), digits)
-
-    def test_garble_middle(self):
-        self.assertEqual(
-            number([
-                "    _  _     _ ",
-                "  | _|  ||_||_ ",
-                "  ||_  _|  | _|",
-                "               "
-            ]), '12?45')
-
-    def test_grid3186547290(self):
-        digits = '3186547290'
-        self.assertEqual(
-            grid(digits), [
-                " _     _  _  _     _  _  _  _ ",
-                " _|  ||_||_ |_ |_|  | _||_|| |",
-                " _|  ||_||_| _|  |  ||_  _||_|",
-                "                              "
-            ])
-
-    def test_invalid_grid(self):
+    def test_col_number_not_multiple_of_three(self):
         with self.assertRaises(ValueError):
-            grid('123a')
+            convert(["    ",
+                     "   |",
+                     "   |",
+                     "    "])
+
+    def test_recognizes_110101100(self):
+        input_grid = [
+            "       _     _        _  _ ",
+            "  |  || |  || |  |  || || |",
+            "  |  ||_|  ||_|  |  ||_||_|",
+            "                           "
+        ]
+        self.assertEqual(convert(input_grid), "110101100")
+
+    def test_garbled_numbers_in_string(self):
+        input_grid = [
+            "       _     _           _ ",
+            "  |  || |  || |     || || |",
+            "  |  | _|  ||_|  |  ||_||_|",
+            "                           "
+        ]
+        self.assertEqual(convert(input_grid), "11?10?1?0")
+
+    def test_recognizes_2(self):
+        self.assertEqual(convert([" _ ",
+                                  " _|",
+                                  "|_ ",
+                                  "   "]), "2")
+
+    def test_recognizes_3(self):
+        self.assertEqual(convert([" _ ",
+                                  " _|",
+                                  " _|",
+                                  "   "]), "3")
+
+    def test_recognizes_4(self):
+        self.assertEqual(convert(["   ",
+                                  "|_|",
+                                  "  |",
+                                  "   "]), "4")
+
+    def test_recognizes_5(self):
+        self.assertEqual(convert([" _ ",
+                                  "|_ ",
+                                  " _|",
+                                  "   "]), "5")
+
+    def test_recognizes_6(self):
+        self.assertEqual(convert([" _ ",
+                                  "|_ ",
+                                  "|_|",
+                                  "   "]), "6")
+
+    def test_recognizes_7(self):
+        self.assertEqual(convert([" _ ",
+                                  "  |",
+                                  "  |",
+                                  "   "]), "7")
+
+    def test_recognizes_8(self):
+        self.assertEqual(convert([" _ ",
+                                  "|_|",
+                                  "|_|",
+                                  "   "]), "8")
+
+    def test_recognizes_9(self):
+        self.assertEqual(convert([" _ ",
+                                  "|_|",
+                                  " _|",
+                                  "   "]), "9")
+
+    def test_recognizes_string_of_decimal_numbers(self):
+        input_grid = [
+            "    _  _     _  _  _  _  _  _ ",
+            "  | _| _||_||_ |_   ||_||_|| |",
+            "  ||_  _|  | _||_|  ||_| _||_|",
+            "                              "
+        ]
+        self.assertEqual(convert(input_grid), "1234567890")
+
+    def test_recognizes_numbers_separated_by_empty_lines(self):
+        input_grid = [
+            "    _  _ ",
+            "  | _| _|",
+            "  ||_  _|",
+            "         ",
+            "    _  _ ",
+            "|_||_ |_ ",
+            "  | _||_|",
+            "         ",
+            " _  _  _ ",
+            "  ||_||_|",
+            "  ||_| _|",
+            "         "
+        ]
+        self.assertEqual(convert(input_grid), "123,456,789")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/simple-linked-list/README.md

@@ -0,0 +1,49 @@
+# Simple Linked List
+
+Write a simple linked list implementation that uses Elements and a List.
+
+The linked list is a fundamental data structure in computer science,
+often used in the implementation of other data structures. They're
+pervasive in functional programming languages, such as Clojure, Erlang,
+or Haskell, but far less common in imperative languages such as Ruby or
+Python.
+
+The simplest kind of linked list is a singly linked list. Each element in the
+list contains data and a "next" field pointing to the next element in the list
+of elements.
+
+This variant of linked lists is often used to represent sequences or
+push-down stacks (also called a LIFO stack; Last In, First Out).
+
+As a first take, lets create a singly linked list to contain the range (1..10),
+and provide functions to reverse a linked list and convert to and from arrays.
+
+When implementing this in a language with built-in linked lists,
+implement your own abstract data type.
+
+## Hints
+
+To support `list()`, see [implementing an iterator for a class.](https://docs.python.org/3/tutorial/classes.html#iterators)
+
+Additionally, note that Python2's `next()` has been replaced by `__next__()` in Python3. For dual compatibility, `next()` can be implemented as:
+
+```Python
+def next(self):
+    return self.__next__()
+```
+
+## 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).
+
+## Source
+
+Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists. [http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000](http://www.brpreiss.com/books/opus8/html/page96.html#SECTION004300000000000000000)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.