UNIT I

ALGORITHMIC PROBLEM SOLVING

1.1 ALGORITHMS
In computing, we focus on the type of problems categorically known as algorithmic
problems, where their solutions are expressible in the form of algorithms.

The term ‗algorithm‘ was derived from the name of Mohammed al-Khowarizmi, a
Persian mathematician in the ninth century. Al-Khowarizmi → Algorismus (in Latin) →
Algorithm.

An algorithm is a well-defined computational procedure consisting of a set of

instructions that takes some value or set of values, as input, and produces some value or
set of values, as output. In other word, an algorithm is a procedure that accepts data;
manipulate them following the prescribed steps, so as to eventually fill the required unknown
with the desired value(s).

Input Algorithm Output

People of different professions have their own form of procedure in their line of work,
and they call it different names. For instance, a cook follows a procedure commonly known
as a recipe that converts the ingredients (input) into some culinary dish (output), after a
certain number of steps.

1.1.1 The Characteristics of a Good Algorithm

 Precision – the steps are precisely stated (defined).
 Uniqueness – results of each step are uniquely defined and only depend on the input
and the result of the preceding steps.
 Finiteness – the algorithm stops after a finite number of instructions are executed.
 Effectiveness – algorithm should be most effective among many different ways
to solve a problem.
 Input – the algorithm receives input.
 Output – the algorithm produces output.
 Generality – the algorithm applies to a set of inputs.

1.2 BUILDING BLOCKS OF ALGORITHM (INSTRUCTIONS, STATE,

CONTROL FLOW, FUNCTIONS)
An algorithm is an effective method that can be expressed within a finite amount of
space and time and in a well-defined formal language for calculating a function. Starting from
an initial state and initial input, the instructions describe a computation that, when executed,
proceeds through a finite number of well-defined successive states, eventually producing
"output" and terminating at a final ending state. The transition from one state to the next is
not necessarily deterministic; that algorithms, known as randomized algorithms.

An instruction is a single operation, that describes a computation. When it executed

it convert one state to other.

Typically, when an algorithm is associated with processing information, data can be

read from an input source, written to an output device and stored for further processing.
Stored data are considered as part of the internal stateof the entity performing the algorithm.
In practice, the state is stored in one or more data structures.

The state of an algorithm is defined as its condition regarding stored data. The stored
data in an algorithm are stored as variables or constants. The state shows its current values or
contents.

Because an algorithm is a precise list of precise steps, the order of computation is

always crucial to the functioning of the algorithm. Instructions are usually assumed to be
listed explicitly, and are described as starting "from the top" and going "down to the bottom",
an idea that is described more formally by flow of control.

In computer science, control flow (or flow of control) is the order in which
individual statements, instructions or function calls of an algorithm are executed or evaluated.

For complex problems our goal is to divide the task into smaller and simpler functions
during algorithm design. So a set of related sequence of steps, part of larger algorithm is
known as functions.

1.2.1 Control Flow

Normally Algorithm has three control flows they are:
 Sequence
 Selection
 Iteration

Sequence: A sequence is a series of steps that occur one after the other, in the same order
every time. Consider a car starting off from a set of lights. Imagine the road in front of the car
is clear for many miles and the driver has no need to slow down or stop. The car will start in
first gear, then move to second, third, fourth and finally fifth. A good driver (who doesn‘t
have to slow down or stop) will move through the gears in this sequence, without skipping
gears.

Selection: A selection is a decision that has to be made. Consider a car approaching a set of
lights. If the lights turn from green to yellow, the driver will have to decide whether to stop or
continue through the intersection. If the driver stops, she will have to wait until the lights are
green again.

Iteration: Iteration is sometimes called repetition, which means a set of steps which are
repeated over and over until some event occurs. Consider the driver at the red light, waiting
for it to turn green. She will check the lights and wait, check and wait. This sequence will be
repeated until the lights turn green.

1.3 NOTATION OF ALGORITHM

There are four different Notation of representing algorithms:

 Step-Form
 Pseudocode
 Flowchart
 Programming Language

1.3.1 Algorithm as Step-Form

It is a step – by – step procedure for solving a task or problem. The steps

must be ordered, unambiguous and finite in number. It is English like representation of logic
which is used to solve the problem.

Some guidelines for writing Step-Form algorithm are as follows:

 Keep in mind that algorithm is a step-by-step process.

 Use begin or start to start the process.
 Include variables and their usage.
 If there are any loops, try to give sub number lists.
 Try to give go back to step number if loop or condition fails.
 Use jump statement to jump from one statement to another.
 Try to avoid unwanted raw data in algorithm.
 Define expressions.
 Use break and stop to terminate the process.

For accomplishing a particular task, different algorithms can be written. The

different algorithms differ in their requirements of time and space. The programmer selects
the best suited algorithm for the given task to be solved.

Let as look at two simple algorithms to find the greatest among three numbers,
as follows:

Algorithm 1.1:

Step 1: Start.
Step 2: Read the three numbers A,B,C.
Step 3: Compare A and B. If A is greater perform step 4 else perform step 5.
Step 4: Compare A and C. If A is greater, output ―A is greater‖ else output ―C is greater‖.
Step 5: Compare B and C. If B is greater, output ―B is greatest‖ else output ―C is greatest‖.
Step 6: Stop.
Algorithm 1.2:

Step 1: Start.
Step 2: Read the three numbers A,B,C.
Step 3: Compare A and B. If A is greater, store Ain MAX, else store B in MAX.
Step 4: Compare MAX and C. If MAX is greater, output ―MAX is greater‖ else output ―C is
greater‖.
Step 5: Stop.
Both the algorithms accomplish same goal, but in different ways. The
programmer selects the algorithm based on the advantages and disadvantages of each
algorithm. For example, the first algorithm has more number of comparisons, whereas in
second algorithm an additional variable MAX is required.

In the Algorithm 1.1, Algorithm 1.2, step 1 and 2 are in sequence logic and step 3, 4,
and 5 are in selection logic. In order to illustrate iteration logic, consider one more example.

Design an algorithm for adding the test scores given as: 26, 49, 98, 87, 62, 75
Algorithm 1.3:

Step 1: Start
Step 2: Sum = 0
Step 3: Get a value
Step 4: sum = sum + value
Step 5: If next value is present, go to step 3. Otherwise, go to step 6
Step 6: Output the sum
Step 7: Stop
In the Algorithm 1.3 step 5 have a go to statement with a back ward step
reference, so it means that iteration logic.

1.3.2 Pseudocode
Pseudocode ("sort of code") is another way of describing algorithms. It is
called "pseudo" code because of its strong resemblance to "real" program code. Pseudocode
is essentially English with some defined rules of structure and some keywords that make
it appear a bit like program code.

Some guidelines for writing pseudocode are as follows.

Note: These are not "strict" guidelines. Any words used that have similar form and function
may be used in an emergency - however, it would be best to stick to the pseudocode words
used here.

 for start and finish BEGIN MAINPROGRAM, END MAINPROGRAM -

this is often abbreviated to BEGIN and END - especially in smaller programs
 for initialization INITIALISATION, END INITIALISATION - this part is
optional, though it makes your program structure clearer
 for subprogram BEGIN SUBPROGRAM, END SUBPROGRAM
 for selection IF, THEN, ELSE, ENDIF
 for multi-way selection CASEWHERE, OTHERWISE, ENDCASE
 for pre-test repetition WHILE, ENDWHILE
  for post-test repetition REPEAT, UNTIL
 Keywords are written in capitals.
 Structural elements come in pairs, eg for every BEGIN there is an END, for
every IF there is an ENDIF, etc.
 Indenting is used to show structure in the algorithm.
 The names of subprograms are underlined. This means that when refining
the solution to a problem, a word in an algorithm can be underlined and a
subprogram developed. This feature is to assist the use of the ‗top-down‘
development concept.

1.3.3 Flowcharts
Flowcharts are a diagrammatic method of representing algorithms. They use
an intuitive scheme of showing operations in boxes connected by lines and arrows that
graphically show the flow of control in an algorithm.

Table 1.1lists the flowchart symbol drawing, the name of the flowchart
symbol in Microsoft Office (with aliases in parentheses), and a short description of where and
how the flowchart symbol is used.

Table 1.1: Flowchart Symbols

NAME
SYMBOL DESCRIPTION
(ALIAS)
Flow Line
Flow line connectors show the direction that the process
(Arrow,
flows.
Connector
)
Terminator
(Terminal Terminators show the start and stop points in a process.
Point, Oval)
The Data flowchart shape indicates inputs to and outputs
Data
from a process. As such, the shape is more often referred
(I/O
to as an I/O shape than a Data shape.
)
Pretty self-explanatory - the Document flowchart symbol
Document
is for a process step that produces a document.
Show a Process or action step. This is the most common
Process
symbol in flowcharts.
Indicates a question or branch in the process flow.
Decision Typically, a Decision flowchart shape is used when there
are 2 options (Yes/No, No/No-Go, etc.)
This symbol is typically small and is used as a Connector
to show a jump from one point in the process flow to
another. Connectors are usually labeled with capital letters
Connector (A, B, AA) to show matching jump points. They are handy
(Inspection for avoiding flow lines that cross other shapes and flow
) lines. They are also handy for jumping to and from a
sub-
processes defined in a separate area than the main
flowchart.
 A Predefined Process symbol is a marker for another
Predefined
process step or series of process flow steps that are
Process
formally defined elsewhere. This shape commonly depicts
(Subroutine)
sub-processes (or subroutines in programming flowcharts).
As the names states, any process step that is a Preparation
Preparation
process flow step, such as a set-up operation.
Magnetic
The most universally recognizable symbol for a data
Disk
storage location, this flowchart shape depicts a database.
(Database)

1.3.4 Control Structures of Pseudocode and Flowcharts

Each control structures can be built from the basic elements as shown below.

Sequence: A sequence is a series of steps that take place one after another. Each step is
represented here by a new line.

Pseudocode Flowchart

BEGIN
Statement
Statement
END

Our sequence example of changing gears could be described as follows :

Pseudocode Flowchart
BEGIN

1st Gear

2nd Gear

3rd Gear

4th Gear

5th Gear

END
Selection : A Selection is a decision. Some decisions may be answered as Yes or No. These
are called binary selections. Other decisions have more than two answers. These are
called multiway selections.

A binary selection may be described in pseudocode and flow chart as follows :

Pseudocode Flowchart
IF (question) THEN

statement

ELSE

statement

ENDIF

An example of someone at a set of traffic lights follows :

Pseudocode Flowchart
IF (lights are green) THEN

Go

ELSE

Stop

ENDIF

A Multiway Selection may be described as follows :

Pseudocode Flowchart

CASEWHERE (question)

Alternative 1: Statement

Alternative 2 : Statement

OTHERWISE : Statement

ENDCASE
An example of someone at a set of traffic lights follows :

Pseudocode Flowchart

CASEWHERE Lights are :

Green : Go

Amber : Slowdown

Red : Stop

ENDCASE

Repetition: A sequence of steps which are repeated a number of times, is called repetition.
For a repeating process to end, a decision must be made. The decision is usually called a test.
The position of this test divides repetition structures into two types : Pre-test and Post-test
repetitions.

Pre-test repetitions (sometimes called guarded loops) will perform the test before any part
of the loop occurs.

Post-test repetitions (sometimes called un-guarded loops) will perform the test after the
main part of the loop (the body) has been performed at least once.

Pre-test repetitions may be described in as follows :

Pseudocode Flowchart

WHILE (question)

Statement

ENDWHILE
A traffic lights example follows :

Pseudocode Flowchart

WHILE (lights are not green)

wait

ENDWHILE

Post-test repetitions may be described as follows:

Pseudocode Flowchart

REPEAT

Statement

UNTIL (Question)

A traffic lights example follows :

Pseudocode Flowchart

REPEAT

Wait

UNTIL lights are green

Sub-Programs: A sub-program is a self-contained part of a larger program. The use of sub-
programs helps with "Top-Down" design of an algorithm, by providing a structure through
which a large and unwieldy solution may be broken down into smaller, more manageable,
components.

A sub-program is described as:

Pseudocode Flowchart

subprogram

Consider the total concept of driving a car. This activity is made up of a number of sub-
processes which each contribute to the driver arriving at a destination. Therefore, driving may
involve the processes of "Starting the car"; "Engaging the gears"; "Speeding up and slowing
down"; "Steering"; and "Stopping the car".

A (not very detailed) description of driving may look something like:

Pseudocode Flowchart

BEGIN

Start Car

Engage Gears

Navigate Car

Stop Car

END
Note that the sub-program "Navigate Car" could be further developed into:

Pseudocode Flowchart

BEGINSUBPROGRAM Navigate

Steer Car

Speed up and slow down car

ENDSUBPROGRAM

In the example above, each of the sub-programs would have whole algorithms of their own,
incorporating some, or all, of the structures discussed earlier.

1.3.5 Programming Language

Computers won‘t understand your algorithm as they use a different language.

It will need to be translated into code, which the computer will then follow to complete a
task. This code is written in a programming language. There are many programming
languages available. Some of you may come across are C, C++, Java, Python, etc... Each of
this languageis suited to different things. In this book we will learn about Python
programming language.

1.4 RECURSION

A recursive algorithm is an algorithm which calls itself with "smaller (or

simpler)" input values, and which obtains the result for the current input by applying simple
operations to the returned value for the smaller (or simpler) input. More generally if a
problem can be solved utilizing solutions to smaller versions of the same problem, and the
smaller versions reduce to easily solvable cases, then one can use a recursive algorithm to
solve that problem.

1.4.1 Example

For positive values of n, let's write n!, as we known n! is a product of numbers

starting from n and going down to 1. n! = n. (n-1)…… 2 .1. But notice that (n-1) 2.1 is
another way of writing (n-1)!, and so we can say that n!=n.(n−1)!. So we wrote n! as a
product in which one of the factors is (n−1)!. You can compute n! by computing (n−1)! and
then multiplying the result of computing (n−1)! by n. You can compute the factorial function
on n by first computing the factorial function on n−1. So computing (n−1)! is
a subproblem that we solve to compute n!.
Let's look at an example: computing 5!.

 You can compute 5! as 5⋅4!.

 Now you need to solve the subproblem of computing 4!, which you can compute as 4⋅
3!.
 Now you need to solve the subproblem of computing 3!, which is 3⋅2!.
 Now 2!, which is 2⋅1!.
 Now you need to compute 1!. You could say that 1! =1, because it's the product of all
the integers from 1 through 1. Or you can apply the formula that 1! = 1⋅0!. Let's do it
by applying the formula.
 We defined 0! to equal 1.
 Now you can compute1!=1⋅0!=1.
 Having computed 1!=1, you can compute 2!=2⋅1!=2.
 Having computed 2!=2, you can compute 3!=3⋅2!=6.
 Having computed 3!=6, you can compute 4!=4⋅3!=24.
 Finally, having computed 4!=24, you can finish up by computing 5!=5⋅4!=120.

So now we have another way of thinking about how to compute the value of n!, for all
nonnegative integers n:

 If n=0, then declare that n!=1.

 Otherwise, n must be positive. Solve the subproblem of computing (n−1)!, multiply
this result by n, and declare n! equal to the result of this product.

When we're computing n! in this way, we call the first case, where we immediately know the
answer, the base case, and we call the second case, where we have to compute the same
function but on a different value, the recursive case.

Base case is the case for which the solution can be stated non‐recursively(ie. the answer is
known). Recursive case is the case for which thesolution is expressed in terms of a smaller
version ofitself.
1.4.2 Recursion in Step Form
Recursion may be described as follows:
Syntax for recursive algorithm
Step 1: Start
Step 2: Statement(s)
Step 3: Call Subprogram(argument)
Step 4: Statement(s)
Step 5: Stop

Step 1: BEGIN Subprogram(argument)

Step 2: If base case then return base solution
Step 3: Else return recursive solution, include call subprogram(smaller version of argument)
Recursive algorithm solution for factorial problem

Step 1: Start
Step 2: Read number n
Step 3: Call factorial(n) and store the result in f
Step 4: Print factorial f
Step 5: Stop

Step 1: BEGIN factorial(n)

Step 2: If n==1 then return 1
Step 3: Else
Return n*factorial(n-1)

1.4.3 Recursion in Flow Chart

Syntax for recursive flow chart

Begin
Subprogram subprogram(argument)
call(argument)

Return recursive No Is base

solution with Case
Subprogram
call(smaller
version of
argument) Yes

Return base solution

Figure 1.1 Recursive Flow chart

Syntax
End
Begin Factorial(N) Subprogram
Start

yes
Read N Is
N==1

Fact=Factorial(N)
No

Return 1 Return N*Factorial(N-1)

Print Fact

Stop
End Factorial

Figure 1.2 Recursive flow chart solution for factorial problem

1.4.4 Recursion in Pseudocode

Syntax for recursive Pseudocode

SubprogramName(argument) BEGIN SUBPROGRAM SubprogramName(argument)
Is base Case
Return base case solution
Else
Return recursive solution with
SubprogramName (smaller version of
argument)
ENDSUBPROGRAM
Recursive Pseudocode solution for factorial problem

BEGIN Factorial BEGIN SUBPROGRAM Factotial(n)

REAR N IF n==1 THEN RETURN 1

Fact= Factorial(N) ELSE RETURN n*Factorial(n-1)

PRINT Fact ENDSUBPROGRAM

END

1.5 ALGORITHMIC PROBLEM SOLVING

We can consider algorithms to be procedural solutions to problems. These solutions

are not answers but specific instructions for getting answers. It is this emphasis on precisely
defined constructive procedures that makes computer science distinct from other disciplines.
In particular, this distinguishes it from theoretical mathematics, whose practitioners are
typically satisfied with just proving the existence of a solution to a problem and, possibly,
investigating the solution‘s properties. Let us discuss a sequence of steps one typically goes
through in designing and analysing an algorithm

1. Understanding the problem

2. Ascertain the capabilities of the computational device
3. Exact /approximate solution
4. Decide on the appropriate data structure
5. Algorithm design techniques
6. Methods of specifying an algorithm
7. Proving an algorithms correctness
8. Analysing an algorithm

Understanding the problem:

The problem given should be understood completely. Check if it is similar to some standard
problems & if a Known algorithm exists. Otherwise a new algorithm has to be developed.
Ascertain the capabilities of the computational device:

Once a problem is understood, we need to Know the capabilities of the computing

device this can be done by Knowing the type of the architecture, speed & memory
availability.

Exact /approximate solution:

Once algorithm is developed, it is necessary to show that it computes answer for all the
possible legal inputs. The solution is stated in two forms, exact solution or approximate
solution. Examples of problems where an exact solution cannot be obtained are i) Finding a
square root of number. ii) Solutions of nonlinear equations.

Decide on the appropriate data structure:

Some algorithms do not demand any ingenuity in representing their inputs. Some others are
in fact are predicted on ingenious data structures. A data type is a well-defined collection of
data with a well-defined set of operations on it. A data structure is an actual implementation
of a particular abstract data type. The Elementary Data Structures are Arrays: These let you
access lots of data fast. (good) .You can have arrays of any other data type. (good) .However,
you cannot make arrays bigger if your program decides it needs more space. (bad). Records:
These let you organize non-homogeneous data into logical packages to keep everything
together. (good) .These packages do not include operations, just data fields (bad, which is
why we need objects) .Records do not help you process distinct items in loops (bad, which is
why arrays of records are used) Sets: These let you represent subsets of a set with such
operations as intersection, union, and equivalence. (good) .Built-in sets are limited to a
certain small size. (bad, but we can build our own set data type out of arrays to solve this
problem if necessary)

Algorithm design techniques:

Creating an algorithm is an art which may never be fully automated. By mastering these
design strategies, it will become easier for you to develop new and useful algorithms.
Dynamic programming is one such technique. Some of the techniques are especially useful in
fields other than computer science such as operation research and electrical engineering.
Some important design techniques are linear, nonlinear and integer programming

Methods of specifying an algorithm:

There are mainly two options for specifying an algorithm: use of natural language or
pseudocode& Flowcharts. A Pseudo code is a mixture of natural language & programming
language like constructs. A flowchart is a method of expressing an algorithm by a collection
of connected geometric shapes.

Proving algorithms correctness:

Once algorithm is developed, it is necessary to show that it computes answer for all the
possible legal inputs .We refer to this process as algorithm validation. The process of
validation is to assure us that this algorithm will work correctly independent of issues
concerning programming language it will be written in.

Analysing algorithms:

As an algorithm is executed, it uses the computers central processing unit to perform

operation and its memory (both immediate and auxiliary) to hold the program and data.
Analysis of algorithms and performance analysis refers to the task of determining how much
computing time and storage an algorithm requires. This is a challenging area in which
sometimes requires grate mathematical skill. An important result of this study is that it allows
you to make quantitative judgments about the value of one algorithm over another. Another
result is that it allows you to predict whether the software will meet any efficiency constraint
that exits.

1.6 ILLUSTRATIVE PROBLEMS

1.6.1 Find Minimum in a List

Consider the following requirement specification:

A user has a list of numbers and wishes to find the minimum value in the list.
An Algorithm is required which will allow the user to enter the numbers, and which will
calculate the minimum value that are input. The user is quite happy to enter a count of the
numbers in the list before entering the numbers.

Finding the minimum value in a list of items isn‘t difficult. Take the first
element and compare its value against the values of all other elements. Once we find a
smaller element we continue the comparisons with its value. Finally we find the minimum.

Figure 1.3 Steps to Find Minimum Element in a List

Step base algorithm to find minimum element in a list

Step 1: Start
Step 2: Declare variables N, E, i and MIN.
Step 3: READ total number of element in the List as N
Step 4: READ first element as E
Step 5: MIN =E
Step 6: SET i=2
Step 7: IF i>n go to Step 12 ELSE go to step 8
Step 8: READ ith element as E
Step 9: IF E < MIN THEN SET MIN = E
Step 10: i=i+1
Step 11: go to step 7
Step 12: Print MIN
Step 13: Stop

Figure 1.4FlowChart to Find Minimum Element in a List

Pseudocode to find minimum element in a list

READ total number of element in the List as N

READ first element as E
SET MIN =E
SET i=2
WHILE i<=n
READ ith element as E
IF E < MIN THEN
SET MIN = E
ENDIF
INCREMENT i by ONE
ENDWHILE
PRINT MIN

1.6.2 Insert a Card in a List of Sorted Cards

Insert a Card in a List of Sorted Cards – is same as inserting an element into a sorted array.

We start from the high end of the array and check to see if that's where we want to insert the
data. If so, fine. If not, we move the preceding element up one and then check to see if we
want to insert x in the ―hole‖ left behind. We repeat this step as necessary.

Thus the search for the place to insert x and the shifting of the higher elements of the array
are accomplished together.

Position 0 1 2 3 4 5 Element To Be Insert

Original List 4 6 9 10 11 7
7>11 × 4 6 9 10 11
7>10 × 4 6 9 10 11
7>9 × 4 6 9 10 11
7>6 √ 4 6 7 9 10 11
Figure 1.5 Steps to Insert a Card in a List of Sorted Cards

Step base algorithm toInsert a Card in a List of Sorted Cards

Step 1: Start
Step 2: Declare variables N, List[], i, and X.
Step 3: READ Number of element in sorted list as N
Step 4: SET i=0
Step 5: IF i<N THEN go to step 6 ELSE go to step 9
Step 6: READ Sorted list element as List[i]
Step 7: i=i+1
Step 8: go to step 5
Step 9: READ Element to be insert as X
Step 10: SET i = N-1
Step 11: IF i>=0 AND X<List[i] THEN go to step 12 ELSE go to step15
Step 12: List[i+1]=List[i]
Step 13: i=i-1
Step 14: go to step 11
Step 15: List[i+1]=X

Figure 1.6Flow Chart to Insert a Card in a List of Sorted Cards

Pseudocode to Insert a Card in a List of Sorted Cards

READ Number of element in sorted list as N

SET i=0
WHILE i<N
READ Sorted list element as List[i]
 i=i+1
ENDWHILE
READ Element to be insert as X
SET i = N-1
WHILE i >=0 and X < List[i]
List[i+1] =List[i]
i=i–1
END WHILE
List[i+1] = X

1.6.3 Guess an Integer Number in a Range

Let's play a little game to give an idea of how different algorithms for the same
problem can have wildly different efficiencies. The computer is going to randomly select an
integer from 1 to N and ask you to guess it. The computer will tell you if each guess is too
high or too low. We have to guess the number by making guesses until you find the number
that the computer chose. Once found the number, think about what technique used, when
deciding what number to guess next?

Maybe you guessed 1, then 2, then 3, then 4, and so on, until you guessed the
right number. We call this approach linear search, because you guess all the numbers as if
they were lined up in a row. It would work. But what is the highest number of guesses you
could need? If the computer selects N, you would need N guesses. Then again, you could be
really lucky, which would be when the computer selects 1 and you get the number on your
first guess. How about on average? If the computer is equally likely to select any number
from 1 to N, then on average you'll need N/2 guesses.
But you could do something more efficient than just guessing 1, 2, 3, 4, …,
right? Since the computer tells you whether a guess is too low, too high, or correct, you can
start off by guessing N/2. If the number that the computer selected is less than N/2, then
because you know that N/2 is too high, you can eliminate all the numbers from N/2 to N from
further consideration. If the number selected by the computer is greater than N/2, then you
can eliminate 1 through N/2. Either way, you can eliminate about half the numbers. On your
next guess, eliminate half of the remaining numbers. Keep going, always eliminating half of
the remaining numbers. We call this halving approach binary search, and no matter which
number from 1 to N the computer has selected, you should be able to find the number in at
most log2N+1 guesses with this technique. The following table shows the maximum number
of guesses for linear search and binary search for a few number sizes:

Highest Number Max Linear Search Guesses Max Binary Search Guesses
10 10 4
100 100 7
1,000 1,000 10
10,000 10,000 14
100,000 100,000 17
1,000,000 1,000,000 20

Figure 1.7Flow Chart for Guess an Integer Number in a Range

Step base algorithm to Guess an Integer Number in a Range

Step 1: Start
Step 2: SET Count =0
Step 3: READ Range as N
Step 4: SELECT an RANDOMNUMBER from 1 to N as R
Step 6: READ User Guessed Number as G
Step 7: Count = Count +1
Step 8: IF R==G THEN go to step 11 ELSE go to step 9
Step 9: IF R< G THEN PRINT ―Guess is Too High‖ AND go to step 6 ELSE go to step10
Step 10: IF R>G THEN PRINT ―Guess is Too Low‖ AND go to step 6
Step 11: PRINT Count as Number of Guesses Took

Pseudocode to Guess an Integer Number in a Range

SET Count =0
READ Range as N
SELECT an RANDOM NUMBER from 1 to N as R
WHILE TRUE
READ User guessed Number as G
Count =Count +1
IF R== G THEN
BREAK
ELSEIF R<G THEN
DISPLAY ―Guess is Too High‖
ELSEIF R>G THEN
DISPLAY ―Guess is Too Low‖
ENDIF
ENDWHILE
DISPLAY Count as Number of guesses Took

1.6.4 Tower of Hanoi

Tower of Hanoi, is a mathematical puzzle which consists of three towers
(pegs) and more than one rings is as depicted in Figure 1.8. These rings are of different sizes
and stacked upon in an ascending order, i.e. the smaller one sits over the larger one.

Figure 1.8 Tower of Hanoi

 The mission is to move all the disks to some another tower without violating
the sequence of arrangement. A few rules to be followed for Tower of Hanoi are:

Rules

 Only one disk can be moved among the towers at any given time.
 Only the "top" disk can be removed.
 No large disk can sit over a small disk.

Figure 1.9Step by Step Moves in Solving Three Disk Tower of Hanoi Problem

Algorithm:

To write an algorithm for Tower of Hanoi, first we need to learn how to solve this problem
with lesser amount of disks, say → 1 or 2. We mark three towers with name, source,
destination and aux (only to help moving the disks). If we have only one disk, then it can
easily be moved from source to destination tower.

If we have 2 disks −

 First, we move the smaller (top) disk to aux tower.

 Then, we move the larger (bottom) disk to destination tower.
 And finally, we move the smaller disk from aux to destination tower.

So now, we are in a position to design an algorithm for Tower of Hanoi with more than two
disks. We divide the stack of disks in two parts. The largest disk (nth disk) is in one part and
all other (n-1) disks are in the second part.

Our ultimate aim is to move disk n from source to destination and then put all other (n-1)
disks onto it. We can imagine to apply the same in a recursive way for all given set of disks.
The steps to follow are −
Step 1 − Move n-1 disks from source to
aux Step 2 − Move nth disk from source to
dest Step 3 − Move n-1 disks from aux to
dest
A recursive Step based algorithm for Tower of Hanoi can be driven as follows −

Step 1: BEGIN Hanoi(disk, source, dest, aux)

Step 2: IF disk == 1 THEN go to step 3 ELSE go to step 4
Step 3: move disk from source to dest AND go to step 8
Step 4: CALL Hanoi(disk - 1, source, aux, dest)
Step 6: move disk from source to dest
Step 7: CALL Hanoi(disk - 1, aux, dest, source)
Step 8: END Hanoi
A recursive Pseudocodefor Tower of Hanoi can be driven as follows –

Procedure Hanoi(disk, source, dest, aux)

IF disk == 1 THEN
move disk from source to dest
ELSE
Hanoi(disk - 1, source, aux, dest) // Step 1
move disk from source to dest // Step 2
Hanoi(disk - 1, aux, dest, source) // Step 3
END IF
END Procedure

Figure 1.10Flow Chart for Tower of Hanoi Algorithm

Tower of Hanoi puzzle with n disks can be solved in minimum 2n−1 steps.