Module - 1

MCSC1C03: Principles of Programming Methodology

LEESHMA K
ASSISTANT PROFESSOR
DEPT. OF COMPUTER SCIENCE
ST.JOSEPH’S COLLEGE , DEVAGIRI
 References:

1. Martin M. Lipschutz and Seymour Lipschutz, Schaum’s Outline of

Theory and Problems of Data Processing.

2. Anil Bikas Chaudhuri, The Art Of Programming Through Flowcharts

& Algorithms, Laxmi Publications, New Delhi.

3. Jean Paul Trembley and Pual G Sorenson, An Introduction to Data

Structures with Applications, Tata McGraw Hill.

 Syllabus
Problem Solving - Flow Chart – Algorithm Design - Introduction to C Programming - overview and
importance of C - C Program Structure and Simple programs - Creation and Compilation of C
Programs under Linux and Windows Platforms. Elements of C Language and Program constructs -
structure of C program - character set, tokens, keywords, identifier - Data types, constants,
symbolic constants, variables, declaration, data input and output, assignment statements.
Operators in C - arithmetic operators, relational operators, logical operators, assignment
operators, increment and decrement operators, conditional operators, special operators,
precedence of operators - arithmetic expressions - evaluation of expressions, type conversion
inexpressions - precedence and associativity - mathematical functions - I/O operations.
Problem-solving
Problem-solving in programming methodology involves a systematic approach

to analyzing, designing, and implementing solutions to computational problems.

Step 1: understand the problem.

Step 2: create a step-by-step plan for how you’ll solve it.

Step 3: carry out the plan and write the actual code.

Step 4: look back and possibly refactor your solution if it could be better.
 Problem solving

Problem solving is a sequential process of analyzing information related to a given situation and generating
appropriate response options.
• In order to solve a problem by the computer , one has to pass through certain stages or steps. They are :

1. Understand the problem

7. Optimize and refine
2. Formulate a model 8. Document and Maintain
3. Develop an algorithm 9. Iterate and Improve
4. Write the problem

5. Test the problem

6. Evaluate the solution

 1. Understand the problem
• Understand completely the problem given before design.

• It is very important to specify exactly the set of inputs that the problem needs to handle.

• Identify the problem domain

• Ask clarifying questions

• Consider edge cases and exceptions: Think about any potential edge cases or exceptions that might arise in the
problem. These can include scenarios where inputs are at their minimum or maximum values, cases where
unexpected or invalid input is provided, or situations where certain conditions may cause the solution to behave
differently.

• Visualize the problem

• Research if necessary: If the problem involves unfamiliar concepts or techniques, consider conducting research to
enhance your understanding.
 2. Formulate the problem
• Processing part of the problem
• define the problem in a clear and concise manner
• It involves understanding the requirements, constraints, and desired outcomes, and translating them into a
well-defined problem statement.
• Define the boundaries and scope of the problem.
• Provide examples or sample inputs and expected outputs to illustrate the problem statement.
• Review the problem statement to ensure that it captures all the necessary information accurately and
completely.
 3. Develop an algorithm
 Develop a precise plan of what we want the computer to do.
 A set of sequential steps usually written in ordinary language to solve a given problem is
called Algorithm.
 It may be possible to solve a problem in more than one ways, resulting in more than one
algorithm.
 Algorithms can solve many, but not all, problems
 Many problems can be solved in a reasonable time
 Some require heuristic (approximate) approaches to solve them in a reasonable time
 Some problems cannot be solved using any algorithm
 4. Write the program

• Now we have to transform the algorithm from into a set of instructions that can be
understood by the computer.
• Writing a program is often called “writing code” or “implementing algorithm” . So
the source code is actually the program itself.
• Below is a program that implements our algorithm for finding the average of a set
of grades
 5. Test the program
• Once you have a program written that compiles , you need to make sure that it solves the problem that it

was intended to solve and that the solutions are correct.

• What are Programming Bugs?

A software bug is an error or mistake that causes a computer program to misbehave. These bugs

are generally the result of mistakes made by the programmer either in the design or the source

code. Some are caused by compilers that generated invalid code.

• In other words, if an error is encountered during the test it can cause malfunction. For example, incorrect

data description, statements, input data, design, etc.

• If the output of your program is incorrect , it is possible that you did not convert your algorithm into

a proper program.

• You should fix as many bugs in your program as you can find.

• To find bugs effectively , you should test your program with many test cases .

• It is also a good idea to have others test your program because they may think up situations or input

data that you may never have thought of.

• The process of finding and fixing errors in your code is called debugging.
 6. Evaluate the solution
• Evaluating the solution is an essential step in problem solving as it helps
determine the effectiveness, feasibility, and suitability of the proposed
solution.
• It involves assessing whether the solution addresses the underlying
problem, meets the desired objectives, and considers various factors such
as cost, resources, and potential risks.
• Once your program produces a result that seems correct , you need to re-consider

the original problem and make sure that the answer is formatted into a proper

solution to the problem. This process is known as evaluation.

• It is important to remember that the computer will only do what you told it to do.

It is up to you to interpret the results in a meaningful way and determine whether

or not it solves the original problem.

• Examine the feasibility of implementing the solution. Assess whether it can be
realistically implemented within the available resources, time constraints, and any
other limitations. Consider factors such as technical feasibility, resource availability,
expertise required, and any legal or ethical considerations.
7. Optimize and refine:

• Analyze the efficiency and performance of your

solution.
• Look for opportunities to optimize the code by
reducing time complexity or improving memory
usage.
• Refactor the code to make it more readable,
maintainable, and modular.
8. Document and maintain:

• Document your code by adding comments

and writing clear explanations of the logic
and functionality.
• This helps in understanding and maintaining
the code in the future.
9. Iterate and improve:

• If the solution does not meet all the

requirements or if there are additional
features to be implemented, iterate through
the problem-solving process again, starting
from step 1.
 Types of algorithm representation
1. Pseudo code :
• Pseudocode is a simplified programming language-like notation that describes the
steps of an algorithm in a more structured manner.
• It uses a combination of natural language and basic programming constructs, such
as conditional statements, loops, and function calls.
• Pseudocode allows for a more detailed and precise representation of the algorithm
without getting into the specifics of a particular programming language.
2. Flow chart:
• Flowcharts use graphical symbols and arrows to represent the steps and
flow of an algorithm.
• Each symbol represents an action or decision point, and the arrows depict
the order in which the steps are executed.
• Flowcharts provide a visual representation of the algorithm's logic and can
be helpful in understanding the overall structure and flow of a solution.
 Flow Chart for Structured Programming

• Flowchart is a graphical representation of an algorithm. Programmers

often use it as a program-planning tool to solve a problem. It makes
use of symbols which are connected among them to indicate the flow
of information and processing.
• In structured programming, flowcharts are commonly used to
represent the structure and control flow of a program.
• The process of drawing a flowchart for an algorithm is known as
“flowcharting”.
Basic Symbols used in Flowchart Designs

• Terminal: The oval symbol indicates Start, Stop and Halt in a

program’s logic flow. A pause/halt is generally used in a
program logic under some error conditions. Terminal is the
first and last symbols in the flowchart.
• Input/Output: A parallelogram denotes any function of
input/output type. Program instructions that take input from
input devices and display output on output devices are
indicated with parallelogram in a flowchart.
• Processing: A box represents arithmetic instructions. All
arithmetic processes such as adding, subtracting,
multiplication and division are indicated by action or process
symbol.
• Decision Diamond symbol represents a decision point.
Decision based operations such as yes/no question or
true/false are indicated by diamond in flowchart.
• Connectors: Whenever flowchart becomes complex or it
spreads over more than one page, it is useful to use connectors
to avoid any confusions. It is represented by a circle.

• Flow lines: Flow lines indicate the exact sequence in which

instructions are executed. Arrows represent the direction of
flow of control and relationship among different symbols of
flowchart.
 Rules
For Creating Flowchart :

A flowchart is a graphical representation of an algorithm. It should follow

some rules while creating a flowchart
• Rule 1: Flowchart opening statement must be ‘start’ keyword.
• Rule 2: Flowchart ending statement must be ‘end’ keyword.
• Rule 3: All symbols in the flowchart must be connected with an arrow line.
• Rule 4: The decision symbol in the flowchart is associated with the arrow
line.
 RULES FOR PSEUDOCODE
1. Write only one statement per line
• Each statement in your pseudo code should express just one action for the computer.
• If the task list is properly drawn, then in most cases each task will correspond to one
line of pseudo code.
 2. Capitalize initial keyword

• READ and WRITE are in caps. There are just a few keywords we will use:
• READ, WRITE, IF, ELSE, ENDIF, WHILE, ENDWHILE, REPEAT, UNTIL
 3. Indent to show hierarchy

• We will use a particular indentation pattern in each of the design structures:

• SEQUENCE: keep statements that are “stacked” in sequence all starting in the
same column.
• SELECTION: indent the statements that fall inside the selection structure, but not
the keywords that form the selection
• LOOPING: indent the statements that fall inside the loop, but not the keywords
that form the loop
 4. End multiline structures

• The ENDIF (or END whatever) always is in line with the IF (or whatever starts the
structure).
• Use any of the END keywords to end multi-line sections (ENDIF, ENDWHILE).
 5. Keep statements language independent

Resist the urge to write in whatever language you are most comfortable with. In the

long run, you will save time! There may be special features available in the language

you plan to eventually write the program in; if you are SURE it will be written in that

language, then you can use the features. If not, then avoid using the special features.
 Advantages of Pseudo code
• Improves the readability of any approach. It’s one of the best approaches to start implementation
of an algorithm.
• Acts as a bridge between the program and the algorithm or flowchart. Also works as a rough
documentation, so the program of one developer can be understood easily when a pseudo code is
written out. In industries, the approach of documentation is essential. And that’s where a pseudo-
code proves vital.
• The main goal of a pseudo code is to explain what exactly each line of a program should do, hence
making the code construction phase easier for the programmer.
 find area of a circle of radius r.
• Inputs to the algorithm: Radius r of the circle.
• Expected output : Area of the circle.
• Algorithm
• Step 1: start
Step 2: Read/input the radius r of the circle.
Step 3 : Area pi*r*r //calculation of area
Step 4 : Print Area.
Step 6 : End
• Inputs to the algorithm: First num1, Second num2
• Expected output : sum of two numbers
• Algorithm
Step 1: start Write an algorithm to read two
numbers and find their sum
Step 2 : read the first num1
Step 3 : read the second num2
Step 4 : Sum ------ num1+num2 //calculation of sum
Step 5 : Print Sum
Step 6 : End
 What is a Flowchart?

• Flowchart is a graphical representation of an algorithm. Programmers often

use it as a program-planning tool to solve a problem. It makes use of
symbols which are connected among them to indicate the flow of
information and processing.
• The process of drawing a flowchart for an algorithm is known as
“flowcharting”.
flowchart to calculate the average of two
numbers.
Example : Draw a flowchart to find the area of a
circle of radius r.

r*r
Write the algorithm and flow chart to convert temperature from
Fahrenheit to Celsius.

• Inputs to the algorithm : Temperature in Fahrenheit.

• Expected output : Temperature in Celsius.
• Algorithm
Step 1 : start
Step 2 : read temperature in Fahrenheit F
Step 3 : C5/9*(F - 32)
Step 4 : Print temperature in Celsius: C
Atep 5 : End.
 Types of control sequences

• There are 3 types of control sequences in programming . They are :

– Sequences

– Branching ( Selection)

– Loop ( Repetition)
Conditional Flow)
• Selection Logic Selection Logic simply involves a number of
conditions or parameters which decides one out of several
written modules. The structures which use these type of
logic are known as Conditional Structures. These structures
can be of three types:
1. simple if
2. If-else
3. If –elseif-else
Simple if
If (condition) then:

[Module A]

[End of If structure]
If (Condition), then:
[Module A]
Else:
[Module B]
[End if structure]
If (condition A), then:
[Module A]
Else if (condition B), then:
[Module B]
..
..
Else if (condition N), then:
[Module N]
[End If structure]
Flow chart of if-else
Write algorithm and draw flow chart to find the greater
number between two numbers.
• Algorithm
• Step 1 : start
• Step 2 : read / Input A and B
READ
• Step 3 : If A greater than B then print A
• Step 4 : If B greater than A then print B
• Step 5 : End

PRIN PRINT
T
Write algorithm and draw flow chart to find the
greater number between three numbers.
 Inputs to the algorithm : Temperature in
Fahrenheit.
• Expected output : Temperature in Celsius.
• Algorithm
Step 1 : start
Step 2 : read / Input A ,B and C
Step 3 : If(A>=B) and (A>=C) then print A is the largest.
Step 4 : If(B>=A) and (B>=C) then print B is the largest.
Step 4 : If(C>=A) and (C>=B) then print A is the largest.
Step 5 : End
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.
Pseudo code:

1. Start
2. Input a set of 4 marks
3. Calculate their average by summing and dividing by 4
4. if average is below 50 Print
“FAIL”
5. else
Print “PASS”
6. Stop
1. START:
2. Initialize variables:
- mark1, mark2, mark3, mark4: float (input marks obtained in four subjects)
- average: float (to store the calculated average)
- passingGrade: float (define the minimum passing grade, e.g., 50)
3. Input marks for four subjects:

4. Calculate the average:

- average = (mark1 + mark2 + mark3 + mark4) / 4

5. Check if the average is greater than or equal to passingGrade:

- IF average >= passingGrade:
- Display "Passing"
- ELSE:
- Display "Failing"

6. Print the final grade and the student's passing status

7. END
Example
• Write an algorithm to find the maximum element in an array
of integers. The function should take an array of integers as
input and return the maximum value present in the array.
Algorithm
1. Start the function findMaximumElement which takes an array of integers as

input.

2. Check if the array is empty:

If it is empty, return None as there is no maximum element.

3. Initialize a variable maxElement with the first element of the array.

4. Iterate through the array from the second element to the last element:

5. Compare each element with maxElement.

6. If the current element is greater than maxElement, update maxElement to

the current element.

7. After the loop ends, maxElement will hold the maximum value in the array.

8. Return maxElement as the result.

C For Loop Flowchart
Step 1: Start.

Step 2: Initialize variables.

Step 3: Check FOR condition.

Step 4: If the condition is true, then go to step 5 otherwise

go to step 7.

Step 5: f = f * i.

Step 6: Go to step 3.

Step 7: Print value of factorial.

Step 8: Stop.
Program to find all numbers between 1 to 100 divisible by 4
Algorithm:
Step 1: Start

Step 2: Initialize variables

Step 3: For condition

Step 4: If condition. If it is true, then go to step

5 otherwise to step 7

Step 5: Print value

Step 6: Increment the value of "i" by 1

Step 7: Go to step 3

Step 8: Stop
How does the while loop work?
Step 1. The while loop evaluates the controlling expression.
Step 2. If the controlling expression is false, the body of the while
statement is never executed, and control skips the while statement and
jumps to the next statement in the program.
Step 3. If the controlling expression is true or any non zero value, then
control jump within the body of while loop and execute the statements
in a sequential way. Might be there is only a single statement attached
with a while loop.
Step 4. After the execution of while loop statements, the process is
repeated from step 1.
While Loops
do...while loop
do while loop
• The do while loop is a post tested loop. Using the do-while
loop, we can repeat the execution of several parts of the
statements. The do-while loop is mainly used in the case
where we need to execute the loop at least once. The do-
while loop is mostly used in menu-driven programs where
the termination condition depends upon the end user.