1.5Pseudocode & programming

Sixteen of Exam B's twenty questions are algorithm problems written in pseudocode. So that no specific programming language is required, IPA defines its own pseudocode notation. This section is not about writing code but about building the skill to accurately read and trace given pseudocode. Once you can read it fluently, the algorithm knowledge from the previous sections (search, sort, complexity) becomes directly usable in the actual question format.

1.5.1Basic notation: procedures, variables, and assignment

• A procedure is a named unit of processing (equivalent to a function or method in other languages). It is declared as type: procedureName(argType: argName, ...) and returns a value with return. Callers invoke it as procedureName(arguments).
• A variable is declared as type: variableName. Assignment uses the arrow symbol <- (written <- in this note), as in variableName <- expression, storing the right-hand value into the left-hand variable. Note this differs in meaning from the mathematical equals sign "=".
• An array element is addressed by index, as in A[i]. IPA pseudocode indices are 1-based (1-origin) by convention, which differs from many programming languages that use 0-based indexing—an important point to watch for.

1.5.2Conditional branching and loops

• Conditional branching takes the form if (condition) then action1 elseif (condition2) then action2 else action3 endif. Conditions are evaluated top to bottom, and only the first branch whose condition is true executes, after which control skips to endif.
• A for loop takes the form for (i from 1 to n step 1) action endfor and is used when the number of iterations is known in advance. A while loop takes the form while (condition) action endwhile, repeating the action only while the condition holds true (used when the iteration count is not known in advance).
• Tracing means manually executing pseudocode line by line, as a computer would, writing down how each variable's value changes (often in a table). Building a value table as you go makes it much easier to catch mistakes partway through.

Let us trace the following pseudocode procedure. integer: sum(array of integer: A, integer: n) takes array A and count n, initializes a running total with integer: total <- 0, then repeats total <- total + A[i] inside for (i from 1 to n step 1) (incrementing i by 1 from 1 to n), and finally returns the sum via return total. Trace it with A = {1, 2, 3, 4, 5} and n = 5. Start with total = 0. At i = 1: total <- 0 + A[1] (=1) = 1. At i = 2: total <- 1 + A[2] (=2) = 3. At i = 3: total <- 3 + A[3] (=3) = 6. At i = 4: total <- 6 + A[4] (=4) = 10. At i = 5: total <- 10 + A[5] (=5) = 15. Once i exceeds n (=5), the loop ends, and return total returns 15. This step-by-step process of writing values into a table is exactly what tracing means—tedious as it may feel at first, always writing the values down by hand substantially cuts careless mistakes. If you rewrote this for loop using while (i <= n), forgetting to add a manual update i <- i + 1 inside the loop body would cause an infinite loop—a for loop manages the iteration count automatically, but a while loop requires you to update every variable involved in its condition yourself.

1.5.3Section summary

• Assignment = <- (right-hand side into left-hand side). Array indices are 1-origin. if/elseif/else/endif evaluates top to bottom and executes only the first true branch
• for = a loop with a known count, while = a condition-driven loop (watch for infinite loops from a missed update)
• Tracing = manually executing line by line and writing values into a table. An essential skill for both fill-in-the-blank and final-value questions