Browse topic-based Data Structure And Algorithm practice sets.
302 practice sets · Page 7 of 16
Find the maximum sub-array sum for the given elements. {-2, -1, -3, -4, -1, -2, -1, -5, -4}
-3
5
3
-1
Correct Answer: D — -1
Explanation:
All the elements are negative. So, the maximum sub-array sum will be equal to the largest element. The largest element is -1 and therefore, the maximum sub-array sum is -1.
Find the maximum sub-array sum for the given elements. {2, -1, 3, -4, 1, -2, -1, 5, -4}
3
5
8
6
Correct Answer: B — 5
Explanation:
The maximum sub-array sum is 5.
Given a one-dimensional array of integers, you have to find a sub-array with maximum sum. This is the maximum sub-array sum problem. Which of these methods can be used to solve the problem?
Dynamic programming
Two for loops (naive method)
Divide and conquer
Dynamic programming, naïve method and Divide and conquer methods
Correct Answer: D — Dynamic programming, naïve method and Divide and conquer methods
Explanation:
Dynamic programming, naïve method and Divide and conquer methods can be used to solve the maximum sub array sum problem.
Which of the following lines should be inserted to complete the above code?
arr[row][k] - arr[k + 1][col] + mat[row - 1] * mat[k] * mat[col];
arr[row][k] + arr[k + 1][col] - mat[row - 1] * mat[k] * mat[col];
arr[row][k] + arr[k + 1][col] + mat[row - 1] * mat[k] * mat[col];
arr[row][k] - arr[k + 1][col] - mat[row - 1] * mat[k] * mat[col];
Correct Answer: C — arr[row][k] + arr[k + 1][col] + mat[row - 1] * mat[k] * mat[col];
Explanation:
The line arr[row][k] + arr[k + 1][col] + mat[row - 1] * mat[k] * mat[col] should be inserted to complete the above code.
Consider the brute force implementation in which we find all the possible ways of multiplying the given set of n matrices. What is the time complexity of this implementation?
O(n!)
O(n^{3})
O(n^{2})
Exponential
Correct Answer: D — Exponential
Explanation:
The time complexity of finding all the possible ways of multiplying a set of n matrices is given by (n-1)^{th} Catalan number which is exponential.
Consider the matrices P, Q, R and S which are 20 x 15, 15 x 30, 30 x 5 and 5 x 40 matrices respectively. What is the minimum number of multiplications required to multiply the four matrices?
6050
7500
7750
12000
Correct Answer: C — 7750
Explanation:
The minimum number of multiplications required is 7750.
Consider the matrices P, Q and R which are 10 x 20, 20 x 30 and 30 x 40 matrices respectively. What is the minimum number of multiplications required to multiply the three matrices?
18000
12000
24000
32000
Correct Answer: A — 18000
Explanation:
The minimum number of multiplications are 18000. This is the case when the matrices are parenthesized as (P*Q)*R.
Consider the two matrices P and Q which are 10 x 20 and 20 x 30 matrices respectively. What is the number of multiplications required to multiply the two matrices?
10*20
20*30
10*30
102030
Correct Answer: D — 102030
Explanation:
The number of multiplications required is 102030.
Which of the following is the recurrence relation for the matrix chain multiplication problem where mat[i-1] * mat[i] gives the dimension of the ith matrix?
dp[i,j] = 1 if (i=j dp[i,j] = min{dp[i,k] + dp[k+1,j]})
dp[i,j] = 0 if (i=j dp[i,j] = min{dp[i,k] + dp[k+1,j]})
dp[i,j] = 1 if (i=j dp[i,j] = min{dp[i,k] + dp[k+1,j]} + mat[i-1]*mat[k]*mat[j]).
dp[i,j] = 0 if (i=j dp[i,j] = min{dp[i,k] + dp[k+1,j]} + mat[i-1]*mat[k]*mat[j]).
Correct Answer: D — dp[i,j] = 0 if (i=j dp[i,j] = min{dp[i,k] + dp[k+1,j]} + mat[i-1]*mat[k]*mat[j]).
Explanation:
The recurrence relation is given by:
dp[i,j] = 0 if i=j
(dp[i,j] = min{dp[i,k] + dp[k+1,j]} + mat[i-1]*mat[k]*mat[j]).
Which of the following methods can be used to solve the matrix chain multiplication problem?
Dynamic programming
Brute force
Recursion
Dynamic Programming, Brute force, Recursion
Correct Answer: D — Dynamic Programming, Brute force, Recursion
Explanation:
Dynamic Programming, Brute force, Recursion methods can be used to solve the matrix chain multiplication problem.
Which of the following lines completes the above code?
strrev(str2)
str2 = str1
len2 = strlen(str2)
strlen(str2)
Correct Answer: A — strrev(str2)
Explanation:
To find the longest palindromic subsequence, we need to reverse the copy of the string, which is done by strrev.
Longest palindromic subsequence is an example of ______________
Greedy algorithm
2D dynamic programming
1D dynamic programming
Divide and conquer
Correct Answer: B — 2D dynamic programming
Explanation:
Longest palindromic subsequence is an example of 2D dynamic programming.
For every non-empty string, the length of the longest palindromic subsequence is at least one.
True
False
Correct Answer: A — True
Explanation:
A single character of any string can always be considered as a palindrome and its length is one.
What is the time complexity of the brute force algorithm used to find the length of the longest palindromic subsequence?
O(1)
O(2^{n})
O(n)
O(n^{2})
Correct Answer: B — O(2^{n})
Explanation:
In the brute force algorithm, all the subsequences are found and the length of the longest palindromic subsequence is calculated. This takes exponential time.
What is the length of the longest palindromic subsequence for the string "ababcdabba"?
6
7
8
9
Correct Answer: B — 7
Explanation:
The longest palindromic subsequence is "abbabba" and its length is 7.
For which of the following, the length of the string is not equal to the length of the longest palindromic subsequence?
A string that is a palindrome
A string of length one
A string that has all the same letters(e.g. aaaaaa)
Some strings of length two
Correct Answer: D — Some strings of length two
Explanation:
A string of length 2 for eg: ab is not a palindrome.
Which of the following is not a palindromic subsequence of the string "ababcdabba"?
abcba
abba
abbbba
adba
Correct Answer: D — adba
Explanation:
'adba' is not a palindromic sequence.
Which of the following methods can be used to solve the longest palindromic subsequence problem?
Dynamic programming
Recursion
Brute force
Dynamic programming, Recursion, Brute force
Correct Answer: D — Dynamic programming, Recursion, Brute force
Explanation:
Dynamic programming, Recursion, Brute force can be used to solve the longest palindromic subsequence problem.
In the brute force implementation to find the longest increasing subsequence, all the subsequences of a given sequence are found. All the increasing subsequences are then selected and the length of the longest subsequence is found. What is the time complexity of this brute force implementation?
O(n)
O(n^{2})
O(n!)
O(2^{n})
Correct Answer: D — O(2^{n})
Explanation:
The time required to find all the subsequences of a given sequence is 2^{n}, where 'n' is the number of elements in the sequence. So, the time complexity is O(2^{n}).
The number of increasing subsequences with the longest length for the given sequence are: {10, 9, 8, 7, 6, 5}
3
4
5
6
Correct Answer: D — 6
Explanation:
Each array element individually forms a longest increasing subsequence and so, the length of the longest increasing subsequence is 1. So, the number of increasing subsequences with the longest length is 6.
