1.

Exercise on developing algorithms

Algorithm in C Language

Algorithm is a step-by-step procedure, which defines a set of instructions to be executed in a certain order
to get the desired output. Algorithms are generally created independent of underlying languages, i.e. an
algorithm can be implemented in more than one programming language.

Algorithms tell the programmers how to code the program.

From the data structure point of view, following are some important categories of algorithms −

 Search − Algorithm to search an item in a data structure.

 Sort − Algorithm to sort items in a certain order.
 Insert − Algorithm to insert item in a data structure.
 Update − Algorithm to update an existing item in a data structure.
 Delete − Algorithm to delete an existing item from a data structure.

Characteristics of an Algorithm

Not all procedures can be called as algorithm.

An algorithm should have the following characteristics−

 Unambiguous − Algorithm should be clear and unambiguous. Each of its steps (or phases), and
their inputs/outputs should be clear and must lead to only one meaning.
 Input − An algorithm should have 0 or more well-defined inputs.
 Output − An algorithm should have 1 or more well-defined outputs, and should match the
desired output.
 Finiteness − Algorithms must terminate after a finite number of steps.
 Feasibility − Should be feasible with the available resources.
 Independent − An algorithm should have step-by-step directions, which should be independent
of any programming code.

How to Write an Algorithm?

There are no well-defined standards for writing algorithms. Rather, it is problem and resource dependent.
Algorithms are never written to support a particular programming code.

As we know that all programming languages share basic code constructs like loops (do, for, while), flow-
control (if-else), etc. These common constructs can be used to write an algorithm.

We write algorithms in a step-by-step manner, but it is not always the case. Algorithm writing is a process
and is executed after the problem domain is well-defined. That is, we should know the problem domain,
for which we are designing a solution.
Example

Let’s try to learn algorithm-writing by using an example.

Problem − Design an algorithm to add two numbers and display the result.

Step 1 − START

Step 2 − declare three integers a, b & c

Step 3 − define values of a & b

Step 4 − add values of a & b

Step 5 − store output of step 4 to c

Step 6 − print c

Step 7 − STOP

Alternatively, the algorithm can be written as −

Step 1 − START ADD

Step 2 − get values of a & b

Step 3 − c ← a + b

Step 4 − display c

Step 5 − STOP

In design and analysis of algorithms, usually the second method is used to describe an algorithm.
It makes it easy for the analyst to analyze the algorithm ignoring all unwanted definitions. He can
observe what operations are being used and how the process is flowing.

Writing step numbers, is optional.

We design an algorithm to get a solution of a given problem. A problem can be solved in more than one
ways.

Hence, many solution algorithms can be derived for a given problem. The next step is to analyze those
proposed solution algorithms and implement the best suitable solution.
Algorithm Analysis

Efficiency of an algorithm can be analyzed at two different stages, before implementation and after
implementation. They are the following −

 A Priori Analysis − This is a theoretical analysis of an algorithm. Efficiency of an algorithm is

measured by assuming that all other factors, for example, processor speed, are constant and have
no effect on the implementation.
 A Posterior Analysis − This is an empirical (observed or practical) analysis of an algorithm. The
selected algorithm is implemented using programming language. This is then executed on target
computer machine. In this analysis, actual statistics like running time and space required, are
collected.

We shall learn about a priori algorithm analysis. Algorithm analysis deals with the execution or running
time of various operations involved. The running time of an operation can be defined as the number of
computer instructions executed per operation.

Algorithm Complexity

Suppose X is an algorithm and n is the size of input data, the time and space used by the algorithm X are
the two main factors, which decide the efficiency of X.

 Time Factor − Time is measured by counting the number of key operations such as comparisons
in the sorting algorithm.
 Space Factor − Space is measured by counting the maximum memory space required by the
algorithm.

The complexity of an algorithm f(n) gives the running time and/or the storage space required by the
algorithm in terms of n as the size of input data.

Space Complexity

Space complexity of an algorithm represents the amount of memory space required by the algorithm in its
life cycle. The space required by an algorithm is equal to the sum of the following two components −

 A fixed part that is a space required to store certain data and variables, that are independent of the
size of the problem. For example, simple variables and constants used, program size, etc.
 A variable part is a space required by variables, whose size depends on the size of the problem.
For example, dynamic memory allocation, recursion stack space, etc.

Space complexity S(P) of any algorithm P is S(P) = C + SP(I), where C is the fixed part and S(I) is the
variable part of the algorithm, which depends on instance characteristic I. Following is a simple example
that tries to explain the concept −

Algorithm: SUM(A, B)
Step 1 – START
Step 2 – C ← A + B + 10
Step 3 – Stop
Here we have three variables A, B, and C and one constant. Hence S(P) = 1 + 3. Now, space depends on
data types of given variables and constant types and it will be multiplied accordingly.

Time Complexity

Time complexity of an algorithm represents the amount of time required by the algorithm to run to
completion. Time requirements can be defined as a numerical function T(n), where T(n) can be measured
as the number of steps, provided each step consumes constant time.

For example, addition of two n-bit integers takes n steps. Consequently, the total computational time is
T(n) = c ∗ n, where c is the time taken for the addition of two bits. Here, we observe that T(n) grows
linearly as the input size increases.
Algorithm 1: Add two numbers entered by the user
Step 1: Start
Step 2: Declare variables num1, num2 and sum.
Step 3: Read values num1 and num2.
Step 4: Add num1 and num2 and assign the result to sum.
sum←num1+num2
Step 5: Display sum
Step 6: Stop

Algorithm 2: Find the largest number among three numbers

Step 1: Start
Step 2: Declare variables a,b and c.
Step 3: Read variables a,b and c.
Step 4: If a > b
If a > c
Display a is the largest number.
Else
Display c is the largest number.
Else
If b > c
Display b is the largest number.
Else
Display c is the greatest number.
Step 5: Stop

Algorithm 3: Find the factorial of a number

Step 1: Start
Step 2: Declare variables n, factorial and i.
Step 3: Initialize variables
factorial ← 1
i←1
Step 4: Read value of n
Step 5: Repeat the steps until i = n
5.1: factorial ← factorial*i
5.2: i ← i+1
Step 6: Display factorial
Step 7: Stop
Algorithm 4: Check whether a number is prime or not
Step 1: Start
Step 2: Declare variables n, i, flag.
Step 3: Initialize variables
flag ← 1
i←2
Step 4: Read n from the user.
Step 5: Repeat the steps until i=(n/2)
5.1 If remainder of n÷i equals 0
flag ← 0
Go to step 6
5.2 i ← i+1
Step 6: If flag = 0
Display n is not prime
else
Display n is prime
Step 7: Stop

Algorithm 5: Find the Fibonacci series till the term less than 1000
Step 1: Start
Step 2: Declare variables first_term,second_term and temp.
Step 3: Initialize variables first_term ← 0 second_term ← 1
Step 4: Display first_term and second_term
Step 5: Repeat the steps until second_term ≤ 1000
5.1: temp ← second_term
5.2: second_term ← second_term + first_term
5.3: first_term ← temp
5.4: Display second_term
Step 6: Stop

Algorithm 6: Find Roots of a Quadratic Equation ax2 + bx + c = 0

Step 1: Start
Step 2: Declare variables a, b, c, D, x1, x2, rp and ip;
Step 3: Calculate discriminant
D ← b2-4ac
Step 4: If D ≥ 0
r1 ← (-b+√D)/2a
r2 ← (-b-√D)/2a
Display r1 and r2 as roots.
Else
Calculate real part and imaginary part
rp ← -b/2a
ip ← √(-D)/2a
Display rp+j(ip) and rp-j(ip) as roots
Step 5: Stop
 2. Exercise on drawing flowcharts

Flowchart in C Language
Flowchart is a diagrammatic representation of sequence of logical steps of a program. Flowcharts
use simple geometric shapes to depict processes and arrows to show relationships and
process/data flow.
A flowchart is a diagrammatic representation of an algorithm. A flowchart can be helpful for both
writing programs and explaining the program to others.
Symbols Used In Flowchart

Symbol Purpose Description

Indicates the flow of logic by

Flow line
connecting symbols.

Represents the start and the end

Terminal(Stop/Start)
of a flowchart.

Used for input and output

Input/Output
operation.

Used for arithmetic operations

Processing
and data-manipulations.

Used for decision making

Decision
between two or more alternatives.

On-page Connector Used to join different flowline

Used to connect the flowchart

Off-page Connector
portion on a different page.

Predefined Represents a group of statements

Process/Function performing one processing task.

Note: Though flowcharts can be useful for writing and analyzing a program, drawing a flowchart
for complex programs can be more complicated than writing the program itself. Hence, creating
flowcharts for complex programs is often ignored.
1. Add two numbers entered by the user.

Flowchart to add two numbers

2. Find the largest among three different numbers entered by the user.

Flowchart to find the largest among three numbers.

3. Find all the roots of a quadratic equation ax2+bx+c=0

Flowchart to find roots of a quadratic equation

4. Find the Fibonacci series till term≤1000.

Flowchart to display the Fibonacci Series

 3. Exercise on structure of C program

The components of the basic structure of a C program consists of 7 parts

1. Documentation Section
It is the section in which you can give comments to make the program more interactive. The
compiler won’t compile this and hence this portion would not be displayed on the output screen.
2. Preprocessor directives Section
This section involves the use of header files that are to included necessarily program.
3. Definition section
This section involves the variable definition and declaration in C.
4. Global declaration Section
This section is used to define the global variables to be used in the programs, that means you can
use these variables throughout the program.
5. Function prototype declaration section
This section gives the information about a function that includes, the data type or the return
type, the parameters passed or the arguments.
6. Main function
It is the major section from where the execution of the program begins. The main section
involves the declaration and executable section.
7. User-defined function section
When you want to define your function that fulfills a particular requirement, you can define them
in this section.
1. Program to demonstrate Structure of a simple C Program
 4. Exercise on Keywords, identifiers, constants, variables
What is variable?
Variables in C have the same meaning as variables in algebra. A variable in C is a storage unit,
which sets a space in memory to hold a value and can take different values at different times
during program execution.
Rules to construct a valid variable name
1. A variable name may consists of letters, digits and the underscore ( _ ) characters.
2. A variable name must begin with a letter. Some system allows to starts the variable name with
an underscore as the first character.
3. ANSI standard recognizes a length of 31 characters for a variable name. However, the length
should not be normally more than any combination of eight alphabets, digits, and underscores.
4. Uppercase and lowercase are significant. That is the variable Totamt is not the same
as totamt and TOTAMT.
5. The variable name may not be a C reserved word (keyword).
Some valid variable names

Total Amount ctr name1

n1 M_age AMOUNT
Some invalid variable names
13th (name) 111 %nm

Naming Conventions
Generally, C programmers maintain the following conventions for naming variables.
 Start a variable name with lowercase letters.
 Try to use meaningful identifiers
 Separate "words" within identifiers with mixed upper and lowercase (for example empCode)
or underscores (for example emp_code).
 For symbolic constants use all uppercase letters (for example #define LENGTH 100, #define
MRP 45).
Keywords and Identifiers
Every C word is classified as either a keyword or an identifier. Each keyword has a specific
meaning and these meanings cannot be changed. Keywords serve as basic building blocks for
program statements. There are only 32 keywords in C. The list of all keywords in ANSI C is listed
in the following table. All keywords must be written in lowercase.

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Constants
Constants in C refer to a specific quantity that doesn't change during the execution of a program.
Types of Constants
 Integer Constants
 Real Constants
 Single Character Constants
 String Constants
Rules to construct Integer Constant
 An integer constant refers to a sequence of digits. The three types of integers are decimal, octal
and hexadecimal
 No embedded blanks, commas, and non-numeric character are permitted within an integer
constant.
 An integer constant must contain one digit
 Decimal integers consist set of digits, 0 to 9 without any decimal point and can be preceded by an
optional +ve or -ve sign.
 An octal integer constant contains any combination of digits between 0 and 7 with a leading 0.
 A hexadecimal constant contains any combination of digits between 0 and 9 and can also hold
alphabets between A and F or a and f with prefix 0x or 0X. Alphabets A or a represents number
10 and F or f represents 15.
 The largest integer value for the 16-bit machine is 32767 and 2147483647 for a 32-bit machine.
Example of various valid numeric constants

Constant Type Constant Type

241 Decimal Integer 047 Octal Integer
-973 Decimal Integer 053 Octal Integer
0 Decimal Integer 0X59 Hexadecimal Integer
+4177 Decimal Integer 0x47F Hexadecimal Integer

Example of some invalid numeric constants

05 241
7,412
$120
Rules to construct Real Constant
 A real constant is a number that may have a fractional part.

 It could be either +ve or -ve.

 No embedded blanks, commas, and non-numeric character are permitted within a real constant.
 A real number may also be expressed in exponential notation. An exponent is an integer number
with an optional plus or minus sign. Exponential is useful for representing the number which is
very large or very small in magnitude.

Example of various valid real constants

0.0045 -.71
+45.203 0.45e3

-0.547 0.78e-4

337. 2.79E4

.478. -4.69E-4

Initialization of Variables
Variables are given initial values, or initialized, when declared. See the following examples :
 char abc = 'X';
 int marks =77;
 float amount = 45.23;
Write initialized variables on a separate line and a comment beside the variable name is a good idea. See
the following examples :
 int qty; /* quantity of an item */
 float value = 12.10; /* purchase value of an item */
 int marks; /* marks of a subject */

5. Exercise on data types and operators in a simple C program

6. Exercise on input and output of characters
7. Exercise on formatted input and output.
8. Exercise on simple if statement
9. Exercise on if else statement
10. Exercise on else if ladder statement
11. Exercise on switch statement
12. Exercise on conditional operator
13. Exercise on while statement
14. Exercise on for statement
15. Exercise on do...while statement
16. Exercise on one dimensional arrays
17. Exercise on two dimensional arrays
18. Exercise on string handling functions.
19. Exercise on Functions
20. Exercise on Recursion
21. Exercise on structures
22. Exercise on Files.