Skip to main content

A University-Level Understanding of Number with an eye towards elementary education

Shannon Ezzat

Section 4.1 Addition Algorithms

Subsection 4.1.1 The Standard Addition Algorithm

The vast majority of students who learn arithmetic in North America lean to add using the following algorithm. As it’s so common, it usually gets named the standard addition algorithm. In short, starting from the smallest place value to the largest (that is, from right to left) we add the place values of our numbers separately, and regroup (or "carry") any groups of the next largest place value (so the place value directly to the left) as we go.
🔗
We can write this algorithmically (as a series of steps) as follows. Also note that these steps are written in language appropriate for university students, so teachers would have to adapt the wording appropriately for their audience of students:
🔗
  1. Write one number below the other so that each place value is in its own column. Now begin at the rightmost column.
    🔗
    🔗
  2. Add the digits together (including any regroupings). If the sum is 10 or larger, write a 1 above the column to the left (this signifies that we regrouped 10 of the current place value to one of the place value to the left.)
    🔗
    🔗
  3. If there are no non-zero digits in any column to the left, you are done. Otherwise move to the next column to the left and go to Step 2.
    🔗
    🔗

Example 4.1.1.

Let’s add \(447+629\) slowly and carefully using this algorithm and visualize it using blocks.
🔗
First, let’s view the two numbers in terms of blocks:
🔗
First we add the ones place. Note tha we have \(7+9 = 16\) ones. We can regroup ten (10) of those to make one of the next place value, that is, one ten. We write that regrouping as a 1 above, and we are still left with 6 ones, so we can write that down:
🔗
We now move on to the next place; the tens. We have \(4+2+1\) tens (the additional 1 being the regrouping from the last step). So we have 7 tens. Note that as we’re working in our usual base ten, we do not have enough tens to regroup, so we simply write that we have 7 tens.
447 and 629 in blocks adding tens
🔗
Now let’s move on to the next place; the hundreds. We have \(4+6=10\) hundreds. We can group all ten of those (with 0 left over after regrouping) to make one of the next place value, that is, one thousand. As this is the final place that our numbers contain, we don’t need to mark a regrouping and simply write down that we have 1 thousand and 0 hundreds.
🔗
Thus we finally have that \(447+629=1076\text{.}\)
🔗
If we think about this carefully, the addition algorithm above relies on the properties of associativity and commutativity in addition to place value. We are using these properties when we add each place value separately and regroup any "carries" with the place value to the left. Let’s write out what the standard addition algorithm is doing in the example above in a little more detail.
🔗
\begin{equation*} 447+629 = (400+40+7) + (600+20+9) \text{ expanded place value representation} \end{equation*}
\begin{equation*} = (400+600) + (40+20) + (7+9) \text{ associativity and commutativity} \end{equation*}
\begin{equation*} = (400 +600) + (40 + 20) + (16) \text{ addition} \end{equation*}
\begin{equation*} = (400 +600) + (40 + 20) + (10+6) \text{ expanded place value representation} \end{equation*}
\begin{equation*} = (400 + 600) + (40 + 20 +10) +6 \text{ associativity and commutativity} \end{equation*}
\begin{equation*} = (400+600) +70 + 6 \text{ addition} \end{equation*}
\begin{equation*} = (1000) + 70 +6 \text{ addition} \end{equation*}
\begin{equation*} = 1000 + 70 + 6 \text{ expanded place value representation} \end{equation*}
\begin{equation*} = 1076 \text{ addition} \end{equation*}
🔗
We won’t go into as much detail with all algorithms in this section, but note that underpinning all of the algorithms are the arithmetic properties from SECTION REFERENCE
🔗
Note that the pictorial/block representation becomes difficult after thousands (as we run out of dimensions, as discussed above) but the idea behind the algorithm still applies for numbers with any place values.
🔗

Checkpoint 4.1.2.

Add the following numbers using the standard algorithm. Draw blocks as we did above and make sure to note the place values of any regroupings/carries you do:
🔗
  1. \(\displaystyle 45+58\)
    🔗
    🔗
  2. \(\displaystyle 208+737\)
    🔗
    🔗
  3. \(\displaystyle 9997+839\)
    🔗
    🔗
🔗
Of course, there is nothing special about base ten; we can add numbers in any base we wish! Let’s look at two examples in other bases. Note that we will not have the "addition facts" of adding single digits in other bases memorized, so we have to be careful when adding. If needed we can do a little side calculation, or draw a diagram to help us.
🔗
Also, so we don’t get confused with the language of tens/hundreds/thousands/etc, we refer to the place value to the left of the ones the "longs" place, the next one to the left the "squares" place, and the next one to the left of that the "cubes" place.
🔗

Example 4.1.3.

Using the standard addition algorithm, let’s add \(435_{seven}+43_{seven}.\) The algorithm remains the same, except now we regroup whenever we have seven of one place.
🔗
We start by adding the ones. We have \(5_{seven}+3_{seven} = 11_{seven}\) as we regroup seven of the eight ones to get 1 long (made up of seven ones) and 1 one. We write down the one remaining:
🔗
Now we move on to add the longs place. We have \(3_{seven}+4_{seven}+1_{seven}=10_{seven}\text{.}\) Thus we regroup seven longs to make one square, adn we have one long left over. We write this down in our working:
🔗
Finally we add the squares place. We have \(4_{seven}+1_{seven}=5_{seven}\) squares, nothing that the bottom addend has no squares. Thus we write this down:
🔗
Thus we have that \(435_{seven}+43_{seven} = 511_{seven}\) and we have finished.
🔗
🔗
Let’s now work in base twelve. Remember we *do not* regroup when we have ten or eleven of one place, and we use the symbols \(A\) and \(B\) to denote these quantities, respectively.
🔗

Example 4.1.4.

Let’s find the sum \(6A3_{twelve}+90B_{twelve}\text{.}\) First of all, it will be helpful to view these as blocks:
🔗
Let’s start with the ones place. We have \(3_{twelve}+B_{twelve} = 12_{twelve} \) ones (think three + eleven ones is fourteen ones), where we regrouped twelve ones to make 1 long (containing twelve ones) with 2 ones remaining. We "carry" our one long, and write down our 2 ones:
🔗
Now we add our longs place. We have \(A_{twelve}+0_{twelve}+1_{twelve} = B_{twelve}\) longs. Since eleven longs is not enough to regroup in base twelve, we simply write this down.
🔗
Now we add our squares place. We have \(6_{twelve}+9_{twelve} = 13_{twelve}\) squares, where twelve squares are regrouped to make one of the next place value (cubes) and we have 3 squares remaining. (Do this calculation on the side to make sure that you understand it). Since we are "out" of places in our numbers we simply write this down in our algorithm:
🔗
We have just calculated that \(6A3_{twelve}+90B_{twelve} = 13B2_{twelve}\) and we are finished.
🔗
🔗

Checkpoint 4.1.5.

Add the following using pictures/blocks as a guide if needed. If you do, try to make sure you understand how the blocks correspond to steps in the algorithm:
  1. \(\displaystyle 45_{eight} + 71_{eight}\)
    🔗
    🔗
  2. \(\displaystyle 210_{three}+221_{three}\)
    🔗
    🔗
  3. \(\displaystyle 54A_{twelve}+BA7_{twelve}\)
    🔗
    🔗
🔗
For these, do not draw pictures. Add them using only the standard addition algorithm:
  1. \(\displaystyle 552_{six}+25_{six}\)
    🔗
    🔗
  2. \(101101_{two}+110111_{two}\) (remember you only need two of a place to regroup, and the digit set base two is \(D=\{0,1\}\)).
    🔗
    🔗
  3. \(\displaystyle 4A095_{twelve}+3BB78_{twelve}\)
    🔗
    🔗
  4. \(422_{five}+344_{five}+43_{five}+141_{five}\) (you may have to regroup more that one grouping in some places)
    🔗
    🔗
🔗
🔗
🔗

Subsection 4.1.2 Partial Sums

In the standard algorithm, we added our regrouping to the next place value as we went. Instead, we could add each place value separately without dealing with the regrouping and then the regroupings to each place value as our final step. This is called the partial sum algorithm, as you are finding the sums of each place value (these are the partial sums) and then adding these together to obtain the final answer. Let’s take a look at an example, and in fact let’s look at the same problem that we did previously with the standard addition algorithm:
🔗

Example 4.1.6.

Let’s add \(447+629\) slowly and carefully using partial sums and visualize it using blocks.
🔗
\(7+9=16\) \(40+20=60\)
447+629 in blocks adding longs using partial sums
\(400+600=1000\text{.}\)
447+629 in blocks adding squares using partial sums
🔗
We note that this is not *that* different to the standard addition algorithm, as the "carries" are added at the end rather than as we go.
🔗
🔗

Subsection 4.1.3 Same Change Algorithm

Let’s now discuss the same change algorithm. To help us illustrate the idea (any why it’s useful to know) we start with an example. Let’s add \(998+314\) in our heads. Try doing this now.
🔗
I’m sure that most people reading this book did not mentally perform the standard algorithm for this calculation. In fact, I can imagine that many people noticed that 998 was 2 smaller than 1000, so they added 2 to 1000 and, to "balance" out, they subtracted 2 from 314. Step 1:
998+314 Same Change
Step 2:
998+314 Same Change adding and subtracting
Step 3:
998+314 changed to 1000+312
Then adding \(1000+312\) is very easy in your head.
998+314 changed to 1000+312 final result
In fact, you can use this idea to add any two numbers.
🔗
In general, we are using the fact that if \(a,b, \in \mathbb{N}_0\) we know that \(a+b = (a+c)+(b-c)\) since we can use associativity and commutativity to rearrange the RHS to \(a+b+(c-c) = a+b+0 = a+b\text{.}\) In fact, since this holds for *any* whole numbers \(a,b,c\) we can indeed use this idea to judiciously choose the \(c\) in the calculation to make our computation easier.
🔗
In the first example we chose \(c=2\) so that our addition step in each place value was as easy as possible; adding 0 in fact does nothing. Thus, we turned our calculation into \((998+2)+(314-2) = 1000+312 = 1312.\)
🔗
Note that this idea doesn’t necessarily make the calculation easier and other than a few cases like the above, where one number is "close" to a round number, it’s not very useful. However, we bring this up because there is a related algorithm for subtraction that is very useful!
🔗
🔗

Subsection 4.1.4 Lattice Algorithm

Another common method is the lattice algorithm. This is very similar to the partial sums algorithm except regroupings are displayed slightly differently. In this algorithm, each place value has a box divided into two diagonally; one section for the place value itself, and one for the next larger place value for the regroupings. This regrouping section looks connected to the diagonal section of the box to the left which contains the same place value. Like partial sums, each place value is then added separately to obtain the final sum. Again, let’s look at our usual example. Note that we won’t draw the blocks again for this example, as the regrouping is the same as for the other algorithms we’ve covered:
🔗

Example 4.1.7.

Let’s add \(447+629\text{.}\) We align our two numbers as usual, and then draw a box for each place value split into two sections by a diagonal line, and just for teaching purposes, we will indicate the place value of each section of each box.
🔗
We now add each place value separately. Starting with the ones place we add \(7+9=16\) ones, which we regroup into \(1\) ten and \(6\) ones. We write this in the leftmost box.
🔗
We continue with the other two places similarly. Note that we do not need to regroup any tens, so we leave the hundreds section of that box blank (or we can put a \(0\) there). Thus are final partial sum should look like this:
🔗
Finally, we add the box sections diagonally to obtain our final sum of \(1076\text{.}\)
The lattice algorithm final answer
🔗
🔗

Checkpoint 4.1.8.

Think about the following questions about the algorithms above:
🔗
  1. For which algorithms is direction important? Do you need to add right-to-left, or can you add any place values in any order?
    🔗
    🔗
  2. Which algorithms are easiest to explain using blocks? Which are most difficult?
    🔗
    🔗
  3. Which algorithms are the quickest? Are they the quickest in all cases?
    🔗
    🔗
  4. Which algorithms take up the least amount of space on your paper? Which take up the most?
    🔗
    🔗
  5. For each algorithm, determine a situation where that algorithm is the best to use. The situation could be adding particular numbers efficiently, or needing to teach addition in the classroom, or some other situation!
    🔗
    🔗
🔗
🔗
🔗
PrevTopNext