Pseudocode: An Introduction

Flowcharts were the first design tool to be widely used, but unfortunately they do not
very well reflect some of the concepts of structured programming. Pseudocode, on the
other hand, is a newer tool and has features that make it more reflective of the
structured concepts. Unfortunately, the narrative presentation is not as easy to
understand and follow.

RULES FOR PSEUDOCODE

1. Write only one stmt per line

Each stmt in your pseudocode should express just one action for the computer.
If the task list is properly drawn, then in most cases each task will correspond to
one line of pseudocode.

EX: TASK LIST:

Read name, hourly rate, hours worked, deduction rate
Perform calculations
gross = hourlyRate * hoursWorked
deduction = grossPay * deductionRate
net pay = grossPay – deduction
Write name, gross, deduction, net pay

PSEUDOCODE:
READ name, hourlyRate, hoursWorked, deductionRate
grossPay = hourlyRate * hoursWorked
deduction = grossPay * deductionRate
netPay = grossPay – deduction
WRITE name, grossPay, deduction, netPay

2. Capitalize initial keyword

In the example above, READ and WRITE are in caps. There are just a few
keywords we will use:

READ, WRITE, IF, ELSE, ENDIF, WHILE, ENDWHILE, REPEAT, UNTIL

3. Indent to show hierarchy

We will use a particular indentation pattern in each of the design structures:

SEQUENCE: keep statements that are “stacked” in sequence all starting in the
same column.

SELECTION: indent the statements that fall inside the selection structure, but not
the keywords that form the selection
 LOOPING: indent the statements that fall inside the loop, but not the keywords
that form the loop
EX: In the example above, employees whose grossPay is less than 100 do not
have any deduction.

TASK LIST:
Read name, hourly rate, hours worked, deduction rate
Compute gross, deduction, net pay
Is gross >= 100?
YES: calculate deduction
NO: no deduction
Write name, gross, deduction, net pay

PSEUDOCODE:
READ name, hourlyRate, hoursWorked
grossPay = hourlyRate * hoursWorked
IF grossPay >= 100
deduction = grossPay * deductionRate
ELSE
deduction = 0
ENDIF
netPay = grossPay – deduction
WRITE name, grossPay, deduction, netPay

4. End multiline structures

See how the IF/ELSE/ENDIF is constructed above. The ENDIF (or END
whatever) always is in line with the IF (or whatever starts the structure).

5. Keep stmts language independent

Resist the urge to write in whatever language you are most comfortable with. In
the long run, you will save time! There may be special features available in the
language you plan to eventually write the program in; if you are SURE it will be
written in that language, then you can use the features. If not, then avoid using
the special features.
SELECTION STRUCTURE
We looked at this in Chap 2:

yes no
amount
< 1000

interestRate = interestRate =
.06 .10

The pseudocode for this would be:

IF amount < 1000

interestRate = .06 // the “yes” or “true” action
ELSE
interestRate = .10 // the “no” or “false” action
ENDIF

Some selections are of the “do it or don’t” (one sided) variety. For example:

The pseudocode for this is:

yes
average
< 60 ? IF average < 60
DO SendWarning
ENDIF
DO no
SendWarning
It is considered poor form to have a 1-sided IF stmt where the action is on the “no” or
ELSE side. Consider this code:

IF average < 60
NULL
ELSE
DO GivePassingGrade
ENDIF

This could (and should) be rewritten to eliminate the NULL “yes” part. To do that, we
change the < to its opposite: >= as follows:

IF average >= 60
DO GivePassingGrade
ENDIF

NESTING IF STATEMENTS
What if we wanted to put a little menu up on the screen:
1. Solitaire
2. Doom
3. Monopoly
and have the user select which game to play. How would we activate the correct
game?
READ
READ gameNumber gameNumber
IF gameNumber = 1
DO Solitaire
ELSE
IF gameNumber = 2 yes no
gameNumber
DO Doom =1?
ELSE yes no
DO Monopoly gameNumber
=2?
ENDIF DO
ENDIF Solitaire

DO Doom DO
Monopoly

We must pay particular attention to where the IFs end. The nested IF must be
completely contained in either the IF or the ELSE part of the containing IF. Watch for
and line up the matching ENDIF.
LOOPING STRUCTURES
One of the most confusing things for students first seeing a flowchart is telling the loops
apart from the selections. This is because both use the diamond shape as their control
symbol. In pseudocode this confusion is eliminated. To mark our loops we will use
these pairs: WHILE / ENDWHILE REPEAT / UNTIL

The loop shown here (from the last

START chapter) will have the following
pseudocode:

Count = 0 count = 0
WHILE count < 10
ADD 1 to count
WRITE count
ENDWHILE
WRITE “The end”
Count no
< 10
yes
Notice that the connector and test at the
top of the loop in the flowchart become
Write the WHILE stmt in pseudocode. The
Add 1 to count “The end of the loop is marked by
end” ENDWHILE.

What statement do we execute when

STOP
Write the loop is over? The one that follows
the ENDWHILE.
count

Sometimes it is desirable to put the steps that are inside the loop into a separate
module. Then the pseudocode might be this:

Mainline We often use this name for the first module.

count = 0 Initialization comes first
WHILE count < 10
DO Process The processing loop uses this module
ENDWHILE
WRITE “The end” Termination does clean-up

Process Go thru these steps and then return to the

ADD 1 to count module that sent you here (Mainline)
WRITE count
 This time we will see how to write pseudocode
START for an UNTIL loop:

count = 0
Count = 0 REPEAT
ADD 1 to count
WRITE count
UNTIL count >= 10
WRITE “The end”

Add 1 to count Notice how the connector at the top of the loop
corresponds to the REPEAT keyword, while
the test at the bottom corresponds the the
UNTIL stmt. When the loop is over, control
Write goes to the stmt following the UNTIL.
count

no Count
>= 10
yes

Write
“The end”

STOP
ADVANTAGES AND DISADVANTAGES
Pseudocode Disadvantages
 It’s not visual
 There is no accepted standard, so it varies widely from company to company

Pseudocode Advantages
 Can be done easily on a word processor
 Easily modified
 Implements structured concepts well

Flowchart Disadvantages
 Hard to modify
 Need special software (not so much now!)
 Structured design elements not all implemented

Flowchart Advantages
 Standardized: all pretty much agree on the symbols and their meaning
 Visual (but this does bring some limitations)

HOW WE STORE AND ACCESS DATA

What happens when we execute READ stmt?
READ name, hoursWorked, hourlyRate, deductionRate

The computer stores all program data into memory locations. It knows these location by
their addresses. It is perfectly able to understand code like:
READ 19087, 80976, 10943, 80764
but we would have a hard time with it. So we name our storage locations using words
that are descriptive to us. Every language has its own (different) set of rules about how
these names are formed. We will use a simple style:

 variable names will start with a lowercase letter

 they will have no spaces in them
 additional words in them will start with a capital
 names must be unique within the program
 consistent use of names

The READ statement tells the computer to get a value from the input device (keyboard,
file, …) and store it in the names memory location.

When we need to compute a value in a program (like grossPay) we will use what is
called an assignment stmt.
variable = expression

Be careful to understand the difference between these two stmts:

num1 = num2
num2 = num1
The WRITE stmt is used to display information on the output device (screen, printer).
To display words, enclose them in quotes. A variable’s value will be displayed. So if the
variable name currently contains John Smith, then the stmt
WRITE “Employee name: “, name
will output like this:
Employee name: John Smith

CALCULATION SYMBOLS
We will often have to represent an expression like the one that computes grossPay. To
symbolize the arithmetic operators we use these symbols
grouping ( )
exponent ** or ^
multiply *
divide /
add +
subtract -

There is a precedence or hierarchy implied in these symbols.

ORDER OF EXECUTION
( ) equations in parenthesis

** exponentiation Please Excuse My Dear Aunt Sally

/ * division and multiplication

+ - addition and subtraction

Note: when operators of equal value are to be executed, the order of execution
is left to right.

Examples:
AREA = R2
SUM = A2 + B2
PERIM = 2(L + W)
2
A A A A D D
C C 2  C
BC B B BC B BC

value = 100*2/5-3 = 200/5-3 = 40-3 = 37

value = 100*2/(5-3) = 100*2/2 = 200/2 = 100
value = 100*((2/5)-3) = 100*(.4-3) = 100*-2.6 = -260
SELECTION
When we have to make a choice between actions, we almost always base that choice
on a test. The test uses phrases like “is less than” or “is equal to”. There is a
universally accepted set of symbols used to represent these phrases:
> (greater than)
< (less than)
>= (greater than or equal to)
<= (less than or
= (equal to)
<> (not equal to)

It is interesting to notice that these can be paired up:

SYMBOL IS OPPOSITE TO

> <=
< >=
= <>

LOGICAL OPERATORS: AND, OR, NOT

AND: if any of the conditions are false, the whole expression is false.

ex: IF day = “Saturday” AND weather = “sunny”

WRITE “Let’s go to the beach!”
ENDIF

OR: if any of the conditions are true, the whole expression is true

ex: IF month = “June” OR month = “July” OR month = “August”

WRITE “Yahoo! Summer vacation!”
ENDIF

NOT: reverses the outcome of the expression; true becomes false, false becomes true.

ex: IF day <> “Saturday” AND day <> “Sunday”

WRITE “Yuk, another work day”
ENDIF
 Pseudo code Tutorial and Exercises – Teacher’s Version

Pseudo-code is an informal way to express the design of a computer program or an algorithm in

1.45. The aim is to get the idea quickly and also easy to read without details. It is like a young child
putting sentences together without any grammar. There are several ways of writing pseudo-code;
there are no strict rules. But to reduce ambiguity between what you are required to do and what
you express let’s base the pseudo code on the few defined conventions and carry out the exercises.

Pseudo-code Examples Repeatedly steps through the list to be

sorted, comparing each pair of adjacent
Let’s see few examples that can be used to write pseudo-code.
items and swapping them if they are in
1. Sort the wrong order.

Taking the sorting example; let’s sort an array using the Bubble sort technique. This sorting
algorithm could be implemented in all programming languages but let’s see the C implementation.

void ArraySort(int This[], CMPFUN fun_ptr, uint32 ub)

{
/* bubble sort */

uint32 indx;
uint32 indx2;
int temp;
int temp2;
int flipped;
What’s your impression?
if (ub <= 1)
return; Is it easy to understand at once
this C implementation?
indx = 1;
do
{
flipped = 0;
for (indx2 = ub - 1; indx2 >= indx; --indx2)
{
temp = This[indx2];
temp2 = This[indx2 - 1];
if ((*fun_ptr)(temp2, temp) > 0) Bubble sort is mostly used in teaching.
{ However, its performance is slow and in
This[indx2 - 1] = temp;
This[indx2] = temp2; 2.44 the students will discover that there
flipped = 1; are better algorithms.
}
}
} while ((++indx < ub) && flipped);
}

Page 1 of 16
Here is some pseudo code for this algorithm.
What’s easier to understand,
Set n to number of records to be sorted
the implementation in C or
repeat
pseudo-code?
flag = false;
for counter = 1 to n-1 do
if key[counter] > key[counter+1] then
swap the records;
set flag = true;
end if
end do
n = n-1;
until flag = false or n=1

OR the same can be expressed more concisely in words as below

repeat
set a flag to False
for each pair of keys
if the keys are in the wrong order then
swap the keys
set the flag to True
end if
next pair
until flag is not set. This is easier than the programming language but is not
so precise. Hence the above pseudo code examples are
OR even as follows
more useful for implementing purposes. This one-line
Keep swapping items until array is in order version may raise questions such as “on what basis do I
swap the items?” Therefore, it is important to be precise
too.

The main part is that it is important to provide easy to read but precise instructions; this will keep
the design simple and unambiguous.

Taking a practical example, if I gave you the following instructions:

(a) Take a left, then take a right, go down the stairs, on your right enter the kitchen, pick a cup
and pour some hot water and add some hot chocolate….

OR

(b) Please make me a hot chocolate.

The above line of instruction depends on the reader, some prefer to (a) if not experienced while
others prefer (b) because it nails it to the point. It is pretty concise too.

Page 2 of 16
Let us take Example 1 and divide the algorithm implementation in stages and conquer.

Example 1: Compute Fibonacci numbers till 50. C implementation

int main( )
{
int n, k, f1, f2, f;
if ( n < 2 ) return n;
else {
f1 = f2 = 1;
for(k=2;k<n;k++)
{
f = f1 + f2;
f2 = f1; The statements with // are
f1 = f; just comments
}
return f;
}

Let us first declare and initialise all the variables.

Declare an integer variable called n // n is the numberlimit

Declare an integer variable sum // f is the sum
Declare an integer variable f1 // f1 is temporary storage
Declare an integer variable f2 // f2 is temporary storage

set loopcounter to 2 // assigning the variables declared above to

values
set sum to 0
set f1 and f2 to 1
Instead of an equal sign an
set n to 50
arrow sign ← can also be
used
Now the computation and displaying the output

repeat n times
sum = f1 + f2
f2 = f1
f1 = sum
print sum
end loop

Page 3 of 16
If all the above sections of pseudo code are put together we will get something looking like the
example below

Pseudo Code Example 1

1.
Declare an integer variable called n
2.
Declare an integer variable sum
3.
Declare an integer variable f1
4.
Declare an integer variable f2
5.
set sum to 0
6.
set f1 and f2 to 1
7.
set n to 50
8.
repeat n times
a. sum = f1 + f2
b. f2 = f1
c. f1 = sum
For example in Pseudo
d. print sum
9.
Code Example1 the
end loop scope of a loop starts at
line 9 and ends at 10
Points to note

 Usually scope terminators such as start and end are used.

 Say if you want to consider a check if the n is more than 2 then you can have an if – endif
statement
if n < 2 then
If this condition is true only then continue initialising the
print n
end if temporary variables and the computation else exit of the function

This if – endif statement would come in before code line 7. Pseudo Code Example 1 is one of the
ways that pseudo code can be written. Below is another example where it exempts the declaration
of the variable and directly initialises them to a value. It is quite wordy than Pseudo Code Example 1.

Pseudo- Code Example 2

Initialise n to fifty
Initialise sum to zero
Initialise f1 and f2 to zero
repeat n times
add f1 and f2, store this value in sum
assign f1’s current value to f2
assign sum’s current value to f1
end loop

These examples are just suggested ways of writing pseudo-code. There are various approaches that
you can use. I have included a number of links in Table 2 each having variations of pseudo-code
writing techniques with few examples. No strict rules are defined but just easy to read but precise.

Page 4 of 16
Let’s look at another example

2. Nested Function

Now let’s have an example of a nested function in other words where a function calls another
function.

Exercise: Create an array of size 10 and assign random values to each element of the array and print.
The random values are generated by another function which we do not implement but it is just
invoked to complete our need.

Example 3: The implementation is in Java programming language.

int arr; // Declaring a variable called arr

// which will be later used to create an array
arr = new int[10]; // Initialising the array
for(int i = 0; i < arr.size(); i++) // Loop
{
arr[i] = random (); // insert random numbers into the array
print arr[i];

Pseudo Code Example 3

Since there is a use of the loopcounter to
Declare an integer variable arr succeed to the next element in the array
Declare an integer variable loopcounter the for loop is vital.

Set arr to size 10

for loopcounter = 0 to (size of arr)-1
arr[loopcounter] = random()
loopcounter = loopcounter + 1
print arr[loopcounter]
endfor

Points to note

 There are two function calls random() and size(). size() gets the size of the initialised array
and randon() generates numbers randomly.

The process could be re-written in a wordier format and quite precise than the above example. See
Pseudo Code Example 4 for this.

Pseudo Code Example 4

fill the array with random variables

Pseudo Code Example 4 is very concise description of the algorithm and most programmers know
how to implement it.

Page 5 of 16
 Desk – Checking

Desk checking is a way of testing your algorithm; it can be also called as code walk through. There
are several ways of testing for example by showing it to peers or by implementing it into a
programming language and just executing the code step-by-step. But desk checking is faster and it
helps one to think like a compiler and a debugger.

The Desk Check Guide at the link below has a range of examples with desk checking.
http://ironbark.bendigo.latrobe.edu.au/subjects/PE/2005s1/other_resources/desk_check_guide.ht
ml . This guide creates a table of input, outputs and various variables against the code lines and
checks what happens to the variables at each line of code. But this seems to be time consuming
especially if the algorithm is complex. Desk checking checks the internal workings of an algorithm.
There is power point on the teaching on desk checking. Use this link
http://www.docstoc.com/docs/15885541/Desk-Checking.

There is no fixed way of desk checking but taking the Fibonacci example I have suggested a simpler
way to do it (simpler than the Desk Check Guide).

Let us make n = 6 and the set values are of f1 = f2 = 1.

Table 1: Fibonacci desk-check

Code line 11 Code line 12 Code line 13 Code line 14 Code line 15
At loopcounter Sum (f1 + f2) f2 f1 Increment loop by 1
2 2 1 1 3
3 3 2 3 4
4 5 3 5 5
5 8 5 8 6

Side check: is it overlimit

Answer : No, then continue.

Hits the limit. STOP Looping.

Page 6 of 16
Extra Information

There are few keywords that are common while writing pseudo-code.

Looping and selection

 Keywords :
Do While...EndDo;
Do Until...Enddo;
Case...EndCase;
If...Endif;
Call;
When;

 Most authors use scope terminators (Start-end, If-endif, for-endfor, do-endo) for loops
and iteration.

As verbs, use the words

 Generate,Compute,Process, etc.
 Words such as set, reset, increment, compute, calculate, add, sum, multiply, ...
 Displaying :
o print, display, input, output, edit, test , etc. with careful indentation tend to
foster desirable pseudocode.

Expressions

Common Operators: =, +, -, *, /, (), <, <=, >, >=, [], %, ^. Sometimes add, sum, subtract, etc. are used
instead. But a + b is better and quick to understand. Such are language independent while some are
not such as % or mod. Thus, it is better to specifically mention modulo, e.g. a modulo B.

It is not necessary to include data declarations in your pseudo code.

Page 7 of 16
Useful links

All these links cover all the AS expectations but one particular link does not cover all of them. Hence, I have listed all these in a table. So for further
information you can refer to the following links. These include various sites of pseudo-code writing tutorials/information and desk checking.

Table 2: Useful Links with extra information and various examples to practice

Link Difference Level of useful

1 http://ironbark.bendigo.latrobe.edu.au/subjects/PE/2005s1/other Has number of desk checking examples Adequate
_resources/desk_check_guide.html
2 http://ironbark.bendigo.latrobe.edu.au/subjects/PE/2005s1/other Has pseudo code examples Basic
_resources/pseudocode_guide.html
3 http://userpages.wittenberg.edu/bshelburne/Comp150/Algorithm Shows use of various pseudo-code jargon Too basic
s.htm
4 http://www.unf.edu/~broggio/cop3530/3530pseu.htm Does not declare the variables first , instead initializes Basic
them directly, only examples and also shows use of
parameters in pseudo code
5 http://www.dreamincode.net/forums/topic/59022-using-pseudo- A simple example but emphasises the importance of Basic
code-to-design-application-logic/ specifying in detail
6 http://www.roseindia.net/tutorialsearch/?t=pseudocode Links to several examples of pseudo-code (with various Basic
scenarios) writing from Java
7 http://users.csc.calpoly.edu/~jdalbey/SWE/pdl_std.html Pseudo-code conventions and simple examples, calling of Basic
sub-procedures
8 http://www.brpreiss.com/books/opus5/html/book.html Complicated algorithms available that can be used to Advanced material
write pseudo - code for interested
students (beyond
AS)

Page 8 of 16
 We live and learn.

There are few exercises below. These exercises are of a mixed range such as achieved, merit and excellence. They aim to cover the advanced concepts from
computer science to ensure students gain an understanding of modular algorithmic structure design. These exercises can be taken further and
implemented as expected for AS 2.46

Exercise 1: String reverse - Design an algorithm that reverses a string and print it.

Sample Answer Achieved Uses indexed data structure- array,

includes data type, specifies variables ,
Algorithm start uses the value in the data structure
(prints the string in the reverse order)
Declare an array of string type variable called word Merit ×
Declare a loopcounter Excellence ×
Store a string in the array word
for loopcounter = (length of the word) – 1 to 0
loopcounter = loopcounter – 1
print arrayword[loopcounter]
endfor
Algorithm end

Page 9 of 16
Exercise 2: Replace every third element in the array with the value 10. Assume that an array filled with values is already provided. (Hint: Use example 3)

Sample Answer1
Achieved Uses indexed data structure- array,
for loopcounter = 2 to size of the array length – 1 includes data type, specifies variables
arr[loopcounter]= 10; Merit Modifies the content in the indexed
data-structure, has boundary cases
loopcounter = loopcounter + 3; Excellence ×
endfor
A better way of
writing for loop.
Sample Answer 2 OR Sample Answer 3

Set loopcounter to 0 for the array from 2 to size of the array length -1 by 3
for every third element in the array replace the existing value with 10
replace the existing value with 10 endfor
increment loopcounter by 3 ;
endfor

ASIDE: You can extend this exercise for example; consider there are duplicated values in the array. To delete duplicated values you will have to first sort the
array and then delete them. Moreover, you will have to decrease the size of the array. In addition you can also insert values at various places in the array.

Page 10 of 16
 Achieved ×
Merit Modifies the contents of the indexed data structure
Excellence (If Sample Answer 3 is used then this level can be achieved
too). It calls a module to conduct the Caesar Cipher.
Exercise 3: Caesar Cipher- it is an encryption technique for sending secret messages. Let’s take the example of the alphabets.

You can have a look and experiment with various words at http://www.secretcodebreaker.com/caesar-cipher.html. This

Sample Answer

for each character c

output = ( c+3 ) modulo 26

Alternatives for the output statement can be: Define code (parameters: c)
return c + 3 modulo 26
Sample Answer 2 Sample Answer 3
output k characters after c in the alphabets OR output code(c)

For some the Sample Answer1 is easier to understand while for others the alternatives spell out all that they need. Note: If Sample Answer 3 is used then it
satisfies the excellence expectation.

Page 11 of 16
 Achieved ×
Merit ×
Excellence Calls modules, well-structured logical
decomposed task.
Exercise 4: Multiple modules

Print a line of stars and then for five times print an asterisk, multiple spaces and print an asterisk and then finally print again a line of stars.

Sample Answer FullLine() *****

print 5 asterisks * *
FullLine newline * *
repeat five times * *
HollowLine()
* *
HollowLine print *
*****
print 3 spaces
FullLine print *
newline

ASIDE: To fulfil each of the condition of the exercise two separate functions have been defined - FullLine and a HollowLine. These have no parameters. We
could have compressed it all in one function as below.

print 5 asterisks
newline Which one is elegant, the one
repeat five times above or this one?
print *
print 3 spaces
print *
newline
print 5 asterisks
newline

The example above has modules that constitute a well-structured logical decomposition for the task.

There are more similar exercises, but these use parameters. Even though the AS does not expect to let’s practice with these.

Page 12 of 16
 Achieved ×
Merit ×
Excellence Calls modules, well-structured logical
Exercise 5: Convert binary to Hexadecimal (relates to AS 2.44) decomposed task.

Convert an integer (a decimal) number to hexadecimal.

Sample Answer
ConvBintoHex (parameters: binarynumber)
Declare a string variable numbin Divides binary number in groups each containing 4
Read in value numbin to a value of binary numbers binary number and computes a value for each group
Call ConvBintoHex(arguments:numbin) and return the hexadecimal numbers
print numhex

Important to note: The word Call is significantly used when invoking another procedure or module.

The function contains a parameter and in the relevant box it shows how to write pseudo-code for functions with parameters. Note the difference when a
function with parameters is defined and when it is called. When the function is invoked it uses the notation ‘arguments’ but the notation used for the
function header is ‘parameters’. Some websites use: Call function name with parameter name, for example Call ConBintoHex with numbin.

Other Sample Answers

Declare a string variable numbin
Declare a long variable numhex
Read in value numbin to a value of binary numbers
numhex ← Call ConvBintoHex(arguments:numbin) OR Call ConvBintoHex(arguments:numbin) and store the result
print numhex

Page 13 of 16
 Achieved ×
Merit ×
Excellence Calls modules, well-structured logical
decomposed task.
Exercise 6: Tower of Hanoi

Before starting the exercise a video at this link http://www.youtube.com/watch?v=bPgv9D0lMfs&feature=related can be shown to the students.
Furthermore, http://www.youtube.com/watch?v=aGlt2G-DC8c can be shown to the students; this video shows the tower of Hanoi process in a slow
motion and with few disks.

While writing the pseudo-code for tower of Hanoi for a number of disks there are few considerations. The disks of different sizes are stacked in ascending
order of size; from the largest to the bottom to the smallest at the top. Stack the disks from tower one to tower three as shown in the figure below. Only
one disk may be moved at a time. No disk may be placed on top of a smaller disk at any time (even in the process of stacking). Let’s experiment with three
disks.

Tower A Tower B Tower C Tower A Tower B Tower C

Sample Answer

Algorithm start
Move from Tower A to Tower C
Move from Tower A to Tower B
Move from Tower C to Tower B
Move from Tower A to Tower C
Move from Tower B to Tower A
Move from Tower B to Tower C
Move from Tower A to Tower C
Algorithm end

Page 14 of 16
The algorithm calls a module named move, this module moves the each disk one at a time. I have included a pseudo code found on a website to handle
indefinite number of disks.

FUNCTION MoveTower(disk, source, dest, spare):

There is more to this pseudo code that is it calls its function recursively.
IF disk == 0, THEN: (http://www.cs.cmu.edu/~cburch/survey/recurse/hanoiimpl.html)
move disk from source to dest
ELSE:
MoveTower(disk - 1, source, spare, dest) // Step 1 above
move disk from source to dest // Step 2 above
MoveTower(disk - 1, spare, dest, source) // Step 3 above
END IF

Page 15 of 16
Let’s see if you can solve this.

Say, you ask a friend to go out and buy 1L of milk, and if there are eggs, to buy 10. So what does your friend buy in the end?i

It is precise, is it unambiguous?

MORAL: There is no one defined way of writing pseudo code but a pseudo-code should possess three elements: clarity, precision and concise.

~~~~~~~~~~~~~~~~~~~~~~~ HAVE FUN ~~~~~~~~~~~~~~~~~~~~~~~

i
10 Litres of milk

Page 16 of 16