diff --git a/exercises/practice/wordy/.approaches/config.json b/exercises/practice/wordy/.approaches/config.json
index 670284d4715..957fc960bfd 100644
--- a/exercises/practice/wordy/.approaches/config.json
+++ b/exercises/practice/wordy/.approaches/config.json
@@ -1,7 +1,7 @@
{
"introduction": {
"authors": ["BethanyG"],
- "contributors": ["bobahop"]
+ "contributors": ["bobahop", "yrahcaz7"]
},
"approaches": [
{
@@ -9,49 +9,56 @@
"slug": "string-list-and-dict-methods",
"title": "String, List, and Dictionary Methods",
"blurb": "Use Core Python Features to Solve Word Problems.",
- "authors": ["BethanyG"]
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
},
- {
- "uuid": "d3ff485a-defe-42d9-b9c6-c38019221ffa",
+ {
+ "uuid": "d3ff485a-defe-42d9-b9c6-c38019221ffa",
"slug": "import-callables-from-operator",
"title": "Import Callables from the Operator Module",
"blurb": "Use Operator Module Methods to Solve Word Problems.",
- "authors": ["BethanyG"]
- },
- {
- "uuid": "61f44943-8a12-471b-ab15-d0d10fa4f72f",
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
+ },
+ {
+ "uuid": "61f44943-8a12-471b-ab15-d0d10fa4f72f",
"slug": "regex-with-operator-module",
"title": "Regex with the Operator Module",
"blurb": "Use Regex with the Callables from Operator to solve word problems.",
- "authors": ["BethanyG"]
- },
- {
- "uuid": "46bd15dd-cae4-4eb3-ac63-a8b631a508d1",
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
+ },
+ {
+ "uuid": "46bd15dd-cae4-4eb3-ac63-a8b631a508d1",
"slug": "lambdas-in-a-dictionary",
"title": "Lambdas in a Dictionary to Return Functions",
"blurb": "Use lambdas in a dictionary to return functions for solving word problems.",
- "authors": ["BethanyG"]
- },
- {
- "uuid": "2e643b88-9b76-45a1-98f4-b211919af061",
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
+ },
+ {
+ "uuid": "2e643b88-9b76-45a1-98f4-b211919af061",
"slug": "recursion",
- "title": "Recursion for Iteration.",
+ "title": "Recursion for Iteration",
"blurb": "Use recursion with other strategies to solve word problems.",
- "authors": ["BethanyG"]
- },
- {
- "uuid": "1e136304-959c-4ad1-bc4a-450d13e5f668",
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
+ },
+ {
+ "uuid": "1e136304-959c-4ad1-bc4a-450d13e5f668",
"slug": "functools-reduce",
- "title": "Functools.reduce for Calculation",
+ "title": "functools.reduce for Calculation",
"blurb": "Use functools.reduce with other strategies to calculate solutions.",
- "authors": ["BethanyG"]
- },
- {
+ "authors": ["BethanyG"],
+ "contributors": ["yrahcaz7"]
+ },
+ {
"uuid": "d643e2b4-daee-422d-b8d3-2cad2f439db5",
"slug": "dunder-getattribute",
- "title": "dunder with __getattribute__",
+ "title": "Dunder with __getattribute__",
"blurb": "Use dunder methods with __getattribute__.",
- "authors": ["bobahop"]
+ "authors": ["bobahop"],
+ "contributors": ["yrahcaz7"]
}
]
}
diff --git a/exercises/practice/wordy/.approaches/dunder-getattribute/content.md b/exercises/practice/wordy/.approaches/dunder-getattribute/content.md
index 167460f2d3c..26652cc693f 100644
--- a/exercises/practice/wordy/.approaches/dunder-getattribute/content.md
+++ b/exercises/practice/wordy/.approaches/dunder-getattribute/content.md
@@ -1,6 +1,5 @@
# Dunder methods with `__getattribute__`
-
```python
OPS = {
"plus": "__add__",
@@ -12,11 +11,12 @@ OPS = {
def answer(question):
question = question.removeprefix("What is").removesuffix("?").strip()
- if not question: raise ValueError("syntax error")
+ if not question:
+ raise ValueError("syntax error")
if question.startswith("-") and question[1:].isdigit():
return -int(question[1:])
- elif question.isdigit():
+ if question.isdigit():
return int(question)
found_op = False
@@ -24,30 +24,31 @@ def answer(question):
if name in question:
question = question.replace(name, op)
found_op = True
- if not found_op: raise ValueError("unknown operation")
+ if not found_op:
+ raise ValueError("unknown operation")
ret = question.split()
while len(ret) > 1:
try:
x, op, y, *tail = ret
- if op not in OPS.values(): raise ValueError("syntax error")
+ if op not in OPS.values():
+ raise ValueError("syntax error")
ret = [int(x).__getattribute__(op)(int(y)), *tail]
except:
raise ValueError("syntax error")
return ret[0]
-
```
-This approach begins by defining a [dictionary][dictionaries] of the word keys with their related [`dunder-methods`][dunder] methods.
-Since only whole numbers are involved, the available `dunder-methods` are those for the [`int`][int] class/namespace.
+This approach begins by defining a [dictionary][dictionaries] of the word keys with their related [dunder method][dunder] values.
+Since only whole numbers are involved, the available dunder methods are those for the [`int`][int] class/namespace.
The supported methods for the `int()` namespace can be found by using `print(dir(int))` or `print(int.__dict__)` in a Python terminal.
-See [`SO: Difference between dir() and __dict__`][dir-vs-__dict__] for more details.
+See [this StackOverflow post][dir-vs-__dict__] for more details.
.__dict__`](https://docs.python.org/3/reference/datamodel.html#object.__dict__) is a mapping of an objects writable attributes.
+The dunder method [`.__dict__`](https://docs.python.org/3/reference/datamodel.html#object.__dict__) is a mapping of an object's writable attributes.
~~~~
.get()`][dict-get], among other strategies.
+This approach uses a [`try-except`][handling-exceptions] statement for handling unknown operators.
+It does this by raising an error inside the `try` block when `symbol` does not match any operator word.
+The `except` block will catch this error (or any other error raised inside the `try` block), and `raise` a `ValueError("syntax error")` instead.
+(You can look at [exception chaining in the Python docs][exception-chaining] for further detail on this subject.)
+
+Alternatives could use a [dictionary][dict] to store word to operator mappings that could be looked up in the `while-loop` using [`.get()`][dict-get], among other strategies.
For more details and variations, read the [String, List and Dictionary Methods][approach-string-list-and-dict-methods] approach.
.__getattribute__`][getattribute] to find the [callable][callable] operation in the `int()` class [namespace][namespace] / dictionary.
-This works because the operators for basic math (_"+, -, *, /, //, %, **"_) have been implemented as callable methods for all integers (_as well as floats and other number types_) and are automatically loaded when the Python interpreter is loaded.
-
-As described in the first link, it is considered bad form to directly call a `dunder method` (_there are some exceptions_), as they are intended mostly for internal Python use, user-defined class customization, and operator overloading (_a specific form of class-customization_).
+This approach uses the [dunder methods][dunder-methods] / ["special methods"][special-methods] / "magic methods" associated with the `int` class, using the dunder method called [`.__getattribute__`][getattribute] to find the [callable][callable] operation in the `int` class [namespace][namespace] / dictionary.
+This works because the operators for basic math (_`+`, `-`, `*`, `/`, `//`, `%`, `**`_) have been implemented as callable methods for all integers (_as well as floats and other numeric types_) and are automatically loaded when the Python interpreter is loaded.
-This is why the `operator` module exists - as a vehicle for providing callable methods for basic math when **not** overloading or customizing class functionality.
+As described in the first link, it is considered bad form to directly call a dunder method (_there are some exceptions_), as they are intended mostly for internal Python use, user-defined class customization, and operator overloading (_a specific form of class-customization_).
-For more detail on this solution, take a look at the [dunder method with `__getattribute__` approach][approach-dunder-getattribute].
+This is why the `operator` module exists — It is a vehicle for providing callable methods for basic math when **not** overloading or customizing class functionality.
+For more detail on this solution, take a look at the [dunder methods with `__getattribute__` approach][approach-dunder-getattribute].
-[PEMDAS]: https://www.mathnasium.com/math-centers/eagan/news/what-pemdas-e
+[PEMDAS]: https://www.mathnasium.com/blog/what-is-pemdas
[approach-dunder-getattribute]: https://exercism.org/tracks/python/exercises/wordy/approaches/dunder-getattribute
[approach-functools-reduce]: https://exercism.org/tracks/python/exercises/wordy/approaches/functools-reduce
[approach-import-callables-from-operator]: https://exercism.org/tracks/python/exercises/wordy/approaches/import-callables-from-operator
@@ -468,8 +452,9 @@ For more detail on this solution, take a look at the [dunder method with `__geta
[callable]: https://treyhunner.com/2019/04/is-it-a-class-or-a-function-its-a-callable/
[dict-get]: https://docs.python.org/3/library/stdtypes.html#dict.get
[dict]: https://docs.python.org/3/library/stdtypes.html#dict
-[dunder-methods]: https://www.pythonmorsels.com/what-are-dunder-methods/?watch
+[dunder-methods]: https://www.pythonmorsels.com/what-are-dunder-methods/
[endswith]: https://docs.python.org/3.9/library/stdtypes.html#str.endswith
+[exception-chaining]: https://docs.python.org/3/tutorial/errors.html#exception-chaining
[filter]: https://docs.python.org/3/library/functions.html#filter
[find]: https://docs.python.org/3.9/library/stdtypes.html#str.find
[functools-reduce]: https://docs.python.org/3/library/functools.html#functools.reduce
diff --git a/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/content.md b/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/content.md
index d78f3e7db83..75f5da8a260 100644
--- a/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/content.md
+++ b/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/content.md
@@ -1,13 +1,12 @@
# Lambdas in a Dictionary to Return Functions
-
```python
OPERATIONS = {
- 'minus': lambda a, b: a - b,
- 'plus': lambda a, b: a + b,
- 'multiplied': lambda a, b: a * b,
- 'divided': lambda a, b: a / b
- }
+ "minus": lambda a, b: a - b,
+ "plus": lambda a, b: a + b,
+ "multiplied": lambda a, b: a * b,
+ "divided": lambda a, b: a / b
+}
def answer(question):
@@ -19,7 +18,7 @@ def answer(question):
if (question.startswith("-") and question[1:].isdigit()) or question.isdigit():
return int(question)
- if not question:
+ if not question:
raise ValueError("syntax error")
equation = question.replace("by", "").split()
@@ -35,32 +34,31 @@ def answer(question):
return equation[0]
```
-This approach is nearly identical to the [string, list, and dict methods][approach-string-list-and-dict-methods] and the [import callables from the operator][approach-import-callables-from-operator] approaches, so it is recommended that you review those before going over this one.
-The major difference here is the use of [`lambda expressions`][lambdas] in place of `operator` methods or string representations in the OPERATIONS dictionary.
+This approach is nearly identical to the [string, list, and dict methods][approach-string-list-and-dict-methods] and the [import callables from the `operator` module][approach-import-callables-from-operator] approaches, so it is recommended that you review those before going over this one.
+The major difference here is the use of [`lambda expressions`][lambdas] in place of `operator` methods or string representations in the `OPERATIONS` dictionary.
`lambda expressions` are small "throwaway" expressions that are simple enough to not require a formal function definition or name.
They are most commonly used in [`key functions`][key-functions], the built-ins [`map`][map] and [`filter`][filter], and in [`functools.reduce`][functools-reduce].
- `lambdas` are also often defined in areas where a function is needed for one-time use or callback but it would be onerous or confusing to create a full function definition.
+`lambdas` are also often defined in areas where a function is needed for one-time use or callback but it would be onerous or confusing to create a full function definition.
The two forms are parsed identically (_they are both function definitions_), but in the case of [`lambdas`][lambda], the function name is always "lambda" and the expression cannot contain statements or annotations.
For example, the code above could be re-written to include user-defined functions as opposed to `lambda expressions`:
-
```python
-def add_(x, y):
+def _add(x, y):
return x + y
-def mul_(x, y):
+def _mul(x, y):
return x * y
-def div_(x, y):
- return x//y
+def _div(x, y):
+ return x // y
-def sub_(x, y):
+def _sub(x, y):
return x - y
def answer(question):
- operations = {'minus': sub_,'plus': add_,'multiplied': mul_,'divided': div_}
+ operations = {"minus": _sub, "plus": _add, "multiplied": _mul, "divided": _div}
if not question.startswith("What is") or "cubed" in question:
raise ValueError("unknown operation")
@@ -70,11 +68,11 @@ def answer(question):
if (question.startswith("-") and question[1:].isdigit()) or question.isdigit():
return int(question)
- if not question:
+ if not question:
raise ValueError("syntax error")
- equation = question.replace("by", "").split()
-
+ equation = question.replace("by", "").split()
+
while len(equation) > 1:
try:
x_value, operation, y_value, *rest = equation
@@ -87,8 +85,9 @@ def answer(question):
```
However, this makes the code more verbose and does not improve readability.
-In addition, the functions need to carry a trailing underscore to avoid potential shadowing or name conflict.
-It is better and cleaner in this circumstance to use `lambda expressions` for the functions - although it could be argued that importing and using the methods from `operator` is even better and clearer.
+In addition, the functions need to have a leading underscore to indicate that they are internal functions for the module, which helps avoid potential shadowing or name conflict (see [PEP 8][pep-8-naming-styles] for more detail).
+
+It is better and cleaner in this circumstance to use `lambda expressions` for the functions — although it could be argued that importing and using the methods from `operator` is even better and clearer.
[approach-import-callables-from-operator]: https://exercism.org/tracks/python/exercises/wordy/approaches/import-callables-from-operator
[approach-string-list-and-dict-methods]: https://exercism.org/tracks/python/exercises/wordy/approaches/string-list-and-dict-methods
@@ -98,3 +97,4 @@ It is better and cleaner in this circumstance to use `lambda expressions` for th
[lambda]: https://docs.python.org/3/reference/expressions.html#lambda
[lambdas]: https://docs.python.org/3/howto/functional.html#small-functions-and-the-lambda-expression
[map]: https://docs.python.org/3/library/functions.html#map
+[pep-8-naming-styles]: https://peps.python.org/pep-0008/#descriptive-naming-styles
diff --git a/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/snippet.txt b/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/snippet.txt
index 3769bef8c5c..1364338e161 100644
--- a/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/snippet.txt
+++ b/exercises/practice/wordy/.approaches/lambdas-in-a-dictionary/snippet.txt
@@ -1,6 +1,6 @@
OPERATIONS = {
- 'minus': lambda a, b: a - b,
- 'plus': lambda a, b: a + b,
- 'multiplied': lambda a, b: a * b,
- 'divided': lambda a, b: a / b
- }
\ No newline at end of file
+ "minus": lambda a, b: a - b,
+ "plus": lambda a, b: a + b,
+ "multiplied": lambda a, b: a * b,
+ "divided": lambda a, b: a / b
+}
\ No newline at end of file
diff --git a/exercises/practice/wordy/.approaches/recursion/content.md b/exercises/practice/wordy/.approaches/recursion/content.md
index 794f1b41c19..4cad29778d4 100644
--- a/exercises/practice/wordy/.approaches/recursion/content.md
+++ b/exercises/practice/wordy/.approaches/recursion/content.md
@@ -1,6 +1,5 @@
# Recursion for Iteration
-
[Any function that can be written iteratively (_with loops_) can be written using recursion][recursion-and-iteration], and [vice-versa][recursion-is-not-a-superpower].
A recursive strategy [may not always be obvious][looping-vs-recursion] or easy — but it is always possible.
So the `while-loop`s used in other approaches to Wordy can be re-written to use recursive calls.
@@ -13,9 +12,9 @@ That being said, Python famously does not perform [tail-call optimization][tail-
-?\d+) multiplied by (?P-?\d+)"),
- div: re.compile(r"(?P-?\d+) divided by (?P-?\d+)"),
- add: re.compile(r"(?P-?\d+) plus (?P-?\d+)"),
- sub: re.compile(r"(?P-?\d+) minus (?P-?\d+)"),
- }
+ mul: re.compile(r"(?P-?\d+) multiplied by (?P-?\d+)"),
+ div: re.compile(r"(?P-?\d+) divided by (?P-?\d+)"),
+ add: re.compile(r"(?P-?\d+) plus (?P-?\d+)"),
+ sub: re.compile(r"(?P-?\d+) minus (?P-?\d+)"),
+}
# This regex looks for any digit 0-9 (optionally negative) followed by any valid operation,
# ending in any digit (optionally negative).
@@ -129,76 +126,83 @@ VALIDATE = re.compile(r"(?P-?\d+) (multiplied by|divided by|plus|minus) (?P
-## Variation 2: Use Regex, Recurse within the For-loop
+## Variation 2: Use regex, recurse within the for-loop
+
+~~~~exercism/caution
+As of the time of writing, this variation of the approach passes all of the tests that are currently in the Exercism test suite.
+**However**, it gives an incorrect answer to any sufficiently long problem, such as the following: "What is 1 plus -10 multiplied by 3 minus 4?"
+
+Parsing this example from left to right, we get `((1 + -10) * 3) - 4 == -31`.
+However, this variation returns `9` in this case, [as seen here][recursion-in-loop-pythontutor].
+[recursion-in-loop-pythontutor]: https://pythontutor.com/visualize.html#code=import%20re%0Afrom%20operator%20import%20add,%20mul,%20sub%0Afrom%20operator%20import%20floordiv%20as%20div%0A%0ADIGITS%20%3D%20re.compile%28r%22-%3F%5Cd%2B%22%29%0A%0AOPERATORS%20%3D%20%28%0A%20%20%20%20%28mul,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20multiplied%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28div,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20divided%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28add,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20plus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28sub,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20minus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%29%0A%0Adef%20answer%28question%29%3A%0A%20%20%20%20if%20not%20question.startswith%28%22What%20is%22%29%20or%20%22cubed%22%20in%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22unknown%20operation%22%29%0A%0A%20%20%20%20question%20%3D%20question.removeprefix%28%22What%20is%22%29.removesuffix%28%22%3F%22%29.strip%28%29%0A%0A%20%20%20%20if%20not%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%0A%20%20%20%20return%20calculate%28question%29%0A%0Adef%20calculate%28question%29%3A%0A%20%20%20%20if%20DIGITS.fullmatch%28question%29%3A%0A%20%20%20%20%20%20%20%20return%20int%28question%29%0A%0A%20%20%20%20for%20operation,%20pattern%20in%20OPERATORS%3A%0A%20%20%20%20%20%20%20%20if%20matches%20%3A%3D%20pattern.match%28question%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20operation%28calculate%28matches%5B%22x%22%5D%29,%20calculate%28matches%5B%22y%22%5D%29%29%20%23%20%3C--%20the%20loop%20is%20paused%20here%20to%20make%20the%20two%20recursive%20calls.%0A%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%0Aprint%28answer%28%22What%20is%201%20plus%20-10%20multiplied%20by%203%20minus%204%3F%22%29%29%0A%0Aprint%28%22Answer%20should%20be%3A%22,%20%28%281%20%2B%20-10%29%20*%203%29%20-%204%29%0A%0Aprint%28%22Result%20from%20wrong%20order%3A%22,%20%281%20%2B%20-10%29%20*%20%283%20-%204%29%29&curInstr=0&mode=display&origin=opt-frontend.js&py=311
+~~~~
```python
import re
@@ -206,55 +210,57 @@ from operator import add, mul, sub
from operator import floordiv as div
DIGITS = re.compile(r"-?\d+")
+
OPERATORS = (
(mul, re.compile(r"(?P.*) multiplied by (?P.*)")),
(div, re.compile(r"(?P.*) divided by (?P.*)")),
(add, re.compile(r"(?P.*) plus (?P.*)")),
(sub, re.compile(r"(?P.*) minus (?P.*)")),
- )
+)
def answer(question):
- if not question.startswith( "What is") or "cubed" in question:
+ if not question.startswith("What is") or "cubed" in question:
raise ValueError("unknown operation")
-
- question = question.removeprefix( "What is").removesuffix("?").strip()
+
+ question = question.removeprefix("What is").removesuffix("?").strip()
if not question:
raise ValueError("syntax error")
-
+
return calculate(question)
def calculate(question):
if DIGITS.fullmatch(question):
return int(question)
-
+
for operation, pattern in OPERATORS:
- if match := pattern.match(question):
- return operation(calculate(match['x']), calculate(match['y'])) #<-- the loop is paused here to make the two recursive calls.
+ if matches := pattern.match(question):
+ return operation(calculate(matches["x"]), calculate(matches["y"])) # <-- The loop is paused here to make the two recursive calls.
raise ValueError("syntax error")
```
-This solution uses a `tuple` of nested `tuples` containing the operators from `operator` and regex in place of the dictionaries that have been used in the previous approaches.
-This saves some space, but requires that the nested `tuples` be unpacked as the main `tuple` is iterated over (_note the `for operation, pattern in OPERATORS:` in the `for-loop`_ ) so that operations can be matched to strings in the question.
- The regex is also more generic than the example above (_anything before and after the operation words is allowed_).
+This solution uses a `tuple` of nested `tuple`s containing the operators and the regex in place of the dictionaries that have been used in the previous approaches.
+This saves some space, but requires that the nested `tuple`s be unpacked as the main `tuple` is iterated over (_note the `for operation, pattern in OPERATORS:` in the `for-loop`_) so that operations can be matched to strings in the question.
+The regex is also more generic than the example above (_anything before and after the operation words is allowed_).
Recursion is used a bit differently here from the previous variations — the calls are placed [within the `for-loop`][recursion-within-loops].
-Because the regex are more generic, they will match a `digit-operation-digit` trio in a longer question, so the line `return operation(calculate(match['x']), calculate(match['y']))` is effectively splitting a question into parts that can then be worked on in their own stack frames.
+Because the regex are more generic, they will match a `digit-operation-digit` trio in a longer question, so the line `return operation(calculate(matches["x"]), calculate(matches["y"]))` is effectively splitting a question into parts that can then be worked on in their own stack frames.
For example:
1. "1 plus -10 multiplied by 13 divided by 2" would match on "1 plus -10" (_group x_) **multiplied by** "13 divided by 2" (_group y_).
-2. This is re-arranged to `mul(calculate("1 plus -10"), calculate("13 divided by 2"))`
-3. At this point, the loop pauses as the two recursive calls to `calculate()` spawn
+2. This is re-arranged to `mul(calculate("1 plus -10"), calculate("13 divided by 2"))`.
+3. At this point, the loop pauses as the two recursive calls to `calculate()` spawn.
4. The loop runs again — and so do the calls to `calculate()` — until there isn't any match that splits the question or any errors.
5. One at a time, the numbers are returned from the `calculate()` calls on the stack, until the main `mul(calculate("1 plus -10"), calculate("13 divided by 2"))` is solved, at which point the answer is returned.
-For a more visual picture, you can step through the code on [pythontutor.com][recursion-in-loop-pythontutor].
+For a more visual picture of the process (including how it fails on long inputs), you can step through the code on [pythontutor.com][recursion-in-loop-pythontutor].
[amortization]: https://www.investopedia.com/terms/a/amortization.asp
[approach-import-callables-from-operator]: https://exercism.org/tracks/python/exercises/wordy/approaches/import-callables-from-operator
[backtracking]: https://en.wikipedia.org/wiki/Backtracking
+[base-case]: https://en.wikipedia.org/wiki/Recursion_(computer_science)#Base_case
[bellman-ford]: https://www.programiz.com/dsa/bellman-ford-algorithm
[bfs]: https://en.wikipedia.org/wiki/Breadth-first_search
[bisection-search]: https://en.wikipedia.org/wiki/Bisection_method
@@ -272,7 +278,7 @@ For a more visual picture, you can step through the code on [pythontutor.com][re
[re-match]: https://docs.python.org/3/library/re.html#re.match
[re]: https://docs.python.org/3/library/re.html
[recursion-and-iteration]: https://web.mit.edu/6.102/www/sp23/classes/11-recursive-data-types/recursion-and-iteration-review.html#:~:text=The%20converse%20is%20also%20true,we%20are%20trying%20to%20solve.
-[recursion-in-loop-pythontutor]: https://pythontutor.com/render.html#code=import%20re%0Afrom%20operator%20import%20add,%20mul,%20sub%0Afrom%20operator%20import%20floordiv%20as%20div%0A%0ADIGITS%20%3D%20re.compile%28r%22-%3F%5Cd%2B%22%29%0AOPERATORS%20%3D%20%28%0A%20%20%20%20%28mul,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20multiplied%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28div,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20divided%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28add,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20plus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28sub,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20minus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%29%0A%0Adef%20answer%28question%29%3A%0A%20%20%20%20if%20not%20question.startswith%28%20%22What%20is%22%29%20or%20%22cubed%22%20in%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22unknown%20operation%22%29%0A%20%20%20%20%0A%20%20%20%20question%20%3D%20question.removeprefix%28%20%22What%20is%22%29.removesuffix%28%22%3F%22%29.strip%28%29%0A%0A%20%20%20%20if%20not%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%20%20%20%20%0A%20%20%20%20return%20calculate%28question%29%0A%0Adef%20calculate%28question%29%3A%0A%20%20%20%20if%20DIGITS.fullmatch%28question%29%3A%0A%20%20%20%20%20%20%20%20return%20int%28question%29%0A%20%20%20%20%20%20%20%20%0A%20%20%20%20for%20operation,%20pattern%20in%20OPERATORS%3A%0A%20%20%20%20%20%20%20%20if%20match%20%3A%3D%20pattern.match%28question%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20operation%28calculate%28match%5B'x'%5D%29,%20calculate%28match%5B'y'%5D%29%29%20%23%3C--%20the%20loop%20is%20paused%20here%20to%20make%20the%20two%20recursive%20calls.%0A%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%0Aprint%28answer%28%22What%20is%201%20plus%20-10%20multiplied%20by%2013%20divided%20by%202%3F%22%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
+[recursion-in-loop-pythontutor]: https://pythontutor.com/visualize.html#code=import%20re%0Afrom%20operator%20import%20add,%20mul,%20sub%0Afrom%20operator%20import%20floordiv%20as%20div%0A%0ADIGITS%20%3D%20re.compile%28r%22-%3F%5Cd%2B%22%29%0A%0AOPERATORS%20%3D%20%28%0A%20%20%20%20%28mul,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20multiplied%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28div,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20divided%20by%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28add,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20plus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%20%20%20%20%28sub,%20re.compile%28r%22%28%3FP%3Cx%3E.*%29%20minus%20%28%3FP%3Cy%3E.*%29%22%29%29,%0A%29%0A%0Adef%20answer%28question%29%3A%0A%20%20%20%20if%20not%20question.startswith%28%22What%20is%22%29%20or%20%22cubed%22%20in%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22unknown%20operation%22%29%0A%0A%20%20%20%20question%20%3D%20question.removeprefix%28%22What%20is%22%29.removesuffix%28%22%3F%22%29.strip%28%29%0A%0A%20%20%20%20if%20not%20question%3A%0A%20%20%20%20%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%0A%20%20%20%20return%20calculate%28question%29%0A%0Adef%20calculate%28question%29%3A%0A%20%20%20%20if%20DIGITS.fullmatch%28question%29%3A%0A%20%20%20%20%20%20%20%20return%20int%28question%29%0A%0A%20%20%20%20for%20operation,%20pattern%20in%20OPERATORS%3A%0A%20%20%20%20%20%20%20%20if%20matches%20%3A%3D%20pattern.match%28question%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20operation%28calculate%28matches%5B%22x%22%5D%29,%20calculate%28matches%5B%22y%22%5D%29%29%20%23%20%3C--%20the%20loop%20is%20paused%20here%20to%20make%20the%20two%20recursive%20calls.%0A%20%20%20%20raise%20ValueError%28%22syntax%20error%22%29%0A%0Aprint%28answer%28%22What%20is%201%20plus%20-10%20multiplied%20by%203%20minus%204%3F%22%29%29%0A%0Aprint%28%22Answer%20should%20be%3A%22,%20%28%281%20%2B%20-10%29%20*%203%29%20-%204%29%0A%0Aprint%28%22Result%20from%20wrong%20order%3A%22,%20%281%20%2B%20-10%29%20*%20%283%20-%204%29%29&curInstr=0&mode=display&origin=opt-frontend.js&py=311
[recursion-is-not-a-superpower]: https://inventwithpython.com/blog/2021/09/05/recursion-is-not-a-superpower-an-iterative-ackermann/
[recursion-within-loops]: https://stackoverflow.com/questions/4795527/how-recursion-works-inside-a-for-loop
[tail-call-optimization]: https://neopythonic.blogspot.com/2009/04/tail-recursion-elimination.html
diff --git a/exercises/practice/wordy/.approaches/recursion/snippet.txt b/exercises/practice/wordy/.approaches/recursion/snippet.txt
index 373481f8f4b..0a6a15c20d3 100644
--- a/exercises/practice/wordy/.approaches/recursion/snippet.txt
+++ b/exercises/practice/wordy/.approaches/recursion/snippet.txt
@@ -1,8 +1,8 @@
def calculate(equation):
if len(equation) == 1: return int(equation[0])
- else:
- try:
- x_value, operation, y_value, *rest = equation
- equation = [OPERATIONS[operation](int(x_value), int(y_value)), *rest]
- except: raise ValueError("syntax error")
- return calculate(equation)
\ No newline at end of file
+ try:
+ x_value, operation, y_value, *rest = equation
+ equation = [OPERATIONS[operation](int(x_value), int(y_value)), *rest]
+ except:
+ raise ValueError("syntax error")
+ return calculate(equation)
\ No newline at end of file
diff --git a/exercises/practice/wordy/.approaches/regex-with-operator-module/content.md b/exercises/practice/wordy/.approaches/regex-with-operator-module/content.md
index d3d5c21430d..0bf7362cf17 100644
--- a/exercises/practice/wordy/.approaches/regex-with-operator-module/content.md
+++ b/exercises/practice/wordy/.approaches/regex-with-operator-module/content.md
@@ -1,5 +1,4 @@
-# Regex and the Operator Module
-
+# Regex with the `operator` Module
```python
import re
@@ -9,85 +8,85 @@ from operator import floordiv as div
OPERATIONS = {"plus": add, "minus": sub, "multiplied by": mul, "divided by": div}
REGEX = {
- 'number': re.compile(r'-?\d+'),
- 'operator': re.compile(f'(?:{"|".join(OPERATIONS)})\\b')
+ "number": re.compile(r"-?\d+"),
+ "operator": re.compile(f"(?:{'|'.join(OPERATIONS)})\\b")
}
# Helper function to extract a number from the question.
def get_number(question):
# Match a number.
- pattern = REGEX['number'].match(question)
-
+ pattern = REGEX["number"].match(question)
+
# Toss an error if there is no match.
if not pattern:
raise ValueError("syntax error")
-
- # Remove the matched pattern from the question, and convert
- # that same pattern to an int. Return the modified question and the int.
- return [question.removeprefix(pattern.group(0)).lstrip(),
+
+ # Remove the matched pattern from the question, and convert that
+ # same pattern to an int. Return the modified question and the int.
+ return [question.removeprefix(pattern.group(0)).lstrip(),
int(pattern.group(0))]
# Helper function to extract an operation from the question.
def get_operation(question):
- # Match an operation word
- pattern = REGEX['operator'].match(question)
-
+ # Match an operation word.
+ pattern = REGEX["operator"].match(question)
+
# Toss an error if there is no match.
if not pattern:
raise ValueError("unknown operation")
-
- # Remove the matched pattern from the question, and look up
- # that same pattern in OPERATIONS. Return the modified question and the operator.
+
+ # Remove the matched pattern from the question, and look up that same
+ # pattern in OPERATIONS. Return the modified question and the operator.
return [question.removeprefix(pattern.group(0)).lstrip(),
OPERATIONS[pattern.group(0)]]
def answer(question):
prefix = "What is"
-
+
# Toss an error right away if the question isn't valid.
if not question.startswith(prefix):
raise ValueError("unknown operation")
-
+
# Clean the question by removing the suffix and prefix and whitespace.
question = question.removesuffix("?").removeprefix(prefix).lstrip()
- # the question should start with a number
+ # The question should start with a number.
question, result = get_number(question)
# While there are portions of the question left, continue to process.
while len(question) > 0:
- # can't have a number followed by a number
- if REGEX['number'].match(question):
+ # Can't have a number followed by a number.
+ if REGEX["number"].match(question):
raise ValueError("syntax error")
# Call get_operation and unpack the result
# into question and operation.
question, operation = get_operation(question)
-
- # Call get_number and unpack the result
+
+ # Call get_number and unpack the result
# into question and num
question, num = get_number(question)
- # Perform the calculation, using result and num as
- # arguments to operation.
+ # Perform the calculation, using result and num
+ # as arguments to operation.
result = operation(result, num)
return result
```
-This approach uses two dictionaries: one of operations imported from `operators`, and another that holds regex for matching digits and matching operations in the text of a question.
+This approach uses two dictionaries: one of operations imported from `operators`, and another that holds regex for matching digits and matching operations in the text of a question.
-It defines two "helper" functions, `get_number()` and `get_operation`, that take a question and use the regex patterns to remove, convert, and return a number (_`get_number()`_) or an operation (_`get_operation()`_), along with a modified "new question".
+It defines two "helper" functions (`get_number()` and `get_operation()`), that both take a question and use the regex patterns to remove, convert, and return a number (_`get_number()`_) or an operation (_`get_operation()`_), along with a modified "new question".
-In the `answer()` function, the question is checked for validity (_does it start with "What is"_), and a `ValueError("unknown operation")` it raised if it is not a valid question.
-Next, the question is cleaned with [`str.removeprefix`][removeprefix] & [`str.removesuffix`][removesuffix], removing "What is" and "?".
-Left-trailing white space is stripped with the help of [`lstrip()`][lstrip].
+In the `answer()` function, the question is checked for validity (_if it starts with "What is"_), and a `ValueError("unknown operation")` it raised if it is not a valid question.
+Next, the question is cleaned with [`str.removeprefix`][removeprefix] and [`str.removesuffix`][removesuffix], removing "What is" and "?".
+Left-trailing whitespace is stripped with the help of [`str.lstrip()`][lstrip].
After that, the variable `result` is declared with an initial value from `get_number()`.
The question is then iterated over via a `while-loop`, which calls `get_operation()` and `get_number()` — "reducing" the question by removing the leading numbers and operator.
The return values from each call are [unpacked][unpacking] into a "leftover" question portion, and the number or operator.
-The returned operation is then made [callable][callable] using `()`, with result and the "new" number (_returned from `get_number()`_) passed as arguments.
-The `loop` then proceeds with processing of the "new question", until the `len()` is 0.
+The returned operation is then used as a [callable][callable] by putting `()` after the name, with `result` and the "new" number (_returned from `get_number()`_) passed as arguments.
+The loop then proceeds with the processing of the "new question", until the `len()` is 0.
Once there is no more question to process, `result` is returned as the answer.
diff --git a/exercises/practice/wordy/.approaches/regex-with-operator-module/snippet.txt b/exercises/practice/wordy/.approaches/regex-with-operator-module/snippet.txt
index 4d89edb5377..e9f549370a8 100644
--- a/exercises/practice/wordy/.approaches/regex-with-operator-module/snippet.txt
+++ b/exercises/practice/wordy/.approaches/regex-with-operator-module/snippet.txt
@@ -1,5 +1,5 @@
while len(question) > 0:
- if REGEX['number'].match(question):
+ if REGEX["number"].match(question):
raise ValueError("syntax error")
question, operation = get_operation(question)
diff --git a/exercises/practice/wordy/.approaches/string-list-and-dict-methods/content.md b/exercises/practice/wordy/.approaches/string-list-and-dict-methods/content.md
index cce88a4bb06..eaa5b334048 100644
--- a/exercises/practice/wordy/.approaches/string-list-and-dict-methods/content.md
+++ b/exercises/practice/wordy/.approaches/string-list-and-dict-methods/content.md
@@ -1,6 +1,5 @@
# String, List, and Dictionary Methods
-
```python
def answer(question):
if not question.startswith("What is") or "cubed" in question:
@@ -43,33 +42,34 @@ This eliminates all the [current cases][unknown-operation-tests] where a [`Value
Should the definition of a question expand or change, this strategy would need to be revised.
-The question is then "cleaned" by removing the prefix "What is" and the suffix "?" ([`str.removeprefix`][removeprefix], [`str.removesuffix`][removesuffix]), replacing "by" with "" ([`str.replace`][str-replace]), and [stripping][strip] any leading or trailing whitespaces.
+The question is then "cleaned" by removing the prefix `"What is"` and the suffix `"?"` ([`str.removeprefix`][removeprefix], [`str.removesuffix`][removesuffix]), replacing `"by"` with `""` ([`str.replace`][str-replace]), and [stripping][strip] any leading or trailing whitespace.
If the question is now an empty string, a `ValueError("syntax error")` is raised.
-The remaining question string is then converted into a `list` of elements via [`str.split`][split], and that `list` is iterated over using a `while-loop` with a `len()` > 1 condition.
+The remaining question string is then converted into a `list` of elements via [`str.split`][split], and that `list` is iterated over using a `while-loop` with a `len() > 1` condition.
Within a [`try-except`][handling-exceptions] block to trap/handle any errors (_which will all map to `ValueError("syntax error")`_), the question `list` is divided up among 4 variables using [bracket notation][bracket-notation]:
1. The first element, `x_value`. This is assumed to be a number, so it is converted to an `int()`
2. The third element, `y_value`. This is also assumed to be a number and converted to an `int()`.
-3. The second element, `symbol`. This is assumed to be an operator, and is left as-is.
-4. The `remainder` of the question, if there is any. This is a [slice][list-slice] starting at index 3, and going to the end.
+3. The second element, `symbol`. This is assumed to be an operator, and is left as-is.
+4. The `remainder` of the question, if there is any. This is a [slice][list-slice] starting at index 3 and going to the end.
-`symbol` is then tested for "plus, minus, multiplied, or divided", and the `formula` list is modified by applying the given operation, and creating a new `formula` `list` by concatenating a `list` of the first product with the `remainder` list.
+`symbol` is then tested for "plus", "minus", "multiplied", or "divided", and the `formula` list is modified by applying the given operation, and creating a new `formula` `list` by concatenating a `list` of the first product with the `remainder` list.
If `symbol` doesn't match any known operators, a `ValueError("syntax error")` is raised.
+(Note that this is still inside the `try-except` block, so the [exception is chained][exception-chaining].)
Once `len(formula) == 1`, the first element (`formula[0]`) is converted to an `int()` and returned as the answer.
+.get`][dict-get] method, which takes a [default argument][default-argument] for when a [`KeyError`][keyerror] is thrown.
-Here the default for `dict.get()` is set to the element being iterated over, which is effectively _"if not found, skip it"_.
-This means the number strings will be passed through, even though they would otherwise toss an error.
- The results of iterating through the question are appended to `formula` via [`list.append`][list-append].
+Here the default for `dict.get()` is set to the element being iterated over, which is effectively _"if not found, skip it"_.
+This means that the number strings will be passed through, even though they would otherwise toss an error.
+The results of iterating through the question are appended to `formula` via [`list.append`][list-append].
-This dictionary is not necessary, but does potentially make adding/tracking future operations easier, although the `if-elif-else` block in the `while-loop` is equally awkward for maintenance (_see the [import callables from operator][approach-import-callables-from-operator] for a way to replace the block_).
+This dictionary is not necessary, but does potentially make adding/tracking future operations easier, although the `if-elif-else` block in the `while-loop` is equally awkward for maintenance (_see the [import callables from operator approach][approach-import-callables-from-operator] for a way to replace the block_).
The `while-loop`, `if-elif-else` block, and the `try-except` block are then the same as in the initial approach.
-
-````exercism/note
+~~~~exercism/note
There are a couple of common alternatives to the `loop-append` used here:
-1. [`list-comprehensions`][list-comprehension] duplicate the same process in a more succinct and declarative fashion. This one also includes filtering out "by":
+1. [List comprehensions][list-comprehension] duplicate the same process in a more succinct and declarative fashion. This one also includes filtering out "by":
```python
-
- formula = [OPERATIONS.get(operation, operation) for
- operation in question.split() if operation != 'by']
- ```
+ formula = [OPERATIONS.get(operation, operation) for
+ operation in question.split() if operation != "by"]
+ ```
-2. The built-in [`filter()`][filter] and [`map()`][map] functions used with a [`lambda`][lambdas] to process the elements of the list.
- This is identical in process to both the `loop-append` and the `list-comprehension`, but might be easier to reason about for those coming from a more functional programming language:
+2. The built-in [`filter()`][filter] and [`map()`][map] functions used with a [`lambda`][lambdas] to process the elements of the list.
+ This is identical in process to both the `loop-append` and the list comprehension, but might be easier to reason about for those coming from a more functional programming language:
```python
- formula = list(map(lambda x : OPERATIONS.get(x, x),
- filter(lambda x: x != "by", question.split())))
+ formula = list(map(lambda op: OPERATIONS.get(op, op),
+ filter(lambda op: op != "by", question.split())))
```
[list-comprehension]: https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions
[lambdas]: https://docs.python.org/3/howto/functional.html#small-functions-and-the-lambda-expression
[filter]: https://docs.python.org/3/library/functions.html#filter
[map]: https://docs.python.org/3/library/functions.html#map
-````
-
- Rather than indexing and slicing, [concept: unpacking and multiple assignment](/tracks/python/concepts/unpacking-and-multiple-assignment) can be used to assign the variables.
- However, this does require a modification to the returned formula `list`:
+~~~~
+Rather than indexing and slicing, [concept:python/unpacking-and-multiple-assignment]() can be used to assign the variables.
+However, this does require a modification to the returned formula `list`:
- ```python
- x_value, operation, y_value, *remainder = formula # <-- Unpacking won't allow conversion to int() here.
+```python
+ x_value, symbol, y_value, *remainder = formula # <-- Unpacking won't allow conversion to int() here.
...
- if symbol == "+":
- formula = [int(x_value) + int(y_value)] + remainder # <-- Instead, conversion to int() must happen here.
+ if symbol == "+":
+ formula = [int(x_value) + int(y_value)] + remainder # <-- Instead, conversion to int() must happen here.
...
- return int(formula[0])
- ```
-
+ return int(formula[0])
+```
-## Variation 2: Structural Pattern Matching to Replace `if-elif-else`
+