Algorithms and data flow

An algorithm describes the method, not just the final answer. It must be precise enough for the same valid input to be handled in the intended way. Algorithms can be represented in three forms:

Most useful algorithms can also be understood as input, processing and output:

The input is not necessarily the first value visible in an algorithm, and the output is not simply the last variable used. Ask instead: What data enters the solution? What is done with it? What information leaves the solution?

Sequence and selection

Sequence still exists inside a branch or loop. It does not mean that the whole algorithm must be one straight path.

In a two-way selection, one branch is followed when the condition is true and the other when it is false. The algorithm then continues with the next instruction after the selection.

Consider this Python 3 program code as a written Paper 1 algorithm:

tickets = int(input())          # 01
total = tickets * 6             # 02
if tickets >= 5:                # 03
    print("Group booking")      # 04
else:                           # 05
    print("Standard booking")   # 06
print(total)                    # 07

With the supplied input 6, line 1 accepts the input and line 2 processes it to produce 36. The condition on line 3 is true, so line 4 is followed and lines 5-6 are skipped. Line 7 then follows in sequence.

Predicted screen output for input 6:

Group booking
36

The common near-miss is to treat if and else as two instructions that both run. They are alternative paths: only the matching branch is followed.

Two kinds of repetition

The correct loop depends on what controls the repetition.

This written Python algorithm produces three copies of Scan:

for count in range(1, 4):   # 01
    print("Scan")           # 02

The values supplied by range(1, 4) are 1, 2 and 3; the stop value 4 is not included. The chosen range therefore controls three passes.

doors_open = 2                       # 01
while doors_open > 0:                # 02
    print("Check door")              # 03
    doors_open = doors_open - 1      # 04
print("Complete")                    # 05

For the supplied starting value 2, the condition is true twice. The predicted output is therefore:

Check door
Check door
Complete

A while condition is checked before each pass. If doors_open began at 0, the loop body would execute zero times and only Complete would be output. This is different from assuming that every loop must run at least once.

When writing the two forms in pseudocode, make the controller visible:

REPEAT <known number> TIMES
    <steps>
END REPEAT

WHILE <condition is true>
    <steps that can lead to a new condition result>
END WHILE

Iteration over items

The loop is controlled by the actual items to be visited, not by a separately chosen number. Here the supplied data structure is a list of three parcel codes:

parcel_codes = ["A2", "B1", "C4"]   # 01
for code in parcel_codes:             # 02
    print(code)                        # 03

The first pass uses A2, the second uses B1 and the third uses C4. The predicted output is:

A2
B1
C4

Compare the controlling ideas:

Count-controlled repetition and iteration can happen to make the same number of passes, but that does not make them identical. for position in range(3) is controlled by three generated numbers; for code in parcel_codes is controlled by the three actual parcel-code items.

Flowchart control

A flowchart makes the route through an algorithm visible. It is useful for seeing the order of processing, where a decision splits the route, and where a loop returns to an earlier condition without depending on one programming language's syntax.

Pearson uses six symbols in Paper 1 questions:

[DIAGRAM: asset_name: Flowchart symbols and a condition-controlled loop; asset_slug: 1_2_1_control_flow_input_and_output__diagram_01; recommended_method: image_gen; description: Original 16:9 monochrome teaching diagram. The left panel shows the six Pearson Paper 1 flowchart symbols with exact short labels Start/End, Process, Input/Output, Decision, Flow line and Pre-defined subprogram. The right panel shows Start leading to INPUT jobs, then decision jobs > 0?; Yes leads to PROCESS Complete one job, then PROCESS jobs = jobs - 1, with an arrow returning to the decision; No leads to OUTPUT Done and then End. Both decision outcomes are labelled, all arrows are directed, and there are no hanging paths.]

In the worked loop, the decision is tested before the process. The Yes route completes one job, changes the amount remaining and returns to the same decision. The No route leaves the loop, outputs Done and reaches the end. A decision diamond contains the question; an action such as Complete one job belongs in a process rectangle.

When writing a flowchart, check that every symbol is connected, every arrow has an unambiguous direction, and every two-way decision has two clearly labelled outcomes that reach the correct next step.

Complete algorithms

Real algorithms combine constructs. The key is to decide what controls each section rather than choosing a construct because its keyword looks familiar.

Requirement: A reviewer inputs a minimum rating. The supplied data structure is ratings = [4, 2, 5]. For every rating, output Recommend when it meets the minimum and Review otherwise. After every item has been handled, output Finished.

One clear pseudocode solution is:

INPUT minimum_rating
FOR EACH rating IN ratings
    IF rating >= minimum_rating THEN
        OUTPUT "Recommend"
    ELSE
        OUTPUT "Review"
    END IF
END FOR
OUTPUT "Finished"

With supplied input 4, the algorithm visits ratings 4, 2 and 5 in turn. The selection produces Recommend, Review and Recommend. Only after the iteration has finished does the final instruction run in sequence.

Predicted output:

Recommend
Review
Recommend
Finished

This one algorithm contains all of the following relationships:

• Input: the minimum rating.
• Processing: compare each supplied rating with the minimum and choose a message.
• Iteration: visit every item in ratings.
• Selection: choose one of two messages for the current item.
• Sequence: output Finished only after the loop ends.
• Output: the three item messages followed by the final message.

To write a new algorithm, first state the required input and output. Put unavoidable steps into sequence, use selection only where a condition chooses a path, then choose a fixed count, a continuing condition or every-item iteration for any repeated block. Finally, follow each possible route on paper to check that it reaches the intended output.