Arithemetic Formatter Project (Project 1) - Scientific Computing with Python (freeCodeCamp.org)

ABSTRACT

This project presents a Python-based solution to format simple arithmetic problems vertically and side by side. The function processes a list of addition and subtraction expressions and arranges them in a structured, readable format similar to handwritten calculations. The primary objective is to enhance understanding of string manipulation, error handling mostly by using conditional statements, and formatting in Python programming. The function also provides the option to display the results of each calculation. This task is appropriate for programming beginners and supports foundational skills in structured problem-solving.

CONTENTS

ABSTRACT

CONTENTS

1 INTRODUCTION

2 PYTHON CODE AND PERSONAL SOLUTION

3 OUTPUT

4 CONCLUSION AND DISCUSSION

 

1 INTRODUCTION

In elementary arithmetic, it is common to align numbers vertically when solving addition or subtraction problems, and even multiplication or division but in the scope of this project, only the first two methods are taken in consideration (mathantics 2012), (freeCodeCamp). This visual arrangement aids clarity and helps learners understand the computational process. Inspired by this approach, the objective of this project is to create a Python function that automatically formats a given list of arithmetic expressions in a vertical layout.

This function follows specific formatting and validation rules to ensure correct output. It offers a practical way to learn and practice Python concepts such as conditionals, loops, string formatting, and function definitions (freeCodeCamp ). This task not only enhances basic programming skills but also demonstrates how logical thinking is applied in real-world tasks.

2 PROJECT REQUIREMENT AND PYTHON CODE WITH PERSONAL SOLUTION

The python function developed is named as follows: 

arithmetic_arranger(problems, show_answers=False)

It receives a list of strings containing arithmetic problems, an optional Boolean flag that controls whether to display the answers, respectively. Moving to key steps of building the function, limiting the number of problems as for the input value is the first constraint to be met, the function checks if more than five problems are provided. If so, it returns an appropriate error message. 

Then, each problem is parsed and validated by splitting each into three parts, the first operand, the operator ('+' or '-'), lastly and the second operand. The function ensures only the operators '+' and '-' are accepted; operands contain digits only; each operand is no longer than four digits; spacing, which interpolates between two adjacent problems 4 spaces and right-alignment for all number on each line of each problem.

The function constructs four lines: Line 1 is for placing the first operand; line 2 presents the operator and second operand; line 3 is a line of dashes; line 4 is optional, which shows the results or the solution for each problem. Some of example output of the program should have the format as in FIGURE 1.

FIGURE 1. The manual ideation before coding.

The following part is pure code pasted from my source Python file. However, for more clear and readable version, it can be accessed via the following GitHub link to my pushed repository TriPham2006/Arithmetic_formatter.

def arithmetic_arranger(problems, show_answers=False):

    

    # First constraint

    if len(problems) > 5:

        return 'Error: Too many problems.'

        

    # BREAKING DOWN THE FORMAT 

    first_operands = [first_operand.split()[0] for first_operand in problems]    # List of first operands

    operators = [operator.split()[1] for operator in problems]  # List of operators

    second_operands = [second_operand.split()[2] for second_operand in problems]  # List of second operands

    

    # Constraints for input 

    for i in range(len(problems)):

        if operators[i] not in ('+', '-'):

            return "Error: Operator must be '+' or '-'."

        if not first_operands[i].isdigit() or not second_operands[i].isdigit():

            return 'Error: Numbers must only contain digits.'

        if len(first_operands[i]) > 4 or len(second_operands[i]) > 4 or len(first_operands[i]) < 1 or len(second_operands[i]) < 1:

            return 'Error: Numbers cannot be more than four digits.'

    

# BREAKING DOWN ELEMENTS OF EACH PROBLEM

    answers = [(int(first_operands[i]) + int(second_operands[i])) if operators[i] == '+' else (int(first_operands[i]) - int(second_operands[i])) for i in range(len(problems))] # List of answers

    width = [max(len(first_operands[i]), len(second_operands[i])) for i in range(len(problems))]    # Width of each problem block when formatting

    dashes = ['-'*(width[i] + 2) for i in range(len(problems))]   # List of dashes used for formatting

    

    # MODIFYING LIST1 AND LIST2 

    # Space multipliers for each line presented

    space_l1 = []   # List of space multipliers for list 1

    space_l2 = []   # List of space multipliers for line 2

    space_al = []   # List of space multipliers for answer line

    for i in range(len(problems)):

        space_l1.append(len(dashes[i]) - len(first_operands[i]))

        space_l2.append(len(dashes[i]) - len(second_operands[i]) - 1)

        space_al.append(len(dashes[i]) - len(str(answers[i])))

    

    #LINES OF OPERATIONS

    line_1 = [(' '*space_l1[i]) + first_operands[i] for i in range(len(problems))] # First operands

    line_2 = [operators[i] + (" " * space_l2[i]) + second_operands[i] for i in range(len(problems))] # Operators and second operands

    answer_line = [(" " * space_al[i]) + str(answers[i]) for i in range(len(problems))]

    

    # FORMATTING THE PROBLEMS

    # Format without answers

    arranged_format = ("    ".join(line_1) + "\n" +

                "    ".join(line_2) + "\n" +

                "    ".join(dashes)

    )

    # Format with answers included

    if show_answers:

        return arranged_format + "\n" + "    ".join(answer_line)

    else:

        return arranged_format

# TESTING CALLS

#print(arithmetic_arranger(["3801 - 2", "123 + 49"]))

#print(arithmetic_arranger(["1 + 2", "1 - 9380"]))

#print(arithmetic_arranger(["3 + 855", "3801 - 2", "45 + 43", "123 + 49"]))

#print(arithmetic_arranger(["11 + 4", "3801 - 2999", "1 + 2", "123 + 49", "1 - 9380"]))

#print(arithmetic_arranger(["44 + 815", "909 - 2", "45 + 43", "123 + 49", "888 + 40", "653 + 87"]))

#print(arithmetic_arranger(["3 / 855", "3801 - 2", "45 + 43", "123 + 49"]))

#print(arithmetic_arranger(["24 + 85215", "3801 - 2", "45 + 43", "123 + 49"]))

#print(arithmetic_arranger(["98 + 3g5", "3801 - 2", "45 + 43", "123 + 49"]))

#print(arithmetic_arranger(["3 + 855", "988 + 40"], True))

#print(arithmetic_arranger(["32 - 698", "1 - 3801", "45 + 43", "123 + 49", "988 + 40"], True))

 

3 OUTPUT

After writing the code by following with the project rules, the program has to be tested by calling the project defined function arithmetic_arranger() within the 10 pre-called print()s before successfully complete the project. The desired output can be referenced as follows in FIGURE 3. 

FIGURE 2. The final output on the terminal which passed all the tests of the project.

4 CONCLUSION AND DISCUSSION

This project successfully demonstrates how basic arithmetic problems can be formatted programmatically using Python. Although the mathematical operations themselves are simple, the coding process reinforces essential programming concepts, such as string manipulation, input validation, and control flow.
One of the key challenges was ensuring all formatting was consistent across varying lengths of operands. Additionally, including detailed error messages enhances the robustness and user-friendliness of the function.
Overall, this task is an effective exercise for beginner programmers and can serve as a stepping stone toward more complex text-based applications in Python.

REFERENCES

freeCodeCamp.org. Build an Arithmetic Formatter Project. [online] Available at: https://www.freecodecamp.org/learn/scientific-computing-with-python/build-an-arithmetic-formatter-project/build-an-arithmetic-formatter-project (Accessed 13 Jul. 2025).

APPENDICES

I would like to express my sincere gratitude to all the staff at freeCodeCamp for their continuous contributions in developing such a generous and educational platform. Thanks to freeCodeCamp, learners from all backgrounds can access high-quality materials and advance at their own pace, entirely free of charge. <3

On a personal note, I acknowledge that my solution may not be as clear or readable as I initially intended. Nevertheless, I believe that sharing the process, how I landed at the final result, is essential for evaluating my approach and improving my ideation skills in future projects. So, here is the final capture of this blog, a photo of my beginning ideation which was handwritten on a large wall-mounted sticker. Thank you for visiting my blog! 

FIGURE 3. The manual ideation at first stage before coding.

And yes... the photo had been taken a month ago before I started writing this blog :)))