Longest Common Substring in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Longest Common Substring Length Calculation

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

DSA Rust

fn longest_common_substring(s1: &str, s2: &str) -> usize {
    let bytes1 = s1.as_bytes();
    let bytes2 = s2.as_bytes();
    let mut max_len = 0;
    let mut dp = vec![vec![0; bytes2.len() + 1]; bytes1.len() + 1];

    for i in 1..=bytes1.len() {
        for j in 1..=bytes2.len() {
            if bytes1[i - 1] == bytes2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] + 1;
                if dp[i][j] > max_len {
                    max_len = dp[i][j];
                }
            }
        }
    }
    max_len
}

fn main() {
    let s1 = "ababc";
    let s2 = "babca";
    println!("{}", longest_common_substring(s1, s2));
}

A 2

B 4

C 5

D 3

💡 Hint

Trace the dynamic programming table to find the longest matching substring.

The longest common substring between "ababc" and "babca" is "bab" which has length 3.

The code uses a 2D table to track matching characters and updates the maximum length found.

🧠 Conceptual

intermediate

Understanding the Purpose of the DP Table in Longest Common Substring

In the dynamic programming approach to find the longest common substring, what does each cell dp[i][j] represent?

A The starting index of the longest common substring in s1

B The length of the longest common substring ending at s1[i-1] and s2[j-1]

C The length of the longest common subsequence up to s1[i-1] and s2[j-1]

D The total number of common substrings between s1 and s2 up to indices i and j

💡 Hint

Think about what information is needed to build the solution step-by-step.

Each dp[i][j] stores the length of the longest common substring that ends exactly at s1[i-1] and s2[j-1].

This helps to extend substrings character by character.

🔧 Debug

advanced

Identify the Error in Longest Common Substring Implementation

What error does the following Rust code produce when compiled and run?

DSA Rust

fn longest_common_substring(s1: &str, s2: &str) -> usize {
    let bytes1 = s1.as_bytes();
    let bytes2 = s2.as_bytes();
    let mut max_len = 0;
    let mut dp = vec![vec![0; bytes2.len()]; bytes1.len()];

    for i in 1..=bytes1.len() {
        for j in 1..=bytes2.len() {
            if bytes1[i - 1] == bytes2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] + 1;
                if dp[i][j] > max_len {
                    max_len = dp[i][j];
                }
            }
        }
    }
    max_len
}

fn main() {
    let s1 = "abc";
    let s2 = "abc";
    println!("{}", longest_common_substring(s1, s2));
}

A Index out of bounds panic at runtime

B Compilation error due to missing semicolon

C Returns 0 instead of correct length

D No error, outputs 3

💡 Hint

Check how dp vector is initialized and accessed.

The dp vector is initialized with size bytes1.len() x bytes2.len(), but the loops access dp[i][j] where i and j go up to bytes1.len() and bytes2.len() inclusive.

This causes an index out of bounds panic at runtime.

🚀 Application

advanced

Longest Common Substring Result After Updates

Given the strings s1 = "abcdefg" and s2 = "xyzabcde", what is the longest common substring after changing s2 to "xyzabcdf"?

A "abcdf"

B "abcde"

C "abcd"

D "xyz"

💡 Hint

Compare substrings carefully after the last character change.

Original s2 ends with "abcde" matching s1's start, length 5.

After changing last character to 'f', the common substring is "abcd" of length 4.

🧠 Conceptual

expert

Time Complexity of Longest Common Substring Algorithm

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

A O(m * n)

B O(max(m, n))

C O(m^2 + n^2)

D O(m + n)

💡 Hint

Consider the nested loops iterating over both strings.

The algorithm uses a 2D table of size m x n and fills each cell once.

Thus, the time complexity is O(m * n).

Practice

1. What does the Longest Common Substring problem find between two strings?

easy

A. The longest sequence of characters that appears in both strings consecutively

B. The longest sequence of characters that appears in both strings but not necessarily consecutively

C. The total number of common characters between two strings

D. The longest string formed by combining both strings

Solution

1. Step 1: Understand the problem definition

   The Longest Common Substring problem looks for the longest continuous sequence of characters that appears in both strings without interruption.

2. Step 2: Differentiate from similar problems

   Unlike Longest Common Subsequence, which allows gaps, Longest Common Substring requires characters to be consecutive.

3. Final Answer:

   The longest sequence of characters that appears in both strings consecutively -> Option A

4. Quick Check:

   Longest Common Substring = consecutive matching characters [OK]

Hint: Look for continuous matching characters in both strings [OK]

Common Mistakes:

• Confusing substring with subsequence
• Thinking characters can be non-consecutive
• Counting total common characters instead of longest sequence

2. Which Rust code snippet correctly initializes a 2D vector for dynamic programming in Longest Common Substring?

easy

A. let mut dp = vec![vec![0; n + 1]; m + 1];

B. let dp = vec![vec![0; m]; n];

C. let mut dp = vec![vec![0; m + 1]; n];

D. let dp = vec![vec![0; n]; m + 1];

Solution

1. Step 1: Understand dimensions for DP table

   For strings of length m and n, dp table size should be (m+1) x (n+1) to include empty prefixes.

2. Step 2: Check Rust vector initialization syntax

   vec![vec![0; n + 1]; m + 1] creates m+1 rows each with n+1 zeros, matching DP table size.

3. Final Answer:

   let mut dp = vec![vec![0; n + 1]; m + 1]; -> Option A

4. Quick Check:

   DP table size = (m+1) x (n+1) [OK]

Hint: DP table size = (length+1) for both strings [OK]

Common Mistakes:

• Swapping m and n in vector sizes
• Forgetting +1 for empty string row/column
• Using immutable vector when mutability is needed

3. What is the output of this Rust code snippet for strings s1 = "abcde" and s2 = "abfde"?

let s1 = "abcde";
let s2 = "abfde";
let m = s1.len();
let n = s2.len();
let mut dp = vec![vec![0; n + 1]; m + 1];
let mut max_len = 0;
for i in 1..=m {
    for j in 1..=n {
        if s1.as_bytes()[i - 1] == s2.as_bytes()[j - 1] {
            dp[i][j] = dp[i - 1][j - 1] + 1;
            if dp[i][j] > max_len {
                max_len = dp[i][j];
            }
        }
    }
}
println!("{}", max_len);

medium

A. 3

B. 4

C. 2

D. 1

Solution

1. Step 1: Compare characters and fill DP table

   Matching characters are 'a' and 'b' at start, then 'd' and 'e' at the end. The longest continuous match is "ab" with length 2.

2. Step 2: Track max_len during iteration

   max_len updates to 1 for 'a', then 2 for 'b', resets for mismatch, then 1 for 'd' and 1 for 'e'. So max_len = 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Longest common substring length = 2 [OK]

Hint: Check consecutive matches, longest is "ab" length 2 [OK]

Common Mistakes:

• Counting non-consecutive matches
• Confusing substring length with subsequence length
• Ignoring reset of dp on mismatch

4. Identify the bug in this Rust code snippet for Longest Common Substring:

let s1 = "hello";
let s2 = "yellow";
let m = s1.len();
let n = s2.len();
let mut dp = vec![vec![0; n]; m];
let mut max_len = 0;
for i in 1..=m {
    for j in 1..=n {
        if s1.as_bytes()[i - 1] == s2.as_bytes()[j - 1] {
            dp[i][j] = dp[i - 1][j - 1] + 1;
            if dp[i][j] > max_len {
                max_len = dp[i][j];
            }
        }
    }
}
println!("{}", max_len);

medium

A. Loop ranges should start from 0, not 1

B. DP vector size is incorrect; should be (m+1) x (n+1)

C. Comparison should use chars(), not as_bytes()

D. max_len should be initialized to 1, not 0

Solution

1. Step 1: Check DP vector initialization

   DP vector is initialized with size m x n, but loops access dp[i][j] with i and j starting at 1, causing out-of-bounds error.

2. Step 2: Correct DP vector size

   DP vector should be sized (m+1) x (n+1) to safely access dp[i][j] for i and j in 1..=m and 1..=n.

3. Final Answer:

   DP vector size is incorrect; should be (m+1) x (n+1) -> Option B

4. Quick Check:

   DP size must match loop indices [OK]

Hint: DP size = (length+1) to avoid index errors [OK]

Common Mistakes:

• Using wrong DP vector size causing panic
• Starting loops at 0 but indexing with i-1
• Confusing bytes and chars for comparison

5. Given two strings s1 = "ababc" and s2 = "babca", write a Rust function to find the longest common substring and return it. What is the correct longest common substring?

hard

A. "bab"

B. "babc"

C. "abca"

D. "abc"

Solution

1. Step 1: Use DP to find longest common substring length and end index

   By comparing characters and updating dp, the longest common substring length is 3, ending at index 4 in s1.

2. Step 2: Extract substring from s1 using end index and length

   Substring of length 3 ending at index 4 in s1 is "abc".

3. Final Answer:

   "abc" -> Option D

4. Quick Check:

   Longest common substring = "abc" length 3 [OK]

Hint: Track max length and end index, then slice substring [OK]

Common Mistakes:

• Choosing substring from wrong string
• Confusing substring with subsequence
• Not updating end index when max length changes