Algorithm Design and Analysis: A Comprehensive Guide

Desklib provides solved assignments and past papers to help students succeed.

Table of Contents
Introduction......................................................................................................................................2
LO1..................................................................................................................................................3
P1.................................................................................................................................................3
LO2..................................................................................................................................................5
P2.................................................................................................................................................5
LO4..................................................................................................................................................7
P4.................................................................................................................................................7
P5.................................................................................................................................................8
Conclusion.......................................................................................................................................9
References......................................................................................................................................10

Introduction
In this program, we will learn about algorithm and what are the guideline to make an algorithm
and determine the process to carry out this execution. In LO1 we will discuss about what is an
algorithm and also, we will discuss the process of building and using one algorithm. We will also
learn about the steps which are significant in any algorithm development, like what are pre-
requisite need and what are the steps are taken during the development process. To explain
further we will also create an algorithm for adding 2 number and we will later on construct and
design a relationship between the designed algorithm and its code variant.
In LO2 we will discuss what are different types of programming paradigm. We will learn about
programming paradigm by coming across 4 types of programming paradigm which are Event-
driven, procedural paradigm, object-oriented paradigm and functional paradigm. But in this
section, we will focus on only 3 out of 4, excluding functional paradigm.
In LO3 we will use python programming and its various concepts to develop a code for
employee’s salary wage. We are presented with the information about commission standards in
the question and have to find what amount of salary they will get paid after adding they earned
commission of that month
IN LO4 we will discuss the process of debugging and how debugging is helpful in finding the
errors and bugs in the program.

LO1
P1
The word ‘Algorithm’ is defined as a set protocols or rules for a process which are designed for
some problem-solving techniques. In other words, an algorithm is a problem-solving technique
in a step by step procedure to execute some line of calculation or implement some type of
functionality by giving required input and get desired output.
In general terms, a cooking recipe can be considered as an example for real world algorithm, as it
contains step by step instructions for each step of preparation with all fundamentally required
variables or ingredient.
Characteristics of Algorithm
As no one will ever follow each step and functionality of the recipe for making a dish, so we
have to make sure that the provided instructions are clear and understandable on a novice level
so that a beginner standard user can make appropriate dish. In case of algorithms too, these
requirements must follow so that everyone can make meaning of given instructions. The various
types of requirements are as follows:
1. Clear and Unambiguous: The algorithm must give one specific output for every aspect
of methodology and all steps must be understandable and ambiguous in nature.
2. Well-Defined Inputs: If an algorithm is defined in such a way that it takes input in some
format than their have to be some kind of to ensure that the inputs are well-defined.
3. Well-Defined Inputs: The yielded output must be of same type and same value as
desired. To ensure the integrity of the presented output the functionality to identify that
must be well defined.
4. Finiteness: The algorithm must not run forever which means that sooner or later the
process part of any good algorithm must come to an end, because any infinite running
algorithm will give no result and will keep on using system resources.
5. Language Independent: A good algorithm must have the functionality to be
implemented on any desired programming language, which means if a algorithm is
developed in C++ then it shouldn’t change its processing or yielded result for languages
like Java or Python (Jain, et.al 2018)
Steps to design an Algorithm
Below are significant points which are required as pre-requisite:
 This algorithm must be able to solve defined problem.
 During the solution of any problem all the constraint must be considered.
 Input has to be considered in order to solve the problem.
 The output must the desired one when the solution is completed.
 The derived output must be the expected one and within the given constraints.
Step 1: The first step is to check whether the pre-requisite requirements are fulfilled or not.

Step 2: The second step is to design the algorithm:
After confirmation of pre-requisite requirements, we have to start the process of designing the
algorithm (Gulshan, et.al 2016).
Example: Algorithm to add two number and print their sum:
a. START
b. Declaring Num1 and Num2 as 2 integer variables
c. Parse the two number to add as inputs in variables Num1 and Num2.
d. To store the result of these two number’s sums, declare a third variable
e. Store the added value of these two number in the above variable.
f. Print the final result value of sum
g. END
Step 3: Algorithm testing by implementation using programming language:
Code:
#include<iostream.h>
using namespace std
int main()
{
int Num1, Num2;
int Sum_value;
cout<<”Enter the value of first number”<<endl;
cin>>Num1;
cout<<”Enter the value of second number”<<endl;
cin>>Num2;
Sum_value=Num1+Num2;
cout<<”The sum of these two number is: ”<<Sum_value<<endl;
return 0;
}
Output:
Enter the value of first number: 4
Enter the value of second number: 7
The sum of these two number is: 11

LO2
P2
There are many ways to classify programming languages and one of the ways is using
programming paradigm methodology. There are 4 types of programming paradigm which
includes, procedural paradigm (BASIC, COBOL, Ada), objective-oriented paradigm (C++,
Java), declarative paradigm (Prolog) and functional paradigm (Scheme, LISP) and event-driven
paradigm (VB, C#).
In this section, we will discuss about 3 out of 4 from above types:
 Procedural paradigm: Procedural paradigm is known to be a subtype of imperative
programming which means that methods are structures on such a way that the statements
are designed to and called as procedure. In this these so-called procedures are scope
bounded. In procedural programming many a times there are more than one module and
in those various modules there are more than one subprogram (Knuth, et.al 2015)
 Object-oriented paradigm: After the development of Procedural Programming Language,
object-oriented paradigm was developed as an extension of it. In OOP’s, each program is
combination of smaller units known as object. These objects have different task and
properties for each case in which they are defined. These programmed defined objects
have limited dependencies or in some cases no dependencies on implementation.
 Event-Driven paradigm: Various programming languages application works in such a
have that certain methods or objects are called by actions like mouse click, key press, or
sensor input. This programming paradigm usually works well with GUI or Graphical
User Interface applications. These types of programs are mostly work with threads or text
output from other programs.
Event Driven Programming
Paradigm
Procedural Programming
Paradigm
Object Oriented
Programming Paradigm
Gives the user a GUI or
graphical user interface for
execution of their program.
Allows user to use methods
and statements as procedure
and interface to read and
write code.
Present user with an interface
to write command in
modules.
Various actions like click of
mouse, key press, cursor
movement, etc to execute line
of code or to make events
happen.
Code is written and executed
in sequential order or also
known as linear fashion.
Methods and objects are
created in order to execute the
lines of code or execute pre-
defined specific tasks.
Main objective is on selecting
interface for user.
Main objective to make sure
that execution of steps is
sequential.
Data must be accessed by an
unauthorised user or party.

Languages like Visual Basic
and C# are event driven
programming paradigm.
Languages like C, Fortran,
COBOL are Procedural
Programming paradigm.
Languages like C++, Java are
object-oriented programming
paradigm.
Characteristics of event programming paradigm
1. Service orientated: This characteristic means that in some programming language the
user has to perform an event like clicking a mouse button or moving the mouse pointer,
keyboard strokes in order to access some services.
2. Time Driven: In many programs, we have to use some time dependent code in order to
run the application efficiently. It means that the specific block of code is written in such a
way that they will be executed within an hour or a week from execution which means that
we have module in our program which is time driven.
3. Event handlers: In most of the programming languages, we have event handlers which
are used in case of any specific point in code. This characteristic is used in case of
exception or in case where the program is null or void. We programmers usually use
event handler (Lafore, 2017).
4. Trigger functions: Trigger functions is used when specific event is executed, they are
used alongside with event handlers.
5. Events: In event driven programming we use various events and triggered functions to
execute various modules like mouse click, keyboard stroke, etc.
Characteristics of object programming paradigm
1. Inheritance: In object-oriented programming, we can derive class member and member
functions from another class, this is called Inheritance.
2. Polymorphism: Poly means many and morph means forms, in object-oriented
programming we apply this characteristic when we use same name for more than one
function but with different parameter type (Tsai, 2017).
3. Abstraction: Not showing details at conceptual level is known as data abstraction.
4. Encapsulation: Storing data in a safe and secure way without any interference from
outside reference.
Characteristic of procedural programming paradigm
1. Main objective is to focus on procedure and not in program data.
2. The whole program is a collective of functions, calculations, printing and scanning.
3. All function shares Global data more often
4. The only things move from function to function is data.

LO4
P4
In computer programming and software development, correcting error or resolving issues is
called the debugging process. As the name suggest debugging means removing the bug from the
program. This process is the part of event handling or software testing as after building the code
we have to test it so that each functionality can be checked and verified according to program
needs. As we know that program code can be of 10-20 lines or it can of thousands and thousands
of lines, for each case the only way for debugging is going line by line and checking whether
each stage is going smoothly or not.
Figure 1: Debugging process
Common debugging tools
First is Source code analysers, this tool includes complexity analyser, common code error and
security which can be very helpful in debugging a program. A complexity analyser is designed to
find every complicated or detailed code modules which are very complex to understand and even
more complex to solve them.
Other tools can find what lines of code are not being executed by the compiler during the
debugging process so that we can know for sure where the problem lies. Also, some tools help
the user to find out how different devices will display the written program (Loksa, et.al 2016)
Some of the debugging tools are more on an open source platform or based on scripting language
like kali or ubuntu which means they are not executed in an IDE except they need manual
methodology in order to find and remove said bugs.
In Operating system like windows we have an application called Troubleshooting which generate
report on any application or software allotted by user.
Facilities for debugging in IDE
To use the full force of debugging perspective, we have to use the determined executables for
debugging. There is various information about debug in the compiler that lets the debugger
establish a connection between the binary source code file and the source code.

Debug view allows the user to manage process of debugging of execution process in the
workbench. In this debug view various threads are interrupted or suspended of every debugging
target. It shows those threads as a stack of bugs which are to be resolved in sequential order.
P5
Indentation
In any programming, indentation is very basic requirement and is very common practice among
programmers. Indentation means giving proper tab space between lines of codes so that it is in
proper format for understanding. Generally, in python indentation plays a vital role because in
python we don’t use scope to make different block of codes. For example, in for loop of python
we use indentation to make sure that that line of code stays in that for loop statement (Ohm, et.al
2012).
Maximum Line Length
It is common practice to use only 79 characters in each line of python code. This make the code
look well written and easy on eyes. Any decent programmer will be able to understand the code
which is written according to coding standards (Devanbu, et.al 2016).
Comments
Using proper comments is very important for writing proper code. Comments are the code
statements which are not shown in the output of the program but they have a major role in the
editor section, as they describe each code line’s functionality (Matharu, et.al 2015).

Conclusion
In this program, we learnt about algorithm and what are the guideline to make an algorithm and
determine the process to carry out this execution. In LO1 we learned about what is an algorithm
and also, we discussed the process of building and using one algorithm. We also learned about
the steps which are significant in any algorithm development, like what are pre-requisite need
and what steps are taken during the development process. To explain further we created an
algorithm for joining two number and we later on construct a relationship between the designed
algorithm and its code variant.
In LO2 we discussed what are different types of programming paradigm. We came across 4
types of programming paradigm which are Event-driven, procedural paradigm, object-oriented
paradigm and functional paradigm. But in this section, we have to focus on only 3 out of 4,
excluding functional paradigm.
In LO3 we used python programming and its various concepts to develop a code for employee’s
salary wage. We were presented with the information about commission standards and have to
find what amount of salary they will get paid after adding they earned commission of that month
IN LO4 we discussed the process of debugging and how debugging is helpful in finding the
errors and bugs in the program.

References
Ohm, J.R., Sullivan, G.J., Schwarz, H., Tan, T.K. and Wiegand, T., 2012. Comparison of the
coding efficiency of video coding standards—including high efficiency video coding
(HEVC). IEEE Transactions on circuits and systems for video technology, 22(12), pp.1669-
1684.
Lafore, R., 2017. Data structures and algorithms in Java. Sams publishing.
Devanbu, P., Zimmermann, T. and Bird, C., 2016, May. Belief & evidence in empirical software
engineering. In 2016 IEEE/ACM 38th International Conference on Software Engineering
(ICSE) (pp. 108-119). IEEE.
Matharu, G.S., Mishra, A., Singh, H. and Upadhyay, P., 2015. Empirical study of agile software
development methodologies: A comparative analysis. ACM SIGSOFT Software Engineering
Notes, 40(1), pp.1-6.
Tsai, L.Y., 2017. Concurrent Algorithms in Transactional Data Structures (Doctoral
dissertation).
Abrahamsson, P., Salo, O., Ronkainen, J. and Warsta, J., 2017. Agile software development
methods: Review and analysis. arXiv preprint arXiv:1709.08439.
Knuth, D.E., 2015. The Art of Computer Programming, Volume 4, Fascicle 6: Satisfiability.
Addison-Wesley Professional.
Loksa, D., Ko, A.J., Jernigan, W., Oleson, A., Mendez, C.J. and Burnett, M.M., 2016, May.
Programming, problem solving, and self-awareness: effects of explicit guidance. In Proceedings
of the 2016 CHI Conference on Human Factors in Computing Systems (pp. 1449-1461). ACM.
Gulshan, V., Peng, L., Coram, M., Stumpe, M.C., Wu, D., Narayanaswamy, A., Venugopalan,
S., Widner, K., Madams, T., Cuadros, J. and Kim, R., 2016. Development and validation of a
deep learning algorithm for detection of diabetic retinopathy in retinal fundus
photographs. Jama, 316(22), pp.2402-2410.
Jain, H., 2018. Problem Solving in Data Structures & Algorithms Using Java. Independently
published.