NOEMI D.

DIONEDA (FACULTY-IN-CHARGE)

1
Definition of Algorithm

An algorithm is an ordered set

of unambiguous, executable
steps that defines a
terminating process.

2
Algorithm Representation

Requires well-defined primitives

A collection of primitives
constitutes a programming
language.

3
Folding a Bird From a Square
Piece of Paper

4
Origami Primitives

5
Pseudocode Primitives
• Assignment
name = expression

• Example
RemainingFunds = CheckingBalance +
SavingsBalance

6
Pseudocode Primitives

Conditional selection
if (condition):
activity

Example
if (sales have decreased):
lower the price by 5%

7
Pseudocode Primitives

 Conditional selection
if (condition):
activity
else:
activity

 Example
if (year is leap year):
daily total = total / 366
else:
daily total = total / 365

8
Pseudocode Primitives

 Repeated execution
while (condition):
body

 Example
while (tickets remain to be sold):
sell a ticket

9
Pseudocode Primitives

 Indentation shows nested conditions

if (not raining):
if (temperature == hot):
go swimming
else:
play golf
else:
watch television

10
Pseudocode Primitives

• Define a function
def name():

• Example
def ProcessLoan():

• Executing a function
if (. . .):
ProcessLoan()
else:
RejectApplication()

11
The Procedure Greetings in
Pseudocode

12
Pseudocode Primitives

• Using parameters
def Sort(List):
.
.

• Executing Sort on different

lists
Sort(the membership list)

Sort(the wedding guest list)

13
Polya’s Problem Solving Steps

1. Understand the problem.

2. Devise a plan for solving the
problem.
3. Carry out the plan.
4. Evaluate the solution for accuracy
and its potential as a tool for solving
other problems.

14
Polya’s Steps in the Context of
Program Development
1. Understand the problem.
2. Get an idea of how an algorithmic function
might solve the problem.
3. Formulate the algorithm and represent it as
a program.
4. Evaluate the solution for accuracy and its
potential as a tool for solving other
problems.

15
Getting a Foot in the Door

 Try working the problem

backwards
 Solve an easier related problem
Relax some of the problem
constraints
Solve pieces of the problem first
(bottom up methodology)
 Stepwise refinement: Divide the
problem into smaller problems
(top-down methodology)
16
Ages of Children Problem

 Person A is charged with the task of

determining the ages of B’s three children.
 B tells A that the product of the children’s ages is
36.
 A replies that another clue is required.
 B tells A the sum of the children’s ages.
 A replies that another clue is needed.
 B tells A that the oldest child plays the piano.
 A tells B the ages of the three children.
 How old are the three children?

17
Analyzing the Possibilities

18
The Sequential Search Algorithm
Pseudocode
def Search (List, TargetValue):
if (List is empty):
Declare search a failure
else:
Select the first entry in List
to be TestEntry
while (TargetValue > TestEntry
and entries remain):
Select the next entry in
List as TestEntry
if (TargetValue == TestEntry):
Declare search a success
else:
Declare search a failure

19
Components of Repetitive
Control

20
Iterative Structures

 Pretest loop:
while (condition):
body
 Posttest loop:
repeat:
body
until(condition)

21
The While Loop Structure

22
The Repeat Loop Structure

23
Sorting the List Fred, Alex,
Diana, Byron, and Carol
Alphabetically

24
The Insertion Sort Algorithm
expressed in pseudocode
def Sort(List):
N = 2
while (N <= length of List):
Pivot = Nth entry in List
Remove Nth entry leaving a hole in
List
while (there is an Entry above the
hole and Entry > Pivot):
Move Entry down into the hole
leaving
a hole in the list above the
Entry
Move Pivot into the hole
N = N + 1

25
Recursion

The execution of a procedure

leads to another execution of
the procedure.
Multiple activations of the
procedure are formed, all but
one of which are waiting for
other activations to complete.

26
Applying Our Strategy to Search
a List for the Entry John

27
A First Draft of the Binary Search
Technique
if (List is empty):
Report that the search failed
else:
TestEntry = middle entry in the List
if (TargetValue == TestEntry):
Report that the search succeeded
if (TargetValue < TestEntry):
Search the portion of List preceding
TestEntry for
TargetValue, and report the result of
that search
if (TargetValue > TestEntry):
Search the portion of List following
TestEntry for
TargetValue, and report the result of
that search

28
The Binary Search Algorithm in
Pseudocode
def Search(List, TargetValue):
if (List is empty):
Report that the search failed
else:
TestEntry = middle entry in the List
if (TargetValue == TestEntry):
Report that the search succeeded
if (TargetValue < TestEntry):
Sublist = portion of List
preceding TestEntry
Search(Sublist, TargetValue)
if (TargetValue > TestEntry):
Sublist = portion of List
following TestEntry
Search(Sublist, TargetValue)

29
Recursively Searching

30
Second Recursive Search, First
Snapshot

31
Second Recursive Search, Second
Snapshot

32
Algorithm Efficiency

 Measured as number of instructions

executed
 Bigtheta notation: Used to represent
efficiency classes
 Example: Insertion sort is in Θ(n2)
 Best,worst, and average case
analysis

33
Applying the Insertion Sort in a
Worse-case Situation

34
Graph of the Worse-case Analysis
of the Insertion Sort Algorithm

35
Graph of the Worse-case Analysis
of the Binary Search Algorithm

36
Software Verification

Proof of correctness
Assertions
• Preconditions
• Loop invariants
Testing

37
Chain Separating Problem

 A traveler has a gold chain of seven links.

 He must stay at an isolated hotel for seven
nights.
 The rent each night consists of one link from
the chain.
 What is the fewest number of links that must
be cut so that the traveler can pay the hotel
one link of the chain each morning without
paying for lodging in advance?

38
Separating the Chain Using Only
Three Cuts

39
Solving the Problem with Only
One Cut

40
The Assertions Associated with a
Typical While Structure

41
THANK YOU FOR
LISTENING!!!

42
Reference

Brookshear J.G. & Brylow

D. (2015). Computer
Science: An Overview 12th
Edition. ISBN: 973-0-13-
376006-4

43