From b10dd7c17e7965938ad4101947f4bb95347d9fc5 Mon Sep 17 00:00:00 2001 From: Egor Kostan Date: Mon, 22 Sep 2025 13:14:00 -0700 Subject: [PATCH] All Your Base --- all-your-base/.exercism/config.json | 27 ++++++ all-your-base/.exercism/metadata.json | 1 + all-your-base/HELP.md | 130 ++++++++++++++++++++++++++ all-your-base/README.md | 78 ++++++++++++++++ all-your-base/all_your_base.py | 33 +++++++ all-your-base/all_your_base_test.py | 106 +++++++++++++++++++++ 6 files changed, 375 insertions(+) create mode 100644 all-your-base/.exercism/config.json create mode 100644 all-your-base/.exercism/metadata.json create mode 100644 all-your-base/HELP.md create mode 100644 all-your-base/README.md create mode 100644 all-your-base/all_your_base.py create mode 100644 all-your-base/all_your_base_test.py diff --git a/all-your-base/.exercism/config.json b/all-your-base/.exercism/config.json new file mode 100644 index 0000000..57499d1 --- /dev/null +++ b/all-your-base/.exercism/config.json @@ -0,0 +1,27 @@ +{ + "authors": [ + "behrtam" + ], + "contributors": [ + "cmccandless", + "Dog", + "ikhadykin", + "N-Parsons", + "pywkm", + "smt923", + "tqa236", + "yawpitch" + ], + "files": { + "solution": [ + "all_your_base.py" + ], + "test": [ + "all_your_base_test.py" + ], + "example": [ + ".meta/example.py" + ] + }, + "blurb": "Convert a number, represented as a sequence of digits in one base, to any other base." +} diff --git a/all-your-base/.exercism/metadata.json b/all-your-base/.exercism/metadata.json new file mode 100644 index 0000000..b997316 --- /dev/null +++ b/all-your-base/.exercism/metadata.json @@ -0,0 +1 @@ +{"track":"python","exercise":"all-your-base","id":"12190969a73746768d803caa893ef7c0","url":"https://exercism.org/tracks/python/exercises/all-your-base","handle":"myFirstCode","is_requester":true,"auto_approve":false} \ No newline at end of file diff --git a/all-your-base/HELP.md b/all-your-base/HELP.md new file mode 100644 index 0000000..59cb30f --- /dev/null +++ b/all-your-base/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 all_your_base.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/all-your-base/README.md b/all-your-base/README.md new file mode 100644 index 0000000..347b8a9 --- /dev/null +++ b/all-your-base/README.md @@ -0,0 +1,78 @@ +# All Your Base + +Welcome to All Your Base on Exercism's Python Track. +If you need help running the tests or submitting your code, check out `HELP.md`. + +## Introduction + +You've just been hired as professor of mathematics. +Your first week went well, but something is off in your second week. +The problem is that every answer given by your students is wrong! +Luckily, your math skills have allowed you to identify the problem: the student answers _are_ correct, but they're all in base 2 (binary)! +Amazingly, it turns out that each week, the students use a different base. +To help you quickly verify the student answers, you'll be building a tool to translate between bases. + +## Instructions + +Convert a sequence of digits in one base, representing a number, into a sequence of digits in another base, representing the same number. + +~~~~exercism/note +Try to implement the conversion yourself. +Do not use something else to perform the conversion for you. +~~~~ + +## About [Positional Notation][positional-notation] + +In positional notation, a number in base **b** can be understood as a linear combination of powers of **b**. + +The number 42, _in base 10_, means: + +`(4 × 10¹) + (2 × 10⁰)` + +The number 101010, _in base 2_, means: + +`(1 × 2⁵) + (0 × 2⁴) + (1 × 2³) + (0 × 2²) + (1 × 2¹) + (0 × 2⁰)` + +The number 1120, _in base 3_, means: + +`(1 × 3³) + (1 × 3²) + (2 × 3¹) + (0 × 3⁰)` + +_Yes. Those three numbers above are exactly the same. Congratulations!_ + +[positional-notation]: https://en.wikipedia.org/wiki/Positional_notation + +## Exception messages + +Sometimes it is necessary to [raise an exception](https://docs.python.org/3/tutorial/errors.html#raising-exceptions). When you do this, you should always include a **meaningful error message** to indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. For situations where you know that the error source will be a certain type, you can choose to raise one of the [built in error types](https://docs.python.org/3/library/exceptions.html#base-classes), but should still include a meaningful message. + +This particular exercise requires that you use the [raise statement](https://docs.python.org/3/reference/simple_stmts.html#the-raise-statement) to "throw" a `ValueError` for different input and output bases. The tests will only pass if you both `raise` the `exception` and include a meaningful message with it. + +To raise a `ValueError` with a message, write the message as an argument to the `exception` type: + +```python +# for input. +raise ValueError("input base must be >= 2") + +# another example for input. +raise ValueError("all digits must satisfy 0 <= d < input base") + +# or, for output. +raise ValueError("output base must be >= 2") +``` + +## Source + +### Created by + +- @behrtam + +### Contributed to by + +- @cmccandless +- @Dog +- @ikhadykin +- @N-Parsons +- @pywkm +- @smt923 +- @tqa236 +- @yawpitch \ No newline at end of file diff --git a/all-your-base/all_your_base.py b/all-your-base/all_your_base.py new file mode 100644 index 0000000..93e5e30 --- /dev/null +++ b/all-your-base/all_your_base.py @@ -0,0 +1,33 @@ +""" +Convert a sequence of digits in one base, representing a number, +into a sequence of digits in another base, representing the same number. +""" + + +def rebase(input_base: int, digits: list[int], output_base: int): + """ + Convert a non-negative integer represented as digits in one base to digits in another base. + + :param int input_base: Base of the input digits; must be >= 2. + :param list[int] digits: Sequence of digits where each d satisfies 0 <= d < input_base. + Leading zeros are allowed; an empty list denotes 0. + :param int output_base: Base for the output digits; must be >= 2. + :returns: Digits of the same number in ``output_base``, without leading zeros + (except ``[0]`` for zero). + :rtype: list[int] + :raises ValueError: If ``input_base < 2``, if any digit violates ``0 <= d < input_base``, + or if ``output_base < 2``. + """ + + # for input. + if input_base < 2: + raise ValueError("input base must be >= 2") + + # another example for input. + for d in digits: + if not 0 <= d < input_base: + raise ValueError("all digits must satisfy 0 <= d < input base") + + # or, for output. + if output_base < 2: + raise ValueError("output base must be >= 2") diff --git a/all-your-base/all_your_base_test.py b/all-your-base/all_your_base_test.py new file mode 100644 index 0000000..af84d3b --- /dev/null +++ b/all-your-base/all_your_base_test.py @@ -0,0 +1,106 @@ +# 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/all-your-base/canonical-data.json +# File last updated on 2023-07-20 + +import unittest + +from all_your_base import ( + rebase, +) + + +class AllYourBaseTest(unittest.TestCase): + def test_single_bit_one_to_decimal(self): + self.assertEqual(rebase(2, [1], 10), [1]) + + def test_binary_to_single_decimal(self): + self.assertEqual(rebase(2, [1, 0, 1], 10), [5]) + + def test_single_decimal_to_binary(self): + self.assertEqual(rebase(10, [5], 2), [1, 0, 1]) + + def test_binary_to_multiple_decimal(self): + self.assertEqual(rebase(2, [1, 0, 1, 0, 1, 0], 10), [4, 2]) + + def test_decimal_to_binary(self): + self.assertEqual(rebase(10, [4, 2], 2), [1, 0, 1, 0, 1, 0]) + + def test_trinary_to_hexadecimal(self): + self.assertEqual(rebase(3, [1, 1, 2, 0], 16), [2, 10]) + + def test_hexadecimal_to_trinary(self): + self.assertEqual(rebase(16, [2, 10], 3), [1, 1, 2, 0]) + + def test_15_bit_integer(self): + self.assertEqual(rebase(97, [3, 46, 60], 73), [6, 10, 45]) + + def test_empty_list(self): + self.assertEqual(rebase(2, [], 10), [0]) + + def test_single_zero(self): + self.assertEqual(rebase(10, [0], 2), [0]) + + def test_multiple_zeros(self): + self.assertEqual(rebase(10, [0, 0, 0], 2), [0]) + + def test_leading_zeros(self): + self.assertEqual(rebase(7, [0, 6, 0], 10), [4, 2]) + + def test_input_base_is_one(self): + with self.assertRaises(ValueError) as err: + rebase(1, [0], 10) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "input base must be >= 2") + + def test_input_base_is_zero(self): + with self.assertRaises(ValueError) as err: + rebase(0, [], 10) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "input base must be >= 2") + + def test_input_base_is_negative(self): + with self.assertRaises(ValueError) as err: + rebase(-2, [1], 10) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "input base must be >= 2") + + def test_negative_digit(self): + with self.assertRaises(ValueError) as err: + rebase(2, [1, -1, 1, 0, 1, 0], 10) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual( + err.exception.args[0], "all digits must satisfy 0 <= d < input base" + ) + + def test_invalid_positive_digit(self): + with self.assertRaises(ValueError) as err: + rebase(2, [1, 2, 1, 0, 1, 0], 10) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual( + err.exception.args[0], "all digits must satisfy 0 <= d < input base" + ) + + def test_output_base_is_one(self): + with self.assertRaises(ValueError) as err: + rebase(2, [1, 0, 1, 0, 1, 0], 1) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "output base must be >= 2") + + def test_output_base_is_zero(self): + with self.assertRaises(ValueError) as err: + rebase(10, [7], 0) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "output base must be >= 2") + + def test_output_base_is_negative(self): + with self.assertRaises(ValueError) as err: + rebase(2, [1], -7) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "output base must be >= 2") + + def test_both_bases_are_negative(self): + with self.assertRaises(ValueError) as err: + rebase(-2, [1], -7) + self.assertEqual(type(err.exception), ValueError) + self.assertEqual(err.exception.args[0], "input base must be >= 2")