1. PROGRAMMING, ALGORITHMS AND FLOWCHARTS

2. What is Programming?
Series of instructions to a computer to accomplish a task
Instructions must be written in a way the computer can understand
Programming languages are used to write programs

3. ALGORITHMS AND FLOWCHARTS
A typical programming task can be divided into two phases:
Problem solving phase
produce an ordered sequence of steps that describe solution of problem
this sequence of steps is called an algorithm
Implementation phase
implement the program in some programming language

4. Devise an algorithm for cooking a sausage on a barbecue

5. Steps in Problem Solving
First produce a general algorithm.
Refine the algorithm successively to get step by step detailed algorithm that is very close to a computer language.
Pseudocode is an artificial and informal language that helps programmers develop algorithms. Pseudocode is very similar to everyday English.

6. Pseudocode & Algorithm
Example 1: Write an algorithm to determine a student’s final grade and indicate whether it is passing or failing. The final grade is calculated as the average of four marks.
Start with a general algorithm.

7. General Algorithm Pseudocode: Input a set of 4 marks
Calculate their average by summing and dividing by 4
if average is below 50
Print “FAIL”
else
Print “PASS”

8. Detailed Algorithm Step 1: Input M1,M2,M3,M4
Step 2: GRADE  (M1+M2+M3+M4)/4
Step 3: if (GRADE < 50) then
Print “FAIL”
else
Print “PASS”
endif

9. Task: add two numbers Pseudocode: Start Get two numbers Add them
Print the answer
End

10. Next Step - The Flowchart
A graphical representation of the sequence of operations in an information system or program. Information system flowcharts show how data flows from source documents through the computer to final distribution to users. Program flowcharts show the sequence of instructions in a single program or subroutine. Different symbols are used to draw each type of flowchart.
The sequence of the flowchart and the algorithm MUST match.

11. The Flowchart A Flowchart shows logic of an algorithm
emphasizes individual steps and their interconnections
e.g. control flow from one action to the next

12. Flowchart Symbols Basic
Denotes a self-contained section of the program
Module

13. Example Step 1: Input M1,M2,M3,M4 Step 2: GRADE  (M1+M2+M3+M4)/4
START
Input
M1,M2,M3,M4
GRADE(M1+M2+M3+M4)/4 IS
GRADE<50
PRINT
“FAIL”
STOP Y N
Step 1: Input M1,M2,M3,M4
Step 2: GRADE  (M1+M2+M3+M4)/4
Step 3: if (GRADE <50) then
Print “FAIL”
else
Print “PASS”
endif
PRINT
“PASS”

14. Control Structures Represent the flow of logic through the programme.
There are four main control structures:
Sequence
Decision – incorporating if-then-else
Repetition
Case

15. Sequence Structure a series of actions are performed in sequence
START
Display message “How many hours did you work?”
Read Hours
Display message “How much do you get paid per hour?”
Read Pay Rate
Multiply Hours by Pay Rate. Store result in Gross Pay.
Display Gross Pay
END
a series of actions are performed in sequence
This is the flowchart for a program which calculates an employee’s gross pay.

16. Example 1
Write an algorithm and draw a flowchart to convert the length in feet to centimetres.
Pseudocode:
Input the length in feet (Lft)
Calculate the length in cm (Lcm) by multiplying LFT with 30
Print length in cm (LCM)

17. Example Algorithm Step 1: Input Lft Step 2: Lcm  Lft x 30
Flowchart
Algorithm
Step 1: Input Lft
Step 2: Lcm  Lft x 30
Step 3: Print Lcm
START
Input
Lft
Lcm  Lft x 30
STOP
Print
Lcm

18. Example 2
Write an algorithm and draw a flowchart that will read the two sides of a rectangle and calculate its area.
Pseudocode
Input the width (W) and Length (L) of a rectangle
Calculate the area (A) by multiplying L with W
Print A

19. Example 2 Algorithm Step 1: Input W,L Step 2: A  L x W
Step 3: Print A
START
Input
W, L
A  L x W
STOP
Print A

20. DECISION STRUCTURES Decision Structure
One of two possible actions is taken, depending on a condition.
A new symbol, the diamond, indicates a yes/no question.

21. Decision Structures
Sometimes only one choice is necessary
YES NO

22. Example 1 Pseudocode: Start Get year born Calculate age Print age
If age > 50 print OLD
End

23. Flowchart Start Get year born Calculate age Print age
Get yr
Flowchart
Start
Get year born
Calculate age
Print age
If age > 50 print OLD
End
Calc age
Print age Y
Age>50
OLD N
End

24. Decision Structure
Sometimes two choices are offered. If the answer to the question is yes, the flow follows one path. If the answer is no, the flow follows another path
YES NO

25. Decision Structure
In the flowchart segment below, the question “is x < y?” is asked. If the answer is no, then process A is performed. If the answer is yes, then process B is performed.
YES NO
x < y
Process B
Process A

26. IF–THEN–ELSE STRUCTURE
The structure is as follows
If condition then
true alternative
else
false alternative

27. IF–THEN–ELSE STRUCTURE
The algorithm for the flowchart is as follows:
If A>B then
print A
else
print B is
A>B
Print A
Print B N Y

28. Example 1
A ticket seller is issuing show tickets at the gate. When the patrons arrive, he asks how old each one is. It they are under 12, they pay half price. If they are 12 or over, they pay full price.
Algorithm
Get age
Age < 12?
If Age < 12
Then
Pay half price
Else
Pay full price

29. Flowchart
Begin
Input age
YES NO
Age < 12
Half price
Full price
End

30. Example 2
Write an algorithm that reads two values, determines the largest value and prints the largest value with an identifying message.
ALGORITHM
Step 1: Input VALUE1, VALUE2
Step 2: if (VALUE1 > VALUE2) then
MAX  VALUE1
else
MAX  VALUE2
endif
Step 3: Print “The largest value is”, MAX

31. Example 2 MAX  VALUE2 STOP N Y START Input VALUE1,VALUE2 MAX  VALUE1is
VALUE1>VALUE2
Print
MAX

32. Example 3
Write the algorithm and draw the flowchart for the following:
Enter two numbers, x and y. If x is less than y, square x to give the result a, otherwise, add x + y to give the result a.

33. YES NO x < y Algorithm Input x Input y x < y? If x <y Then
a = x^
Else
a = x+y
YES NO
x < y
Calculate a as x times 2.
Calculate a as x plus y.

34. NESTED IFS One of the alternatives within an IF–THEN–ELSE statement
may involve further IF–THEN–ELSE statement

36. Repetition (Iteration) Structure
Repetition Structure
Repetition (Iteration) Structure
A repetition structure represents part of the program that repeats. This type of structure is commonly known as a loop.

37. Repetition Structure
Notice the use of the diamond symbol. A loop tests a condition, and if the condition exists, it performs an action. Then it tests the condition again. If the condition still exists, the action is repeated. This continues until the condition no longer exists.

38. Repetition Structure
In the flowchart segment, the question “is x < y?” is asked. If the answer is yes, then Process A is performed. The question “is x < y?” is asked again. Process A is repeated as long as x is less than y. When x is no longer less than y, the repetition stops and the structure is exited.
x < y
Process A
YES

39. So this might look like…
x < y
Add 1 to x
YES
When would this loop exit?

40. Out of Control! YES x < y Display x
The action performed by a repetition structure must eventually cause the loop to terminate. Otherwise, an infinite loop is created.
In this flowchart segment, x is never changed. Once the loop starts, it will never end.
QUESTION: How can this flowchart be modified so it is no longer an infinite loop?
x < y
Display x
YES

41. Pre-test ( Before) Loop
This type of structure is known as a pre-test repetition structure. The condition is tested BEFORE any actions are performed.
x < y?
Display x
Add 1 to x
YES

42. Post-test (After) Loop
Display x
Add 1 to x
YES
x < y
This flowchart segment shows a post-test repetition structure.
The condition is tested AFTER the actions are performed.
A post-test repetition structure always performs its actions at least once.

43. Case Structure
One of several possible actions is taken, depending on the contents of a variable.
Used for MORE THAN TWO decisions

44. The structure below indicates actions to perform depending on the value in years_employed.
CASE years_employed 1 2 3
Other
bonus = 100
bonus = 200
bonus = 400
bonus = 800

45. 1 2 3 Other If years_employed = 2, bonus is set to 200
CASE years_employed 1 2 3
Other
bonus = 100
bonus = 200
bonus = 400
bonus = 800
If years_employed = 1, bonus is set to 100
If years_employed is any other value, bonus is set to 800

46. Draw the Flowchart for the above example
Case Algorithm
Input a Grade Case based on Grade     Case =100         Report “Perfect Score” (or suitable command eg Grade = Perfect)     Case > 89         Report “Grade = A”     Case > 79         Report “Grade = B”     Case > 69         Report “Grade = C”     Case > 59         Report “Grade = D”     Default (or Else)         Report “Grade = F” End Case
Draw the Flowchart for the above example

47. >89 >79 >69 > 59 100 other Flowchart CASE grade Grade =A
Grade = B
Grade = C
Grade = D
100
other
Grade = Perfect
Grade = F

48. Construct the algorithm and the flowchart for the following procedure:
An egg packing business needs to devise a process to sort eggs for delivery to supermarkets. If the eggs weigh 50 grams, they are Class A eggs. If they weigh 60 grams, they are Class B eggs. If they weigh 70 grams, they are Class C eggs. If they weigh more than 70 grams, they are Class D eggs.

49. 50 60 70 > 70 Algorithm Flowchart
Input a Weight Case based on Weight     Case =50         Class = A
    Case =60         Class = B     Case = 70         Class = C
    Case > 70         Class = D
    OR         Default/ Else Class = D  End Case
CASE weight 50 60 70
> 70
Class =A
Class = B
Class = C
Class = D

50. Modules (stepwise refinement)
A program module is a part of a program that makes sense on its own, just like a paragraph in an essay should make sense on its own. In large programs, such as those used in industry, programs are developed as separate modules and then put together.
The process of representing modules in flowcharts is known as stepwise refinement. You will look at this more closely when you start programming.

51. A separate flowchart can be constructed for the module.
START
Display message “How many hours did you work?”
Read Hours
Display message “How much do you get paid per hour?”
Read Pay Rate
Multiply Hours by Pay Rate. Store result in Gross Pay.
Display Gross Pay
END
START
END
Read Input.
Call calc_pay function.
Display results.
The position of the module symbol indicates the point the module is executed.
A separate flowchart can be constructed for the module.

52. A simpler example… could look like
CASE weight 50 60 70
> 70
Class =A
Class = B
Class = C
Class = D
Input weight
Calculate class
Display class

53. A complete program example
When you use stepwise refinement, the complete, refined flowchart is drawn first.
Then the modules are named and drawn in order.
This program lists the AFL team name and points total for all teams that have a full-forward from the AFL competition who has kicked at least 10 goals.

54. Startup
Headings

55. MainLoop Check pos Check conf Check goals Goals >= 10 Check AFL

56. Although this procedure is listed as a module in the opening flow chart, it’s unsuitable. Why?
Finish