Totalling

Totalling is the algorithm of finding the sum of a set of values. An accumulator variable starts at 0 and each item's value is added to it.

• Accumulator — INTEGER (or REAL), initialised to 0 before the loop.
• Add value — Total <- Total + Value inside the loop.
• Output — the final total is printed AFTER the loop.
• Use REAL — if values may have decimals (e.g. prices).

// Sum the integers from 1 to 5
DECLARE Total : INTEGER
Total <- 0
FOR I <- 1 TO 5
  Total <- Total + I
NEXT I
OUTPUT "Sum is ", Total

Output: Sum is 15. Each iteration adds the value of I (1, then 2, then 3, ...) to the accumulator.

The totalling pattern has four steps: initialise the accumulator to 0, loop over the items, add each item's value to the accumulator, and output the final total after the loop.

// General totalling pattern
DECLARE Total : INTEGER
Total <- 0                    // 1. INITIALISE before the loop
FOR I <- 1 TO N
  Total <- Total + Value(I)   // 2. ADD each value (no IF needed)
NEXT I
OUTPUT "Total: ", Total       // 3. OUTPUT after the loop

• Initialise ONCE — accumulator <- 0 before the loop, never inside.
• Add unconditionally — basic totalling adds every value.
• Selective totalling — wrap the add in an IF for criteria (e.g. positives only).
• OUTPUT after loop — print the final total, not the running total.

When the values come from the user, a sentinel loop reads them until a stop signal is entered. The accumulator adds each value inside the loop body.

// Sum the prices the user enters (0 to stop)
DECLARE Price : REAL
DECLARE Total : REAL
Total <- 0
INPUT Price                      // prime read
WHILE Price <> 0 DO
  Total <- Total + Price
  INPUT Price                    // read next value
ENDWHILE
OUTPUT "Total due: ", Total

• Prime read — first INPUT before the WHILE, so the condition has a value to test.
• Inner INPUT — read the next value inside the loop body.
• Sentinel excluded — the stop value (0) is NOT added to the total.
• WHILE preferred — because the body may need to be skipped entirely.

Arrays pair naturally with FOR loops for totalling. Loop through each element by index, add its value to the accumulator. For selective totalling, wrap the add in an IF.

DECLARE A : ARRAY[1:5] OF INTEGER
DECLARE Total : INTEGER
Total <- 0
FOR I <- 1 TO 5
  Total <- Total + A[I]
NEXT I
OUTPUT "Sum = ", Total

DECLARE A : ARRAY[1:5] OF INTEGER
DECLARE Total : INTEGER
Total <- 0
FOR I <- 1 TO 5
  IF A[I] > 0 THEN
    Total <- Total + A[I]
  ENDIF
NEXT I
OUTPUT "Positive sum = ", Total

• 1-based indexing — CIE arrays declared ARRAY[1:N] start at index 1.
• FOR I <- 1 TO N — visits every element exactly once.
• Add element by index — Total <- Total + A[I].
• Selective totalling — wrap the add in an IF for criteria.

Three classic totalling problems: sum of a known range, sentinel-controlled sum of user input, and selective totalling of array elements.

Example 1 — Sum 1 to 10 (FOR Loop)

DECLARE Sum : INTEGER
Sum <- 0
FOR I <- 1 TO 10
  Sum <- Sum + I
NEXT I
OUTPUT "Sum = ", Sum   // outputs 55

Each iteration adds the value of I to the accumulator. Final sum = 1 + 2 + ... + 10 = 55.

Example 2 — Sentinel Sum of User Input

DECLARE V, Sum : INTEGER
Sum <- 0
INPUT V
WHILE V <> -1 DO
  Sum <- Sum + V
  INPUT V
ENDWHILE
OUTPUT "Sum = ", Sum

Reads values until the user enters -1. Each value is added to Sum; -1 itself is NOT added (it is the sentinel).

Example 3 — Single-Pass Average (Total + Count)

DECLARE Mark : ARRAY[1:10] OF INTEGER
DECLARE Total, Count : INTEGER
DECLARE Avg : REAL
Total <- 0
Count <- 0
FOR I <- 1 TO 10
  Total <- Total + Mark[I]   // totalling
  Count <- Count + 1         // counting
NEXT I
Avg <- Total / Count
OUTPUT "Average = ", Avg

Totalling and counting run side-by-side in one loop. After the loop, divide to get the average. Use REAL for Avg so the division is not truncated.

A quick recap of everything covered on totalling:

• Purpose — Find the sum of a set of values.
• Initialise before loop — Total <- 0 BEFORE the loop, never inside.
• Add the value — Total <- Total + Value (not + 1 like counting).
• Output after loop — Print the final total AFTER the loop ends.
• Selective totalling — Wrap the add in an IF for criteria (e.g. positives).
• Sentinel excluded — The stop value is NOT added to the total.
• Arrays use FOR — FOR I <- 1 TO N to visit every element by index.
• Average = Total / Count — Totalling + counting in one loop gives the average.