Longest Common Substring in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Longest Common Substring Length Calculation

What is the output of the following C code that calculates the length of the longest common substring between two strings?

DSA C

int longestCommonSubstring(char *s1, char *s2) {
    int maxLen = 0;
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int dp[len1+1][len2+1];
    for (int i = 0; i <= len1; i++) {
        for (int j = 0; j <= len2; j++) {
            dp[i][j] = 0;
        }
    }
    for (int i = 1; i <= len1; i++) {
        for (int j = 1; j <= len2; j++) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > maxLen) {
                    maxLen = dp[i][j];
                }
            } else {
                dp[i][j] = 0;
            }
        }
    }
    return maxLen;
}

int main() {
    char s1[] = "abcdef";
    char s2[] = "zcdemf";
    printf("%d", longestCommonSubstring(s1, s2));
    return 0;
}

A 3

B 2

C 4

D 1

💡 Hint

Check the longest continuous matching substring between the two strings.

The longest common substring between "abcdef" and "zcdemf" is "cde" which has length 3.

🧠 Conceptual

intermediate

Understanding the Difference Between Longest Common Substring and Longest Common Subsequence

Which statement correctly describes the difference between the longest common substring and the longest common subsequence of two strings?

A Longest common subsequence requires characters to be contiguous in both strings, while longest common substring does not.

B Longest common substring requires characters to be contiguous in both strings, while longest common subsequence does not.

C Both require characters to be contiguous in both strings.

D Neither requires characters to be contiguous in both strings.

💡 Hint

Think about whether the characters must be next to each other or can be spread out.

Longest common substring needs the matching characters to be next to each other in both strings. Longest common subsequence allows characters to be in order but not necessarily contiguous.

🔧 Debug

advanced

Identify the Bug in Longest Common Substring Implementation

What error will the following C code produce when run, and why?

DSA C

int longestCommonSubstring(char *s1, char *s2) {
    int maxLen = 0;
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int dp[len1][len2];
    for (int i = 0; i < len1; i++) {
        for (int j = 0; j < len2; j++) {
            dp[i][j] = 0;
        }
    }
    for (int i = 1; i <= len1; i++) {
        for (int j = 1; j <= len2; j++) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > maxLen) {
                    maxLen = dp[i][j];
                }
            } else {
                dp[i][j] = 0;
            }
        }
    }
    return maxLen;
}

A Segmentation fault due to accessing dp out of bounds.

B Compilation error due to missing header files.

C Returns 0 always because dp is never updated.

D Runs correctly and returns the longest common substring length.

💡 Hint

Check the size of dp and the indices used to access it.

The dp array is declared with size [len1][len2], but the code accesses dp[i][j] where i and j go up to len1 and len2 inclusive, causing out-of-bounds access and segmentation fault.

🚀 Application

advanced

Longest Common Substring in DNA Sequences

Given two DNA sequences, which approach is best to find the longest common substring efficiently?

A Use recursion without memoization to explore all substring matches.

B Use a brute force approach checking all substrings of one sequence in the other.

C Use dynamic programming with a 2D array to track matching substrings.

D Use a hash set to store all substrings of the first sequence and check the second.

💡 Hint

Consider time complexity and memory usage for large sequences.

Dynamic programming with a 2D array efficiently computes the longest common substring in O(n*m) time, suitable for DNA sequences. Brute force and recursion are too slow, and hash sets are inefficient for substring matching.

🧠 Conceptual

expert

Time Complexity of Longest Common Substring Algorithm

What is the time complexity of the standard dynamic programming algorithm to find the longest common substring of two strings of lengths n and m?

A O(max(n, m))

B O(n + m)

C O(n^2 * m^2)

D O(n * m)

💡 Hint

Consider the nested loops iterating over both strings.

The algorithm uses two nested loops each running up to n and m, resulting in O(n * m) time complexity.