trackler 2.2.1.107 → 2.2.1.108

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

@@ -1,149 +1,99 @@
-MAX_PINS = 10
-NUM_FRAMES = 10
+MAX_FRAME = 10
 
 
-class BowlingGame(object):
-    """This class manages the Bowling Game including the roll and score
-    methods"""
-    def __init__(self):
-        self.rolls = []
-        self.totalScore = 0
-        self.currentFrame = Frame()
-        self.bonusRollsAccrued = 0
-        self.bonusRollsSeen = 0
-
-    def roll(self, pins):
-        if self.isBonusRoll():
-            self.bonusRollsSeen += 1
-
-        # is the second roll valid based off the first?
-        if (self.currentFrame.isOpen() and
-           self.currentFrame.getFrame()[0] is not None):
-            if self.currentFrame.getFrame()[0] + pins > MAX_PINS:
-                raise ValueError("This roll will cause the current frame  "
-                                 "to be getter than the max number of pins")
-
-        # open a new frame if the last one has been closed
-        if not self.currentFrame.isOpen():
-            self.currentFrame = Frame()
-
-        # valid roll between 0-10
-        if pins in range(MAX_PINS + 1):
-            # raise an error if the game is over and they try to roll again
-            if ((len(self.rolls) == NUM_FRAMES) and
-               self.bonusRollsAccrued == 0):
-                raise IndexError("Max Frames have been reached.  Too many "
-                                 "rolls")
-            else:
-                self.currentFrame.roll(pins,
-                                       self.isBonusRoll(),
-                                       self.bonusRollsAccrued,
-                                       self.bonusRollsSeen)
-                # if we closed it add it to our rolls
-                if not self.currentFrame.isOpen():
-                    self.rolls.append(self.currentFrame)
-                    # If this is the last frame did we earn any bonus rolls?
-                    if len(self.rolls) == NUM_FRAMES:
-                        self.bonusRollsEarned()
-        else:
-            raise ValueError("Amount of pins rolled is greater than the max "
-                             "number of pins")
-
-    def score(self):
-        frame_index = 0
-
-        while (frame_index <= NUM_FRAMES-1):
-            frame = self.rolls[frame_index].getFrame()
+class Frame(object):
+    def __init__(self, idx):
+        self.idx = idx
+        self.throws = []
 
-            roll1 = frame[0]
-            roll2 = frame[1]
+    @property
+    def total_pins(self):
+        """Total pins knocked down in a frame."""
+        return sum(self.throws)
 
-            if self.isStrike(roll1):
-                self.totalScore += roll1 + self.stikeBonus(frame_index)
-            else:
-                if self.isSpare(roll1, roll2):
-                    self.totalScore += roll1 + roll2 + \
-                                       self.spareBonus(frame_index)
-                else:
-                    self.totalScore += roll1 + roll2
+    def is_strike(self):
+        return self.total_pins == 10 and len(self.throws) == 1
 
-            frame_index += 1
+    def is_spare(self):
+        return self.total_pins == 10 and len(self.throws) == 2
 
-        return self.totalScore
+    def is_open(self):
+        return self.total_pins < 10 and len(self.throws) == 2
 
-    def isStrike(self, pins):
-        return True if pins == MAX_PINS else False
+    def is_closed(self):
+        """Return whether a frame is over."""
+        return self.total_pins == 10 or len(self.throws) == 2
 
-    def isSpare(self, roll1, roll2):
-        return True if roll1 + roll2 == MAX_PINS else False
+    def throw(self, pins):
+        if self.total_pins + pins > 10:
+            raise ValueError("a frame's rolls cannot exceed 10")
+        self.throws.append(pins)
 
-    def stikeBonus(self, frame_index):
-        bonusroll1 = self.rolls[frame_index+1].getFrame()[0]
-        bonusroll2 = 0
-        # need to go further out if the next on is a strike
-        if bonusroll1 == 10:
-            bonusroll2 = self.rolls[frame_index+2].getFrame()[0]
-        else:
-            bonusroll2 = self.rolls[frame_index+1].getFrame()[1]
-        # edge case - if the last roll is a stike the bonus rolls needs to be
-        # validated
-        if (not self.isStrike(bonusroll1) and
-           (bonusroll1 + bonusroll2 > MAX_PINS)):
-            raise ValueError("The bonus rolls total to greater than the max "
-                             "number of pins")
-        else:
-            return bonusroll1 + bonusroll2
+    def score(self, next_throws):
+        result = self.total_pins
+        if self.is_strike():
+            result += sum(next_throws[:2])
+        elif self.is_spare():
+            result += sum(next_throws[:1])
+        return result
 
-    def spareBonus(self, frame_index):
-        return self.rolls[frame_index+1].getFrame()[0]
 
-    def isLastFrame(self, frame_index):
-        return True if frame_index >= len(self.rolls)-1 else False
+class BowlingGame(object):
+    def __init__(self):
+        self.current_frame_idx = 0
+        self.bonus_throws = []
+        self.frames = [Frame(idx) for idx in range(MAX_FRAME)]
+
+    @property
+    def current_frame(self):
+        return self.frames[self.current_frame_idx]
+
+    def next_throws(self, frame_idx):
+        """Return a frame's next throws in the form of a list."""
+        throws = []
+        for idx in range(frame_idx + 1, MAX_FRAME):
+            throws.extend(self.frames[idx].throws)
+        throws.extend(self.bonus_throws)
+        return throws
+
+    def roll_bonus(self, pins):
+        tenth_frame = self.frames[-1]
+        if tenth_frame.is_open():
+            raise IndexError("cannot throw bonus with an open tenth frame")
+
+        self.bonus_throws.append(pins)
+
+        # Check against invalid fill balls, e.g. [3, 10]
+        if (len(self.bonus_throws) == 2 and self.bonus_throws[0] != 10 and
+                sum(self.bonus_throws) > 10):
+            raise ValueError("invalid fill balls")
+
+        # Check if there are more bonuses than it should be
+        if tenth_frame.is_strike() and len(self.bonus_throws) > 2:
+            raise IndexError(
+                "wrong number of fill balls when the tenth frame is a strike")
+        elif tenth_frame.is_spare() and len(self.bonus_throws) > 1:
+            raise IndexError(
+                "wrong number of fill balls when the tenth frame is a spare")
 
-    def bonusRollsEarned(self):
-        if len(self.rolls) == NUM_FRAMES:
-            lastFrame = self.rolls[NUM_FRAMES-1].getFrame()
-            if self.isStrike(lastFrame[0]):
-                self.bonusRollsAccrued = 2
-            elif self.isSpare(lastFrame[0], lastFrame[1]):
-                self.bonusRollsAccrued = 1
+    def roll(self, pins):
+        if not 0 <= pins <= 10:
+            raise ValueError("invalid pins")
+        elif self.current_frame_idx == MAX_FRAME:
+            self.roll_bonus(pins)
         else:
-            self.bonusRollsAccrued = 0
-        return
-
-    def isBonusRoll(self):
-        # if we've already seen all
-        return True if len(self.rolls) >= NUM_FRAMES else False
+            self.current_frame.throw(pins)
+            if self.current_frame.is_closed():
+                self.current_frame_idx += 1
 
-
-class Frame(object):
-    """This class is for internal use only.  It divides up the array of
-    rolls into Frame objects"""
-    def __init__(self):
-        self.rolls = [None, None]
-        self.open = True
-
-    def roll(self, roll, bonusRoll, accruedBonuses, seenBonuses):
-        # if it's a strike we close the frame
-        if roll == 10:
-            self.rolls[0] = 10
-            self.rolls[1] = 0
-            self.open = False
-        else:
-            # first roll, but frame is still open
-            if self.rolls[0] is None:
-                self.rolls[0] = roll
-                # may need to close bonus roll frames before 2 have been seen
-                if bonusRoll and seenBonuses == accruedBonuses:
-                    self.rolls[1] = 0
-                    self.open = False
-            else:
-                # second roll, closes frame
-                self.rolls[1] = roll
-                self.open = False
-
-    def isOpen(self):
-        return self.open
-
-    def getFrame(self):
-        return self.rolls
+    def score(self):
+        if self.current_frame_idx < MAX_FRAME:
+            raise IndexError("frame less than 10")
+        if self.frames[-1].is_spare() and len(self.bonus_throws) != 1:
+            raise IndexError(
+                "one bonus must be rolled when the tenth frame is spare")
+        if self.frames[-1].is_strike() and len(self.bonus_throws) != 2:
+            raise IndexError(
+                "two bonuses must be rolled when the tenth frame is strike")
+        return sum(frame.score(self.next_throws(frame.idx))
+                   for frame in self.frames)

data/tracks/python/exercises/bracket-push/bracket_push.py

@@ -1,2 +1,2 @@
-def check_brackets(input_string):
+def is_paired(input_string):
     pass

data/tracks/python/exercises/bracket-push/bracket_push_test.py

@@ -1,54 +1,54 @@
 import unittest
 
-from bracket_push import check_brackets
+from bracket_push import is_paired
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class BracketPushTests(unittest.TestCase):
     def test_paired_square_brackets(self):
-        self.assertEqual(check_brackets("[]"), True)
+        self.assertEqual(is_paired("[]"), True)
 
     def test_empty_string(self):
-        self.assertEqual(check_brackets(""), True)
+        self.assertEqual(is_paired(""), True)
 
     def test_unpaired_brackets(self):
-        self.assertEqual(check_brackets("[["), False)
+        self.assertEqual(is_paired("[["), False)
 
     def test_wrong_ordered_brackets(self):
-        self.assertEqual(check_brackets("}{"), False)
+        self.assertEqual(is_paired("}{"), False)
 
     def test_wrong_closing_bracket(self):
-        self.assertEqual(check_brackets("{]"), False)
+        self.assertEqual(is_paired("{]"), False)
 
     def test_paired_with_whitespace(self):
-        self.assertEqual(check_brackets("{ }"), True)
+        self.assertEqual(is_paired("{ }"), True)
 
     def test_simple_nested_brackets(self):
-        self.assertEqual(check_brackets("{[]}"), True)
+        self.assertEqual(is_paired("{[]}"), True)
 
     def test_several_paired_brackets(self):
-        self.assertEqual(check_brackets("{}[]"), True)
+        self.assertEqual(is_paired("{}[]"), True)
 
     def test_paired_and_nested_brackets(self):
-        self.assertEqual(check_brackets("([{}({}[])])"), True)
+        self.assertEqual(is_paired("([{}({}[])])"), True)
 
     def test_unopened_closing_brackets(self):
-        self.assertEqual(check_brackets("{[)][]}"), False)
+        self.assertEqual(is_paired("{[)][]}"), False)
 
     def test_unpaired_and_nested_brackets(self):
-        self.assertEqual(check_brackets("([{])"), False)
+        self.assertEqual(is_paired("([{])"), False)
 
     def test_paired_and_wrong_nested_brackets(self):
-        self.assertEqual(check_brackets("[({]})"), False)
+        self.assertEqual(is_paired("[({]})"), False)
 
     def test_math_expression(self):
         self.assertEqual(
-            check_brackets("(((185 + 223.85) * 15) - 543)/2"), True)
+            is_paired("(((185 + 223.85) * 15) - 543)/2"), True)
 
     def test_complex_latex_expression(self):
         self.assertEqual(
-            check_brackets(
+            is_paired(
                 ("\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{"
                  "x} &... x^2 \\end{array}\\right)")), True)
 

data/tracks/python/exercises/bracket-push/example.py

@@ -1,8 +1,8 @@
-def check_brackets(string):
+def is_paired(input_string):
     counterparts = {')': '(', '}': '{', ']': '['}
 
     stack = []
-    for char in string:
+    for char in input_string:
         if char in counterparts.values():
             stack.append(char)
         elif char in counterparts:

data/tracks/python/exercises/change/change_test.py

@@ -2,8 +2,8 @@ import unittest
 
 from change import find_minimum_coins
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class ChangeTest(unittest.TestCase):
     def test_single_coin_change(self):
@@ -37,13 +37,26 @@ class ChangeTest(unittest.TestCase):
         self.assertEqual(find_minimum_coins(0, [1, 5, 10, 21, 25]), [])
 
     def test_error_testing_for_change_smaller_than_smallest_coin(self):
-        self.assertEqual(find_minimum_coins(3, [5, 10]), -1)
+        with self.assertRaisesWithMessage(ValueError):
+            find_minimum_coins(3, [5, 10])
 
     def test_error_if_no_combination_can_add_up_to_target(self):
-        self.assertEqual(find_minimum_coins(94, [5, 10]), -1)
+        with self.assertRaisesWithMessage(ValueError):
+            find_minimum_coins(94, [5, 10])
 
     def test_cannot_find_negative_change_values(self):
-        self.assertEqual(find_minimum_coins(-5, [1, 2, 5]), -1)
+        with self.assertRaisesWithMessage(ValueError):
+            find_minimum_coins(-5, [1, 2, 5])
+
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex
+        except AttributeError:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
 
 
 if __name__ == "__main__":

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

@@ -1,6 +1,6 @@
 def find_minimum_coins(total_change, coins):
     if total_change < 0:
-        return -1
+        raise ValueError("cannot find negative change values")
     min_coins_required = [1e9] * (total_change + 1)
     last_coin = [0]*(total_change + 1)
     min_coins_required[0] = 0
@@ -15,7 +15,7 @@ def find_minimum_coins(total_change, coins):
                     last_coin[change] = change - coin
         min_coins_required[change] = final_result
     if min_coins_required[total_change] == 1e9:
-        return -1
+        raise ValueError("no combination can add up to target")
     else:
         last_coin_value = total_change
         array = []

data/tracks/python/exercises/circular-buffer/circular_buffer.py

@@ -9,3 +9,15 @@ class BufferEmptyException(Exception):
 class CircularBuffer(object):
     def __init__(self, capacity):
         pass
+
+    def read(self):
+        pass
+
+    def write(self, data):
+        pass
+
+    def overwrite(self, data):
+        pass
+
+    def clear(self):
+        pass

data/tracks/python/exercises/circular-buffer/circular_buffer_test.py

@@ -7,7 +7,7 @@ from circular_buffer import (
 )
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class CircularBufferTest(unittest.TestCase):
     def test_read_empty_buffer(self):
@@ -34,7 +34,7 @@ class CircularBufferTest(unittest.TestCase):
         self.assertEqual(buf.read(), '1')
         self.assertEqual(buf.read(), '2')
 
-    def test_full_buffer_cant_written(self):
+    def test_cant_write_to_full_buffer(self):
         buf = CircularBuffer(1)
         buf.write('1')
         with self.assertRaisesWithMessage(BufferFullException):
@@ -70,7 +70,7 @@ class CircularBufferTest(unittest.TestCase):
         buf.write('2')
         self.assertEqual(buf.read(), '2')
 
-    def test_clear_does_nothin_empty_buffer(self):
+    def test_clear_does_nothing_on_empty_buffer(self):
         buf = CircularBuffer(1)
         buf.clear()
         buf.write('1')
@@ -91,14 +91,7 @@ class CircularBufferTest(unittest.TestCase):
         self.assertEqual(buf.read(), '2')
         self.assertEqual(buf.read(), '3')
 
-    def test_write_full_buffer(self):
-        buf = CircularBuffer(2)
-        buf.write('1')
-        buf.write('2')
-        with self.assertRaisesWithMessage(BufferFullException):
-            buf.write('A')
-
-    def test_over_write_replaces_oldest_remaning_item(self):
+    def test_overwrite_replaces_oldest_remaining_item(self):
         buf = CircularBuffer(3)
         buf.write('1')
         buf.write('2')

data/tracks/python/exercises/clock/clock.py

@@ -2,5 +2,14 @@ class Clock(object):
     def __init__(self, hour, minute):
         pass
 
-    def __add__(self, other):
+    def __repr__(self):
+        pass
+
+    def __eq__(self, other):
+        pass
+
+    def __add__(self, minutes):
+        pass
+
+    def __sub__(self, minutes):
         pass