Introduction to Pseudocode and Control Structures in Programming

1. Leading Decision Loops: The condition is checked at the beginning.
2. Trailing Decision Loops: The condition is checked at the end.
3. Counted Loops: The repetition occurs a specific, predetermined number of times.

The DOWHILE Structure (Leading Decision)

The DOWHILE structure is a leading decision loop. This means the logical condition is tested before any instructions in the loop are executed.

The process follows these steps:

1. The logical condition $p$ is tested.
2. If $p$ is true, the statements within the block are executed.
3. The ENDDO delimiter triggers a return to re-test condition $p$.
4. This continues until $p$ becomes false, at which point the program moves to the next statement after ENDDO.

Important Consideration: Because the test happens at the start, you may need to perform "initial processing" to set up the variables required for the condition to be tested correctly.

The Danger of the Endless Loop

A critical responsibility of the programmer is to ensure the loop eventually terminates. You must include a process within the loop that eventually makes the condition false. If the condition never becomes false, the program enters an endless loop, which can cause the system to freeze or crash.

Example: Processing 15 Temperatures To convert 15 Fahrenheit temperatures to Celsius, we use a DOWHILE loop with a counter:

Set temperature_count to zero
DOWHILE temperature_count < 15
    Prompt operator for f_temp
    Get f_temp
    Compute c_temp = (f_temp - 32) * 5/9
    Display c_temp
    Add 1 to temperature_count
ENDDO
Display ‘All temperatures processed’

The REPEAT .. UNTIL Structure (Trailing Decision)

In contrast to DOWHILE, the REPEAT .. UNTIL structure is a trailing decision loop. The condition is tested at the end of the loop, which guarantees that the statements within the loop will be executed at least once before the first test occurs.

While DOWHILE continues as long as a condition is true, REPEAT .. UNTIL typically continues until a specific condition becomes true.

Counted Loops and Sequential Files

A counted loop is used when you know exactly how many times a task must be repeated (like the 15-temperature example above).

When working with files, we often use loops to process records until we reach the end of the file. Common pseudo code expressions for this include:

• DOWHILE more records exist
• DOWHILE NOT EOF (End Of File).

Data Aggregation: Accumulators

When processing large amounts of data through loops, we often need to keep track of totals. This is achieved using accumulators. An accumulator is a variable that is initialized to zero and is then incremented or updated during every iteration of a loop.

For example, if you are counting how many students are enrolled in a specific course, you would:

1. Set total_students to zero before the loop starts.
2. Inside the loop, every time a matching student is found, increment the variable: total_students = total_students + 1.

Exam Tip: When designing an algorithm that requires totals (like counting males vs. females), always remember to initialize your accumulators to zero before the loop begins. If you don't, your totals will be mathematically incorrect.