trackler 2.2.1.64 → 2.2.1.65

data/tracks/python/.gitignore

@@ -7,3 +7,5 @@ tmp
 bin/configlet
 bin/configlet.exe
 .idea/
+.cache
+__pycache__

data/tracks/python/config.json

@@ -1200,6 +1200,20 @@
         "reactive_programming"
       ]
     },
+    {
+      "uuid": "6f196341-0ffc-9780-a7ca-1f817508247161cbcd9",
+      "slug": "binary-search-tree",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics":[
+        "recursion",
+        "classes",
+        "trees",
+        "searching",
+        "object_oriented_programming"
+      ]
+    },
     {
       "uuid": "e7351e8e-d3ff-4621-b818-cd55cf05bffd",
       "slug": "accumulate",

data/tracks/python/exercises/binary-search-tree/README.md

@@ -0,0 +1,71 @@
+# Binary Search Tree
+
+Insert and search for numbers in a binary tree.
+
+When we need to represent sorted data, an array does not make a good
+data structure.
+
+Say we have the array `[1, 3, 4, 5]`, and we add 2 to it so it becomes
+`[1, 3, 4, 5, 2]` now we must sort the entire array again! We can
+improve on this by realizing that we only need to make space for the new
+item `[1, nil, 3, 4, 5]`, and then adding the item in the space we
+added. But this still requires us to shift many elements down by one.
+
+Binary Search Trees, however, can operate on sorted data much more
+efficiently.
+
+A binary search tree consists of a series of connected nodes. Each node
+contains a piece of data (e.g. the number 3), a variable named `left`,
+and a variable named `right`. The `left` and `right` variables point at
+`nil`, or other nodes. Since these other nodes in turn have other nodes
+beneath them, we say that the left and right variables are pointing at
+subtrees. All data in the left subtree is less than or equal to the
+current node's data, and all data in the right subtree is greater than
+the current node's data.
+
+For example, if we had a node containing the data 4, and we added the
+data 2, our tree would look like this:
+
+      4
+     /
+    2
+
+If we then added 6, it would look like this:
+
+      4
+     / \
+    2   6
+
+If we then added 3, it would look like this
+
+       4
+     /   \
+    2     6
+     \
+      3
+
+And if we then added 1, 5, and 7, it would look like this
+
+          4
+        /   \
+       /     \
+      2       6
+     / \     / \
+    1   3   5   7
+
+
+## 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
+
+Wikipedia [https://en.wikipedia.org/wiki/Binary_search_tree](https://en.wikipedia.org/wiki/Binary_search_tree)
+
+## 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/binary-search-tree/binary_search_tree.py

@@ -0,0 +1,14 @@
+class TreeNode(object):
+    def __init__(self, value):
+        self.value = value
+
+
+class BinarySearchTree(object):
+    def __init__(self):
+        pass
+
+    def add(self, value):
+        pass
+
+    def search(self, value):
+        pass

data/tracks/python/exercises/binary-search-tree/binary_search_tree_test.py

@@ -0,0 +1,58 @@
+import unittest
+
+from binary_search_tree import BinarySearchTree
+
+
+class BinarySearchTreeTests(unittest.TestCase):
+
+    def test_add_integer_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(1)
+        bst.add(8)
+        bst.add(3)
+        bst.add(5)
+        bst.add(2)
+        self.assertEqual(list(bst.list()), [1, 2, 3, 5, 8])
+
+    def test_add_float_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(7.5)
+        bst.add(5.3)
+        bst.add(5.5)
+        bst.add(6.0)
+        bst.add(7.7)
+        self.assertEqual(list(bst.list()), [5.3, 5.5, 6.0, 7.5, 7.7])
+
+    def test_add_mixed_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(1)
+        bst.add(8)
+        bst.add(7.5)
+        bst.add(5.3)
+        self.assertEqual(list(bst.list()), [1, 5.3, 7.5, 8])
+
+    def test_add_duplicated_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(1)
+        bst.add(1)
+        bst.add(7.5)
+        bst.add(5.3)
+        self.assertEqual(list(bst.list()), [1, 1, 5.3, 7.5])
+
+    def test_search_existent_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(1)
+        bst.add(7.5)
+        self.assertEqual(bst.search(1).value, 1)
+        self.assertEqual(bst.search(7.5).value, 7.5)
+
+    def test_search_nonexistent_numbers(self):
+        bst = BinarySearchTree()
+        bst.add(1)
+        bst.add(7.5)
+        self.assertIs(bst.search(6), None)
+        self.assertIs(bst.search(8.8), None)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/binary-search-tree/example.py

@@ -0,0 +1,61 @@
+from collections import deque
+
+
+class TreeNode(object):
+    def __init__(self, value):
+        self.value = value
+        self.left_node = None
+        self.right_node = None
+
+    def __str__(self):
+        return str(self.value)
+
+
+class BinarySearchTree(object):
+    def __init__(self):
+        self.root = None
+
+    def add(self, value):
+        if(self.root is None):
+            self.root = TreeNode(value)
+        else:
+            inserted = False
+            cur_node = self.root
+
+            while not inserted:
+                if(value <= cur_node.value):
+                    if(cur_node.left_node):
+                        cur_node = cur_node.left_node
+                    else:
+                        cur_node.left_node = TreeNode(value)
+                        inserted = True
+                elif(value > cur_node.value):
+                    if(cur_node.right_node):
+                        cur_node = cur_node.right_node
+                    else:
+                        cur_node.right_node = TreeNode(value)
+                        inserted = True
+
+    def search(self, value):
+        cur_node = self.root
+        found = False
+        while not found:
+            if(cur_node is None):
+                return None
+            elif(value < cur_node.value):
+                cur_node = cur_node.left_node
+            elif(value > cur_node.value):
+                cur_node = cur_node.right_node
+            elif(value == cur_node.value):
+                return cur_node
+
+    def list(self):
+        elements = deque()
+        self.trav_inorder(self.root, elements)
+        return elements
+
+    def trav_inorder(self, node, elements):
+        if(node is not None):
+            self.trav_inorder(node.left_node, elements)
+            elements.append(node.value)
+            self.trav_inorder(node.right_node, elements)

data/tracks/python/exercises/go-counting/go_counting_test.py

@@ -1,5 +1,5 @@
 import unittest
-import gocounting
+import go_counting
 
 
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
@@ -27,63 +27,63 @@ board9x9 = "\n".join([
 
 class GoCountingTest(unittest.TestCase):
     def test_5x5_for_black(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((0, 1))
-        self.assertEqual(stone, gocounting.BLACK)
+        self.assertEqual(stone, go_counting.BLACK)
         self.assertEqual(territory, set([(0, 0), (0, 1), (1, 0)]))
 
     def test_5x5_for_white(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((2, 3))
-        self.assertEqual(stone, gocounting.WHITE)
+        self.assertEqual(stone, go_counting.WHITE)
         self.assertEqual(territory, set([(2, 3)]))
 
     def test_5x5_for_open_territory(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((1, 4))
-        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(stone, go_counting.NONE)
         self.assertEqual(territory, set([(0, 3), (0, 4), (1, 4)]))
 
     def test_5x5_for_non_territory(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((1, 1))
-        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(stone, go_counting.NONE)
         self.assertEqual(territory, set())
 
     def test_5x5_for_valid_coordinate(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((-1, 1))
-        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(stone, go_counting.NONE)
         self.assertEqual(territory, set())
 
     def test_5x5_for_valid_coordinate2(self):
-        board = gocounting.Board(board5x5)
+        board = go_counting.Board(board5x5)
         stone, territory = board.territoryFor((1, 5))
-        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(stone, go_counting.NONE)
         self.assertEqual(territory, set())
 
     def test_one_territory_whole_board(self):
-        board = gocounting.Board(" ")
+        board = go_counting.Board(" ")
         territories = board.territories()
-        self.assertEqual(territories[gocounting.BLACK], set())
-        self.assertEqual(territories[gocounting.WHITE], set())
-        self.assertEqual(territories[gocounting.NONE], set([(0, 0)]))
+        self.assertEqual(territories[go_counting.BLACK], set())
+        self.assertEqual(territories[go_counting.WHITE], set())
+        self.assertEqual(territories[go_counting.NONE], set([(0, 0)]))
 
     def test_two_territories_rectangular_board(self):
         input_board = "\n".join([
             " BW ",
             " BW "
         ])
-        board = gocounting.Board(input_board)
+        board = go_counting.Board(input_board)
         territories = board.territories()
-        self.assertEqual(territories[gocounting.BLACK], set([(0, 0), (0, 1)]))
-        self.assertEqual(territories[gocounting.WHITE], set([(3, 0), (3, 1)]))
-        self.assertEqual(territories[gocounting.NONE], set())
+        self.assertEqual(territories[go_counting.BLACK], set([(0, 0), (0, 1)]))
+        self.assertEqual(territories[go_counting.WHITE], set([(3, 0), (3, 1)]))
+        self.assertEqual(territories[go_counting.NONE], set())
 
     def test_9x9_for_open_territory(self):
-        board = gocounting.Board(board9x9)
+        board = go_counting.Board(board9x9)
         stone, territory = board.territoryFor((0, 8))
-        self.assertEqual(stone, gocounting.NONE)
+        self.assertEqual(stone, go_counting.NONE)
         self.assertEqual(territory,
                          set([(2, 7), (2, 8), (1, 8), (0, 8), (0, 7)]))
 

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

@@ -1,4 +1,6 @@
 def board(inp):
+    if(inp == []):
+        return []
     verify_board(inp)
     rowlen = len(inp[0])
     collen = len(inp)
@@ -7,9 +9,13 @@ def board(inp):
         for i2 in range(rowlen):
             if b[i1][i2] != ' ':
                 continue
-            cnt = inp[i1 - 1][i2 - 1:i2 + 2].count('*') + \
-                inp[i1][i2 - 1:i2 + 2].count('*') + \
-                inp[i1 + 1][i2 - 1:i2 + 2].count('*')
+            low = max(i2 - 1, 0)
+            high = min(i2 + 2, rowlen + 2)
+            cnt = inp[i1][low:high].count('*')
+            if(i1 > 0):
+                cnt += inp[i1 - 1][low:high].count('*')
+            if(i1 < collen - 1):
+                cnt += inp[i1 + 1][low:high].count('*')
             if cnt == 0:
                 continue
             b[i1][i2] = str(cnt)
@@ -17,23 +23,13 @@ def board(inp):
 
 
 def verify_board(inp):
-    # Null board or a null row
-    if not inp or not all(r for r in inp):
-        raise ValueError("Invalid board")
     # Rows with different lengths
     rowlen = len(inp[0])
-    collen = len(inp)
     if not all(len(r) == rowlen for r in inp):
         raise ValueError("Invalid board")
     # Unknown character in board
     cset = set()
     for r in inp:
         cset.update(r)
-    if cset - set('+- *|'):
-        raise ValueError("Invalid board")
-    # Borders not as expected
-    if any(inp[i1] != '+' + '-' * (rowlen - 2) + '+'
-           for i1 in [0, -1]) or any(inp[i1][i2] != '|'
-                                     for i1 in range(1, collen - 1)
-                                     for i2 in [0, -1]):
+    if cset - set(' *'):
         raise ValueError("Invalid board")

data/tracks/python/exercises/minesweeper/minesweeper_test.py

@@ -11,150 +11,139 @@ import unittest
 from minesweeper import board
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 class MinesweeperTest(unittest.TestCase):
-    def test_board1(self):
-        inp = ["+------+",
-               "| *  * |",
-               "|  *   |",
-               "|    * |",
-               "|   * *|",
-               "| *  * |",
-               "|      |",
-               "+------+"]
-        out = ["+------+",
-               "|1*22*1|",
-               "|12*322|",
-               "| 123*2|",
-               "|112*4*|",
-               "|1*22*2|",
-               "|111111|",
-               "+------+"]
+
+    def test_no_rows(self):
+        self.assertEqual(board([]), [])
+
+    def test_no_columns(self):
+        self.assertEqual(board([""]), [""])
+
+    def test_no_mines(self):
+        inp = ["   ",
+               "   ",
+               "   "]
+        out = ["   ",
+               "   ",
+               "   "]
+        self.assertEqual(board(inp), out)
+
+    def test_board_with_only_mines(self):
+        inp = ["***",
+               "***",
+               "***"]
+        out = ["***",
+               "***",
+               "***"]
         self.assertEqual(board(inp), out)
 
-    def test_board2(self):
-        inp = ["+-----+",
-               "| * * |",
-               "|     |",
-               "|   * |",
-               "|  * *|",
-               "| * * |",
-               "+-----+"]
-        out = ["+-----+",
-               "|1*2*1|",
-               "|11322|",
-               "| 12*2|",
-               "|12*4*|",
-               "|1*3*2|",
-               "+-----+"]
+    def test_mine_surrounded_by_spaces(self):
+        inp = ["   ",
+               " * ",
+               "   "]
+        out = ["111",
+               "1*1",
+               "111"]
         self.assertEqual(board(inp), out)
 
-    def test_board3(self):
-        inp = ["+-----+",
-               "| * * |",
-               "+-----+"]
-        out = ["+-----+",
-               "|1*2*1|",
-               "+-----+"]
+    def test_space_surrounded_by_mines(self):
+        inp = ["***",
+               "* *",
+               "***"]
+        out = ["***",
+               "*8*",
+               "***"]
         self.assertEqual(board(inp), out)
 
-    def test_board4(self):
-        inp = ["+-+",
-               "|*|",
-               "| |",
-               "|*|",
-               "| |",
-               "| |",
-               "+-+"]
-        out = ["+-+",
-               "|*|",
-               "|2|",
-               "|*|",
-               "|1|",
-               "| |",
-               "+-+"]
+    def test_horizontal_line(self):
+        inp = [" * * "]
+        out = ["1*2*1"]
         self.assertEqual(board(inp), out)
 
-    def test_board5(self):
-        inp = ["+-+",
-               "|*|",
-               "+-+"]
-        out = ["+-+",
-               "|*|",
-               "+-+"]
+    def test_horizontal_line_mines_at_edges(self):
+        inp = ["*   *"]
+        out = ["*1 1*"]
         self.assertEqual(board(inp), out)
 
-    def test_board6(self):
-        inp = ["+--+",
-               "|**|",
-               "|**|",
-               "+--+"]
-        out = ["+--+",
-               "|**|",
-               "|**|",
-               "+--+"]
+    def test_vertical_line(self):
+        inp = [" ",
+               "*",
+               " ",
+               "*",
+               " "]
+        out = ["1",
+               "*",
+               "2",
+               "*",
+               "1"]
         self.assertEqual(board(inp), out)
 
-    def test_board7(self):
-        inp = ["+--+",
-               "|**|",
-               "|**|",
-               "+--+"]
-        out = ["+--+",
-               "|**|",
-               "|**|",
-               "+--+"]
+    def test_vertical_line_mines_at_edges(self):
+        inp = ["*",
+               " ",
+               " ",
+               " ",
+               "*"]
+        out = ["*",
+               "1",
+               " ",
+               "1",
+               "*"]
         self.assertEqual(board(inp), out)
 
-    def test_board8(self):
-        inp = ["+---+",
-               "|***|",
-               "|* *|",
-               "|***|",
-               "+---+"]
-        out = ["+---+",
-               "|***|",
-               "|*8*|",
-               "|***|",
-               "+---+"]
+    def test_cross(self):
+        inp = ["  *  ",
+               "  *  ",
+               "*****",
+               "  *  ",
+               "  *  "]
+        out = [" 2*2 ",
+               "25*52",
+               "*****",
+               "25*52",
+               " 2*2 "]
         self.assertEqual(board(inp), out)
 
+    def test_large_board(self):
+        inp = [" *  * ",
+               "  *   ",
+               "    * ",
+               "   * *",
+               " *  * ",
+               "      "]
+        out = ["1*22*1",
+               "12*322",
+               " 123*2",
+               "112*4*",
+               "1*22*2",
+               "111111"]
+        self.assertEqual(board(inp), out)
+
+    # Additional test for this track
     def test_board9(self):
-        inp = ["+-----+",
-               "|     |",
-               "|   * |",
-               "|     |",
-               "|     |",
-               "| *   |",
-               "+-----+"]
-        out = ["+-----+",
-               "|  111|",
-               "|  1*1|",
-               "|  111|",
-               "|111  |",
-               "|1*1  |",
-               "+-----+"]
+        inp = ["     ",
+               "   * ",
+               "     ",
+               "     ",
+               " *   "]
+        out = ["  111",
+               "  1*1",
+               "  111",
+               "111  ",
+               "1*1  "]
         self.assertEqual(board(inp), out)
 
     def test_different_len(self):
-        inp = ["+-+",
-               "| |",
-               "|*  |",
-               "|  |",
-               "+-+"]
-        with self.assertRaises(ValueError):
-            board(inp)
-
-    def test_faulty_border(self):
-        inp = ["+-----+",
-               "*   * |",
-               "+-- --+"]
+        inp = [" ",
+               "*  ",
+               "  "]
         with self.assertRaises(ValueError):
             board(inp)
 
     def test_invalid_char(self):
-        inp = ["+-----+",
-               "|X  * |",
-               "+-----+"]
+        inp = ["X  * "]
         with self.assertRaises(ValueError):
             board(inp)