primeiro commit com exercicios de Exercism realizados até esta data

This commit is contained in:
2026-10-17 22:10:27 +01:00
commit 58fccbe27a
708 changed files with 35038 additions and 0 deletions
+34
View File
@@ -0,0 +1,34 @@
{
"authors": [],
"contributors": [
"abhijitparida",
"behrtam",
"cmccandless",
"crsmi",
"Dog",
"gabriel376",
"gabriellhrn",
"ikhadykin",
"kytrinyx",
"lowks",
"N-Parsons",
"pheanex",
"sjakobi",
"tqa236",
"AndrewLawendy"
],
"files": {
"solution": [
"space_age.py"
],
"test": [
"space_age_test.py"
],
"example": [
".meta/example.py"
]
},
"blurb": "Given an age in seconds, calculate how old someone is in terms of a given planet's solar years.",
"source": "Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial.",
"source_url": "https://pine.fm/LearnToProgram/?Chapter=01"
}
+1
View File
@@ -0,0 +1 @@
{"track":"python","exercise":"space-age","id":"4681f2f4a1e34ed3a75ca3766a3bcecb","url":"https://exercism.org/tracks/python/exercises/space-age","handle":"sanctushck","is_requester":true,"auto_approve":false}
+130
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 space_age.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.
+103
View File
@@ -0,0 +1,103 @@
# Space Age
Welcome to Space Age on Exercism's Python Track.
If you need help running the tests or submitting your code, check out `HELP.md`.
## Introduction
The year is 2525 and you've just embarked on a journey to visit all planets in the Solar System (Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus and Neptune).
The first stop is Mercury, where customs require you to fill out a form (bureaucracy is apparently _not_ Earth-specific).
As you hand over the form to the customs officer, they scrutinize it and frown.
"Do you _really_ expect me to believe you're just 50 years old?
You must be closer to 200 years old!"
Amused, you wait for the customs officer to start laughing, but they appear to be dead serious.
You realize that you've entered your age in _Earth years_, but the officer expected it in _Mercury years_!
As Mercury's orbital period around the sun is significantly shorter than Earth, you're actually a lot older in Mercury years.
After some quick calculations, you're able to provide your age in Mercury Years.
The customs officer smiles, satisfied, and waves you through.
You make a mental note to pre-calculate your planet-specific age _before_ future customs checks, to avoid such mix-ups.
~~~~exercism/note
If you're wondering why Pluto didn't make the cut, go watch [this YouTube video][pluto-video].
[pluto-video]: https://www.youtube.com/watch?v=Z_2gbGXzFbs
~~~~
## Instructions
Given an age in seconds, calculate how old someone would be on a planet in our Solar System.
One Earth year equals 365.25 Earth days, or 31,557,600 seconds.
If you were told someone was 1,000,000,000 seconds old, their age would be 31.69 Earth-years.
For the other planets, you have to account for their orbital period in Earth Years:
| Planet | Orbital period in Earth Years |
| ------- | ----------------------------- |
| Mercury | 0.2408467 |
| Venus | 0.61519726 |
| Earth | 1.0 |
| Mars | 1.8808158 |
| Jupiter | 11.862615 |
| Saturn | 29.447498 |
| Uranus | 84.016846 |
| Neptune | 164.79132 |
~~~~exercism/note
The actual length of one complete orbit of the Earth around the sun is closer to 365.256 days (1 sidereal year).
The Gregorian calendar has, on average, 365.2425 days.
While not entirely accurate, 365.25 is the value used in this exercise.
See [Year on Wikipedia][year] for more ways to measure a year.
[year]: https://en.wikipedia.org/wiki/Year#Summary
~~~~
For the Python track, this exercise asks you to create a `SpaceAge` _class_ (_[concept:python/classes]()_) that includes methods for all the planets of the solar system.
Methods should follow the naming convention `on_<planet name>`.
Each method should `return` the age (_"on" that planet_) in years, rounded to two decimal places:
```python
#creating an instance with one billion seconds, and calling .on_earth().
>>> SpaceAge(1000000000).on_earth()
#This is one billion seconds on Earth in years
31.69
```
For more information on constructing and using classes, see:
- [**A First Look at Classes**][first look at classes] from the Python documentation.
- [**A Word About names and Objects**][names and objects] from the Python documentation.
- [**Objects, values, and types**][objects, values and types] in the Python data model documentation.
- [**What is a Class?**][what is a class] from Trey Hunners Python Morsels website.
[first look at classes]: https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes
[names and objects]: https://docs.python.org/3/tutorial/classes.html#a-word-about-names-and-objects
[objects, values and types]: https://docs.python.org/3/reference/datamodel.html#objects-values-and-types
[what is a class]: https://www.pythonmorsels.com/what-is-a-class/
## Source
### Contributed to by
- @abhijitparida
- @behrtam
- @cmccandless
- @crsmi
- @Dog
- @gabriel376
- @gabriellhrn
- @ikhadykin
- @kytrinyx
- @lowks
- @N-Parsons
- @pheanex
- @sjakobi
- @tqa236
- @AndrewLawendy
### Based on
Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial. - https://pine.fm/LearnToProgram/?Chapter=01
+46
View File
@@ -0,0 +1,46 @@
class SpaceAge:
def __init__(self, seconds: int):
self.age_in_seconds: int = seconds
self.precision: int = 2
self.seconds_earth_years: int = int(365.25 * 24 * 60 * 60)
def on_earth(self) -> float:
return round(
self.age_in_seconds /
(self.seconds_earth_years) / 1, self.precision
)
def on_mercury(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 0.2408467, self.precision
)
def on_venus(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 0.61519726, self.precision
)
def on_mars(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 1.8808158, self.precision
)
def on_jupiter(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 11.862615, self.precision
)
def on_saturn(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 29.447498, self.precision
)
def on_uranus(self):
retur round(
self.age_in_seconds / self.seconds_earth_years / 84.016846, self.precision
)
def on_neptune(self):
return round(
self.age_in_seconds / self.seconds_earth_years / 164.79132, self.precision
)
+35
View File
@@ -0,0 +1,35 @@
# These tests are auto-generated with test data from:
# https://github.com/exercism/problem-specifications/tree/main/exercises/space-age/canonical-data.json
# File last updated on 2023-07-19
import unittest
from space_age import (
SpaceAge,
)
class SpaceAgeTest(unittest.TestCase):
def test_age_on_earth(self):
self.assertEqual(SpaceAge(1000000000).on_earth(), 31.69)
def test_age_on_mercury(self):
self.assertEqual(SpaceAge(2134835688).on_mercury(), 280.88)
def test_age_on_venus(self):
self.assertEqual(SpaceAge(189839836).on_venus(), 9.78)
def test_age_on_mars(self):
self.assertEqual(SpaceAge(2129871239).on_mars(), 35.88)
def test_age_on_jupiter(self):
self.assertEqual(SpaceAge(901876382).on_jupiter(), 2.41)
def test_age_on_saturn(self):
self.assertEqual(SpaceAge(2000000000).on_saturn(), 2.15)
def test_age_on_uranus(self):
self.assertEqual(SpaceAge(1210123456).on_uranus(), 0.46)
def test_age_on_neptune(self):
self.assertEqual(SpaceAge(1821023456).on_neptune(), 0.35)