9.1 - 11.3 (LOCKED) - Algorithm & Programming B
9.1 - 11.3 (LOCKED) - Algorithm & Programming B
9.2, 10.2,
1 11.1 to 11.3 Algorithm & Programming Basics
with Majid Tahir
Syllabus Content:
9.2. Algorithms
show understanding that an algorithm is a solution to a problem expressed as a sequence of
defined steps
use suitable identifier names for the representation of data used by a problem
o summarise identifier names using an identifier table
show understanding that many algorithms are expressed using the four basic constructs of
assignment, sequence, selection and repetition
show understanding that simple algorithms consist of input, process, output at various
stages
document a simple algorithm using:
o Structured English
o pseudocode (on the examination paper, any given pseudocode will be presented
using the Courier New font)
o program flowchart
derive pseudocode or a program flowchart from a structured English description of a
problem
derive pseudocode from a given program flowchart or vice versa
use the process of stepwise refinement to express an algorithm to a level of detail from
which the task may be programmed
decompose a problem into sub-tasks leading to the concept of a program module
(procedure/ function)
show an appreciation of why logic statements are used to define parts of an algorithm
solution
use logic statements to define parts of an algorithm solution
10.2 Arrays
use the technical terms associated with arrays including upper and lower bound
select a suitable data structure (1D or 2D array) to use for a given task
use pseudocode for 1D and 2D arrays (pseudocode will use square brackets to contain the
array subscript, for example a 1D array as A[1:n] and a 2D array as C[1:m, 1:n])
write program code using 1D and 2D arrays
write algorithms/program code to process array data including:
Syllabus Content:
11.1 Programming basics
Implement and write pseudocode from a given design presented as either a program
flowchart or structured English
Notes and guidance
Write pseudocode statements for implement and write a program from a given design
presented as either a program flowchart or pseudocode
write pseudocode for:
o the declaration of variables and constants
o the assignment of values to variables and constants
o expressions involving any of the arithmetic or logical operators
o input from the keyboard and output to the console given pseudocode will use the
following structures:
o DECLARE <identifier> : <data type> // declaration
o CONSTANT <identifier> = <value>
o <identifier> ← <value> or <expression> // assignment
o INPUT <identifier>
o OUTPUT <string> , OUTPUT <identifier(s)>
11.2 Constructs
Write pseudocode to write:
Selection
use an ‘IF’ structure including the ‘ELSE’ clause and nested IF statements
use a ‘CASE’ structure
Iteration
use a ‘count-controlled’ loop:
o FOR <identifier> ← <value1> TO <value2> <statement(s)> ENDFOR
o alternatively: FOR <identifier> ← <value1> TO <value2> STEP <value3>
<statement(s)> ENDFOR
use a ‘post-condition’ loop:
o REPEAT <statement(s)> UNTIL <condition>
use a ‘pre-condition’ loop
o WHILE <condition> <statement(s)> ENDWHILE • justify why one loop structure
may be better suited to a problem than the others
Algorithms:
An algorithm is a sequence of steps done to perform some task.
The essential aim of an algorithm is to get a specific output,
An algorithm involves with several continuous steps,
The output comes after the algorithm finished the whole process.
So basically, all algorithms perform logically while following the steps to get an output for a
given input.
Types of Algorithms:
Structured English
Flowcharts
Pseudo codes
Program Code
STRUCTURED ENGLISH:
Structured English provides a more formal way of documenting the stages of the algorithm.
Structured English is a subset of English language that consists of command statements used
to describe an algorithm.
FLOWCHARTS:
Flow chart is a graphical representation of a program.
Flowcharts use different symbols containing information about steps or a sequence of events.
PSEUDOCODE:
Pseudo code is an outline of a program, written as a series of instruction using simple
English sentences.
Pseudo code uses keywords commonly found in high-level languages and mathematical
notation. It describes an algorithm’s steps like program statements, without being bound by the
strict rules of vocabulary and syntax of any particular language, together with ordinary English.
Variable:
Variable is memory location where a value can be stored.
Constants:
Just like variables, constants are "dataholders". They can be used to store data that is
needed at runtime.
In contrast to variable, the content of a constant can't change at runtime, it has a
constant value.
Before the program can be executed (or compiled) the value for a constant must be
known.
Arithmetic
Use the arithmetic operators.
Assignment
Assignment is the process of writing a value into a variable (a named memory location).
For example, Count ← 1 can be read as ‘Count is assigned the value 1’, ‘Count is
made equal to 1’ or ‘Count becomes 1’.
Initialization:
If an algorithm needs to read the value of a variable before it assigns input data or a
calculated value to the variable, the algorithm should assign an appropriate initial value
to the variable, known as Initialization.
Input
We indicate input by words such as INPUT, READ or ENTER, followed by the name of
a variable to which we wish to assign the input value.
Output:
We indicate output by words such as OUTPUT, WRITE or PRINT, followed by a
comma-separated list of expressions.
Totaling
To keep a running total, we can use a variable such as Total or Sum to hold the running
total and assignment statements such as:
Total ← Total + Number (ADD Number to Tota)l
Counting
It is sometimes necessary to count how many times something happens.
To count up or increment by 1, we can use statements such as:
Count ← Count + 1
INCREMENT Count by 1
Structured statements
In the sequence structure the processing steps are carried out one after the other. The
instructions are carried out in sequence, unless a selection or loop is encountered.
Operator Comparison
> Greater than
< Less than
>= Greater than equal to
<= Less than equal to
= Equals to
<> Not equal
() Group
AND And
OR Or
NOT Not
Data types
The following table shows the Visual Basic data types, their supporting common
language runtime types, their nominal storage allocation, and their value ranges.
Pseudo code
BEGIN
DECLARE variable : Datatype
Variable 0 //initialization
Then ...
END
Constants
Creating Constants in Pseudocode is just writing costant name and value with it. In contrast to variable,
the content of a constant can't change at runtime, it has a constant value.
Type of Programs:
Sequence
Selection
Repetitions/Loops
Sequence
Statements are followed in sequence so the order of the statements in a program is
important.
Assignment statements rely on the variables used in the expression on the right-hand
side of the statement all having been given values. Input statements often provide
values for assignment statements. Output statements often use the results from
assignment statements.
Pseudocode VB Code
BEGIN
DECLARE miles,km : REAL
km miles * 1.61
END
IF…THEN…ELSE…ENDIF
CASE…OF…OTHERWISE…ENDCASE
IF…THEN…ELSE…ENDIF
For an IF condition the THEN path is followed if the condition is true and the ELSE path
is followed if the condition is false.
There may or may not be an ELSE path. The end of the statement is shown by ENDIF.
IF ((Height > 1) OR (Weight > 20) OR (Age > 5)) AND (Age < 70)
THEN
PRINT ("You can ride")
ELSE
PRINT ("Too small, too young or too old")
ENDIF
CASE Choice OF
ENDCASE
FLOWCHART:
START
INPUT
marks
Yes
No
PSEUDOCODE VB Code
BEGIN
DECLARE marks : Integer
END
BEGIN
DECLARE marks : INTEGER
PRINT ("Enter marks")
INPUT marks
IF marks >= 80
THEN PRINT ("Grade A")
ELSE IF marks >= 60
THEN PRINT ("Grade B")
ELSE IF marks >= 60
THEN PRINT ("Grade C")
ELSE PRINT ("Grade U")
END IF
END IF
END IF
END
The IF statement is useful, but can get clumsy if you want to consider “multi-way
selections
FLOWCHART:
START
INPUT
marks
Yes OUTPUT
IF marks >= 80
(“Grade A”)
No
Yes OUTPUT
IF marks >=
(“Grade B”)
70
No
IF marks >=60 OUTPUT (“Grade C”)
No Yes
OUTPUT (“Grade U”)
STOP
START
Pseudo code
INPUT marks
BEGIN
DECLARE marks : Integer
OUTPUT
(“Grade U)
STOP
FOR…TO…NEXT
WHILE…DO…ENDWHILE
REPEAT…UNTIL
FOR count = 1 to 10
INPUT number
total = total + number
NEXT count
WHILE … Do LOOP
This loop is used when we don’t know how many times the loop is to be performed. The Loop is
ended when a certain condition is true.
This condition is checked before starting the loop.
REPEAT
Input NUMBER
TOTAL = TOTAL + NUMBER
COUNT = COUNT + 1
Until COUNT = 10
Output Total
The fore loop repeats statements a set number of time. It uses a variable to count how many time it goes
round the loop and stops when it reaches its limit.
BEGIN
DECLARE count, number : Integer
OUTPUT (“Input a number for its times table")
INPUT number
FOR count = 1 To 20
PRINT (number , “times" , count , “ = ” number * Count”)
NEXT
VB code example:
Sub Main(args As String())
Console.WriteLine("Times Table Program")
Dim count, num As Integer
Console.WriteLine("please Input a number for its TimesTable")
num = Console.ReadLine()
For count = 1 To 20
Console.WriteLine(num & " Times " & count & " = " & num * count)
Next
End Sub
OUTPUT of Code
INPUT BiggestSoFar
FOR Counter 1 TO 5
INPUT NextNumber
IF NextNumber > BiggestSoFar
THEN
BiggestSoFar NextNumber
ENDIF
END FOR
The wile loop is known as a test before loop. The condition is tested before entering the loop, but tested
each time it goes round the loop. The number of times the statements within the loop are executed
varies. The test before loop goes round 0 or more times.
This method is useful when processing files and using “read ahead” data
VB Code example
BEGIN
DECLARE name : String
INPUT name
END
The repeat loop is similar to the while loop, but it tests the condition after the statements have been
executed once. This means that this test after loop goes round 1 or more times.
VB code example
BEGIN
DECLARE name : String
REPEAT
INPUT name
PRINT (“Your name is:” name)
UNTIL name = "x"
END
Keeps inputting name and keeps printing name until user enters “X”
FLOWCHART…WHILE-ENDWHILE
START
marks
(“Grade A”)
(“ ”)
INPUT name (“ ”)
LOOP
(“ ”)
(“ ”)
(“
No
STOP
marks
(“Grade A”)
(“
(“
”)
”)
FLOWCHART…REPEAT-UNTIL
(“ ”)
(“ ”) START
(“
marks
(“Grade A”)
(“ ”)
INPUT name (“ ”)
LOOP
(“ ”)
(“ ”)
is”)
OUTPUT (name)
UNTIL
name= “x” No
Yes
STOP
marks
(“Grade A”)
(“ ”)
Computer Science 9618
9.2, 10.2,
1 11.1 to 11.3 Algorithm & Programming Basics
with Majid Tahir
• What the array is going to be used for, so it can be given a meaningful name
• How many items are going to be stored, so the size of the array can be determined.
• What sort of data is to be stored, so that the array can be the appropriate data type.
PRINT (names(1))
BEGIN
End Module
Two Dimensional Arrays (2-D Arrays)
FOR row = 1 To 3
FOR column = 1 To 4
PRINT ("Row = " & row & "column = " & column & “has Value”)
PRINT (table(row, column))
NEXT
NEXT
END
For row = 0 To 2
For column = 0 To 3
Console.WriteLine("Row = " & row & "column = " & column & “has Value”)
Console.WriteLine(matrix(row, column))
Next
Next
Console.ReadKey()
End Sub
Multi-Dimensional Arrays:
A multi-dimensional array can be thought of as a table, each element has a row and column index.
Following example declares a two-dimensional array called matrix and would be declared by
Refrences:
Computer Science by David Watson & Helen Williams
Visual Basic Console Cook Book
Computer Science AS and A level by Sylvia Langfield and Dave Duddell
https://www.sitesbay.com/javascript/javascript-looping-statement
http://wiki.jikexueyuan.com/project/lua/if-else-if-statement.html