# CSCI-B 505 Applied Algorithms (3 cr.) № 5 solution

\$25.00

Category:

## Description

Problem 1: Pattern-matching: The brute-force
Problem 1.1: The brute-force pattern-matching algorithm [10 pt.]
Describe a text D and a pattern P such that the brute-force pattern-matching algorithm runs in
Ω(dp) time.The lengths of D and P are d and p, respectively.
Problem 1.2: Python’s str class and pattern-matching [20 pt]
In this part, you are asked to modify three pattern matching programs given to you (See appendix). Run your modified programs for varying-length patterns and show your results.
The count method in Python’s str class takes a text D and a pattern P and returns the
maximum number of non-overlapping occurrences of a P within D. As an example ‘cdcdcdcdc’.count(‘cdc’) returns 2.
1. Modify the brute-force pattern-matching to return non-overlapping occurrences of a P
within D.
2. Similar to the previous question (Problem 1.2.1), do the same on the Boyer-Moore program.
3. Similar to problem 1.2.1, modify the KMP program.
Problem 2: Experimental Analysis of Pattern-Matching Algorithms
[20 pt.]
Perform an experimental analysis of pattern matching algorithms in terms of:
1. Number of character comparison: Perform an experimental analysis of the efficiency of
the brute-force, the KMP and Boyer-Moore pattern matching algorithms for varying-length
patterns.
2. Relative speed comparison: Perform an experimental comparison of the brute-force, KMP,
and Boyer-Moore pattern-matching algorithms. Run each algorithm against large text documents using varying-length patterns and report the relative running times.
Assignment № 5 Page 2
Problem 3: Matrix-chain Multiplication
The matrix-chain multiplication problem: Given a chain of < D1, D2, . . . , Dn > of n matrices fully
parenthesize the product < D1 ·D2 · · · Dn > in a way so that the number of scalar multiplications
is minimized. Each Di has a pi−1 × pi dimension and i = 1, 2, . . . , n.
1. The Brute-Force: [10 pt.]: Implement a Python program to solve the matrix-chain multiplication problem by the brute force algorithm.
2. Bottom-up Dynamic Programming [20 pt.]: Implement a Python program to solve the
matrix-chain multiplication problem using bottom-up dynamic programming approach.
3. Dynamic Programming with Memoization [Extra Credit, 10 pt.]: Implement a Python program to solve the matrix-chain multiplication problem using dynamic programming with
memoization.
Problem 4: Longest Common Sub-sequence (LCS) Problem [20 pt.]
Implement a Python program to solve LCS problem using dynamic programming. Run your
program to find the best sequence alignment between DNA strings. Show your results.
Longest Common Sub-sequence (LCS) problem: Given two character strings over some
alphabet, find a longest string that is a sub-sequence of given two strings.
Data source: https://www.ncbi.nlm.nih.gov/genbank/
Directions
run them with a variety of inputs and discuss your findings. This homework is due Sunday, Nov
14, 2021 10:00pm. OBSERVE THE TIME. Absolutely no homework will be accepted after that
time. All the work should be your own.
Assignment № 5 Page 3
Appendix
Python program for the Brute-Force pattern-matching algorithm
1 # Brute force
2 def find_brute (T , P ) :
3 n , m = len( T ) , len ( P )
4 # every starting position
5 for i in range (n – m +1) :
6 k = 0
7 # conduct O(k) comparisons
8 while k < m and T [ i + k ] == P [ k ]:
9 k += 1
10 if k == m :
11 return i
12 return -1
Python program for the Boyer-Moore pattern-matching algorithm
1 # Boyer – Moore
2 def find_boyer_moore (T , P ) :
3 n , m = len( T ) , len ( P )
4 if m == 0:
5 return 0
6 last = {}
7 for k in range ( m ) :
8 last [ P [ k ]] = k
9 i = m -1
10 k = m -1
11 while i < n :
12 # If match , decrease i,k
13 if T [ i ] == P [ k ]:
14 if k == 0:
15 return i
16 else :
17 i -= 1
18 k -= 1
19 # Not match , reset the positions
20 else :
21 j = last . get ( T [ i ] , -1)
22 i += m – min (k , j +1)
23 k = m -1
24 return -1
Assignment № 5 Page 4
Python program for the Knuth-Morris-Pratt pattern-matching algorithm
1 # KMP failure function
2 def compute_kmp_fail ( P ) :
3 m = len( P )
4 fail =  * m
5 j = 1
6 k = 0
7 while j < m :
8 if P [ j ] == P [ k ]:
9 fail [ j ] = k +1
10 j += 1
11 k += 1
12 elif k > 0:
13 k = fail [k -1]
14 else :
15 j += 1
16 return fail
1 # KMP
2 def find_kmp (T , P ) :
3 n , m = len( T ) , len ( P )
4 if m == 0:
5 return 0
6 fail = compute_kmp_fail ( P )
7 # print ( fail )
8 j = 0
9 k = 0
10 while j < n :
11 if T [ j ] == P [ k ]:
12 if k == m -1:
13 return j – m +1
14 j += 1
15 k += 1
16 elif k > 0:
17 k = fail [k -1]
18 else :
19 j += 1
20 return -1
Assignment № 5 Page 5