Longest Common Substring in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the 2D vector for dynamic programming.

DSA Rust

let mut dp = vec![vec![0; [1]]; s1.len() + 1];

Drag options to blanks, or click blank then click option'

As2.len() + 1

Bs1.len()

Cs2.len()

Ds1.len() + 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using s1.len() instead of s2.len() for columns.

Not adding 1 to lengths for base case row/column.

We create a 2D vector with rows = s1 length + 1 and columns = s2 length + 1 to store substring lengths.

2fill in blank

medium

Complete the code to update dp when characters match.

DSA Rust

if s1_bytes[i - 1] == s2_bytes[j - 1] {
    dp[i][j] = dp[i - 1][j - 1] [1] 1;
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causing incorrect dp values.

Using '*' or '/' which are not meaningful here.

When characters match, we add 1 to the diagonal dp value to extend the substring.

3fill in blank

hard

Fix the error in updating the maximum length found so far.

DSA Rust

if dp[i][j] [1] max_len {
    max_len = dp[i][j];
    end_index = i;
}

Drag options to blanks, or click blank then click option'

A==

B<

C<=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' which updates max_len incorrectly.

Using '==' which misses longer substrings.

We update max_len only if current dp[i][j] is greater than max_len.

4fill in blank

hard

Fill both blanks to extract the longest common substring from s1.

DSA Rust

let result = &s1[[1]..[2]];

Drag options to blanks, or click blank then click option'

Aend_index - max_len

Bend_index

Cmax_len

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using max_len as start index.

Using 0 as end index.

The substring starts at end_index - max_len and ends at end_index.

5fill in blank

hard

Fill all three blanks to complete the longest common substring function.

DSA Rust

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

    for i in 1..=s1.len() {
        for j in 1..=s2.len() {
            if s1_bytes[i - 1] == s2_bytes[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] [2] 1;
                if dp[i][j] [3] max_len {
                    max_len = dp[i][j];
                    end_index = i;
                }
            }
        }
    }

    s1[(end_index - max_len)..end_index].to_string()
}

Drag options to blanks, or click blank then click option'

As2.len() + 1

B+

C>

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Wrong dp table size causing index errors.

Using wrong operator instead of '+' when updating dp.

Incorrect comparison operator for max_len update.

The dp table columns are s2 length + 1, we add 1 when characters match, and update max_len if current dp[i][j] is greater.

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