trackler 2.2.1.53 → 2.2.1.54

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

@@ -33,13 +33,12 @@ Keep your hands off that filter/reject/whatchamacallit functionality
 provided by your standard library!  Solve this one yourself using other
 basic tools instead.
 
-### Submitting Exercises
+## 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).
 

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

@@ -17,13 +17,12 @@ Examples:
  * A = [1, 2, 3, 4, 5], B = [2, 3, 4], A is a superlist of B
  * A = [1, 2, 4], B = [1, 2, 3, 4, 5], A is not a superlist of, sublist of or equal to B
 
-### Submitting Exercises
+## 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).
 

data/tracks/python/exercises/sum-of-multiples/README.md

@@ -8,16 +8,12 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Given a number, find the sum of the multiples of a given set of numbers,
-up to but not including that number.
-
-### Submitting Exercises
+## 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).
 

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

@@ -5,7 +5,7 @@ Tally the results of a small football competition.
 Based on an input file containing which team played against which and what the
 outcome was, create a file with a table like this:
 
-```
+```text
 Team                           | MP |  W |  D |  L |  P
 Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
 Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
@@ -31,7 +31,7 @@ Input
 
 Your tallying program will receive input that looks like:
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 Devastating Donkeys;Courageous Californians;draw
 Devastating Donkeys;Allegoric Alaskans;win
@@ -42,7 +42,7 @@ Allegoric Alaskans;Courageous Californians;win
 
 The result of the match refers to the first team listed. So this line
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 ```
 
@@ -50,7 +50,7 @@ Means that the Allegoric Alaskans beat the Blithering Badgers.
 
 This line:
 
-```
+```text
 Courageous Californians;Blithering Badgers;loss
 ```
 
@@ -58,19 +58,18 @@ Means that the Blithering Badgers beat the Courageous Californians.
 
 And this line:
 
-```
+```text
 Devastating Donkeys;Courageous Californians;draw
 ```
 
 Means that the Devastating Donkeys and Courageous Californians tied.
 
-### Submitting Exercises
+## 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).
 

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

@@ -4,14 +4,14 @@ Given an input text output it transposed.
 
 Roughly explained, the transpose of a matrix:
 
-```
+```text
 ABC
 DEF
 ```
 
 is given by:
 
-```
+```text
 AD
 BE
 CF
@@ -26,14 +26,14 @@ If the input has rows of different lengths, this is to be solved as follows:
 
 Therefore, transposing this matrix:
 
-```
+```text
 ABC
 DE
 ```
 
 results in:
 
-```
+```text
 AD
 BE
 C
@@ -41,30 +41,29 @@ C
 
 And transposing:
 
-```
+```text
 AB
 DEF
 ```
 
 results in:
 
-```
+```text
 AD
 BE
  F
 ```
 
 In general, all characters from the input should also be present in the transposed output.
-That means that if a column in the input text contains only spaces on its bottom-most row(s), 
+That means that if a column in the input text contains only spaces on its bottom-most row(s),
 the corresponding output row should contain the spaces in its right-most column(s).
 
-### Submitting Exercises
+## 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).
 

data/tracks/python/exercises/tree-building/README.md

@@ -0,0 +1,25 @@
+Refactor a tree building algorithm.
+
+Some web-forums have a tree layout, so posts are presented as a tree. However
+the posts are typically stored in a database as an unsorted set of records. Thus
+when presenting the posts to the user the tree structure has to be
+reconstructed.
+
+Your job will be to refactor a working but slow and ugly piece of code that
+implements the tree building logic for highly abstracted records. The records
+only contain an ID number and a parent ID number. The ID number is always
+between 0 (inclusive) and the length of the record list (exclusive). All records
+have a parent ID lower than their own ID, except for the root record, which has
+a parent ID that's equal to its own ID.
+
+An example tree:
+
+```text
+root (ID: 0, parent ID: 0)
+|-- child1 (ID: 1, parent ID: 0)
+|    |-- grandchild1 (ID: 2, parent ID: 1)
+|    +-- grandchild2 (ID: 4, parent ID: 1)
++-- child2 (ID: 3, parent ID: 0)
+|    +-- grandchild3 (ID: 6, parent ID: 3)
++-- child3 (ID: 5, parent ID: 0)
+```

data/tracks/python/exercises/tree-building/example.py

@@ -0,0 +1,46 @@
+class Record():
+    def __init__(self, record_id, parent_id):
+        self.record_id = record_id
+        self.parent_id = parent_id
+
+    def equal_id(self):
+        return self.record_id == self.parent_id
+
+
+class Node():
+    def __init__(self, node_id):
+        self.node_id = node_id
+        self.children = []
+
+
+def validateRecord(record):
+    if record.equal_id() and record.record_id != 0:
+        # only root(id=0) should have equal id
+        raise ValueError
+    elif not record.equal_id() and record.parent_id >= record.record_id:
+        # non-root node id should be smaller than its parent_id
+        raise ValueError
+
+
+def BuildTree(records):
+    parent_dict = {}
+    node_dict = {}
+    ordered_id = sorted((i.record_id for i in records))
+    for record in records:
+        validateRecord(record)
+        parent_dict[record.record_id] = record.parent_id
+        node_dict[record.record_id] = Node(record.record_id)
+
+    root_id = 0
+    root = None
+
+    for index, record_id in enumerate(ordered_id):
+        if index != record_id:
+            raise ValueError
+        if record_id == root_id:
+            root = node_dict[record_id]
+        else:
+            parent_id = parent_dict[record_id]
+            node_dict[parent_id].children.append(node_dict[record_id])
+
+    return root

data/tracks/python/exercises/tree-building/tree_building.py

@@ -0,0 +1,50 @@
+class Record():
+    def __init__(self, record_id, parent_id):
+        self.record_id = record_id
+        self.parent_id = parent_id
+
+
+class Node():
+    def __init__(self, node_id):
+        self.node_id = node_id
+        self.children = []
+
+
+def BuildTree(records):
+    root = None
+    records.sort(key=lambda x: x.record_id)
+    ordered_id = [i.record_id for i in records]
+    if records:
+        if ordered_id[-1] != len(ordered_id) - 1:
+            raise ValueError
+        if ordered_id[0] != 0:
+            raise ValueError
+    trees = []
+    parent = {}
+    for i in range(len(ordered_id)):
+        for j in records:
+            if ordered_id[i] == j.record_id:
+                if j.record_id == 0:
+                    if j.parent_id != 0:
+                        raise ValueError
+                if j.record_id < j.parent_id:
+                    raise ValueError
+                if j.record_id == j.parent_id:
+                    if j.record_id != 0:
+                        raise ValueError
+                trees.append(Node(ordered_id[i]))
+    for i in range(len(ordered_id)):
+        for j in trees:
+            if i == j.node_id:
+                parent = j
+        for j in records:
+            if j.parent_id == i:
+                for k in trees:
+                    if k.node_id == 0:
+                        continue
+                    if j.record_id == k.node_id:
+                        child = k
+                        parent.children.append(child)
+    if len(trees) > 0:
+        root = trees[0]
+    return root

data/tracks/python/exercises/tree-building/tree_building_test.py

@@ -0,0 +1,183 @@
+import unittest
+
+from tree_building import Record, BuildTree
+
+
+class TestBuildingTest(unittest.TestCase):
+    """
+        Record(record_id, parent_id): records given to be processed
+        Node(node_id): Node in tree
+        BuildTree(records): records as argument and returns tree
+        BuildTree should raise ValueError if given records are invalid
+    """
+
+    def test_empty_list_input(self):
+        records = []
+        root = BuildTree(records)
+        self.assertIsNone(root)
+
+    def test_one_node(self):
+        records = [
+            Record(0, 0)
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_leaf(root, node_id=0)
+
+    def test_three_nodes_in_order(self):
+        records = [
+            Record(0, 0),
+            Record(1, 0),
+            Record(2, 0)
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_branch(root, node_id=0, children_count=2)
+        self.assert_node_is_leaf(root.children[0], node_id=1)
+        self.assert_node_is_leaf(root.children[1], node_id=2)
+
+    def test_three_nodes_in_reverse_order(self):
+        records = [
+            Record(2, 0),
+            Record(1, 0),
+            Record(0, 0)
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_branch(root, node_id=0, children_count=2)
+        self.assert_node_is_leaf(root.children[0], node_id=1)
+        self.assert_node_is_leaf(root.children[1], node_id=2)
+
+    def test_more_than_two_children(self):
+        records = [
+            Record(0, 0),
+            Record(1, 0),
+            Record(2, 0),
+            Record(3, 0)
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_branch(root, node_id=0, children_count=3)
+        self.assert_node_is_leaf(root.children[0], node_id=1)
+        self.assert_node_is_leaf(root.children[1], node_id=2)
+        self.assert_node_is_leaf(root.children[2], node_id=3)
+
+    def test_binary_tree(self):
+        records = [
+            Record(6, 2),
+            Record(0, 0),
+            Record(3, 1),
+            Record(2, 0),
+            Record(4, 1),
+            Record(5, 2),
+            Record(1, 0)
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_branch(root, 0, 2)
+        self.assert_node_is_branch(root.children[0], 1, 2)
+        self.assert_node_is_branch(root.children[1], 2, 2)
+        self.assert_node_is_leaf(root.children[0].children[0], 3)
+        self.assert_node_is_leaf(root.children[0].children[1], 4)
+        self.assert_node_is_leaf(root.children[1].children[0], 5)
+        self.assert_node_is_leaf(root.children[1].children[1], 6)
+
+    def test_unbalanced_tree(self):
+        records = [
+            Record(0, 0),
+            Record(1, 0),
+            Record(2, 0),
+            Record(3, 1),
+            Record(4, 1),
+            Record(5, 1),
+            Record(6, 2),
+        ]
+        root = BuildTree(records)
+
+        self.assert_node_is_branch(root, 0, 2)
+        self.assert_node_is_branch(root.children[0], 1, 3)
+        self.assert_node_is_branch(root.children[1], 2, 1)
+        self.assert_node_is_leaf(root.children[0].children[0], 3)
+        self.assert_node_is_leaf(root.children[0].children[1], 4)
+        self.assert_node_is_leaf(root.children[0].children[2], 5)
+        self.assert_node_is_leaf(root.children[1].children[0], 6)
+
+    def test_root_node_has_parent(self):
+        records = [
+            Record(0, 1),
+            Record(1, 0)
+        ]
+        # Root parent_id should be equal to record_id(0)
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def test_no_root_node(self):
+        records = [
+            Record(1, 0),
+            Record(2, 0)
+        ]
+        # Record with record_id 0 (root) is missing
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def test_non_continuous(self):
+        records = [
+            Record(2, 0),
+            Record(4, 2),
+            Record(1, 0),
+            Record(0, 0)
+        ]
+        # Record with record_id 3 is missing
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def test_cycle_directly(self):
+        records = [
+            Record(5, 2),
+            Record(3, 2),
+            Record(2, 2),
+            Record(4, 1),
+            Record(1, 0),
+            Record(0, 0),
+            Record(6, 3)
+        ]
+        # Cycle caused by Record 2 with parent_id pointing to itself
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def test_cycle_indirectly(self):
+        records = [
+            Record(5, 2),
+            Record(3, 2),
+            Record(2, 6),
+            Record(4, 1),
+            Record(1, 0),
+            Record(0, 0),
+            Record(6, 3)
+        ]
+        # Cycle caused by Record 2 with parent_id(6) greater than record_id(2)
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def test_higher_id_parent_of_lower_id(self):
+        records = [
+            Record(0, 0),
+            Record(2, 0),
+            Record(1, 2)
+        ]
+        # Record 1 have parent_id(2) greater than record_id(1)
+        with self.assertRaises(ValueError):
+            BuildTree(records)
+
+    def assert_node_is_branch(self, node, node_id, children_count):
+        self.assertEqual(node.node_id, node_id)
+        self.assertNotEqual(len(node.children), 0)
+        self.assertEqual(len(node.children), children_count)
+
+    def assert_node_is_leaf(self, node, node_id):
+        self.assertEqual(node.node_id, node_id)
+        self.assertEqual(len(node.children), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()