Design an algorithm to search a number using linear search technique

Problem: Design an algorithm to search a number using linear search technique.
Input :  A list (array) of numbers, number of elements in the list and key to search.
Output : Returns 1 if the key is found otherwise returns 0.

LSEARCH(LIST, N, KEY)

[LIST is an array of numbers, N is the size of the array and key is the number to search]
Repeat For I=0, 1, 2, 3......N-1 [Assuming that array index starts from 0]
If(Key == LIST[I]) then:
Returns 1
[End of If]
Returns 0
Exit.

Design an algorithm to find sum of 'N' natural numbers

Problem: Design an algorithm to find sum of 'N' natural numbers between N1 and N2.
Input : Two numbers N1 and N2.
Output: Sum of N natural numbers.

SUM(N1, N2)

[N1 and N2 are two different natural numbers]
If N1> N2 then:
MAX <-- N1
MIN <-- N2
ELSE:
MAX<-- N2
MIN <-- N1
[End of If]
MIN <-- MIN-1 [ to include MIN in sum]
SUM 1 <-- (MIN * (MIN+1))/2
SUM 2 <-- (MAX * (MAX+1))/2
Return SUM2- SUM1
Exit.

In the above algorithm to find the sum of N natural numbers, the formula N(N+1)/2 is used. Instead of a formula, repetitive statements can also be used that run from MIN to MAX with step 1. The algorithm can be re-written as:

II algorithm 

Problem: Design an algorithm to find sum of 'N' natural numbers between N1 and N2.
Input : Two numbers N1 and N2.
Output: Sum of N natural numbers.

SUM(N1, N2)

[N1 and N2 are two different natural numbers]
If N1> N2 then:
MAX <-- N1
MIN <-- N2
ELSE:
MAX<-- N2
MIN <-- N1
[End of If]
SUM <-- 0
Repeat For I= MIN, MIN+1, MIN+2..........MAX
SUM <-- SUM+1
[End of For]
Return SUM
Exit.

Tracing:
Suppose that the above algorithm SUM1 is called with two numbers 23 and 11.
In the If statements 23>11 condition is TRUE, therefore MAX becomes 23 and MIN becomes 11.
Now the loop repeats for 11, 12, 13, 14 up to 23
(I values).
Every time when the loop is repeated I is added to SUM.
So, finally the value of SUM is returned from the algorithm.

Design an algorithm to find the GCD and LCM of two positive numbers

Problem : Design an algorithm to find the GCD (Greatest Common Divisor) of two positive numbers and use the same to find LCM of two positive numbers.

Input: Two Numbers
Output : Least Common Multiple of two numbers.

GCD(NUM1, NUM2)
Rem <-- NUM1 % NUM2  [% Modulus Operator]
Repeat While Rem <> 0
NUM1 <-- NUM2
NUM2 <-- Rem
Rem <-- NUM1 % NUM2
[End of While]
Return NUM2
Exit.

LCM(NUM1, NUM2)
Return (NUM1 * NUM2) / GCD( NUM1, NUM2)
Exit.

NOTE : Here in this example algorithm, finding LCM in the main problem that can be divided into sub-problem like finding the GCD first and using the same to solve the main problem. So, GCD algorithm is written first and than the other algorithm that can be divided into small problems and algorithm can be written to solve such small problems.

Tracing

Suppose that the LCM algorithm is called using 12 and 16. The algorithm calls GCD with 12 and 16.

Rem <-- 12 % 16 i.e. Rem= 12
Rem is not equal to zero. So, NUM1=16 and NUM2 =12
Rem<-- 16%12 i.e. Rem=4
Rem is not equal to Zero. So, NUM1 =12 and NUM2 =4
Rem <-- 12 % 4 i.e. Rem=0
Rem is equal to Zero.
So, GCD algorithm returns NUM2 that is 4.

When the algorithm LCM gets the result from GCD algorithm its find the expression value
(NUM1 * NUM2) / GCD (NUM1, NUM2).  i.e. (12 * 16)/4

It is equal to 48. 48 is the LCM of 12 and 16

Design an algorithm to find minimum of two distinct numbers

Problem:  Design an algorithm to find minimum of two distinct numbers and using the same, find minimum of three distinct numbers.

Input :  For sub-algorithm 2 numbers and for main algorithm 3 numbers.
Output: Minimum number

MIN_OF_2(NUM1, NUM2)                                                   [Sub-Algorithm]
[NUM1 and NUM2 are two numbers]
If NUM1<NUM2 Then:
Return NUM1
Else:
Return NUM2
[End of If]
Exit

MIN_OF_3(NUM1,NUM2,NUM3)                                     [Main Algorithm]
[NUM1, NUM2, and NUM3 are distinct numbers]
Returns MIN_OF_2(MIN_OF_2(NUM1, NUM2), NUM3)
Exit

Algorithm to find maximum of two unequal numbers

Problem: Algorithm to find maximum of two unequal numbers and use the same to find maximum of four unequal numbers.

Input: For sub-algorithm 2 numbers and for main algorithm 4 numbers.

Output : Returns the maximum of 4 numbers

MAX_OF_2(NUM1, NUM2)      [Sub-algorithm]
[NUM1 and NUM2 are two numbers]
If(NUM1>NUM2) Then:
Returns NUM1
Else:
Return NUM2
[End of If]
Exit.
MAX_OF_4(NUM1, NUM2, NUM3, NUM4)
[NUM1, NUM2, NUM3, and NUM4 are numbers]
TEMP1 <-- MAX_OF_2(NUM1, NUM2)
TEMP2 <-- MAX_OF_2(NUM3, NUM4)
MAX   <-- MAX_OF_2(TEMP1, TEMP2)
Return MAX
Exit.

Design an algorithm to find average of salary

This example is little complex. You will understand it more clearly after reading the user defined data types.
Problem: Design an algorithm to find average of SALARY in an array of EMP struct containing information EMPNO, EMPNAME, and SALARY.
Input: A list employees of the type struct.
Output : Display the average of SALARY.

AVG_SALARY(LIST, SIZE)
[LIST is an array of EMP, SIZE is size of array]
SUM<-- 0
Repeat For I=1,2,3,........SIZE
SUM<--SUM +LIST[I].SALARY
[END of For I]
AVG <-- SUM / SIZE
Write :  'The average Salary is', AVG
Exit

Note : An algorithm, that perform sub-task, may be called in another algorithm. It is a better practice to divide the given problem into sub-problems ans write the individual algorithm to solve such sub-problems. Write the main algorithm to call the sub-algorithms in order to solve the main problem.

Design an algorithm to find the average

Problem :  Design an algorithm to find the average of a subject marks of 'N' number of students.
Input: A list of marks and number of students.
Output: Returns the average marks calculated.

AVG_OF_MARKS(LIST,N)
[LIST is an array containing marks, N is the size of array]
SUM <-- 0
Repeat For I=1,2,3,.........N
SUM<-- SUM+LIST[I]
[END of For I]
AVG <-- SUM/N
Returns AVG
Exit