# I think i did the arithmetic formatter test correctly, but i still failed most of the test. can i get some help? the latest code is at the bottom part

can anyone tell what is wrong my code? i got extremely confuse atm
Thanks for helping me out
here is my code:

``````def arithmetic_arranger(problems):
if len(problems) >= 5:
print ("Error: Too many problems.")
else:
for eq in problems:
if '*' in eq or '/' in eq:
print ('Error: Operator must be '+' or '-'.')
elif '+' in eq:
part = eq.split('+')
strip = [x.strip() for x in part]
print (strip)

longest = 0
short = 0
for num in strip:
if longest < len(num):
longest = len(num)
for num in strip:
if short == 0:
short = len(num)
elif len(num) < short:
short = len(num)
print (longest)
print (short)
print (' '*(len(num)-1), strip[0])
print ('+' + ' '*(longest-(len(num)-1)) + strip[1])
print ('-'*(longest+2))
if True in problems:
print (int(num) + (int(num)))

elif '-' in eq:
part = eq.split('-')
strip = [x.strip() for x in part]
print (strip)

longest = 0
short = 0
for num in strip:
if longest < len(num):
longest = len(num)
for num in strip:
if short == 0:
short = len(num)
elif len(num) < short:
short = len(num)
print (longest)
print (short)
print (' '*(len(num)), strip[0])
print ('+' + ' '*(longest-(len(num)-1)) + strip[1])
print ('-'*(longest+2))
if True in problems:
print (int(num) - (int(num)))
``````

and here is the error:

``````=================== test session starts ====================
platform linux -- Python 3.8.13, pytest-7.1.1, pluggy-1.0.0 -- /nix/store/06c55y0c5yzx5gx4l6k0pp6071zf1y5i-python3-3.8.13/bin/python
cachedir: .pytest_cache
rootdir: /home/runner/boilerplate-arithmetic-formatter
collected 10 items

test_module.py::test_template[test_two_problems_arrangement1] FAILED [ 10%]
test_module.py::test_template[test_two_problems_arrangement2] FAILED [ 20%]
test_module.py::test_template[test_four_problems_arrangement] FAILED [ 30%]
test_module.py::test_template[test_five_problems_arrangement] FAILED [ 40%]
test_module.py::test_template[test_too_many_problems] FAILED [ 50%]
test_module.py::test_template[test_incorrect_operator] FAILED [ 60%]
test_module.py::test_template[test_too_many_digits] FAILED [ 70%]
test_module.py::test_template[test_only_digits] FAILED [ 80%]
test_module.py::test_template[test_two_problems_with_solutions] FAILED [ 90%]
test_module.py::test_template[test_five_problems_with_solutions] FAILED [100%]

========================= FAILURES =========================
______ test_template[test_two_problems_arrangement1] _______

arguments = [['3801 - 2', '123 + 49']]
expected_output = '  3801      123\n-    2    +  49\n------    -----'
fail_message = 'Expected different output when calling "arithmetic_arranger()" with ["3801 - 2", "123 + 49"]'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected different output when calling "arithmetic_arranger()" with ["3801 - 2", "123 + 49"]
E       assert None == '  3801      123\n-    2    +  49\n------    -----'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
['3801', '2']
4
1
3801
+    2
------
['123', '49']
3
2
123
+  49
-----
______ test_template[test_two_problems_arrangement2] _______

arguments = [['1 + 2', '1 - 9380']]
expected_output = '  1         1\n+ 2    - 9380\n---    ------'
fail_message = 'Expected different output when calling "arithmetic_arranger()" with ["1 + 2", "1 - 9380"]'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected different output when calling "arithmetic_arranger()" with ["1 + 2", "1 - 9380"]
E       assert None == '  1         1\n+ 2    - 9380\n---    ------'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
['1', '2']
1
1
1
+ 2
---
['1', '9380']
4
1
1
+ 9380
------
______ test_template[test_four_problems_arrangement] _______

arguments = [['3 + 855', '3801 - 2', '45 + 43', '123 + 49']]
expected_output = '    3      3801      45      123\n+ 855    -    2    + 43    +  49\n-----    ------    ----    -----'
fail_message = 'Expected different output when calling "arithmetic_arranger()" with ["3 + 855", "3801 - 2", "45 + 43", "123 + 49"]'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected different output when calling "arithmetic_arranger()" with ["3 + 855", "3801 - 2", "45 + 43", "123 + 49"]
E       assert None == '    3      3801      45      123\n+ 855    -    2    + 43    +  49\n-----    ------    ----    -----'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
['3', '855']
3
1
3
+ 855
-----
['3801', '2']
4
1
3801
+    2
------
['45', '43']
2
2
45
+ 43
----
['123', '49']
3
2
123
+  49
-----
______ test_template[test_five_problems_arrangement] _______

arguments = [['11 + 4', '3801 - 2999', '1 + 2', '123 + 49', '1 - 9380']]
expected_output = '  11      3801      1      123         1\n+  4    - 2999    + 2    +  49    - 9380\n----    ------    ---    -----    ------'
fail_message = 'Expected different output when calling "arithmetic_arranger()" with ["11 + 4", "3801 - 2999", "1 + 2", "123 + 49", "1 - 9380"]'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected different output when calling "arithmetic_arranger()" with ["11 + 4", "3801 - 2999", "1 + 2", "123 + 49", "1 - 9380"]
E       assert None == '  11      3801      1      123         1\n+  4    - 2999    + 2    +  49    - 9380\n----    ------    ---    -----    ------'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
Error: Too many problems.
__________ test_template[test_too_many_problems] ___________

arguments = [['44 + 815', '909 - 2', '45 + 43', '123 + 49', '888 + 40', '653 + 87']]
expected_output = 'Error: Too many problems.'
fail_message = 'Expected calling "arithmetic_arranger()" with more than five problems to return "Error: Too many problems."'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected calling "arithmetic_arranger()" with more than five problems to return "Error: Too many problems."
E       assert None == 'Error: Too many problems.'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
Error: Too many problems.
__________ test_template[test_incorrect_operator] __________

arguments = [['3 / 855', '3801 - 2', '45 + 43', '123 + 49']]
expected_output = "Error: Operator must be '+' or '-'."
fail_message = 'Expected calling "arithmetic_arranger()" with a problem that uses the "/" operator to return "Error: Operator must be \'+\' or \'-\'."'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
>       actual = arithmetic_arranger(*arguments)

test_module.py:76:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

problems = ['3 / 855', '3801 - 2', '45 + 43', '123 + 49']

def arithmetic_arranger(problems):
if len(problems) >= 5:
print ("Error: Too many problems.")
else:
for eq in problems:
if '*' in eq or '/' in eq:
>           print ('Error: Operator must be '+' or '-'.')
E           TypeError: unsupported operand type(s) for -: 'str' and 'str'

arithmetic_arranger.py:7: TypeError
___________ test_template[test_too_many_digits] ____________

arguments = [['24 + 85215', '3801 - 2', '45 + 43', '123 + 49']]
expected_output = 'Error: Numbers cannot be more than four digits.'
fail_message = 'Expected calling "arithmetic_arranger()" with a problem that has a number over 4 digits long to return "Error: Numbers cannot be more than four digits."'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected calling "arithmetic_arranger()" with a problem that has a number over 4 digits long to return "Error: Numbers cannot be more than four digits."
E       assert None == 'Error: Numbers cannot be more than four digits.'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
['24', '85215']
5
2
24
+ 85215
-------
['3801', '2']
4
1
3801
+    2
------
['45', '43']
2
2
45
+ 43
----
['123', '49']
3
2
123
+  49
-----
_____________ test_template[test_only_digits] ______________

arguments = [['98 + 3g5', '3801 - 2', '45 + 43', '123 + 49']]
expected_output = 'Error: Numbers must only contain digits.'
fail_message = 'Expected calling "arithmetic_arranger()" with a problem that contains a letter character in the number to return "Error: Numbers must only contain digits."'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected calling "arithmetic_arranger()" with a problem that contains a letter character in the number to return "Error: Numbers must only contain digits."
E       assert None == 'Error: Numbers must only contain digits.'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
['98', '3g5']
3
2
98
+ 3g5
-----
['3801', '2']
4
1
3801
+    2
------
['45', '43']
2
2
45
+ 43
----
['123', '49']
3
2
123
+  49
-----
_____ test_template[test_two_problems_with_solutions] ______

arguments = [['3 + 855', '988 + 40'], True]
expected_output = '    3      988\n+ 855    +  40\n-----    -----\n  858     1028'
fail_message = 'Expected solutions to be correctly displayed in output when calling "arithmetic_arranger()" with ["3 + 855", "988 + 40"] and a second argument of `True`.'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
>       actual = arithmetic_arranger(*arguments)
E       TypeError: arithmetic_arranger() takes 1 positional argument but 2 were given

test_module.py:76: TypeError
_____ test_template[test_five_problems_with_solutions] _____

arguments = [['32 - 698', '1 - 3801', '45 + 43', '123 + 49', '988 + 40'], True]
expected_output = '   32         1      45      123      988\n- 698    - 3801    + 43    +  49    +  40\n-----    ------    ----    -----    -----\n -666     -3800      88      172     1028'
fail_message = 'Expected solutions to be correctly displayed in output when calling "arithmetic_arranger()" with five arithmetic problems and a second argument of `True`.'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
>       actual = arithmetic_arranger(*arguments)
E       TypeError: arithmetic_arranger() takes 1 positional argument but 2 were given

test_module.py:76: TypeError
================= short test summary info ==================
FAILED test_module.py::test_template[test_two_problems_arrangement1]
FAILED test_module.py::test_template[test_two_problems_arrangement2]
FAILED test_module.py::test_template[test_four_problems_arrangement]
FAILED test_module.py::test_template[test_five_problems_arrangement]
FAILED test_module.py::test_template[test_too_many_problems]
FAILED test_module.py::test_template[test_incorrect_operator]
FAILED test_module.py::test_template[test_too_many_digits]
FAILED test_module.py::test_template[test_only_digits] - ...
FAILED test_module.py::test_template[test_two_problems_with_solutions]
FAILED test_module.py::test_template[test_five_problems_with_solutions]
==================== 10 failed in 0.30s ====================
``````

Your function does not return a string. It prints a string, but that is not the requirement of the function.

2 Likes

In the function, you must have a line return (put a variable, string, whatever you want to return here) or else the function will return nothing (None).

Your function is returning None since you are using print throughout to display the â€śoutputsâ€ť you want. These print statements are not what the function output is.

If you write x= function (input), x is what the function returns. Right now your function doesnâ€™t have that.

2 Likes

what should i do instead, if i may know?

where should i put return?

You need to create a string that contains all the lines you are printing and the return that string at the very end.

2 Likes

here is my code:

``````def arithmetic_arranger(mylist, truth = False):
uppernum = []
bottomnum = []
strip = []
if len(mylist) > 5:
return 'Error: Too many problems.'
for part in mylist:
string = part.split(' ')
num1 = string[0]
num2 = string[2]
op = string[1]

if num1.isdigit() == False:
return 'Error: Numbers must only contain digits.'
quit()

elif num2.isdigit() == False:
return 'Error: Numbers must only contain digits.'
quit()

elif len(num1) > 4:
return 'Error: Numbers cannot be more than four digits.'
quit()

elif len(num2) > 4:
return 'Error: Numbers cannot be more than four digits.'
quit()

elif '*' in op:
return "Error: Operator must be '+' or '-'."
quit()

elif '/' in op:
return "Error: Operator must be '+' or '-'."
quit()

if op == '+':
num3 = int(num1) + int(num2)

elif op == '-':
num3 = int(num1) - int(num2)

if len(num1) < len(num2):
width = len(num2) + 2
elif len(num2) < len(num1):
width = len(num1) + 2
elif len(num1) == len(num2):
width = len(num1) + 2

spaces1 = width - len(num1)
spaces2 = width - len(num2) - 1
spaces3 = width - len(str(num3))

uppernum.append(' '*spaces1 + num1)
bottomnum.append(op + ' '*spaces2 + num2)
strip.append('-'*width)

upend = '    '.join(uppernum)
botend = '    '.join(bottomnum)
stend = '    '.join(strip)

last = (upend + '\n' + botend + '\n' + stend)

if truth == False:
last = (upend + '\n' + botend + '\n' + stend)
elif truth == True:
last = (upend + '\n' + botend + '\n' + stend + '\n' + ansend)

print(last)
``````

here is the error:

``````_____ test_template[test_five_problems_with_solutions] _____

arguments = [['32 - 698', '1 - 3801', '45 + 43', '123 + 49', '988 + 40'], True]
expected_output = '   32         1      45      123      988\n- 698    - 3801    + 43    +  49    +  40\n-----    ------    ----    -----    -----\n -666     -3800      88      172     1028'
fail_message = 'Expected solutions to be correctly displayed in output when calling "arithmetic_arranger()" with five arithmetic problems and a second argument of `True`.'

@pytest.mark.parametrize('arguments,expected_output,fail_message', test_cases)
def test_template(arguments, expected_output, fail_message):
actual = arithmetic_arranger(*arguments)
>       assert actual == expected_output, fail_message
E       AssertionError: Expected solutions to be correctly displayed in output when calling "arithmetic_arranger()" with five arithmetic problems and a second argument of `True`.
E       assert None == '   32         1      45      123      988\n- 698    - 3801    + 43    +  49    +  40\n-----    ------    ----    -----    -----\n -666     -3800      88      172     1028'

test_module.py:77: AssertionError
------------------- Captured stdout call -------------------
32         1      45      123      988
- 698    - 3801    + 43    +  49    +  40
-----    ------    ----    -----    -----
-666     -3800      88      172     1028
``````