Pseudocode Statements and Flowchart Symbols

WHILE n > 0 DO
    SET digit = n MOD 10
    SET n = n DIV 10
ENDWHILE

FOR i = 1 TO 10 DO
    PRINT i
ENDFOR

Modules. A named piece of work called from elsewhere.

CALL swap(x, y)

Two conventions carry most of the weight. Keywords go in capitals so the structure can be seen without reading the words. The body of every IF and every loop is indented, and the matching ENDIF or ENDWHILE sits at the same indentation as the keyword that opened it.

The same problem, in steps and in pseudocode

Chapter 1 wrote the simple interest algorithm as five numbered steps. Here it is as pseudocode:

BEGIN
    READ P, R, T
    SET SI = (P * R * T) / 100
    PRINT SI
END

For a problem this small the two notations are equally clear, and the numbered steps are shorter. The difference appears the moment there is a decision, because pseudocode shows you where the branch closes and numbered steps only tell you.

Flowcharts

The symbols

A flowchart is drawn with a fixed set of shapes, and the shape carries the meaning. Using a rectangle where a diamond belongs is a mistake even when the words inside it are right.

Two shapes do the work in nearly every chart a first-year student draws: the rectangle for doing something, and the diamond for asking something.

The rules

1. Every flowchart begins with exactly one START terminal and ends with a STOP terminal.
2. Arrows carry the flow, and every arrow has a head. A line without an arrowhead does not say which way the work goes.
3. A decision diamond has one arrow in and exactly two arrows out, and both are labelled, normally Yes and No.
4. Every other symbol has one arrow in and one arrow out.
5. The chart flows top to bottom and left to right, unless a loop takes it back up.
6. Where two paths finish, they join before the chart carries on, so that the flow after them is drawn once and not twice.

Rule 3 is the one that is broken most often. A diamond with three arrows out is not a decision, it is two decisions that have been drawn on top of each other.

How these are drawn here

The charts below are drawn in text so they read on a phone and in a printout. The shapes stand in for the real ones like this, and in your journal and your answer book you draw the shapes from the table above, not these:

Flowchart 1: simple interest

Her practical, part (a):

To calculate simple interest taking principal, rate of interest and number of years as input from user.

        (  START  )
             |
             v
     / READ P, R, T /
             |
             v
   [ SI = (P * R * T) / 100 ]
             |
             v
      / DISPLAY SI /
             |
             v
        (  STOP  )

There is no decision in it, so the chart is a straight line. Read it against the rules: one START, one STOP, every symbol has one arrow in and one out, and the two parallelograms are input and output rather than processes.

Flowchart 2: the greatest of three numbers

Her practical, part (b):

Write a program to find greatest of three numbers using conditional operator.

Now there are decisions, and the chart earns its keep.

              (  START  )
                   |
                   v
           / READ A, B, C /
                   |
                   v
        < A > B AND A > C ? >--- Yes -->[ MAX = A ]
                   |                          |
                   No                         |
                   |                          |
                   v                          |
           < B > C ? >--- Yes -->[ MAX = B ]  |
                   |                    |     |
                   No                   |     |
                   |                    |     |
                   v                    |     |
             [ MAX = C ]                |     |
                   |                    |     |
                   +<-------------------+<----+
                   |
                   v
           / DISPLAY MAX /
                   |
                   v
              (  STOP  )

The three paths set MAX and then join, and the join is the part beginners leave out. DISPLAY MAX is drawn once, not three times, because whichever branch ran, the work after it is the same.

Follow A as 14, B as 27, C as 9 with your finger. The first diamond asks whether 14 is greater than both 27 and 9, and the answer is No, so you go down. The second asks whether 27 is greater than 9, and the answer is Yes, so you go right into MAX = B. Then you come back to the join, display 27, and stop.

Flowchart 3: the leap year

Her practical, part (c):

Write a program to check if the year entered is leap year or not.

           (  START  )
                |
                v
           / READ Y /
                |
                v
  < Y divisible by 400 ? >-- Yes -->[ R = "Leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
  < Y divisible by 100 ? >-- Yes -->[ R = "Not a leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
  < Y divisible by 4 ? >---- Yes -->[ R = "Leap year" ]
                |                            |
                No                           |
                |                            |
                v                            |
     [ R = "Not a leap year" ]               |
                |                            |
                +<---------------------------+
                |
                v
            / DISPLAY R /
                |
                v
           (  STOP  )

Three diamonds in a chain, each with its two labelled exits, and one join at the end. Every process box holds an action, R = "Leap year", and not a bare piece of text. A box containing only the words Leap year would not say what the flowchart is supposed to do with them. Chapter 1 showed why the order has to be 400, then 100, then 4; the chart shows the same fact as a shape, because each No arrow leads into a test that no longer has to worry about the case above it.

The mistakes that cost marks

• A decision with one exit, or three. Two exits, both labelled.
• Unlabelled arrows out of a diamond. The reader cannot tell which branch is which, and neither can you a week later.
• No arrowheads. A flowchart without arrowheads is a picture of some boxes.
• A rectangle used for input. READ and PRINT are parallelograms. This is the commonest shape error.
• Branches that never join. Two copies of the same ending drawn under two branches is a sign the join was forgotten.
• C code inside the boxes. printf("%d", si); in a process box defeats the purpose. Write DISPLAY SI.
• Pseudocode with no closing keyword. An IF without an ENDIF leaves the extent of the branch to the reader's guess.

What can be asked on this, and how to answer it

"Draw the flowchart symbols and state their use." Draw each shape, name it, and give one example of what goes inside it. A named shape with no example is half an answer.

"Write algorithm & draw flowchart for the same." This is her own wording, and both halves are wanted. They must also agree with each other. Write the algorithm first, then draw the chart from it, then check that every step appears in the chart and every box appears in the algorithm.

"What is pseudocode? How does it differ from an algorithm and from a program?" Pseudocode is a structured, language-free way of writing an algorithm, using keywords and indentation but no particular language's grammar. An algorithm may be written in plain English or as pseudocode, so pseudocode is one form an algorithm can take. A program is the algorithm in a real language, which a compiler can translate and a machine can run.

A trace question on a flowchart. You may be given a chart and asked what it prints. Put your finger at START and walk it, writing down each quantity as it changes, exactly as chapter 1 traced a table.