I spent more than two hours and couldn’t solve it. I have 10 years of programming experience (except for python).
Then I went to Dig Deeper tab, and it says that dunder method __getattribute__ should be used. I know dunder was mentioned in syllabus, but it doesn’t mean that we should research all other available methods by ourselves. If we do, then thats not where “Easy” word is appropriate.
Solution has elements of recursion, which alone is not easy category.
We also didn’t cover try except as far as I remember.
So this exercise is not easy at all, it should labeled as medium or even hard. In that case I wouldn’t spend hours trying to solve it, I would go to Dig Deeper after about 20 minutes knowing that I’m not able to solve it.
There are many other ways to solve the exercise, without using recursion or __getattribute__. Regardless, I agree this exercise is not easy.
Each track (language) has their own estimate of difficulty. Using a scale with 1-3 Easy, 4-7 Medium, 8-10 Hard, here is a “wisdom of crowds” median estimate of exercise difficulty. Many tracks consider Wordy to have Medium difficulty.
If you spend enough time on various tracks here, you’ll come to find out that exercise difficulties are very rough estimates and quite subjective. Perhaps a better approach would be to look at the number of attempts and solves: Python impact and status on Exercism (there is a Practice Exercises section)
I know it’s incredibly frustrating to get stumped on something labeled easy, but on the flip side, you shouldn’t give up just because it says it’s hard.
I agree 100%. This was one of the hardest exercises so far, and I struggled with it for a whole day.
As a novice programmer, I have a limited set of tools in my bag, and I’m adding concepts as the learning track introduces them. I approached this using regex and eval(). I discovered eval() in a web search, and after reading about the risks I decided that my regex parsing was narrow enough that it was ok to use here.
My eventual ‘solution’ passed 17/25 test cases (yay, and phew). But some of the rest of the tests had me completely stumped. Wrangling my way through, I got to 23/25, and then I hacked my way through the last couple just so that I could unlock the Dig Deeper (I try to submit first, then view the DD or community solutions).
But the DD then introduced a totally new (and IMO really abstract) concept - magic methods. I find this really frustrating, as I don’t think it’s fair to be expected to know and use concepts like this at this stage.
In many other exercises, the README introduces the necessary concepts before detailing the challenge, or there’s something helpful in the HINTS file. This is helpful because it follows a logical learning path - theory first, then application, then troubleshoot/test/research, and finally submit.
I would urge the contributors to either add concepts & theory information to the README/HINTS, or else change the level of this exercise to hard.
When we first introduced approaches, we accepted any valid approach a contributor wished to cover. That strategy has changed, but exercises like Wordy still have gaps. Just like hint.md files, approaches are a work in progress, and are limited by how much time volunteers have to work on them.
I’ve just pushed an update to the approaches in PR 3783, and they now show/list:
String, List, and Dictionary Methods (no imports, no tricks)
Import Callables from the Operator Module
Regex and the Operator Module
Lambdas in a Dictionary to Return Functions
Recursion for iteration
Functools.reduce for Calculation
As well as the dunder-method approach.
I agree that this problem does take some careful thinking and effort, especially around the error checking. It can also be quite a struggle for anyone who hasn’t done a lot of text processing or “reducing” (foldl).
But I also think it is on the line – it can be solved without any special techniques or methods in Python, using only loops, lists, dictionaries, conditional checks, and concatenation. Of course, much fancier techniques can be used, but they aren’t required.
It isn’t harder than OCR Numbers or Spiral Matrix - which are both also “Easy” at a 3 ranking.
But I did check, and right now it carries a 1. I will do a PR to change it to 3, but I don’t think it really deserves a 4 (medium), as the problems at that level include Tournament, All Your Base, and Minesweeper – which are all much more difficult, IMHO.
@BethanyG I think what hits people hardest is the amount of different techniques required to solve the exercise. This unexpectedly results in a lot of time to invest into this exercise, compared to other “easy” exercises. I’d favor a 5 for that reason.
It just doesn’t feel like there are that many techniques involved. There is the try-except, but that is explained in the instruction append. For the rest, it is all methods and data structures covered in the beginning of the syllabus, and widely used in other easy exercises:
OPERATIONS = {"plus": '+', "minus": '-', "multiplied": '*', "divided": '/'}
def answer(question):
if not question.startswith("What is") or "cubed" in question:
raise ValueError("unknown operation")
question = question.removeprefix("What is").removesuffix("?").strip()
if not question:
raise ValueError("syntax error")
formula = []
for operation in question.split():
if operation == 'by':
continue
else:
formula.append(OPERATIONS.get(operation, operation))
while len(formula) > 1:
try:
x_value, y_value = int(formula[0]), int(formula[2])
symbol = formula[1]
remainder = formula[3:]
if symbol == "+":
formula = [x_value + y_value] + remainder
elif symbol == "-":
formula = [x_value - y_value] + remainder
elif symbol == "*":
formula = [x_value * y_value] + remainder
elif symbol == "/":
formula = [x_value / y_value] + remainder
else:
raise ValueError("syntax error")
except:
raise ValueError("syntax error")
return int(formula[0])
…and you wouldn’t even have to use a dictionary here. You could do a replace instead. And you could use list methods instead of bracket notation. (Edit: list methods are actually more complicated.)
But here is a version without the dictionary or dictionary lookup, using str.replace and an if-elif-else block:
def answer(question):
if not question.startswith("What is") or "cubed" in question:
raise ValueError("unknown operation")
question = question.removeprefix("What is")
question = question.removesuffix("?")
question = question.replace("by", "")
question = question.strip()
if not question:
raise ValueError("syntax error")
formula = question.split()
while len(formula) > 1:
try:
x_value = int(formula[0])
y_value = int(formula[2])
symbol = formula[1]
remainder = formula[3:]
if symbol == "plus":
formula = [x_value + y_value] + remainder
elif symbol == "minus":
formula = [x_value - y_value] + remainder
elif symbol == "multiplied":
formula = [x_value * y_value] + remainder
elif symbol == "divided":
formula = [x_value / y_value] + remainder
else:
raise ValueError("syntax error")
except:
raise ValueError("syntax error")
return int(formula[0])
Difficulty 5 would put it on par with Forth and Binary Tree - and those are much much harder.
