trackler 2.2.1.107 → 2.2.1.108

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

@@ -1,14 +1,20 @@
 class TreeNode(object):
-    def __init__(self, value):
-        self.value = value
+    def __init__(self, data, left, right):
+        self.data = None
+        self.left = None
+        self.right = None
+
+    def __str__(self):
+        fmt = 'TreeNode(data={}, left={}, right={})'
+        return fmt.format(self.data, self.left, self.right)
 
 
 class BinarySearchTree(object):
-    def __init__(self):
+    def __init__(self, tree_data):
         pass
 
-    def add(self, value):
+    def data(self):
         pass
 
-    def search(self, value):
+    def sorted_data(self):
         pass

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

@@ -1,57 +1,98 @@
 import unittest
 
-from binary_search_tree import BinarySearchTree
+from binary_search_tree import BinarySearchTree, TreeNode
 
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
 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)
+    def test_data_is_retained(self):
+        expected = TreeNode('4', None, None)
+        self.assertTreeEqual(BinarySearchTree(['4']).data(), expected)
+
+    # Test inserting data at proper node
+    def test_smaller_data_at_left_node(self):
+        expected = TreeNode('4', TreeNode('2', None, None), None)
+        self.assertTreeEqual(BinarySearchTree(['4', '2']).data(), expected)
+
+    def test_same_number_at_left_node(self):
+        expected = TreeNode('4', TreeNode('4', None, None), None)
+        self.assertTreeEqual(BinarySearchTree(['4', '4']).data(), expected)
+
+    def test_greater_number_at_right_node(self):
+        expected = TreeNode('4', None, TreeNode('5', None, None))
+        self.assertTreeEqual(BinarySearchTree(['4', '5']).data(), expected)
+
+    def test_can_create_complex_tree(self):
+        expected = TreeNode(
+            '4',
+            TreeNode(
+                '2',
+                TreeNode('1', None, None),
+                TreeNode('3', None, None)
+            ),
+            TreeNode(
+                '6',
+                TreeNode('5', None, None),
+                TreeNode('7', None, None)
+            )
+        )
+        self.assertTreeEqual(
+            BinarySearchTree(['4', '2', '6', '1', '3', '5', '7']).data(),
+            expected
+        )
+
+    # Test can sort data
+    def test_can_sort_single_number(self):
+        self.assertEqual(BinarySearchTree(['2']).sorted_data(), ['2'])
+
+    def test_can_sort_if_second_number_is_smaller_than_first(self):
+        self.assertEqual(
+            BinarySearchTree(['2', '1']).sorted_data(), ['1', '2']
+        )
+
+    def test_can_sort_if_second_number_is_same_as_first(self):
+        self.assertEqual(
+            BinarySearchTree(['2', '2']).sorted_data(), ['2', '2']
+        )
+
+    def test_can_sort_if_second_number_is_greater_than_first(self):
+        self.assertEqual(
+            BinarySearchTree(['2', '3']).sorted_data(), ['2', '3']
+        )
+
+    def test_can_sort_complex_tree(self):
+        self.assertEqual(
+            BinarySearchTree(['2', '1', '3', '6', '7', '5']).sorted_data(),
+            ['1', '2', '3', '5', '6', '7']
+        )
+
+    # Utilities
+    def assertTreeEqual(self, tree_one, tree_two):
+        try:
+            self.compare_tree(tree_one, tree_two)
+        except AssertionError:
+            raise AssertionError("{} != {}".format(tree_one, tree_two))
+
+    def compare_tree(self, tree_one, tree_two):
+        self.assertEqual(tree_one.data, tree_two.data)
+
+        # Compare left tree nodes
+        if tree_one.left and tree_two.left:
+            self.compare_tree(tree_one.left, tree_two.left)
+        elif tree_one.left is None and tree_two.left is None:
+            pass
+        else:
+            raise AssertionError
+
+        # Compare right tree nodes
+        if tree_one.right and tree_two.right:
+            self.compare_tree(tree_one.right, tree_two.right)
+        elif tree_one.right is None and tree_two.right is None:
+            pass
+        else:
+            raise AssertionError
 
 
 if __name__ == '__main__':

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

@@ -1,61 +1,51 @@
-from collections import deque
-
-
 class TreeNode(object):
-    def __init__(self, value):
-        self.value = value
-        self.left_node = None
-        self.right_node = None
+    def __init__(self, data, left, right):
+        self.data = data
+        self.left = left
+        self.right = right
 
     def __str__(self):
-        return str(self.value)
+        fmt = 'TreeNode(data={}, left={}, right={})'
+        return fmt.format(self.data, self.left, self.right)
 
 
 class BinarySearchTree(object):
-    def __init__(self):
+    def __init__(self, tree_data):
         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):
+        for data in tree_data:
+            self.add(data)
+
+    def add(self, data):
+        if self.root is None:
+            self.root = TreeNode(data, None, None)
+            return
+        inserted = False
         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)
+        while not inserted:
+            if data <= cur_node.data:
+                if cur_node.left:
+                    cur_node = cur_node.left
+                else:
+                    cur_node.left = TreeNode(data, None, None)
+                    inserted = True
+            elif data > cur_node.data:
+                if cur_node.right:
+                    cur_node = cur_node.right
+                else:
+                    cur_node.right = TreeNode(data, None, None)
+                    inserted = True
+
+    def _inorder_traverse(self, node, elements):
+        if node is not None:
+            self._inorder_traverse(node.left, elements)
+            elements.append(node.data)
+            self._inorder_traverse(node.right, elements)
+
+    def data(self):
+        return self.root
+
+    def sorted_data(self):
+        elements = []
+        self._inorder_traverse(self.root, elements)
+        return elements

data/tracks/python/exercises/binary-search/binary_search_test.py

@@ -3,7 +3,7 @@ import unittest
 from binary_search import binary_search
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class BinarySearchTests(unittest.TestCase):
     def test_finds_value_in_array_with_one_element(self):

data/tracks/python/exercises/book-store/book_store_test.py

@@ -3,75 +3,54 @@ import unittest
 from book_store import calculate_total
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
 class BookStoreTests(unittest.TestCase):
     def test_only_a_single_book(self):
-        self.assertAlmostEqual(calculate_total([1]), 8.00,
-                               places=2)
+        self.assertEqual(calculate_total([1]), 800)
 
     def test_two_of_the_same_book(self):
-        self.assertAlmostEqual(calculate_total([2, 2]), 16.00,
-                               places=2)
+        self.assertEqual(calculate_total([2, 2]), 1600)
 
     def test_empty_basket(self):
-        self.assertAlmostEqual(calculate_total([]), 0.00,
-                               places=2)
+        self.assertEqual(calculate_total([]), 0)
 
     def test_two_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2]), 15.20,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2]), 1520)
 
     def test_three_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2, 3]), 21.60,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2, 3]), 2160)
 
     def test_four_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2, 3, 4]), 25.60,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2, 3, 4]), 2560)
 
     def test_five_different_books(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 2, 3, 4, 5]), 30.00,
-            places=2)
+        self.assertEqual(calculate_total([1, 2, 3, 4, 5]), 3000)
 
     def test_two_groups_of_4_is_cheaper_than_group_of_5_plus_group_of_3(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 5]), 51.20,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 5]), 5120)
 
     def test_group_of_4_plus_group_of_2_is_cheaper_than_2_groups_of_3(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 4]), 40.80,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 4]), 4080)
 
     def test_two_each_of_first_4_books_and_1_copy_each_of_rest(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5]), 55.60,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5]), 5560)
 
     def test_two_copies_of_each_book(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), 60.00,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), 6000)
 
     def test_three_copies_of_first_book_and_2_each_of_remaining(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]),
-            68.00,
-            places=2)
+        self.assertEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]), 6800)
 
     def test_three_each_of_first_2_books_and_2_each_of_remaining_books(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]),
-            75.20,
-            places=2)
+        self.assertEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]), 7520)
 
     def test_four_groups_of_4_are_cheaper_than_2_groups_each_of_5_and_3(self):
-        self.assertAlmostEqual(
+        self.assertEqual(
             calculate_total([1, 1, 2, 2, 3, 3, 4, 5, 1, 1, 2, 2, 3, 3, 4, 5]),
-            102.40,
-            places=2)
+            10240)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/book-store/example.py

@@ -1,4 +1,4 @@
-BOOK_PRICE = 8
+BOOK_PRICE = 800
 
 
 def _group_price(size):

data/tracks/python/exercises/bowling/bowling.py

@@ -1,5 +1,3 @@
-
-
 class BowlingGame(object):
     def __init__(self):
         pass

data/tracks/python/exercises/bowling/bowling_test.py

@@ -3,11 +3,9 @@ import unittest
 from bowling import BowlingGame
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class BowlingTests(unittest.TestCase):
-    def setUp(self):
-        self.game = BowlingGame()
 
     def roll(self, rolls):
         [self.game.roll(roll) for roll in rolls]
@@ -120,23 +118,27 @@ class BowlingTests(unittest.TestCase):
 
     def test_rolls_cannot_score_negative_points(self):
 
-        self.assertRaises(ValueError, self.game.roll, -11)
+        with self.assertRaisesWithMessage(ValueError):
+            self.game.roll(11)
 
     def test_a_roll_cannot_score_more_than_10_points(self):
 
-        self.assertRaises(ValueError, self.game.roll, 11)
+        with self.assertRaisesWithMessage(ValueError):
+            self.game.roll(11)
 
     def test_two_rolls_in_a_frame_cannot_score_more_than_10_points(self):
         self.game.roll(5)
 
-        self.assertRaises(ValueError, self.game.roll, 6)
+        with self.assertRaisesWithMessage(ValueError):
+            self.game.roll(6)
 
     def test_bonus_after_strike_in_last_frame_cannot_score_more_than_10(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10]
 
         self.roll(rolls)
 
-        self.assertRaises(ValueError, self.game.roll, 11)
+        with self.assertRaisesWithMessage(ValueError):
+            self.game.roll(11)
 
     def test_bonus_aft_last_frame_strk_can_be_more_than_10_if_1_is_strk(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10,
@@ -151,42 +153,76 @@ class BowlingTests(unittest.TestCase):
 
         self.roll(rolls)
 
-        self.assertRaises(ValueError, self.game.roll, 10)
+        with self.assertRaisesWithMessage(ValueError):
+            self.game.roll(10)
 
     def test_an_incomplete_game_cannot_be_scored(self):
         rolls = [0, 0]
 
         self.roll(rolls)
 
-        self.assertRaises(IndexError, self.game.score)
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.score()
 
     def test_cannot_roll_if_there_are_already_ten_frames(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
         self.roll(rolls)
 
-        self.assertRaises(IndexError, self.game.roll, 0)
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.roll(0)
 
     def test_bonus_rolls_for_strike_must_be_rolled_before_score_is_calc(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10]
 
         self.roll(rolls)
 
-        self.assertRaises(IndexError, self.game.score)
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.score()
 
     def test_both_bonuses_for_strike_must_be_rolled_before_score(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10]
 
         self.roll(rolls)
 
-        self.assertRaises(IndexError, self.game.score)
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.score()
 
     def test_bonus_rolls_for_spare_must_be_rolled_before_score_is_calc(self):
         rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3]
 
         self.roll(rolls)
 
-        self.assertRaises(IndexError, self.game.score)
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.score()
+
+    def test_cannot_roll_after_bonus_roll_for_spare(self):
+        rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2]
+
+        self.roll(rolls)
+
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.roll(2)
+
+    def test_cannot_roll_after_bonus_rolls_for_strike(self):
+        rolls = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10,
+                 3, 2]
+
+        self.roll(rolls)
+
+        with self.assertRaisesWithMessage(IndexError):
+            self.game.roll(2)
+
+    # Utility functions
+    def setUp(self):
+        self.game = BowlingGame()
+        try:
+            self.assertRaisesRegex
+        except AttributeError:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
 
 
 if __name__ == '__main__':