What is Pseudocode?

A Pseudocode is defined as a step-by-step description of an algorithm. Pseudocode does not use any
programming language in its representation instead it uses the simple English language text as it is
intended for human understanding rather than machine reading.
Pseudocode is the intermediate state between an idea and its implementation(code) in a high-level
language.

What is the need for Pseudocode

Pseudocode is an important part of designing an algorithm, it helps the programmer in planning the
solution to the problem as well as the reader in understanding the approach to the problem.
Pseudocode is an intermediate state between algorithm and program that plays supports the
transition of the algorithm into the program.

Pseudocode is an
intermediate state between algorithm and program

How to write Pseudocode?

Pseudo code is a term which is often used in programming and algorithm-based fields. It is a
methodology that allows the programmer to represent the implementation of an algorithm. Simply,
we can say that it's the cooked-up representation of an algorithm. Often at times, algorithms are
represented with the help of pseudo codes as they can be interpreted by programmers no matter
what their programming background or knowledge is. Pseudo code, as the name suggests, is a false
code or a representation of code which can be understood by even a layman with some school level
programming knowledge.

Algorithm: It's an organized logical sequence of the actions or the approach towards a particular
problem. A programmer implements an algorithm to solve a problem. Algorithms are expressed
using natural verbal but somewhat technical annotations.

Pseudo code: It's simply an implementation of an algorithm in the form of annotations and
informative text written in plain English. It has no syntax like any of the programming language and
thus can't be compiled or interpreted by the computer.

Advantages of Pseudocode

• Improves the readability of any approach. It's one of the best approaches to start
implementation of an algorithm.

• Acts as a bridge between the program and the algorithm or flowchart. Also works as a rough
documentation, so the program of one developer can be understood easily when a pseudo
code is written out. In industries, the approach of documentation is essential. And that's
where a pseudo-code proves vital.

• The main goal of a pseudo code is to explain what exactly each line of a program should do,
hence making the code construction phase easier for the programmer.

How to write a Pseudo-code?

 1. Arrange the sequence of tasks and write the pseudocode accordingly.

2. Start with the statement of a pseudo code which establishes the main goal or the aim.

Example:

This program will allow the user to check

the number whether it's even or odd.

The way the if-else, for, while loops are indented in a program, indent the statements likewise, as it
helps to comprehend the decision control and execution mechanism. They also improve the
readability to a great extent.

Example:
if "1"
print response
"I am case 1"
if "2"
print response
"I am case 2"

1. Use appropriate naming conventions. The human tendency follows the approach to follow
what we see. If a programmer goes through a pseudo code, his approach will be the same as
per it, so the naming must be simple and distinct.

2. Use appropriate sentence casings, such as CamelCase for methods, upper case for constants
and lower case for variables.

3. Elaborate everything which is going to happen in the actual code. Don't make the pseudo
code abstract.

4. Use standard programming structures such as 'if-then', 'for', 'while', 'cases' the way we use it
in programming.

5. Check whether all the sections of a pseudo code is complete, finite and clear to understand
and comprehend.

6. Don't write the pseudo code in a complete programmatic manner. It is necessary to be

simple to understand even for a layman or client, hence don't incorporate too many
technical terms.

Few basic guidelines to be learnt before writing pseudocode.

Input and Output.

Values are input using the INPUT command as follows:

INPUT <identifier>

The identifier should be a variable (that may be an individual element of a data structure such as an
array, or a custom data type).
Values are output using the OUTPUT command as follows:

OUTPUT <value(s)>
Several values, separated by commas, can be output using the same command.

Examples – INPUT and OUTPUT statements

INPUT Answer

OUTPUT Score

OUTPUT "You have ", Lives, " lives left"

Note that the syllabus for IGCSE (0478) gives READ and PRINT as examples for INPUT and OUTPUT
respectively

Inputting and outputting data is an essential part of any program.

When inputting, we will need to assign to a variable - as such, you may go through the following data
types

Data type Pseudocode Python

Integer Number ← 5 number = 5

Real RealNumber ← 3.14 realNumber = 3.14

Character FirstNameInitial ← 'a' firstNameInitial = 'a'

String Password ← "letmein" password = "letmein"

Boolean LightSensor ← True lightSensor = True

Salutations

For different levels of formality, we often want to greet people in different ways - have the user enter
their title (Dr, Mr, Mrs, Miss etc), first name & last name, then display greetings in various levels of
formality.

Variables & Constants

If wanting to store data in our program, we will need to declare either:

• Variables: to hold data that can change

• Constants: to hold data that can't change

Operators

Arithmetic Operators

Within our programs, we will often have to perform calculations - this is where we need arithmetic
(mathematical) operators. Most everyone should already know, a few perhaps not

All Operators

Standard arithmetic operator symbols are used: • + Addition • - Subtraction • * Multiplication • /

Division

+: addition
 • -: subtraction

• *: multiplication

• /: division

• ^: exponentiation (power)

• DIV: returns the quotient of one number divided by another - i.e. how many times the
number can be wholly divided by the other

• MOD: returns the remainder after the integer division (DIV)

Care should be taken with the division operation: the resulting value should be of data type REAL,
even if the operands are integers.

The integer division operators MOD and DIV can be used. However, their use should be explained
explicitly and not assumed.

Multiplication and division have higher precedence over addition and subtraction (this is the normal
mathematical convention). However, it is good practice to make the order of operations in complex
expressions explicit by using parentheses

Logical Operators

The only logic operators (also called relational operators) used are AND, OR and NOT. The operands
and results of these operations are always of data type BOOLEAN.

In complex expressions it is advisable to use parentheses to make the order of operations explicit.

While by themselves, they are not overly useful, when used to execute specific code based on a
condition (if statement) or to continue looping based on the value of a certain condition, then logical
operators become crucial.

There are 3 built-in logical operators:

• AND: both conditions must be true

• OR: at least one condition must be true

• NOT: inverts the condition (FALSE <-> TRUE)

Comparison Operators

There are 6 Comparison operators:

• =: equal to
• >: greater than

• >=: greater than or equal to

• <: less than

• <=: less than or equal to

• <>: not equal to

Boolean Operators
While by themselves, they are not overly useful, when used to execute specific code based on a
condition (if statement) or to continue looping based on the value of a certain condition, then
Boolean operators become crucial

Selection: IF & CASE

IF statements may or may not have an ELSE clause.

IF statements without an else clause are written as follows:

IF <condition>THEN
<Statements>

ENDIF IF

statements with an else clause are written as follows:

IF <condition> THEN

<statements>

ELSE

<statements>

ENDIF

Note that the THEN and ELSE clauses are only indented by two spaces. (They are, in a sense, a
continuation of the IF statement rather than separate statements).

When IF statements are nested, the nesting should continue the indentation of two spaces. In
particular, run-on THEN IF and ELSE IF lines should be avoided.

Often, we want to choose what code executes based on some conditions at runtime - for this, we can
use the following selection statements

• IF: code inside block will be executed if IF condition evaluates to TRUE. IF statements can be
used for any type of condition, but require more code than CASE statements

• CASE: offers more concise syntax for checking individual, multiple values or finite ranges
(INTEGERs or CHARs)

CASE Statements

CASE statements allow one out of several branches of code to be executed, depending on the value
of a variable.
CASE statements are written as follows

CASE OF <identifier>

<value 1> : <statement>

<value 2> : <statement>

...

ENDCASE
An OTHERWISE clause can be the last case:

CASE OF <inentifier>

<value 1> : <statement>

<value 2> :<statement>

...

OTHERWISE <statement>

ENDCASE

It is best practice to keep the branches to single statements as this makes the pseudocode more
readable. Similarly single values should be used for each case. If the cases are more complex, the use
of an IF statement, rather than a CASE statement, should be considered.

Each case clause is indented by two spaces. They can be seen as continuations of the CASE
statement rather than new statements.

Note that the case clauses are tested in sequence. When a case that applies is found, its statement is
executed and the CASE statement is complete. Control is passed to the statement after the ENDCASE.
Any remaining cases are not tested.

If present, an OTHERWISE clause must be the last case. Its statement will be executed if none of the
preceding cases apply

As can be seen, nested IFs can get long quite quickly - in the following cases, we can use CASE
statements to offer more concise syntax:

• to check individual values

• to check multiple values, separated by a comma ,

• to check a finite range of INTEGER or CHAR values using TO

Note: in the syllabus document, only the first option is officially listed, however many past paper
questions and mark schemes use the latter two as well, so it should be fine to use them in the exam

If none of the values equal the value you are checking, then the OTHERWISE keyword can be used to
define the code that gets executed
Some students think you can only have a single line/statement for each case condition - but as you
can see in the OTHERWISE block, we can have as many lines as we want inside each condition

Number, Lowercase, Uppercase

Prompt the user to enter a single character, then output if the character they entered is a number,
lowercase letter, uppercase letter or other.

Loops: - FOR, WHILE, REPEAT UNTIL

Often, we are required to execute a block of code many times - for example, if processing test scores
for every student in the class. For this, there are 3 types of loops (iteration)
• FOR (count-controlled): will execute code a fixed number of times, either known at write
time (e.g. a fixed number of students in a class) or runtime (e.g. looping through every
character in a string entered by the user)

Count-controlled loops are written as follows:

The identifier must be a variable of data type INTEGER, and the values should be expressions
that evaluate to integers.

The variable is assigned each of the integer values from value1 to value2 inclusive, running
the statements inside the FOR loop after each assignment. If value1 = value2 the statements
will be executed once, and if value1 > value2 the statements will not be executed.

It is good practice to repeat the identifier after NEXT, particularly with nested FOR loops.

An increment can be specified as follows:

The increment must be an expression that evaluates to an integer. In this case the identifier
will be assigned the values from value1 in successive increments of increment until it reaches
value2. If it goes past value2, the loop terminates. The increment can be negative.

• WHILE (pre-conditional): checks condition, then executes code - loops while condition
is TRUE - if the condition is initially false, the code will never execute. Use case - e.g. looping
while neither player has won the game

Pre-condition loops are written as follows:

The condition must be an expression that evaluates to a Boolean.

The condition is tested before the statements, and the statements will only be executed if
the condition evaluates to TRUE. After the statements have been executed the condition is
tested again.

The loop terminates when the condition evaluates to FALSE.

The statements will not be executed if, on the first test, the condition evaluates to FALSE.

• REPEAT...UNTIL (post-conditional): executes code, then checks condition - loops while

condition is FALSE. Will always execute at least one time, since condition is checked after that
initial execution. Use case - e.g. asking user to enter password, until they get it correct or
have exceeded max tries.

Post-condition loops are written as follows:

The condition must be an expression that evaluates to a Boolean.

The statements in the loop will be executed at least once. The condition is tested after the
statements are executed and if it evaluates to TRUE the loop terminates, otherwise the statements
are executed again.

Arrays

So far, we have just looked at how to store single values in variables or constants - if we need to store
multiple values of the same data type, we can use arrays

Some advantages of arrays:

• Can easily loop over them - for assigning, inputting, calculating the min/max/mean/total,
searching, sorting, filtering etc

• Less tedious and more flexible than having to create 100s of variables for our data
Declaration and Assignment – 1 D arrays

The general syntax for declaring an array is as follows:

DECLARE <identifier> : ARRAY[<dimensions>] OF <data type>

Note: "dimensions" should be integer pairs in the form <lower bound>:<upper bound>

Declaration & Assignment - 2D Arrays

While sometimes a 1D array is appropriate, sometimes we might want a 2D array which can be
though of as a combination of rows and columns - much like a spreadsheet

For example, assume we want to store both the person's first and last name in separate, easily
accessible locations - in our spreadsheet analogy, we can create a 2D array with 5 rows to store our 5
people and 2 columns to store the first & last name respectively

The other example can be used to declare a 3x3 grid for a simple board game like noughts and
crosses - in this example, let's use a loop to automatically assign a space character to represent an
available cell in the board grid

Note: the order you access elements is row, column, which is the opposite to e.g. x, y co-ordinates in
maths - the acronym I remember being told at school to remember this was roman catholic to
remember the "rc" order - an alternate acronym could be remote control

Outputting Arrays - 1D

In pseudocode, you can't simply use OUTPUT arr to output the contents of an array – you need to
learn how output actually works - i.e. by looping through each element

Note: for IGCSE/O-Level, they will usually tell you the length of the array is either stored in some
variable/constant - e.g. NumberOfPeople or you can infer it from the question - e.g. "hourly
temperatures are taken daily" which indicates you need a 7x24 or 24x7 2D array. One question -
presumably by mistake - they didn't give any way of determining the length of the array - in that
case, you can just make up some variable/constant and pretend that stores the length in the 15
marker

Outputting Arrays - 2D
In this case, since we only have 2 columns, we can access them directly - if we had a large number of
columns, we could use a nested loop, looping through the rows in the outer loop, then the columns
in the inner loop

Min, Max, Sum, Mean

15 mark questions require us to calculate the minimum, maximum, sum and mean of all numbers in
an array

Looking at the code below, note:

• We assign min & max as being the first element - this is since, e.g. if giving min a huge default
value, then if all values happened to be larger than this, we would think the min was this
default value we initially assigned it - same for max, if we chose a small/negative initial value,
but the real values all happened to be less than it

• We then loop through all elements in the array

• Min: if the current element is smaller than the current minimum, then set this current
element as the new minimum

• Max: if the current element is bigger than the current maximum, then set this current
element as the new maximum

• Sum: add each element to the sum

• Mean: divide the sum by the number of elements

Linear Search

Often,we want to search to see whether a specific value exists in an array - we can use linear search
to do that:

1. Initialise an index variable to point to first element in array

2. Loop through array element-by-element

3. If current element is the value we are searching for, then update flag/return TRUE if in a
function etc

4. If item hasn't been found after looping through all elements in the array, then we know the
item doesn't exist

Bubble Sort

In order to sort an array in either ascending or descending order, we can use bubble sort:

1. Assume array is unsorted and loop to the n-1 position (e.g. 1 to 4, if 5 elements) in the array
on the first iteration
 2. Compare elements pair by pair - if in the wrong order (i.e. if current element bigger than
next element for ascending order...or current element smaller than next for descending
order), then swap them by making use of a temporary variable

3. If elements are not sorted after looping over all pairs, then go back to the start

More detailed comments can be seen in the code

Note: when we swap, we need the temporary variable - this is since if we do a <-- b, both variables
now have the same value at this point - b <-- a will be redundant - hence why we need to move one
value into a temporary variable before we update it, then assign this temporary variable value to the
other variable. Drawing a picture with arrows representing the assignments between 3 variables can
help with understanding.

Functions and Procedures – Built-in

Cambridge IGCSE/O-Level pseudocode comes with a few built-in modules (functions or procedures) -
for IGCSE/O-Level/O-Level, the built-in modules are all functions, though custom modules can be
created too which we will see in the below tutorial

Many people get confused about the difference between a function a procedure - the difference
should be fairly easy to understand with practice (next tutorial :)), but is also outlined briefly below:

• Functions will return a value that can be used to assign, in a calculation, a condition, output
statement etc
• Procedures won't return a value - we can output data inside the procedure, but the
procedure itself won't evaluate to an answer

The built-in function categories for IGCSE/O-Level are:

• String Functions
• Numeric Functions

String Functions.

LENGTH

Returns the number of characters in a string

Parameters:

[STRING] - the string to get the length from

LCASE
Converts a character or string to lowercase

Parameters:

[STRING | CHAR] - the string or character to convert to lowercase

UCASE

Converts a character or string to uppercase

Parameters:
 [STRING | CHAR] - the string or character to convert to uppercase

SUBSTRNG

Gets a part of a string, starting from a given index position and containing a given number of
characters

Parameters:

1. [STRING] - the string to extract the substring from

2. [INTEGER] - the starting position of the substring

3. [INTEGER] - the number of characters to get

Numeric Functions
ROUND

Rounds a real number to a given number of decimal places

Parameters:

1. [REAL] - the number to round

2. [INTEGER] - the number of decimal places to round it to

RANDOM

1. Returns a real number between 0-1 inclusive

Functions & Procedures - Custom

The previous tutorial looked at the built-in modules/sub-routines (functions or procedures) - in this
tutorial, we'll look at how to create and call (use) our own

A recap, the difference between a function and procedure is outlined below:

• Functions will return a value that can be used to assign, in a calculation, a condition, output
statement etc

• Procedures won't return a value - we can output data inside the procedure, but the
procedure itself won't evaluate to an answer

The benefits of creating functions and procedures include:

• Organisation - keeps code organised into small, logical blocks

• Reusability - don't have to copy and paste same functionality over and over

• Flexibility - if we need to modify behaviour, we only need to change once inside the module

• Testing - easy to test individual modules to ensure they work

• Parameterisation - can use the same module with different parameters to achieve different
behaviour

Functions

Each time we declare a function, we need:

 • FUNCTION & ENDFUNCTION keywords

• An identifier (function name)

• [optional] A list of parameters

• A return data type

• A return statement for every code path

PROCEDUREs

Declaring a procedure requires less code than a function, since we don't have to return anything -
we simply need:

• PROCEDURE & ENDPROCEDURE keywords

• An identifier (procedure name)

• [optional] A list of parameters

Before writing the pseudocode of any algorithm the following points must be kept in mind.

• Organize the sequence of tasks and write the pseudocode accordingly.

• At first, establishes the main goal or the aim.

Example:

This program will print first N numbers of Fibonacci series.

• Use standard programming structures such as if-else, for, while, and cases the way we use
them in programming. Indent the statements if-else, for, while loops as they are indented in
a program, it helps to comprehend the decision control and execution mechanism. It also
improves readability to a great extent.

Example:

IF "1"
print response
"I AM CASE 1"
IF "2"
print response
"I AM CASE 2"
• Use appropriate naming conventions. The human tendency follows the approach of
following what we see. If a programmer goes through a pseudo code, his approach will be
the same as per that, so the naming must be simple and distinct.

• Reserved commands or keywords must be represented in capital letters. Example: if you are
writing IF…ELSE statements then make sure IF and ELSE be in capital letters.

• Check whether all the sections of a pseudo code are complete, finite, and clear to
understand and comprehend. Also, explain everything that is going to happen in the actual
code.
 • Don't write the pseudocode in a programming language. It is necessary that the pseudocode
is simple and easy to understand even for a layman or client, minimizing the use of technical
terms.

Good vs Bad ways of writing Pseudocode:

Difference between Algorithm and Pseudocode

Algorithm Pseudocode

An Algorithm is used to provide a solution to a A Pseudocode is a step-by-step description of

particular problem in form of a well-defined an algorithm in code-like structure using
step-based form. plain English text.

Pseudocode also uses reserved keywords like

An algorithm only uses simple English words
if-else, for, while, etc.

These are fake codes as the word pseudo

These are a sequence of steps of a solution to a
means fake, using code like structure and
problem
plain English text

There are certain rules for writing

There are no rules to writing algorithms
pseudocode

Pseudocode cannot be considered an

Algorithms can be considered pseudocode
algorithm
Algorithm Pseudocode

It is difficult to understand and interpret It is easy to understand and interpret

Difference between Flowchart and Pseudocode

Flowchart Pseudocode

A Pseudocode is a step-by-step description

A Flowchart is pictorial representation of flow of
of an algorithm in code like structure using
an algorithm.
plain English text.

A Flowchart uses standard symbols for input,

Pseudocode uses reserved keywords like if-
output decisions and start stop statements. Only
else, for, while, etc.
uses different shapes like box, circle and arrow.

This is a way of visually representing data, these These are fake codes as the word pseudo
are nothing but the graphical representation of means fake, using code like structure but
the algorithm for a better understanding of the plain English text instead of programming
code language

Pseudocode is better suited for the purpose

Flowcharts are good for documentation
of understanding