# Learn Interfaces by Building an Equation Solver - Step 53

### Tell us what’s happening:

I’m not sure if this is not well explained or I just don’t get it - is “Solutions” added to the original output_string, the returned output_string , is the rest of the formatting kept the same? This solution looked best graphically but the checker doesn’t like it.

``````from abc import ABC, abstractmethod
import re

class Equation(ABC):
degree: int
type: str

def __init__(self, *args):
if (self.degree + 1) != len(args):
raise TypeError(
f"'Equation' object takes {self.degree + 1} positional arguments but {len(args)} were given"
)
if any(not isinstance(arg, (int, float)) for arg in args):
raise TypeError("Coefficients must be of type 'int' or 'float'")
if args[0] == 0:
raise ValueError("Highest degree coefficient must be different from zero")
self.coefficients = {(len(args) - n - 1): arg for n, arg in enumerate(args)}

def __init_subclass__(cls):
if not hasattr(cls, "degree"):
raise AttributeError(
f"Cannot create '{cls.__name__}' class: missing required attribute 'degree'"
)
if not hasattr(cls, "type"):
raise AttributeError(
f"Cannot create '{cls.__name__}' class: missing required attribute 'type'"
)

def __str__(self):
terms = []
for n, coefficient in self.coefficients.items():
if not coefficient:
coefficient
if n == 0:
terms.append(f'{coefficient:+}')
elif n == 1:
terms.append(f'{coefficient:+}x')
else:
terms.append(f"{coefficient:+}x**{n}")
equation_string = ' '.join(terms) + ' = 0'
return re.sub(r"(?<!\d)1(?=x)", "", equation_string.strip("+"))

@abstractmethod
def solve(self):
pass

@abstractmethod
def analyze(self):
pass

class LinearEquation(Equation):
degree = 1
type = 'Linear Equation'

def solve(self):
a, b = self.coefficients.values()
x = -b / a
return [x]

def analyze(self):
slope, intercept = self.coefficients.values()
return {'slope': slope, 'intercept': intercept}

degree = 2

def __init__(self, *args):
super().__init__(*args)
a, b, c = self.coefficients.values()
self.delta = b**2 - 4 * a * c

def solve(self):
if self.delta < 0:
return []
a, b, _ = self.coefficients.values()
x1 = (-b + (self.delta) ** 0.5) / (2 * a)
x2 = (-b - (self.delta) ** 0.5) / (2 * a)
if self.delta == 0:
return [x1]

return [x1, x2]

def analyze(self):
a, b, c = self.coefficients.values()
x = -b / (2 * a)
y = a * x**2 + b * x + c
if a > 0:
concavity = 'upwards'
min_max = 'min'
else:
concavity = 'downwards'
min_max = 'max'
return {'x': x, 'y': y, 'min_max': min_max, 'concavity': concavity}

def solver(equation):
if not isinstance(equation, Equation):
raise TypeError("Argument must be an Equation object")

# User Editable Region

output_string = f'\n{equation.type:^16}Solutions'
output_string += f'\n\n{equation!s:^24}\n\n'

# User Editable Region

return output_string

lin_eq = LinearEquation(2, 3)
print(solver(lin_eq))

``````

User Agent is: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0`

### Challenge Information:

Learn Interfaces by Building an Equation Solver - Step 53

Hi @jccw100

Here is a comparison of the original code and your code.

The code in blue is the original code, the code in red is your code.
The code in magenta is the overlap.

Add a new piece to your `output_string` formed by the string `'Solutions'` centered in a width of 24 characters. Use a `-` as a fill character, and3. make the string end with two new line characters.

You appear to have modified the seed code.
Please reset the step to restore the original code.

1. Add a new piece to your `output_string` formed by the string `'Solutions'` centered in a width of 24 characters.
2. Use a `-` as a fill character, and
3. make the string end with two new line characters.

Happy coding

Many thanks. Got it.
Do you think it would be easier (and in many ways a better learning experience) to show what is wanted in the lesson (i.e. a screenshot) and then say; reproduce it. That way we know immediately what it should look like and whether a solution is correct and we have to figure out how to do it rather than just trying to follow instructions (that can be ambiguous).

Hi @jccw100

Showing the answer may not develop critical thinking and problem solving skills. Sometimes spending time working out why code doesn’t work helps to gain an understanding of the syntax.

I’m not talking about showing the answer or giving the solution, I’m saying that clearer instructions, that don’t rely on someone’s interpretation of what they think is wanted can be more effective.
Describe the intended result and in cases like this where you require a certain formatted result, provide a visual of what is asked for. That in no way interferes with the critical thinking or the challenge of figuring out the syntax and the coding, it just makes the instructions clearer and wastes less time.

Bugs or suggested improvements for fCC Learn can be reported as GitHub Issues. Whenever reporting a bug, please check first that there isn’t already an issue for it and provide as much detail as possible.

Thanks. Just trying to be helpful. I think fCC is absolutely amazing and a brilliant resource for the world.

1 Like