Card-Games Improvements

Author: J08K

exercises/concept/card-games/.docs/instructions.md

@@ -3,48 +3,39 @@
 Elyse is really looking forward to playing some poker (and other card games) during her upcoming trip to Vegas.
  Being a big fan of "self-tracking" she wants to put together some small functions that will help her with tracking tasks and has asked for your help thinking them through.
 
-
 ## 1. Tracking Poker Rounds
 
 Elyse is especially fond of poker, and wants to track how many rounds she plays - and _which rounds_ those are.
  Every round has its own number, and every table shows the round number currently being played.
  Elyse chooses a table and sits down to play her first round. She plans on playing three rounds.
 
-
 Implement a function `get_rounds(<round_number>)` that takes the current round number and returns a single `list` with that round and the _next two_ that are coming up:
 
-
 ```python
 >>> get_rounds(27)
 [27, 28, 29]
 ```
 
-
 ## 2. Keeping all Rounds in the Same Place
 
 Elyse played a few rounds at the first table, then took a break and played some more rounds at a second table ... but ended up with a different list for each table!
  She wants to put the two lists together, so she can track all of the poker rounds in the same place.
 
-
 Implement a function `concatenate_rounds(<rounds_1>, <rounds_2>)` that takes two lists and returns a single `list` consisting of all the rounds in the first `list`, followed by all the rounds in the second `list`:
 
-
 ```python
 >>> concatenate_rounds([27, 28, 29], [35, 36])
 [27, 28, 29, 35, 36]
 ```
 
-
 ## 3. Finding Prior Rounds
 
 Talking about some of the prior Poker rounds, another player remarks how similarly two of them played out.
  Elyse is not sure if she played those rounds or not.
 
-
 Implement a function `list_contains_round(<rounds>, <round_number>)` that takes two arguments, a list of rounds played and a round number.
  The function will return `True` if the round is in the list of rounds played, `False` if not:
 
-
 ```python
 >>> list_contains_round([27, 28, 29, 35, 36], 29)
 True
@@ -59,7 +50,6 @@ Elyse wants to try out a new game called Black Joe.
  It's similar to Black Jack - where your goal is to have the cards in your hand add up to a target value - but in Black Joe the goal is to get the _average_ of the card values to be 7.
  The average can be found by summing up all the card values and then dividing that sum by the number of cards in the hand.
 
-
 Implement a function `card_average(<hand>)` that will return the average value of a hand of Black Joe.
 
 ```python
@@ -69,16 +59,18 @@ Implement a function `card_average(<hand>)` that will return the average value o
 
 ## 5. Alternate Averages
 
-In Black Joe, speed is important.
- Elyse thinks she can "shortcut" the traditional calculation to get an _average-like_ number by taking the average of the first and last card values in the hand - or by using the "middle" card value (the median) of the hand.
-  She is hoping one of these calculations might come close to the average, but be quicker to calculate during game play. She'd like you to create a function to test her theory out.
+In Black Joe, speed is important. Elyse is going to try and find a faster way of finding the average.
 
+She has thought of two ways of getting an _average-like_ number:
 
-Implement a function `approx_average_is_average(<hand>)` that returns a Boolean.
-The function should return  `True` if _one (or both)_ of Elyse's approximations yields the same value as calculating the "full" average of a hand.
-The function should return `False` if _neither_ approximation formula yields the same value as the "full" average.
-For the sake of a simple median, we are going to assume the hand always has an odd number of card values.
+- Take the average of the _first_ and _last_ number in the hand.
+- Using the median (middle card) of the hand.
+  
+Implement the function `approx_average_is_average(<hand>)`, given `hand`, a list containing the values of the cards in your hand.
 
+Return `True` if either _one_ `or` _both_ of the, above named, strategies result in a number _equal_ to the _actual average_.
+
+Note: _The length of all hands are odd, to make finding a median easier._
 
 ```python
 >>> approx_average_is_average([1, 2, 3])
@@ -98,7 +90,6 @@ Intrigued by the results of her averaging experiment, Elyse is wondering if taki
 
 Implement a function `average_even_is_average_odd(<hand>)` that returns a Boolean indicating if the average of the cards at even indexes is the same as the average of the cards at odd indexes.
 
-
 ```python
 >>> average_even_is_average_odd([1, 2, 3])
 True
@@ -107,16 +98,13 @@ True
 False
 ```
 
-
 ## 7. Bonus Round Rules
 
 Every 11th hand in Black Joe is a bonus hand with a bonus rule: if the last card you draw is a Jack, you double its value.
 
-
 Implement a function `maybe_double_last(<hand>)` that takes a hand and checks if the last card is a Jack (11).
  If the the last card **is** a Jack (11), double its value before returning the hand.
 
-
 ```python
 >>> hand = [5, 9, 11]
 >>> maybe_double_last(hand)

exercises/concept/card-games/.meta/exemplar.py

@@ -44,7 +44,7 @@ def approx_average_is_average(hand):
     """
 
     :param hand: list - cards in hand.
-    :return: bool - is approximate average the same as true average?
+    :return: bool - if approximate average equals to the `true average`.
     """
 
     real_average = card_average(hand)

exercises/concept/card-games/lists.py

@@ -44,7 +44,7 @@ def approx_average_is_average(hand):
     """
 
     :param hand: list - cards in hand.
-    :return: bool - is approximate average the same as true average?
+    :return: bool - if approximate average equals to the `true average`.
     """
 
     pass

exercises/concept/card-games/lists_test.py

@@ -15,108 +15,99 @@ class CardGamesTest(unittest.TestCase):
 
     @pytest.mark.task(taskno=1)
     def test_get_rounds(self):
-        data = [
-            (0, [0, 1, 2]),
-            (1, [1, 2, 3]),
-            (10, [10, 11, 12]),
-            (27, [27, 28, 29]),
-            (99, [99, 100, 101]),
-            (666, [666, 667, 668]),
-        ]
-
-        for variant, (number, rounds) in enumerate(data, start=1):
+
+        input_vars = [0, 1, 10, 27, 99, 666]
+
+        results = [[0, 1, 2], [1, 2, 3], 
+                   [10, 11, 12], [27, 28, 29], 
+                   [99, 100, 101], [666, 667, 668]]
+
+        for variant, (number, rounds) in enumerate(zip(input_vars, results), start=1):
+            error_message = f'Expected rounds {rounds} given the current round {number}.'
             with self.subTest(f'variation #{variant}', input=number, output=rounds):
-                error_message = f'Expected rounds {rounds} given the current round {number}.'
                 self.assertEqual(rounds, get_rounds(number), msg=error_message)
 
+
     @pytest.mark.task(taskno=2)
     def test_concatenate_rounds(self):
-        data = [
-            (([], []), []),
-            (([0, 1], []), [0, 1]),
-            (([], [1, 2]), [1, 2]),
-            (([1], [2]), [1, 2]),
-            (([27, 28, 29], [35, 36]), [27, 28, 29, 35, 36]),
-            (([1, 2, 3], [4, 5, 6]), [1, 2, 3, 4, 5, 6]),
-        ]
-
-        for variant, ((rounds_1, rounds_2), rounds) in enumerate(data, start=1):
+
+        input_vars = [([], []), ([0, 1], []), ([], [1, 2]), 
+                      ([1], [2]), ([27, 28, 29], [35, 36]), 
+                      ([1, 2, 3], [4, 5, 6])]
+
+        results = [[], [0, 1], [1, 2], [1, 2], 
+                   [27, 28, 29, 35, 36], 
+                   [1, 2, 3, 4, 5, 6]]
+
+        for variant, ((rounds_1, rounds_2), rounds) in enumerate(zip(input_vars, results), start=1):
+            error_message = f'Expected {rounds} as the concatenation of {rounds_1} and {rounds_2}.'
             with self.subTest(f'variation #{variant}', input=(rounds_1, rounds_2), output=rounds):
-                error_message = f'Expected {rounds} as the concatenation of {rounds_1} and {rounds_2}.'
                 self.assertEqual(rounds, concatenate_rounds(rounds_1, rounds_2), msg=error_message)
 
+
     @pytest.mark.task(taskno=3)
     def test_list_contains_round(self):
-        data = [
-            (([], 1), False),
-            (([1, 2, 3], 0), False),
-            (([27, 28, 29, 35, 36], 30), False),
-            (([1], 1), True),
-            (([1, 2, 3], 1), True),
-            (([27, 28, 29, 35, 36], 29), True),
-        ]
-
-        for variant, ((rounds, round_number), contains) in enumerate(data, start=1):
+
+        input_vars = [([], 1), ([1, 2, 3], 0), ([27, 28, 29, 35, 36], 30), 
+                      ([1], 1), ([1, 2, 3], 1), ([27, 28, 29, 35, 36], 29)]
+
+        results = [False, False, False, True, True, True]
+
+        for variant, ((rounds, round_number), contains) in enumerate(zip(input_vars, results), start=1):
+            error_message = f'Round {round_number} {"is" if contains else "is not"} in {rounds}.'
             with self.subTest(f'variation #{variant}', input=(rounds, round_number), output=contains):
-                error_message = f'Round {round_number} {"is" if contains else "is not"} in {rounds}.'
-                self.assertEqual(contains,list_contains_round(rounds, round_number),msg=error_message)
+                self.assertEqual(contains, list_contains_round(rounds, round_number), msg=error_message)
+
 
     @pytest.mark.task(taskno=4)
     def test_card_average(self):
-        data = [
-            ([1], 1.0),
-            ([5, 6, 7], 6.0),
-            ([1, 2, 3, 4], 2.5),
-            ([1, 10, 100], 37.0),
-        ]
-
-        for variant, (hand, average) in enumerate(data, start=1):
+
+        input_vars = [[1], [5, 6, 7], [1, 2, 3, 4], [1, 10, 100]]
+
+        results = [1.0, 6.0, 2.5, 37.0]
+
+        for variant, (hand, average) in enumerate(zip(input_vars, results), start=1):
+            error_message=f'Expected {average} as the average of {hand}.'
             with self.subTest(f'variation #{variant}', input=hand, output=average):
-                msg=f'Expected {average} as the average of {hand}.'
-                self.assertEqual(average,card_average(hand),msg=msg)
+                self.assertEqual(average, card_average(hand), msg=error_message)
+
 
     @pytest.mark.task(taskno=5)
     def test_approx_average_is_average(self):
-        data = [
-            ([0, 1, 5], False),
-            ([3, 6, 9, 12, 150], False),
-            ([1, 2, 3, 5, 9], False),
-            ([2, 3, 4, 7, 8], False),
-            ([1, 2, 3], True),
-            ([2, 3, 4], True),
-            ([2, 3, 4, 8, 8], True),
-            ([1, 2, 4, 5, 8], True),
-        ]
-
-        for variant, (hand, same) in enumerate(data, start=1):
+
+        input_vars = [[0, 1, 5], [3, 6, 9, 12, 150], [1, 2, 3, 5, 9],
+                      [2, 3, 4, 7, 8], [1, 2, 3], [2, 3, 4],
+                      [2, 3, 4, 8, 8], [1, 2, 4, 5, 8]]
+
+        results = [False, False, False, False, True, True, True, True]
+
+        for variant, (hand, same) in enumerate(zip(input_vars, results), start=1):
+            error_message = f'Hand {hand} {"does" if same else "does not"} yield the same approximate average.'
             with self.subTest(f'variation #{variant}', input=hand, output=same):
-                error_message = f'Hand {hand} {"does" if same else "does not"} yield the same approximate average.'
                 self.assertEqual(same, approx_average_is_average(hand), msg=error_message)
 
+
     @pytest.mark.task(taskno=6)
     def test_average_even_is_average_odd(self):
-        data = [
-            ([5, 6, 8], False),
-            ([1, 2, 3, 4], False),
-            ([1, 2, 3], True),
-            ([5, 6, 7], True),
-        ]
-
-        for variant, (hand, same) in enumerate(data, start=1):
+
+        input_vars = [[5, 6, 8], [1, 2, 3, 4], [1, 2, 3], [5, 6, 7], ]
+
+        results = [False, False, True, True]
+
+        for variant, (hand, same) in enumerate(zip(input_vars, results), start=1):
+            error_message=f'Hand {hand} {"does" if same else "does not"} yield the same odd-even average.'
             with self.subTest(f'variation #{variant}', input=hand, output=same):
-                msg=f'Hand {hand} {"does" if same else "does not"} yield the same odd-even average.'
-                self.assertEqual(same, average_even_is_average_odd(hand),msg=msg)
+                self.assertEqual(same, average_even_is_average_odd(hand),msg=error_message)
+
 
     @pytest.mark.task(taskno=7)
     def test_maybe_double_last(self):
-        data = [
-            ([1, 2, 11], [1, 2, 22]),
-            ([5, 9, 11], [5, 9, 22]),
-            ([5, 9, 10], [5, 9, 10]),
-            ([1, 2, 3], [1, 2, 3]),
-        ]
-
-        for variant, (hand, doubled_hand) in enumerate(data, start=1):
+
+        input_vars = [[1, 2, 11], [5, 9, 11], [5, 9, 10], [1, 2, 3]]
+
+        results = [[1, 2, 22], [5, 9, 22], [5, 9 , 10], [1, 2, 3]]
+
+        for variant, (hand, doubled_hand) in enumerate(zip(input_vars, results), start=1):
+            error_message=f'Expected {doubled_hand} as the maybe-doubled version of {hand}.'
             with self.subTest(f'variation #{variant}', input=hand, output=doubled_hand):
-                msg=f'Expected {doubled_hand} as the maybe-doubled version of {hand}.'
-                self.assertEqual(doubled_hand,maybe_double_last(hand),msg=msg)
+                self.assertEqual(doubled_hand,maybe_double_last(hand),msg=error_message)