a/exercism
1
0
Fork 0
mirror of https://codeberg.org/andyscott/exercism.git synced 2024-12-21 22:33:11 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Python: completed Card Games

Browse source
This commit is contained in:
Andrew Scott 2024-09-26 17:49:18 -04:00
parent 11966b4315
commit d336d146db
Signed by: a
GPG key ID: 7CD5A5977E4931C1
7 changed files with 813 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
python/card-games/.exercism/config.json Normal file
View file

@ -0,0 +1,24 @@
{
"authors": [
"itamargal",
"isaacg",
"bethanyg"
],
"contributors": [
"valentin-p",
"pranasziaukas"
],
"files": {
"solution": [
"lists.py"
],
"test": [
"lists_test.py"
],
"exemplar": [
".meta/exemplar.py"
]
},
"icon": "poker",
"blurb": "Learn about lists by tracking hands in card games."
}

1
python/card-games/.exercism/metadata.json Normal file
View file

@ -0,0 +1 @@
{"track":"python","exercise":"card-games","id":"47aa83e6f3eb45219f2ef38dc238d4e2","url":"https://exercism.org/tracks/python/exercises/card-games","handle":"Chomp1295","is_requester":true,"auto_approve":false}

130
python/card-games/HELP.md Normal file
View file

@ -0,0 +1,130 @@
# Help
## Running the tests
We use [pytest][pytest: Getting Started Guide] as our website test runner.
You will need to install `pytest` on your development machine if you want to run tests for the Python track locally.
You should also install the following `pytest` plugins:
- [pytest-cache][pytest-cache]
- [pytest-subtests][pytest-subtests]
Extended information can be found in our website [Python testing guide][Python track tests page].
### Running Tests
To run the included tests, navigate to the folder where the exercise is stored using `cd` in your terminal (_replace `{exercise-folder-location}` below with your path_).
Test files usually end in `_test.py`, and are the same tests that run on the website when a solution is uploaded.
Linux/MacOS
```bash
$ cd {path/to/exercise-folder-location}
```
Windows
```powershell
PS C:\Users\foobar> cd {path\to\exercise-folder-location}
```
<br>
Next, run the `pytest` command in your terminal, replacing `{exercise_test.py}` with the name of the test file:
Linux/MacOS
```bash
$ python3 -m pytest -o markers=task {exercise_test.py}
==================== 7 passed in 0.08s ====================
```
Windows
```powershell
PS C:\Users\foobar> py -m pytest -o markers=task {exercise_test.py}
==================== 7 passed in 0.08s ====================
```
### Common options
- `-o` : override default `pytest.ini` (_you can use this to avoid marker warnings_)
- `-v` : enable verbose output.
- `-x` : stop running tests on first failure.
- `--ff` : run failures from previous test before running other test cases.
For additional options, use `python3 -m pytest -h` or `py -m pytest -h`.
### Fixing warnings
If you do not use `pytest -o markers=task` when invoking `pytest`, you might receive a `PytestUnknownMarkWarning` for tests that use our new syntax:
```bash
PytestUnknownMarkWarning: Unknown pytest.mark.task - is this a typo? You can register custom marks to avoid this warning - for details, see https://docs.pytest.org/en/stable/mark.html
```
To avoid typing `pytest -o markers=task` for every test you run, you can use a `pytest.ini` configuration file.
We have made one that can be downloaded from the top level of the Python track directory: [pytest.ini][pytest.ini].
You can also create your own `pytest.ini` file with the following content:
```ini
[pytest]
markers =
task: A concept exercise task.
```
Placing the `pytest.ini` file in the _root_ or _working_ directory for your Python track exercises will register the marks and stop the warnings.
More information on pytest marks can be found in the `pytest` documentation on [marking test functions][pytest: marking test functions with attributes] and the `pytest` documentation on [working with custom markers][pytest: working with custom markers].
Information on customizing pytest configurations can be found in the `pytest` documentation on [configuration file formats][pytest: configuration file formats].
### Extending your IDE or Code Editor
Many IDEs and code editors have built-in support for using `pytest` and other code quality tools.
Some community-sourced options can be found on our [Python track tools page][Python track tools page].
[Pytest: Getting Started Guide]: https://docs.pytest.org/en/latest/getting-started.html
[Python track tools page]: https://exercism.org/docs/tracks/python/tools
[Python track tests page]: https://exercism.org/docs/tracks/python/tests
[pytest-cache]:http://pythonhosted.org/pytest-cache/
[pytest-subtests]:https://github.com/pytest-dev/pytest-subtests
[pytest.ini]: https://github.com/exercism/python/blob/main/pytest.ini
[pytest: configuration file formats]: https://docs.pytest.org/en/6.2.x/customize.html#configuration-file-formats
[pytest: marking test functions with attributes]: https://docs.pytest.org/en/6.2.x/mark.html#raising-errors-on-unknown-marks
[pytest: working with custom markers]: https://docs.pytest.org/en/6.2.x/example/markers.html#working-with-custom-markers
## Submitting your solution
You can submit your solution using the `exercism submit lists.py` command.
This command will upload your solution to the Exercism website and print the solution page's URL.
It's possible to submit an incomplete solution which allows you to:
- See how others have completed the exercise
- Request help from a mentor
## Need to get help?
If you'd like help solving the exercise, check the following pages:
- The [Python track's documentation](https://exercism.org/docs/tracks/python)
- The [Python track's programming category on the forum](https://forum.exercism.org/c/programming/python)
- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
Below are some resources for getting help if you run into trouble:
- [The PSF](https://www.python.org) hosts Python downloads, documentation, and community resources.
- [The Exercism Community on Discord](https://exercism.org/r/discord)
- [Python Community on Discord](https://pythondiscord.com/) is a very helpful and active community.
- [/r/learnpython/](https://www.reddit.com/r/learnpython/) is a subreddit designed for Python learners.
- [#python on Libera.chat](https://www.python.org/community/irc/) this is where the core developers for the language hang out and get work done.
- [Python Community Forums](https://discuss.python.org/)
- [Free Code Camp Community Forums](https://forum.freecodecamp.org/)
- [CodeNewbie Community Help Tag](https://community.codenewbie.org/t/help)
- [Pythontutor](http://pythontutor.com/) for stepping through small code snippets visually.
Additionally, [StackOverflow](http://stackoverflow.com/questions/tagged/python) is a good spot to search for your problem/question to see if it has been answered already.
If not - you can always [ask](https://stackoverflow.com/help/how-to-ask) or [answer](https://stackoverflow.com/help/how-to-answer) someone else's question.

47
python/card-games/HINTS.md Normal file
View file

@ -0,0 +1,47 @@
# Hints
## General
## 1. Tracking Poker Rounds
- Lists in Python may be [constructed][constructed] in multiple ways.
- This function should [return][return] a `list`.
## 2. Keeping all Rounds in the Same Place
- Sequence types such as `list` support [common operations][common sequence operations].
- This function should [return][return] a `list`.
## 3. Finding Prior Rounds
- Sequence types such as `list` support a few [common operations][common sequence operations].
- This function should [return][return] a `bool`.
## 4. Averaging Card Values
- To get the average, this function should count how many items are in the `list` and sum up their values. Then, return the sum divided by the count.
## 5. Alternate Averages
- Sequence types such as `list` support a few [common operations][common sequence operations].
- To access an element, use the square brackets (`<list>[]`) notation.
- Remember that the first element of the `list` is at index 0 from the **left-hand** side.
- In Python, negative indexing starts at -1 from the **right-hand** side. This means that you can find the last element of a `list` by using `<list>[-1]`.
- Think about how you could reuse the code from the functions that you have already implemented.
## 6. More Averaging Techniques
- Sequence types such as `list` already support a few [common operations][common sequence operations].
- Think about reusing the code from the functions that you just implemented.
- The slice syntax supports a _step value_ (`<list>[<start>:<stop>:<step>]`).
## 7. Bonus Round Rules
- Lists are _mutable_. Once a `list` is created, you can modify, delete or add any type of element you wish.
- Python provides a wide range of [ways to modify `lists`][ways to modify `lists`].
[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
[constructed]: https://docs.python.org/3/library/stdtypes.html#list
[return]: https://www.w3schools.com/python/ref_keyword_return.asp
[ways to modify `lists`]: https://realpython.com/python-lists-tuples/#lists-are-mutable

393
python/card-games/README.md Normal file
View file

@ -0,0 +1,393 @@
# Card Games
Welcome to Card Games on Exercism's Python Track.
If you need help running the tests or submitting your code, check out `HELP.md`.
If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)
## Introduction
A [`list`][list] is a mutable collection of items in _sequence_.
Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold reference to any (or multiple) data type(s) - including other lists.
Like any [sequence][sequence type], items can be accessed via `0-based index` number from the left and `-1-based index` from the right.
Lists can be copied in whole or in part via [slice notation][slice notation] or `<list>.copy()`.
Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min()`/`max()`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
List elements can be iterated over using the `for item in <list>` construct.
`for index, item in enumerate(<list>)` can be used when both the element index and the element value are needed.
Under the hood, `lists` are implemented as [dynamic arrays][dynamic array] -- similar to Java's [`ArrayList`][arraylist] type, and are most often used to store groups of similar data (_strings, numbers, sets etc._) of unknown length.
Lists are an extremely flexible and useful data structure and many built-in methods and operations in Python produce lists as their output.
## Construction
A `list` can be declared as a _literal_ with square `[]` brackets and commas between elements:
```python
>>> no_elements = []
>>> no_elements
[]
>>> one_element = ["Guava"]
>>> one_element
['Guava']
>>> elements_separated_with_commas = ["Parrot", "Bird", 334782]
>>> elements_separated_with_commas
['Parrot', 'Bird', 334782]
```
For readability, line breaks can be used when there are many elements or nested data structures within a `list`:
```python
>>> lots_of_entries = [
"Rose",
"Sunflower",
"Poppy",
"Pansy",
"Tulip",
"Fuchsia",
"Cyclamen",
"Lavender"
]
>>> lots_of_entries
['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']
# Each data structure is on its own line to help clarify what they are.
>>> nested_data_structures = [
{"fish": "gold", "monkey": "brown", "parrot": "grey"},
("fish", "mammal", "bird"),
['water', 'jungle', 'sky']
]
>>> nested_data_structures
[{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]
```
The `list()` constructor can be used empty or with an _iterable_ as an argument.
Elements in the iterable are cycled through by the constructor and added to the `list` in order:
```python
>>> no_elements = list()
>>> no_elements
[]
# The tuple is unpacked and each element is added.
>>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))
>>> multiple_elements_from_tuple
['Parrot', 'Bird', 334782]
# The set is unpacked and each element is added.
>>> multiple_elements_from_set = list({2, 3, 5, 7, 11})
>>> multiple_elements_from_set
[2, 3, 5, 7, 11]
```
Results when using a `list` constructor with a `string` or a `dict` may be surprising:
```python
# String elements (Unicode code points) are iterated through and added *individually*.
>>> multiple_elements_string = list("Timbuktu")
>>> multiple_elements_string
['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']
# Unicode separators and positioning code points are also added *individually*.
>>> multiple_code_points_string = list('अभ्यास')
>>> multiple_code_points_string
['अ', 'भ', '्', 'य', 'ा', 'स']
# The iteration default for dictionaries is over the keys, so only key data is inserted into the list.
>>> source_data = {"fish": "gold", "monkey": "brown"}
>>> multiple_elements_dict_1 = list(source_data)
['fish', 'monkey']
```
Because the `list` constructor will only take _iterables_ (or nothing) as arguments, objects that are _not_ iterable will throw a type error.
Consequently, it is much easier to create a one-item `list` via the literal method.
```python
# Numbers are not iterable, and so attempting to create a list with a number passed to the constructor fails.
>>> one_element = list(16)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
# Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
>>> one_element_from_iterable = list((16,))
>>> one_element_from_iterable
[16]
```
## Accessing elements
Items inside lists (_as well as items in other sequence types `str` & `tuple`_) can be accessed via `0-based index` and _bracket notation_.
Indexes can be from **`left`** --> **`right`** (_starting at zero_) or **`right`** --> **`left`** (_starting at -1_).
<table>
<tr>
<td style="vertical-align: top"> index from left ⟹<br><br><br><br><br><br><br></td><td style="vertical-align: middle">
| 0<br>👇🏾 | 1<br>👇🏾 | 2<br>👇🏾 | 3<br>👇🏾 | 4<br>👇🏾 | 5<br>👇🏾 |
|:--------: |:--------: |:--------: |:--------: |:--------: |:--------: |
| P | y | t | h | o | n |
| 👆🏾<br>-6 | 👆🏾<br>-5 | 👆🏾<br>-4 | 👆🏾<br>-3 | 👆🏾<br>-2 | 👆🏾<br>-1 |
</td><td style="vertical-align: bottom"><br><br><br><br><br>⟸ index from right</td>
</tr>
</table>
```python
>>> breakfast_foods = ["Oatmeal", "Fruit Salad", "Eggs", "Toast"]
# Oatmeal is at index 0 or index -4.
>>> breakfast_foods[0]
'Oatmeal'
>>> breakfast_foods[-4]
'Oatmeal'
# Eggs are at index -2 or 2
>>> breakfast_foods[-2]
'Eggs'
>>> breakfast_foods[2]
'Eggs'
# Toast is at -1
>>> breakfast_foods[-1]
'Toast'
```
A section of the elements inside a `list` can be accessed via _slice notation_ (`<list>[start:stop]`).
A _slice_ is defined as an element sequence at position `index`, such that `start <= index < stop`.
_Slicing_ returns a copy of the "sliced" items and does not modify the original `list`.
A `step` parameter can also be used `[start:stop:step]` to "skip over" or filter the `list` elements (_for example, a `step` of 2 will select every other element in the range_):
```python
>>> colors = ["Red", "Purple", "Green", "Yellow", "Orange", "Pink", "Blue", "Grey"]
# If there is no step parameter, the step is assumed to be 1.
>>> middle_colors = colors[2:6]
>>> middle_colors
['Green', 'Yellow', 'Orange', 'Pink']
# If the start or stop parameters are omitted, the slice will
# start at index zero, and will stop at the end of the list.
>>> primary_colors = colors[::3]
>>> primary_colors
['Red', 'Yellow', 'Blue']
```
## Working with lists
The usage of the built-in `sum()` function on a list will return the sum of all the numbers in the list:
```python
>>> number_list = [1, 2, 3, 4]
>>> sum(number_list)
10
```
You can also get the _length_ of a list by using the `len()` function:
```python
>>> long_list = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
>>> len(long_list)
10
```
Lists can be also combined in various ways:
```python
# Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
>>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]
>>> new_via_concatenate
['George', 5, 'cat', 'Tabby']
# Likewise, using the multiplication operator * is the equivalent of using + n times.
>>> first_group = ["cat", "dog", "elephant"]
>>> multiplied_group = first_group * 3
>>> multiplied_group
['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']
```
Lists supply an _iterator_, and can be looped through/over in the same manner as other _sequence types_.
```python
# Looping through the list and printing out each element.
>>> colors = ["Orange", "Green", "Grey", "Blue"]
>>> for item in colors:
... print(item)
...
Orange
Green
Grey
Blue
```
_For a more in-depth explanation, of `loops` and `iterators`, complete the `loops` concept._
[arraylist]: https://beginnersbook.com/2013/12/java-arraylist/
[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
[dict]: https://docs.python.org/3/library/stdtypes.html#dict
[dynamic array]: https://en.wikipedia.org/wiki/Dynamic_array
[list]: https://docs.python.org/3/library/stdtypes.html#list
[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
[set]: https://docs.python.org/3/library/stdtypes.html#set
[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
## Instructions
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
>>> list_contains_round([27, 28, 29, 35, 36], 30)
False
```
## 4. Averaging Card Values
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
>>> card_average([5, 6, 7])
6.0
```
## 5. Alternate Averages
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:
- 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])
True
>>> approx_average_is_average([2, 3, 4, 8, 8])
True
>>> approx_average_is_average([1, 2, 3, 5, 9])
False
```
## 6. More Averaging Techniques
Intrigued by the results of her averaging experiment, Elyse is wondering if taking the average of the cards at the _even_ positions versus the average of the cards at the _odd_ positions would give the same results.
Time for another test function!
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
>>> average_even_is_average_odd([1, 2, 3, 4])
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 last card **is** a Jack (11), double its value before returning the hand.
```python
>>> hand = [5, 9, 11]
>>> maybe_double_last(hand)
[5, 9, 22]
>>> hand = [5, 9, 10]
>>> maybe_double_last(hand)
[5, 9, 10]
```
## Source
### Created by
- @itamargal
- @isaacg
- @bethanyg
### Contributed to by
- @valentin-p
- @pranasziaukas

81
python/card-games/lists.py Normal file
View file

@ -0,0 +1,81 @@
"""Functions for tracking poker hands and assorted card tasks.
Python list documentation: https://docs.python.org/3/tutorial/datastructures.html
"""
def get_rounds(number):
"""Create a list containing the current and next two round numbers.
:param number: int - current round number.
:return: list - current round and the two that follow.
"""
return [number, number + 1, number + 2]
def concatenate_rounds(rounds_1, rounds_2):
"""Concatenate two lists of round numbers.
:param rounds_1: list - first rounds played.
:param rounds_2: list - second set of rounds played.
:return: list - all rounds played.
"""
return rounds_1 + rounds_2
def list_contains_round(rounds, number):
"""Check if the list of rounds contains the specified number.
:param rounds: list - rounds played.
:param number: int - round number.
:return: bool - was the round played?
"""
return number in rounds
def card_average(hand):
"""Calculate and returns the average card value from the list.
:param hand: list - cards in hand.
:return: float - average value of the cards in the hand.
"""
return sum(hand) / len(hand)
def approx_average_is_average(hand):
"""Return if the (average of first and last card values) OR ('middle' card) == calculated average.
:param hand: list - cards in hand.
:return: bool - does one of the approximate averages equal the `true average`?
"""
size = len(hand)
actual_avg = card_average(hand)
first_last = (hand[0] + hand[size - 1]) / 2
median = hand[size // 2]
return actual_avg in (first_last, median)
def average_even_is_average_odd(hand):
"""Return if the (average of even indexed card values) == (average of odd indexed card values).
:param hand: list - cards in hand.
:return: bool - are even and odd averages equal?
"""
return card_average(hand[::2]) == card_average(hand[1::2])
def maybe_double_last(hand):
"""Multiply a Jack card value in the last index position by 2.
:param hand: list - cards in hand.
:return: list - hand with Jacks (if present) value doubled.
"""
if hand[-1] == 11:
hand[-1] *= 2
return hand

137
python/card-games/lists_test.py Normal file
View file

@ -0,0 +1,137 @@
import unittest
import pytest
from lists import (
get_rounds,
concatenate_rounds,
list_contains_round,
card_average,
approx_average_is_average,
average_even_is_average_odd,
maybe_double_last,
)
class CardGamesTest(unittest.TestCase):
@pytest.mark.task(taskno=1)
def test_get_rounds(self):
input_data = [0, 1, 10, 27, 99, 666]
result_data = [[0, 1, 2], [1, 2, 3],
[10, 11, 12], [27, 28, 29],
[99, 100, 101], [666, 667, 668]]
for variant, (number, expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', number=number, expected=expected):
actual_result = get_rounds(number)
error_message = (f'Called get_rounds({number}). '
f'The function returned {actual_result}, '
f'but the tests expected rounds {expected} '
f'given the current round {number}.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=2)
def test_concatenate_rounds(self):
input_data = [([], []), ([0, 1], []), ([], [1, 2]),
([1], [2]), ([27, 28, 29], [35, 36]),
([1, 2, 3], [4, 5, 6])]
result_data = [[], [0, 1], [1, 2], [1, 2],
[27, 28, 29, 35, 36],
[1, 2, 3, 4, 5, 6]]
for variant, ((rounds_1, rounds_2), expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', rounds_1=rounds_1, rounds_2=rounds_2, expected=expected):
actual_result = concatenate_rounds(rounds_1, rounds_2)
error_message = (f'Called concatenate_rounds({rounds_1}, {rounds_2}). '
f'The function returned {actual_result}, but the tests '
f'expected {expected} as the concatenation '
f'of {rounds_1} and {rounds_2}.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=3)
def test_list_contains_round(self):
input_data = [([], 1), ([1, 2, 3], 0),
([27, 28, 29, 35, 36], 30),
([1], 1), ([1, 2, 3], 1),
([27, 28, 29, 35, 36], 29)]
result_data = [False, False, False, True, True, True]
for variant, ((rounds, round_number), expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', rounds=rounds, round_number=round_number, expected=expected):
actual_result = list_contains_round(rounds, round_number)
error_message = (f'Called list_contains_round({rounds}, {round_number}). '
f'The function returned {actual_result}, but round {round_number} '
f'{"is" if expected else "is not"} in {rounds}.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=4)
def test_card_average(self):
input_data = [[1], [5, 6, 7], [1, 2, 3, 4], [1, 10, 100]]
result_data = [1.0, 6.0, 2.5, 37.0]
for variant, (hand, expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', hand=hand, expected=expected):
actual_result = card_average(hand)
error_message = (f'Called card_average({hand}). '
f'The function returned {actual_result}, but '
f'the tests expected {expected} as the average of {hand}.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=5)
def test_approx_average_is_average(self):
input_data = [[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]]
result_data = [False, False, False, False, True, True, True, True]
for variant, (hand, expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', hand=hand, expected=expected):
actual_result = approx_average_is_average(hand)
error_message = (f'Called approx_average_is_average({hand}). '
f'The function returned {actual_result}, but '
f'the hand {hand} {"does" if expected else "does not"} '
f'yield the same approximate average.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=6)
def test_average_even_is_average_odd(self):
input_data = [[5, 6, 8], [1, 2, 3, 4], [1, 2, 3], [5, 6, 7], [1, 3, 5, 7, 9]]
result_data = [False, False, True, True, True]
for variant, (input_hand, expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', input_hand=input_hand, expected=expected):
actual_result = average_even_is_average_odd(input_hand)
error_message = (f'Called average_even_is_average_odd({input_hand}). '
f'The function returned {actual_result}, but '
f'the hand {"does" if expected else "does not"} '
f'yield the same odd-even average.')
self.assertEqual(actual_result, expected, msg=error_message)
@pytest.mark.task(taskno=7)
def test_maybe_double_last(self):
input_data = [(1, 2, 11), (5, 9, 11), (5, 9, 10), (1, 2, 3), (1, 11, 8)]
result_data = [[1, 2, 22], [5, 9, 22], [5, 9, 10], [1, 2, 3], [1, 11, 8]]
for variant, (hand, expected) in enumerate(zip(input_data, result_data), start=1):
with self.subTest(f'variation #{variant}', hand=list(hand), expected=expected):
actual_result = maybe_double_last(list(hand))
error_message = (f'Called maybe_double_last({list(hand)}). '
f'The function returned {actual_result}, but '
f'the tests expected {expected} as the maybe-doubled version of {list(hand)}.')
self.assertEqual(actual_result, expected, msg=error_message)