Problem Solving Approach

PROBLEM SOLVING APPROACH LECTURE NOTES

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

SEMESTER: I YEAR: Jan 2020 – April 2020

1|Page Department of Computer science and Engineering

 Syllabus:

U20EST109 PROBLEM SOLVING APPROACH L T P C Hrs

(Common to CSE,IT,CCE) 3 0 0 3 45

Course Objectives
 To identify the key concepts of computational thinking and problemsolving.
 To know the basics of algorithm and dataorganization.
 To understand the fundamental algorithms and factoringmethods.
 To know the basic concepts of array and problem solvingtechniques.
 To familiarize the concepts of text processing, pattern searching and
recursivealgorithms.

Course Outcomes
After completion of the course, the students will be able to
CO1 - Explain the basic concepts of computational thinking and problem solving. (K2)
CO2 - Explain basic concepts of algorithm and data organization. (K2)
CO3 - Illustrate algorithmic solution to problem solving. (K3)
CO4 - Explain the concepts of array, merging, sorting & searching. (K2)
CO5 - Implement recursive algorithm to solve problems. (K3)

UNITI INTRODUCTION (9Hrs)

Computational Thinking - Information and Data - Converting Information into Data –
Data Capacity – Data Types and Encoding – Logic-Solving Problems – Limits of
Computation – Pseudocode and FlowChart.

UNIT II ALGORITHMIC THINKING &DATAORGANIZATION (9 Hrs)

Algorithmic Thinking: Algorithms – Software and Programming Languages – Actions.
Data Organization: Name list, Graph Hierarchies – Spread Sheets – Text processing –
Patterns – Pseudocode and FlowChart.

UNIT III FUNDAMENTAL ALGORITHMS &FACTORINGMETHODS (9

Hrs)
Fundamental Algorithms: Exchanging – Counting – Summing – Factorial Computation
– Fibonacci Sequence – Reversing the Digit-Base Conversion – Character to number
conversion. Factoring Methods: Finding Square Root – Greatest Common Divisor –
Prime Number – Prime Factor –Pseudocode and FlowChart.

UNIT IV ARRAY, MERGING, SORTINGANDSEARCHING (9 Hrs)

Array Techniques: Introduction – Array order reversal – Array Counting or
Histogramming – Maximum and Minimum of a Set – Removal of Duplicate –
Partitioning – Longest monotone. Sorting and searching: Sorting by Bubble, Selection,
Insertion. Searching: Linear, Binary – Pseudocode and FlowChart.

UNIT V TEXT PROCESSING, PATTERN SEARCHING

&RECURSIVEALGORITHM (9Hrs)
Key word Searching – Text Line Adjustment – Linear Pattern Search – Sub Linear
Pattern Search.Recursion: Towers of Hanoi – Sample Generation – Combination
Generation – Permutation Generation – Pseudocode and FlowChart.
Text Books
1. David Riley and Kenny Hunt, “Computational Thinking for Modern Problem
Solver”, Chapman & Hall / CRC Textbooks in Computing,2014.
2. R. G.Dromey, “How to solve it by Computer”, PHI,2008.
3. Vickers Paul, “How to Think like a Programmer: Problem Solving for the
Bewildered”, Cengage Learning EMEA, 2008.

Reference Books
1. V. Anton Spraul, “Think Like a Programmer: An Introduction to Creative Problem
Solving”, Cengage
Learning EMEA, 2012.
2. Harold Abelson & Gerald Jay Sussman, “Structure and Interpretation of Computer
Programs”, McGraw- Hill Book Company, 1997.
3. Don McAdam, Roger Winn,” A Problem-Solving Approach”, Prentice Hall Canada;
2nd Edition.
4. Kathryn Rentz, Paula Lentz, “A Problem-solving Approach “, McGraw-Hill
Education, 2018.
5. Sham Tickoo “A Problem-solving Approach”, Delmar / Cengage Learning, 2009.

Web References
1. https://www.edx.org/learn/problem-solving
2. https://www.lynda.com/Business-Skills-tutorials/Problem-Solving-
Techniques/553700-2.html
3. https://www.classcentral.com/course/problem-solving-skills-6687
 UNIT - V

UNIT V TEXT PROCESSING, PATTERN SEARCHING

&RECURSIVEALGORITHM (9Hrs)
Key word Searching – Text Line Adjustment – Linear Pattern Search – Sub Linear Pattern
Search.Recursion: Towers of Hanoi – Sample Generation – Combination Generation – Permutation
Generation – Pseudocode and FlowChart.

Two Marks:
1. Define Key word Searching
Two words can be said to match when they agree character-for-character from the first to the
last character. It follows that if the number of character-for-character matches is equal to the
length of both the word sought and the text word then we have a match. For example,

2. Define Text line adjustment.

Read text until we have read n characters. The words completed at this point can then be
printed. We must remember that the input lines may contain less than n, n itself, or more than n
characters.
Consider diagrammatically what is involved when the process is beginning. In this case
assume that the required n is 40 characters.

3. What is linear Pattern Search?

To start on the efficient pattern searching algorithm, let us first examine the simple
pattern matching algorithm more closely.

In this example, the match between the pattern and the string proceeds until we get a
mismatch with the d and the c in the sixth position.

4. What is Sub linear Pattern Search?

Sub linear pattern search is defined as implementing search operation for a given text for a
particular keyword or pattern and record the number of times the keyword or pattern is found.
5. Define Recursion.
Recursion is the process of repeating items in a self-similar way. In programming
languages, if a program allows you to call a function inside the same function, then it is called
a recursive call of the function.

6. List the rules of Towers of Hanoi problem?

The rules are:
1. Only one disk may be moved at a time.
2. A third pole may be used for temporary storage of disks.
3. No disk should ever be placed on top of a disk of smaller diameter.
4. The disks are arranged on the original pole initially with the largest disk on the bottom,
the second largest disk on top of it, and so on. The smallest disk ends up being on top of the
stack.

7. Define Sample Generation?

It is defined as generating all permutations of the first n integers taken r at a time and
allowing unrestricted repetitions. The values of n and r must be greater than zero.

8. Define Combination Generation?

It is defined as generating all combinations of the first n integers taken r at a time where n
and r are greater than or equal to 1.

9. Define Permutation Generation?

It is defined as generating all permutations of the first n integers taken r at a time where n
and rare greater than or equal to 1.

10. Define Pseudocode?

Pseudocode is an artificial and informal language that helps programmers develop
algorithms. Pseudocode is a "text-based" detail (algorithmic) design tool.
The rules of Pseudocode are reasonably straightforward. All statements showing
"dependency" are to be indented.
11. Define Flowchart?
A flowchart is simply a graphical representation of steps. It shows steps in sequential order
and is widely used in presenting the flow of algorithms, workflow or processes.
Typically, a flowchart shows the steps as boxes of various kinds, and their order by
connecting them with arrows.

PART B & C:
1. Explain in detail about Key word Searching in text.(10 Marks)
Problem
Count the number of times a particular word occurs in a given text.

Algorithm development
The text searching problem and related variations of it are commonly encountered in
computing. To give an example, we may wish to determine whether or not the word SENTENCE
occurs in the text:

For example,

A mismatch between two words must therefore mean that the two words are not the same
character-for-character or in other words the number of character-for-character matches is less
than the length of the two words.
For example, we have

From our discussion, we know that, in general, words are preceded by and followed by non-
alphabetic characters.
 It is easy enough after the pattern-match condition has been met to establish whether or not
the next character is alphabetic by simply making the set test

The steps to be taken when a mismatch occurs are therefore:

Algorithm description
1. Establish the word and wordlengthwlength of the search-word.
2. Initialize the match-count nmatches, set preceding character and set pointer for word
array i to 1.
3. While not at end-of-file do
(a) while not end-of-line do
(a.1) read next character;
(a.2) if current text character chr matches ith character in word then
(2.a) extend partial match i by 1,
(2.b) if a word-pattern match then
(b.1) read next character post,
(b.2) if preceding and following character not alphabetic then
(2.a) update match count nmatches,
(b.3) reinitialize pointer to word array i,
(b.4) save following character post as preceding character
else
(2'.a) save current text character as preceding character for match,
(2'.b) reset word array pointer i to first position;
(b) read past end-of-line.
4. Return word-match count nmatches.
The implementation has been designed to handle only lower-case alphabetic characters.

Pascal implementation
Notes on design
1. The dominant instruction for this algorithm will be the comparison of the current text
character with the current word character.
2. At the stage in the search when the first j characters have been read and processed all text
words that completely match the search word in the first j characters will have been
counted.
3. The present algorithm uses a very simple mechanism for the dominant part of the
computation.
4. For example, the present algorithm will not record a match in searching for the pattern
abcabdabc in the text abcabcabdabc.
5. At the cost of specialization, we have developed an algorithm with linear worst-case
behavior rather than the quadratic worst-case behavior that is possible for the corresponding
pattern matching algorithm.
6. In the implementation we have relied upon the fact that Pascal returns a blank when an
end-of-line character is encountered.
7. It is possible to implement significantly more efficient algorithms for solving both the
current problem and also the more general pattern matching problem.

Applications
Limited text searching.
2. Explain in detail about Text Line Adjustment or Text line Length Adjustment. (10
Marks) Problem
Given a set of lines of text of arbitrary length, reformat the text so that no lines of more than
n characters (e.g. 40) are printed.
In each output line the maximum number of words that occupy less than or n characters,
should be printed and no word should extend across two lines. Paragraphs should also remain
indented.

Algorithm development
Let us start thinking about the design for this problem by trying to isolate the basic
mechanisms. We could begin by reading text until we have read n characters. The words
completed at this point can then be printed. We must remember that the input lines may contain
less than n, n itself, or more than n characters.
Consider diagrammatically what is involved when the process is beginning. In this case
assume that the required n is 40 characters.

Let us start by reading 40 characters from the input and placing them in an array.

If we place the first character of the second input line in position 29 we will end up with:

Instead our first output line will only be 36 characters long.

For example, we could use:

With the information as to where the last full word ends the current line can be printed. We
are then left with ANO.

It could be achieved in the following way:

 Problem Solving Approach

The mechanism becomes:

Algorithm description
1. Establish the line length limit limit and add one to it to allow for a space.
2. Initialize word and line character counts to zero and end-of-line flag to false.
3. While not end-of-file do
(a) read and store next character;
(b) if character is a space then
(b.1) if a new paragraph then
(1.a) move to next line and reset character count for new line,
(b.2) add current word length to current line length,
(b.3) if current word causes line length limit to be exceeded then
(3.a) move to next line and set line length to current word length,
(b.4) write out current word and its trailing space and reinitial-ize character
count,
(b.5) turn off end-of-input-line flag,
(b.6) if at end-of-input-line then
(6.a) set end-of-input-line flag and move to next input line.

Pascal implementation

11 | P a g e Department of Computer science and

Engineering
Notes on design
1. The cost of reformatting text is linearly dependent on the number of characters in the
original text.
2. At the point when thejth character in the original text has been read all completed words
in the first j characters will have been output according to the reformatting requirements
established by the variable limit.
3. Focusing on the output of words rather than the output of lines of text leads to a clearer
and simpler algorithm.
4. Notice that the present algorithm handles punctuation and multiple spaces in the text in a
straightforward manner.
5. Comparing the final design with the earlier method we can see that we have managed to
set up simpler initialization and termination conditions.
6. A diagram, although helpful in solving this problem, has tended to influence us to focus
 on a line-oriented rather than a word-oriented solution to the problem.

Applications
Text processing, report writing and file management.

3. Explain in detail about Linear Pattern Search. (10

Marks) Problem
Design and implement a pattern searching algorithm with a performance that is linearly
dependent on the length of the string or text being searched. A count should be made of the
number of times the search pattern occurs in the string.

Algorithm development
To make a start on the more efficient pattern searching algorithm, let us first examine the
simple pattern matching algorithm more closely.

Let us look again more closely at our example to try to discover if there is an alternative
course of action after the mismatch at position 6.

To explore this we can place the pattern at consecutive positions rela-tive to the string. For
example,

Looking once more at our example with the pattern placed in various positions we see that
it would be valid to compare the third character in the pattern with the sixth character in the string
as this would introduce no risk of missing a possible match with the pattern positioned starting at
the fourth character.

To discover this let us look more closely at another pattern.

As a further example, suppose the first five characters in the pattern are matched at the
current location in the string and there is a mismatch at the sixth character. (See Fig. 6.1(c).)
 If the partial match table is called recover and the variable match gives the position in the
pattern when the mismatch occurs then the statement below gives us the new position in the
pattern.

Algorithm description
Description for both the search algorithm and the recovery setup algorithm are given in this
section.
(1) The partial-match table setup algorithm
1. Establish the search pattern.
2. Set initial displacement between the pattern and itself to one.
3. Initialize the zero and first positions in the partial match array to zero.
4. While all positions of pattern relative to itself not considered do
(a) if current pattern and displaced pattern character pairs match
then (a.1) save current degree of partial match,
(a.2) move to next position in pattern and the displaced pat-tern
 else
(a'.1) a mismatch so set partial match to zero,
(a'.2) reset pointer to start of displaced pattern,
(a'.3) move the start of the displaced pattern to the next avail-able position.
5. Return the partial match table.
(2) The linear pattern searching algorithm
1. Establish the pattern to be searched for and the string in which it is to be sought together
with the lengths of the pattern and the string.
2. Set initial values for start of pattern and string and zero the match count.
3. While all appropriate pattern positions in the string have not been examined do
(a) if current string and pattern characters match then
(a.1) extend indices to next pattern/string pair,
(a.2) if a complete match then
(2.a) update complete match count,
(2.b) reset recovery position from the partial match table
else
(a'.1) reset recovery position from the partial match table.
4. Return count of the number of complete matches of the pattern in the string.
(3) The procedure for recovering from mismatches and complete matches
1. Establish the partial match table, the current position in string and position in pattern.
2. If no smaller partial match then
(a) move to next position in string,
(b) return to start of pattern
else
(a') recover from mismatch or complete match by using table to set new smaller
partial match for current position in string.
3. Return smaller partial match and current pattern position.

Pascal implementation
Notes on design
1. In the algorithm for constructing the partial match table, the dominant step is the
character comparison between the pattern and the displaced pattern.
2. For the partial match procedure, after the iteration for a given value of position the
smaller partial matches for the first (position —1) values in the recover table will be
established.
3. Specific examples have been very helpful in uncovering the rather elusive and subtle
observations needed to solve this problem.
4. The algorithm performs correctly for patterns of length one.
5. Even in our algorithm as it stands, we have let a number of inefficiencies creep in for the
sake of clarity and simplicity.
6. The recovery function we have developed, although probably the easiest to understand, is
 not one that minimizes the number of comparisons made by the algorithm.
7. It is possible by constructing an appropriate finite state machine to develop a version of
this algorithm that examines each string character only once.

Applications
Pattern searching in small alphabet systems and multiple keyword searching in text.

4. Explain in detail about Sub Linear Pattern Search. (10

Marks) Problem
Design and implement an algorithm that will efficiently search a given text for a particular
keyword or pattern and record the number of times the keyword or pattern is found.

Algorithm development
In looking for the keyword SENTENCE in the text

In the example above we started off by seeing if the word SENTENCE could start at the
first character in the text, that is,

This is so because the eighth character is a blank and there is no blankin the word
SENTENCE (see Fig. 6.2).

For example,

For example,

That is, we could have the word SENTENCE fitted into the text as follows:
 Let us at this stage recap our progress through the text.

Our basic overall strategy for the central part of our algorithm is therefore:

For example:

Similarly we can arrive at the following skip list:

At this stage there is a problem about what to do when we hit an E or an R. We see that
there are three possible skips associated with E.
For example,

We must therefore decide whether a jump of 7, 4, or 1 is appropriate.

The situation we have is:

Algorithm description
1. Establish the word and text to be searched.
2. Set up the skip table.
 3. Set keyword match count to zero.
4. Set character position i to keyword length.
5. While current character position <textlength do
(a) get numeric value nxt of current character at position i,
(b) index into skip table at position nxt,
(c) if skip value for current character is greater than 0, then
(c.1) increase current position by skip value
else
(c'.1) backwards-match text and word,
(c'.2) if match made update match count,
(c'.3) recover from mismatch.
6. Return match count.

Pascal implementation
 Notes on design
1. Calculating the average case behavior for this algorithm is difficult because of its
dependence on the probability distributions of the text and the word or pattern sought.
th
2. For the searching algorithm, after the i character has been examined all complete
matches of the pattern with the text will have been established and nmatches will represent
the count of such matches at all times.
3. In the algorithm an attempt is made to make the best use of the information gained at
each step.
4. What seems the obvious way to tackle the problem can only lead to an inefficient
algorithm.
5. Table-driven algorithms (as in this case) are often very efficient.
6. The algorithm is more general than a word matching algorithm. It may be more correctly
classified as a pattern matching algorithm.
7. The algorithm is only set to work with ascii characters of the case of the input keyword.

Applications
Text editors, pattern matching, keyword searching.

5. Explain in detail about Recursion: Towers of Hanoi. (10 Marks)

Problem
Design and implement a recursive algorithm to solve the Tower of Hanoi problem for one
or more disks.

Algorithm development
The rules are:
1. Only one disk may be moved at a time.
2. A third pole may be used for temporary storage of disks.
3. No disk should ever be placed on top of a disk of smaller diameter.
4. The disks are arranged on the original pole initially with the largest disk on the
 bottom, the second largest disk on top of it, and so on. The smallest disk ends up
being on top of the stack.

To do this we will consider the case where 6 disks have to be moved from the originpole to
the finalpole.

Let us now reassess this new situation. We have made some progress (with assumptions)
in that the biggest disk is where we want it but there are still 5 other disks in the wrong place.
 If, in general, there are ndisks to be transferred then our initial problem is to:

The problem of size 4 splits into two problems of size 3, which in turn each split into two
problems of size 2, etc.
 If the recursive procedure is called towershanoi and the number of disks to be transferred is
ndisks then the call can have the form:

For this problem, the role of the finalpole and the sparepole are interchanged. Noting this
fact the procedure call for step (a) will be:

The call can take the form:

This time the roles of the originpole and the sparepole are interchanged. The procedure call
will therefore have the form:

for example,

The transferdisk procedure then only needs two case statements, one to identify and print out
the originpole label and a second to identify and print out the finalpole label. The constructs can
have the form:

The body of the recursive procedure can be guarded by a statement of the form:

The Pascal implementation may then be:

To do this the guard will need to be changed to:

With this change the direct transfer for the problem of size 1 will need to be handled
separately. That is,

This modification eliminates the redundant calls for problems of size 1. A complete
description of the algorithm can now be given.

Algorithm description
(1) Towers of Hanoi procedure
1. Establish the number of disks to be transferred, the originpole, the sparepole, and
 the finalpole.
2. If current problem involves transfer of more than one disk then
(a) Recursively call function to transfer all disks except the bot-tom disk from
the current originpole to the sparepole,
(b) transfer the bottom disk from the originpole to the finalpole,
(c) recursively call function to transfer all disks from the sparepole to the
finalpole
else
(a') transfer current disk from the originpole to the finalpole.
(2) Transfer disk procedure
1. Establish the current originpole and finalpole labels.
2. Determine the identity of the current originpole label.
3. Write out the label for the current originpole.
4. Determine the identity of the current finalpole label.
5. Write out the label for the current finalpole indicating that the transfer has been
made to this pole.

Pascal implementations

Notes on design
1. The performance of the towershanoi procedure can be measured in terms of the number
 of transfers needed to move all disks from the originpole to the finalpole.
2. The characterization of the behavior of the towershanoi procedure can be done in terms
very similar to that used to describe the inorder tree traversal
3. In developing this algorithm, we have seen how looking at partial solutions to a problem
can guide us to a simple but powerful general solution.
4. In solving this problem we have done so by decomposing the original problem into two
smaller problems which are solved recursively and then combined to solve the original
problem.
5. Another way of looking at this problem is to say that recursion has allowed us to
postpone the solution of a large problem until a group of other smaller problems has been
solved.
6. We have seen how it is often useful to construct a diagram to model our algorithm's
behavior.
7. With recursion, we usually have several choices for termination. Compare the two Pascal
implementations given in terms of the procedure calls they make.
8. This example helped us to discover the underlying relationship be-tween the Towers of
Hanoi algorithm and inorder tree traversal.
9. This algorithm does not in itself have a practical application other than perhaps
measuring the life of the universe
11. Notice that every alternate move consists of a transfer of the smallest disk from one
pole to another.

6. Explain in detail about Sample Generation. (10

Marks) Problem
Design an algorithm that generates all permutations of the first n integers taken r at a time
and allowing unrestricted repetitions. This is sometimes referred to as sample generation. The
values of n and r must be greater than zero.

Algorithm development
Suppose n refers to the first 5 integers and they are to be sampled 3 at a time (i.e. r = 3).
The first few, and last unrestricted permutations of this set, are listed in Fig. 8.14.
As an aside, it is worth noting that if the integers are restricted to 0 and 1, then for a given r
the set of permutations with restricted repetitions will correspond to the r-bit binary
representations of the first 2' integers (including zero).

Furthermore, since the values inthe third column extend over their complete range for each
change in the second column, we can conclude that this particular problem could be solved with
three nested loops of the form:
 The first step towards a solution to the general problem might therefore take the form:

Basic steps in our mechanism might therefore be:

To ensure that the array element associated with thekth column column[k] takes on its
appropriate set of values we can insert the following statement in the main loop of our mechan-ism:

Before entering the loop column[k] will need to be initialized to zero. If we give our
recursive procedure the name sample and include the refinements suggested above we will have

Our discussion suggests that whenever k = r we will be able to print the next permutation.
We can therefore insert the following statements in the loop of our procedure after updating the
column[k] value:
Algorithm description
1. Establish positive non-zero set size, permutation size, and array for storing permutations.
Also establish index to current column of permutaion set.
2. Initialize current column value to zero.
3. While current column index less than set size do
(a) increase current column value by one,
(b) if current column index not at final column then
(b.1) recursively call procedure to generate all the next column values
associated with current column value
else
(b'.1) new permutation available in array so write it out.
Pascal Implementation
 Notes on design
1. The number of times the conditional test in the loop is executed gives us a measure of the
time complexity of this algorithm (this is equal to the number of nodes in our mechanism
tree).
2. To characterize the behavior of this procedure involving non-linear recursion, let us
consider first the case where the call is made to sample(k+ 1
3. Notice with this algorithm how the solution to a large problem is built up by solving a
succession of smaller interrelated problems.
4. The impractical iterative solution to a specific problem was helpful in guiding us to a
general recursive solution to the problem.
5. When a solution to a problem appears to demand a variable number of nested loops, it is
usually advisable to see if it is possible to solve the problem using non-linear recursion.
6. In the procedure sample, we have chosen to include only the variable k as a parameter for
reasons of efficiency.

Applications
Combinatorics, generation of sequences of numbers with a given base, simulations.

7. Explain in detail about Combination Generation. (10

Marks) Problem
Design an algorithm that generates all combinations of the first n integers taken r at a time
where n and r are greater than or equal to 1.

Algorithm development
There are many occasions in computing science and probability theory applications where
n
we want to know the number of possible ways (written Cr) for choosing a subset of r objects from
a set of n objects.
To simplify the argument let us concentrate on developing an algorithm that will generate
all combinations of the first n integers taken r at a time.
To get a feel for what is involved let us consider a specific example, perhaps that of
generating all combinations of size 3 using the first 5 integers. Note that when dealing with
combinations (as opposed to permutations) of objects, order plays no part. For example, the
sequences {1, 2, 3}, {2, 1, 3} and {3, 1, 2} all represent a single combination. It is not very difficult
to show that the ten combinations of the first five integers taken three at a time are:

The central part of our algorithm for generating combinations of size 3 from the first 5
integers may therefore have the form:

With these changes we get:

We can write down a loop to generate these values as before. The inner loops have been
replaced by a general statement.

If our original procedure is called combinations then we might have:

If the array column is used to store column values of the column set then the starting value
for the kth column in the current situation will be:

Generalizing this, we would expect that the upper limit for the kth column is:

To increment the value of the kth column we can use:

Using this idea and relating the lower limit to the previous column, the loop written
generally will have the form:

Using a line of reasoning similar to that used in the previous algorithm, we see that our
recursive algorithm only makes an update to the rth column when:

Our algorithm essentially makes an inorder traversal of the tree

Our preceding discussion has led us to the conclusion that whenever k = r a new
combination will be available for printing. To print the current combination we can use:
 These steps can be inserted directly after the point where the kth column is updated.

Algorithm description
1. Establish positive non-zero set size, combination size, and array for storing
combinations. Also establish index to current column of combination set.
2. Initialize current column value to current value of previous column.
3. While current column value is less than its upper limit do
(a) increase current column value by one;
(b) if current column not final column then
(b.1) recursively call procedure to generate all the next column values
associated with the current column value
else
(b'.1) new combination available in array so write it out.

Pascal implementation
 Notes on design
1. The number of times the conditional test in the loop is executed gives us a measure of the
time complexity of this algorithm. In this case, there are therefore 5C3+4C2+3C1 = 19
nodes. In the general case, there will be

The depth of recursion is r.

2. To characterize the behavior of this non-linear recursive procedure, let us consider first
the case where the call is made to combinations(k+ 1).
3. With this algorithm, like the preceding one, how the solution to a larger problem is built
up by solving a succession of inter-related smaller problems.
4. The impractical iterative solution to a specific problem was helpful in guiding us to a
general recursive solution to the problem.
5. A set of r nested loops can be replaced by a recursive procedure that calls itself r times.
Many problems can be solved in this way.
6. In the implementation, we have chosen to include only the variable k as a parameter for
reasons of efficiency.
Applications
Combinatorics, applications of probability theory.

8. Explain in detail about Permutation Generation. (10

Marks) Problem
Design an algorithm that generates all permutations of the first n integers taken r at a time
where n and rare greater than or equal to 1.

Algorithm development
Unlike the combinations' situation, order is important and so sequen-ces like {1, 2, 3}, {2,
1, 3} and {3, 1, 2} all represent distinct permutations.
Some of the permutations of the first 5 integers taken 3 at a time are:

The explorations we have made suggest that we may tentatively describe the required
algorithm as follows:

We can summarize our progress with the following outline for a permutation generation
algorithm:

Suppose the first permutation generated for n = 4 is:

 The next permutation will be:

With this addition to our algorithm it should function correctly. The step to be added to the
loop is:

To try to discover a method let us again focus on the steps for going from the first to the
second permutation for n = 4

These two permutations only differ in the order of their last two elements. Our present
algorithm must execute the test

four times to go from the first to the second permutation.

For example, for the 5P3 case when we have the first two columns set as below:

then the possible choices for the third column are:

That is, we could have:

Our task, then, to generate a new permutation will involve exchanging values back and
forth between the chosen and unchosen sets, i.e. schematically our mechanism will involve

Having established these choices we might propose the following loop structure:
 At this point our mechanism produces:

which means that column[2] is prevented from assuming the value 1. Instead, at this point
we want the configuration below.

Algorithm description
1. Establish set size, permutation size, and array for storing permutations (it must be equal
in length to the set size rather than the permutation size). Also establish index to current
column of permutation set.
2. While all available values for current column not selected do
(a) exchangejth value from unchosen set with current column value,
(b) if current column index not at final column then
(b.1) recursively call procedure to generate all the next column values
associated with the current representation for all columns up to the current
column,
else
(b'.1) new permutation available so write it out, (c) reverse the exchange
made in step (a).

Pascal implementation
Notes on design
1. When we study the mechanism tree for this algorithm we see that its time complexity is
proportional to
2. We can characterize the behavior of this algorithm using arguments very similar to those
used in characterizing the previous two algorithms. This is left as an exercise for the reader.
3. In studying our final implementation we notice that it has some built-in inefficiencies.
4. A common problem involving permutations is to generate all permutations of n objects
taken n at a time.
5. Our final implementation, although more efficient than our earlier proposal, has only
been able to gain this efficiency by sacrificing lexical output of the permutations
6. Note that algorithms for generating permutations in lexical order are inherently less
efficient than other algorithms because they must often use more than one exchange to go
from one permutation to the next.
7. In solving this problem once again we have seen how the final solution has been built
from the solution of simpler problems.
8. With our final algorithm, there are two exchanges in the body of the loop.

Applications
Combinatorial problems, simulation.