diff --git a/flower-field/flower_field.py b/flower-field/flower_field.py index d7d48ec..3261a33 100644 --- a/flower-field/flower_field.py +++ b/flower-field/flower_field.py @@ -10,7 +10,16 @@ """ # Relative offsets to the eight neighboring cells around a given position -COORDINATES: tuple[tuple[int, int]] = ( +COORDINATES: tuple[ + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], +] = ( (-1, -1), (-1, 0), (-1, 1), @@ -71,38 +80,18 @@ def _calc_surrounding_flowers(i_row: int, i_col: int, garden: list[str]) -> int: """ if garden[i_row][i_col] != " ": return 0 - return sum( - _process_cell(i_row, offset_row, i_col, offset_col, garden) - for offset_row, offset_col in COORDINATES - ) - - -def _process_cell(i_row, offset_row, i_col, offset_col, garden) -> int: - """ - Return 1 if the neighbor at the given relative offset contains a flower. - - Computes the absolute coordinates from ``(i_row, i_col)`` and the provided - offsets, performs bounds checking to avoid ``IndexError``, and returns ``1`` - only when the cell is within the garden and equals ``"*"``. - - :param int i_row: Row index of the reference cell. - :param int offset_row: Row delta to apply to ``i_row``. - :param int i_col: Column index of the reference cell. - :param int offset_col: Column delta to apply to ``i_col``. - :param list garden: The rectangular garden representation. - :returns: ``1`` when the computed neighbor cell contains a flower, otherwise ``0``. - :rtype: int - """ - row: int = i_row + offset_row - col: int = i_col + offset_col - - if ( - 0 <= row < len(garden) # ROW: Avoid IndexError - and 0 <= col < len(garden[0]) # COL: Avoid IndexError - and garden[row][col] == "*" # Detect/count flower - ): - return 1 - return 0 + total: int = 0 + # Count flowers all around current position + for offset_row, offset_col in COORDINATES: + sum_row = i_row + offset_row + sum_col = i_col + offset_col + if ( + 0 <= sum_row < len(garden) # ROW: Avoid IndexError + and 0 <= sum_col < len(garden[0]) # COL: Avoid IndexError + and garden[sum_row][sum_col] == "*" # Detect/count flower + ): + total += 1 + return total def _validate(garden: list[str]) -> None: diff --git a/resistor-color-trio/.exercism/config.json b/resistor-color-trio/.exercism/config.json new file mode 100644 index 0000000..68dad4c --- /dev/null +++ b/resistor-color-trio/.exercism/config.json @@ -0,0 +1,20 @@ +{ + "authors": [ + "meatball133", + "bethanyg" + ], + "files": { + "solution": [ + "resistor_color_trio.py" + ], + "test": [ + "resistor_color_trio_test.py" + ], + "example": [ + ".meta/example.py" + ] + }, + "blurb": "Convert color codes, as used on resistors, to a human-readable label.", + "source": "Maud de Vries, Erik Schierboom", + "source_url": "https://github.com/exercism/problem-specifications/issues/1549" +} diff --git a/resistor-color-trio/.exercism/metadata.json b/resistor-color-trio/.exercism/metadata.json new file mode 100644 index 0000000..4a6614d --- /dev/null +++ b/resistor-color-trio/.exercism/metadata.json @@ -0,0 +1 @@ +{"track":"python","exercise":"resistor-color-trio","id":"a3ae5a759afb4e5aa99bfe4c281a4bfd","url":"https://exercism.org/tracks/python/exercises/resistor-color-trio","handle":"myFirstCode","is_requester":true,"auto_approve":false} \ No newline at end of file diff --git a/resistor-color-trio/HELP.md b/resistor-color-trio/HELP.md new file mode 100644 index 0000000..f902ec5 --- /dev/null +++ b/resistor-color-trio/HELP.md @@ -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} +``` + +
+ +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 resistor_color_trio.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. \ No newline at end of file diff --git a/resistor-color-trio/README.md b/resistor-color-trio/README.md new file mode 100644 index 0000000..91ea6c0 --- /dev/null +++ b/resistor-color-trio/README.md @@ -0,0 +1,72 @@ +# Resistor Color Trio + +Welcome to Resistor Color Trio on Exercism's Python Track. +If you need help running the tests or submitting your code, check out `HELP.md`. + +## Instructions + +If you want to build something using a Raspberry Pi, you'll probably use _resistors_. +For this exercise, you need to know only three things about them: + +- Each resistor has a resistance value. +- Resistors are small - so small in fact that if you printed the resistance value on them, it would be hard to read. + To get around this problem, manufacturers print color-coded bands onto the resistors to denote their resistance values. +- Each band acts as a digit of a number. + For example, if they printed a brown band (value 1) followed by a green band (value 5), it would translate to the number 15. + In this exercise, you are going to create a helpful program so that you don't have to remember the values of the bands. + The program will take 3 colors as input, and outputs the correct value, in ohms. + The color bands are encoded as follows: + +- black: 0 +- brown: 1 +- red: 2 +- orange: 3 +- yellow: 4 +- green: 5 +- blue: 6 +- violet: 7 +- grey: 8 +- white: 9 + +In Resistor Color Duo you decoded the first two colors. +For instance: orange-orange got the main value `33`. +The third color stands for how many zeros need to be added to the main value. +The main value plus the zeros gives us a value in ohms. +For the exercise it doesn't matter what ohms really are. +For example: + +- orange-orange-black would be 33 and no zeros, which becomes 33 ohms. +- orange-orange-red would be 33 and 2 zeros, which becomes 3300 ohms. +- orange-orange-orange would be 33 and 3 zeros, which becomes 33000 ohms. + +(If Math is your thing, you may want to think of the zeros as exponents of 10. +If Math is not your thing, go with the zeros. +It really is the same thing, just in plain English instead of Math lingo.) + +This exercise is about translating the colors into a label: + +> "... ohms" + +So an input of `"orange", "orange", "black"` should return: + +> "33 ohms" + +When we get to larger resistors, a [metric prefix][metric-prefix] is used to indicate a larger magnitude of ohms, such as "kiloohms". +That is similar to saying "2 kilometers" instead of "2000 meters", or "2 kilograms" for "2000 grams". + +For example, an input of `"orange", "orange", "orange"` should return: + +> "33 kiloohms" + +[metric-prefix]: https://en.wikipedia.org/wiki/Metric_prefix + +## Source + +### Created by + +- @meatball133 +- @bethanyg + +### Based on + +Maud de Vries, Erik Schierboom - https://github.com/exercism/problem-specifications/issues/1549 \ No newline at end of file diff --git a/resistor-color-trio/resistor_color_trio.py b/resistor-color-trio/resistor_color_trio.py new file mode 100644 index 0000000..804aa5f --- /dev/null +++ b/resistor-color-trio/resistor_color_trio.py @@ -0,0 +1,58 @@ +""" +Resistor Color Trio. + +In Resistor Color Duo you decoded the first two colors. +For instance: orange-orange got the main value 33. +The third color stands for how many zeros need to be added to the main value. +The main value plus the zeros gives us a value in ohms. For the exercise it +doesn't matter what ohms really are. +""" + +# Mapping of resistor color names to their corresponding digit values. +COLOR_VALUES: dict[str, int] = { + "black": 0, + "brown": 1, + "red": 2, + "orange": 3, + "yellow": 4, + "green": 5, + "blue": 6, + "violet": 7, + "grey": 8, + "white": 9, +} + + +def label(colors: list[str]) -> str: + """ + Return a human-readable label for a 3-band resistor value. + + The first two colors form the significant digits and the third color + is the multiplier (number of trailing zeros). The resulting value is + scaled to the largest whole unit among ohms, kiloohms, megaohms, or + gigaohms. + + :param colors: Three resistor color names in order [band1, band2, multiplier]. + band1 and band2 provide the significant digits; multiplier + adds zeros. + :return: Formatted resistance value string using the largest whole unit + (e.g., '47 kiloohms', '680 ohms'). + :raises KeyError: If a color name is not recognized. + :raises IndexError: If fewer than three colors are provided. + """ + prefix: str = f"{COLOR_VALUES[colors[0]]}{COLOR_VALUES[colors[1]]}" + postfix: str = f"{'0' * COLOR_VALUES[colors[2]]}" + int_val: int = int(prefix + postfix) + + # Scale to the largest whole unit + # (ohms, kiloohms, megaohms, gigaohms) for readability + if 1000 <= int_val < 1000000: + return f"{int_val // 1000} kiloohms" + + if 1000000 <= int_val < 1000000000: + return f"{int_val // 1000000} megaohms" + + if 1000000000 <= int_val: + return f"{int_val // 1000000000} gigaohms" + + return f"{int_val} ohms" diff --git a/resistor-color-trio/resistor_color_trio_test.py b/resistor-color-trio/resistor_color_trio_test.py new file mode 100644 index 0000000..97394b7 --- /dev/null +++ b/resistor-color-trio/resistor_color_trio_test.py @@ -0,0 +1,42 @@ +# pylint: disable=C0301, C0114, C0115, C0116, R0904 +# These tests are auto-generated with test data from: +# https://github.com/exercism/problem-specifications/tree/main/exercises/resistor-color-trio/canonical-data.json +# File last updated on 2023-07-19 + +import unittest + +from resistor_color_trio import ( + label, +) + + +class ResistorColorTrioTest(unittest.TestCase): + def test_orange_and_orange_and_black(self): + self.assertEqual(label(["orange", "orange", "black"]), "33 ohms") + + def test_blue_and_grey_and_brown(self): + self.assertEqual(label(["blue", "grey", "brown"]), "680 ohms") + + def test_red_and_black_and_red(self): + self.assertEqual(label(["red", "black", "red"]), "2 kiloohms") + + def test_green_and_brown_and_orange(self): + self.assertEqual(label(["green", "brown", "orange"]), "51 kiloohms") + + def test_yellow_and_violet_and_yellow(self): + self.assertEqual(label(["yellow", "violet", "yellow"]), "470 kiloohms") + + def test_blue_and_violet_and_blue(self): + self.assertEqual(label(["blue", "violet", "blue"]), "67 megaohms") + + def test_minimum_possible_value(self): + self.assertEqual(label(["black", "black", "black"]), "0 ohms") + + def test_maximum_possible_value(self): + self.assertEqual(label(["white", "white", "white"]), "99 gigaohms") + + def test_first_two_colors_make_an_invalid_octal_number(self): + self.assertEqual(label(["black", "grey", "black"]), "8 ohms") + + def test_ignore_extra_colors(self): + self.assertEqual(label(["blue", "green", "yellow", "orange"]), "650 kiloohms") diff --git a/solutions/python/flower-field/19/flower_field.py b/solutions/python/flower-field/19/flower_field.py new file mode 100644 index 0000000..67224d5 --- /dev/null +++ b/solutions/python/flower-field/19/flower_field.py @@ -0,0 +1,106 @@ +""" +Flower Field is a compassionate reimagining of the popular game Minesweeper. + +This module provides helpers to validate and annotate a rectangular garden +representation, where each row is a string comprised of spaces and ``*`` +characters. A ``*`` denotes a flower; a space denotes an empty square. + +The goal is to compute numeric hints indicating how many flowers are +adjacent (horizontally, vertically, diagonally) to each square. +""" + +# Relative offsets to the eight neighboring cells around a given position +COORDINATES: tuple[tuple[int, int]] = ( + (-1, -1), + (-1, 0), + (-1, 1), + (0, -1), + (0, 1), + (1, -1), + (1, 0), + (1, 1), +) + + +def annotate(garden: list[str]) -> list[str]: + """ + Annotate a garden with counts of adjacent flowers. + + Expects a rectangular list of strings containing only spaces and ``*``. + Validation errors raise a :class:`ValueError`. + + :param list garden: A list of equal-length strings representing the garden. + ``*`` marks a flower; space marks empty. + :returns: An annotated garden of the same shape. Empty squares are + replaced by digits (``"1"``–``"8"``) when adjacent to flowers; + squares with zero adjacent flowers remain spaces. Flowers + (``*``) are preserved. + :rtype: list[str] + :raises ValueError: If the garden is non-rectangular or contains + invalid characters. + """ + # empty list + if not garden: + return [] + # raise an error when the board receives malformed input + _validate(garden) + return [ + "".join( + str(count) + if (count := _calc_surrounding_flowers(i_row, i_col, garden)) != 0 + else char + for i_col, char in enumerate(row) + ) + for i_row, row in enumerate(garden) + ] + + +def _calc_surrounding_flowers(i_row: int, i_col: int, garden: list[str]) -> int: + """ + Count flowers adjacent to the given cell. + + Counts the eight neighboring positions around ``(i_row, i_col)`` when the + current cell is empty (space). If the cell itself is a flower (``*``), the + count remains zero as the caller preserves flowers unchanged. + + :param int i_row: Row index of the target cell. + :param int i_col: Column index of the target cell. + :param list garden: The rectangular garden representation. + :returns: Number of adjacent flowers (0–8). + :rtype: int + """ + if garden[i_row][i_col] != " ": + return 0 + total: int = 0 + # Count flowers all around current position + for offset_row, offset_col in COORDINATES: + sum_row = i_row + offset_row + sum_col = i_col + offset_col + if ( + 0 <= sum_row < len(garden) # ROW: Avoid IndexError + and 0 <= sum_col < len(garden[0]) # COL: Avoid IndexError + and garden[sum_row][sum_col] == "*" # Detect/count flower + ): + total += 1 + return total + + +def _validate(garden: list[str]) -> None: + """ + Validate the garden shape and contents. + + Ensures the input is rectangular and contains only spaces and ``*``. + Raise ValueError when the board receives malformed input garden is not + a rectangle due to inconsistent row length or contains invalid chars + inside the row. + + :param list garden: A list of equal-length strings to validate. + :raises ValueError: If rows have differing lengths or contain characters + other than space or ``*``. + """ + garden_length = len(garden[0]) + if any( + (len(row) != garden_length or not all(char in " *" for char in row)) + for row in garden + ): + raise ValueError("The board is invalid with current input.") diff --git a/solutions/python/flower-field/20/flower_field.py b/solutions/python/flower-field/20/flower_field.py new file mode 100644 index 0000000..3261a33 --- /dev/null +++ b/solutions/python/flower-field/20/flower_field.py @@ -0,0 +1,115 @@ +""" +Flower Field is a compassionate reimagining of the popular game Minesweeper. + +This module provides helpers to validate and annotate a rectangular garden +representation, where each row is a string comprised of spaces and ``*`` +characters. A ``*`` denotes a flower; a space denotes an empty square. + +The goal is to compute numeric hints indicating how many flowers are +adjacent (horizontally, vertically, diagonally) to each square. +""" + +# Relative offsets to the eight neighboring cells around a given position +COORDINATES: tuple[ + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], + tuple[int, int], +] = ( + (-1, -1), + (-1, 0), + (-1, 1), + (0, -1), + (0, 1), + (1, -1), + (1, 0), + (1, 1), +) + + +def annotate(garden: list[str]) -> list[str]: + """ + Annotate a garden with counts of adjacent flowers. + + Expects a rectangular list of strings containing only spaces and ``*``. + Validation errors raise a :class:`ValueError`. + + :param list garden: A list of equal-length strings representing the garden. + ``*`` marks a flower; space marks empty. + :returns: An annotated garden of the same shape. Empty squares are + replaced by digits (``"1"``–``"8"``) when adjacent to flowers; + squares with zero adjacent flowers remain spaces. Flowers + (``*``) are preserved. + :rtype: list[str] + :raises ValueError: If the garden is non-rectangular or contains + invalid characters. + """ + # empty list + if not garden: + return [] + # raise an error when the board receives malformed input + _validate(garden) + return [ + "".join( + str(count) + if (count := _calc_surrounding_flowers(i_row, i_col, garden)) != 0 + else char + for i_col, char in enumerate(row) + ) + for i_row, row in enumerate(garden) + ] + + +def _calc_surrounding_flowers(i_row: int, i_col: int, garden: list[str]) -> int: + """ + Count flowers adjacent to the given cell. + + Counts the eight neighboring positions around ``(i_row, i_col)`` when the + current cell is empty (space). If the cell itself is a flower (``*``), the + count remains zero as the caller preserves flowers unchanged. + + :param int i_row: Row index of the target cell. + :param int i_col: Column index of the target cell. + :param list garden: The rectangular garden representation. + :returns: Number of adjacent flowers (0–8). + :rtype: int + """ + if garden[i_row][i_col] != " ": + return 0 + total: int = 0 + # Count flowers all around current position + for offset_row, offset_col in COORDINATES: + sum_row = i_row + offset_row + sum_col = i_col + offset_col + if ( + 0 <= sum_row < len(garden) # ROW: Avoid IndexError + and 0 <= sum_col < len(garden[0]) # COL: Avoid IndexError + and garden[sum_row][sum_col] == "*" # Detect/count flower + ): + total += 1 + return total + + +def _validate(garden: list[str]) -> None: + """ + Validate the garden shape and contents. + + Ensures the input is rectangular and contains only spaces and ``*``. + Raise ValueError when the board receives malformed input garden is not + a rectangle due to inconsistent row length or contains invalid chars + inside the row. + + :param list garden: A list of equal-length strings to validate. + :raises ValueError: If rows have differing lengths or contain characters + other than space or ``*``. + """ + garden_length = len(garden[0]) + if any( + (len(row) != garden_length or not all(char in " *" for char in row)) + for row in garden + ): + raise ValueError("The board is invalid with current input.")