Subroutines igcses computer science powerpoint

Subroutines/Subprogram
 is a block of code that preforms a specific task but does not represent the entire
program.
 When a subroutines/subprogram is called, the calling program is halted and control
is transferred to the subroutine.
 After a subprogram has completed execution, the control is passed back to the
calling program
Program
Subprogram Subprogram Subprogram

 User defined subroutines/subprogram
 Two main type of subroutine exist:
 Procedure
 are small section of code that can be reused.
 Do not return a value.
 A parameter allows a value to be passed in to the procedure.
Procedure Pseudocde Python
Syntax PROCEDUERE identifier( Parameter)
Code
ENDPROCEDURE
def identifier (Parameter) :
Code
Parameter :the names of the variable that are used in the
subprogram to the data passed from the main program as
argument.

Procedure without parameter
PROCEDURE Star
OUTPUT “*****”
ENDPROCEDURE
CALL STAR
Main Program
Write a procedure that print five “*” .
Pseudocode
PROCEDURE Star
OUTPUT “*****”
ENDPROCEDURE
CALL Star
SubProgram (Proecedure)
Python
def Star ()
print( “*****” )
Star ()

Procedure without parameter
PROCEDURE Star (Num : INTEGER)
FOR Count  1 TO Num
OUTPUT “*”
NEXT Counter
ENDPROCEDURE
CALL STAR (10)
Main Program
Write a procedure that take the number as parameter and print the given
number of *
Pseudocode
PROCEDURE Star
FOR Count  1 TO Num
ENDPROCEDURE
CALL
SubProgram (Precedure)
Python
def Star (num)
for count in range (num):
Star (10)
( Num: INTEGER)
OUTPUT “*”
Star (10)
print( “*” )
NEXT Counter
10

 User defined subroutines/subprogram
 Function
 are similar to procedure
 The difference is that the functions have one or more values passed to them
and one or more values are returned to the main program.
 A parameter allows a value to be passed in to the procedure.
Procedure Pseudocde Python
Syntax FUNCTION identifier( Parameter) RETURN Datatype
Code
RETURN value
ENDFUNCTION
def identifier (Parameter) :
Code
return value

Function
Write a function that convert a centimeter to meter
Pseudocode
Function Meter
ENDFUNCTION
Mvalue  Meter (10)
Python
def Meter (cm)
ans = cm/100
mvalue = Meter (10)
( cm : INTEGER) RETURN REAL
return ans
RETURN
Ans  cm / 100
Ans

Function
FUNCTION Meter ( Cm : INTEGER ) RETURN REAL
Ans  Cm / 100
RETRUN Ans
Mvalue  Meter (10)
10 0.1

Exercise
1.Write a procedure that convert the given temperature from Fahrenheit to
Celsius and print result temperature
2. Write a function that convert the given temperature from Celsius to
Fahrenheit .

Library Subprogram
 Predefined subprogram/ library subprogram
 Many programming languages include built-in, ready-made functions, such as:
int(value) eg. int( 3.5)
input( String) eg. input(“Enter a number”)
print( String) eg. Print(“hello”)
 Additionally, some languages allow functions to be added in from external files
called libraries.
 Libraries contain pre-written, tested functions

Library SubProgram
 Pseudocode
MOD – return remainder of a division
DIV – return the whole number part of division
ROUND – returns the value of rounded to a given number of decimal places
RANDOM – return random number between 0 and 1
Res  MOD (5 , 2)
Res  DIV ( 5 , 2)
Res  ROUND ( 5.12344 ,2) // 5.12
Res  RANDOM( )

Advantages of Using Subroutines
 The subprogram can be called when needed:
 A single block of code can be used many times in the entire program, avoiding the need
for repeating identical code.
 This improves the modularity of the code, make is easier to understand and helps in the
identification of errors
 There is only one sections of code to be debug:
 If an error is located in a subprogram ,only the individual subroutine needs to be
debugged.
 There is only one section of code to update:
 Improvements and extensions of the code are available everywhere the subprogram is
called

Local and Global variable
 Local variable : a variable that is accessed only from within the
subprogram in which it is created
 Global variable: a variable that can be accessed from anywhere in the
program, including inside subprogram
 Scope of variable : the region of code within which a variable is visible

Example
DECLARE Number1, Number2, Answer : INTEGER
PROCEDURE Test
DECLARE Number3, Answer : INTEGER
Number1 ← 10
Number2 ← 20
Number3 ← 30
Answer ← Number1 + Number2
OUTPUT "Number1 is now ", Number1
OUTPUT "Number2 is now ", Number2
OUTPUT "Answer is now ", Answer
ENDPROCEDURE
Number1 ← 50
Number2 ← 100
Answer ← Number1 + Number2
OUTPUT "Number1 is ", Number1
OUTPUT "Answer is ", Answer
CALL Test
OUTPUT "Number1 is still ", Number1
OUTPUT "Number2 is still ", Number2
OUTPUT "Answer is still ", Answer
Number1 = 10
Number2 = 20
Answer = 150
Answer = 30 // local
Number3 = 30// local

DECLARE a,b, c : INTEGER
PROCEDUR Example ()
BEGIN PROCEDURE
DECLARE a , b , ans: INTEGER
a 10
b 30
c a + b
ans c
OUTPUT a , b, c// 10 ,30 . 40
END PROCEDURE
a 100
b 200
c a + b
OUTPUT a , b , c // 100,200,300
Eample ()
OUTPUT a, b, c // 100 ,200 ,40
a , b, c //global var
a = 100
b =200
c = 40
a, b, ans // local var
a = 10 //local
b= 30
ans = 40

StudentID [ 8, 9,2,1,3]
StudentName  [ “Mya”, “Kyaw”,”Aung”,”Thinzar”,”Kaung”]
PROCEDURE SortID ()
BEGIN PROCEDURE
DECLARE Size : INTEGER
Size = 5
WHILE Size > 1 DO
// implement pass
FOR Index 1 TO Size -1
IF StudentID [Index ] > StudentID[index +1] THEN
Temp  StudentID[index]
StudentID[index] StudentID[index +1]
StudentID[index+1]  Temp
Name  StudentName[index]
StudentName[index] StudentName[index +1]
StudentName[index+1]  Name
ENDIF
NEXT Index
Size  Size -1
ENDWHILE
FOR Index  1 TO 5
OUTPUT StudentID[Index] , StudentName[Index]

StudentID  [ 8, 9,2,1,3]
StudentName  [ “Mya”, “Kyaw”,”Aung”,”Thinzar”,”Kaung”]
PROCEDUER SortID
Last = 4
// pass
REPEAT
Swap  False
FOR index  0 T0 Last -1 DO
IF StudentID [index] > StudentID[ index+1] THEN
Temp  StudentID[ index]
StudenID [index]  StudentID[index+1]
StudentID[index+1]  Temp
TempName StudentName[index]
StudentName[index]  StudentName[index+1]
StudentName[index+1]  TempName
Swap  True
ENDIF
NEXT index
Last  Last -1
UNTIL Swap = FASLE OR Last = 0

Bubble sort (Ascending Order)
1. Start at the beginning of the list
2. Compare the values in the position 0 and
position 1 in the list – if they are not in
ascending order then swap them
3. Compare the values in the position 1 and
position 2 in the list and swap if
necessary
4. Continue to the end of the list
5. If there have been any swaps repeat step
1 to 4
Sorting Algorithm
4 2 6 1 3
4
2 6 1 3
6 1
4
2 1 6 3
3 6
Pass 1
4
2 1 3
4
2 1
Sort 4 2 6 1 3 in ascending order
using bubble sort
Last = 4

4
2 6
1 3
4
2 6
1 3
4
2 6
1 3
3
2 6
1 4
4
2 6
1 3
4
2 6
1 3
4
2 6
1 3
4
2 6
1 3
Sorting Algorithm
Pass 2
Pass 3

Subroutines igcses computer science powerpoint

More Related Content

Similar to Subroutines igcses computer science powerpoint (20)

Recently uploaded (20)

Subroutines igcses computer science powerpoint