Need some help on arithmetic formatter, im near giving up and search up solution online

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.

1 Like

what should i do instead, if i may know?
and thanks for the reply

where should i put return?
also thanks for replying

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

thanks for the answer :smile: