Substring Search Patterns in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the pattern exists in the text using the contains method.

DSA Rust

let text = "hello world";
let pattern = "world";
let found = text.[1](pattern);
println!("Pattern found: {}", found);

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

Acontains

Bends_with

Cstarts_with

Dfind

Attempts:

3 left

💡 Hint

Common Mistakes

Using starts_with or ends_with which only check beginning or end of the string.

Using find which returns an Option, not a boolean.

The contains method checks if the pattern is present anywhere in the text and returns true or false.

2fill in blank

medium

Complete the code to find the starting index of the pattern in the text using the find method.

DSA Rust

let text = "rust programming";
let pattern = "program";
let index = text.[1](pattern);
println!("Pattern starts at: {:?}", index);

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

Astarts_with

Bcontains

Cfind

Dposition

Attempts:

3 left

💡 Hint

Common Mistakes

Using contains which returns a boolean, not an index.

Using position which is for iterators, not strings.

The find method returns an Option with the starting index of the pattern if found.

3fill in blank

hard

Fix the error in the code to correctly get the substring from the found index.

DSA Rust

let text = "data structures";
let pattern = "struct";
if let Some(start) = text.[1](pattern) {
    let substring = &text[start..start + pattern.len()];
    println!("Found substring: {}", substring);
}

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

Aposition

Bfind

Cindex_of

Dcontains

Attempts:

3 left

💡 Hint

Common Mistakes

Using contains which returns a boolean, causing a type mismatch.

Using position which is not a method on strings.

The find method returns the starting index of the pattern, which can be used to slice the string.

4fill in blank

hard

Fill both blanks to create a loop that finds all occurrences of the pattern in the text.

DSA Rust

let text = "ababababa";
let pattern = "aba";
let mut start = 0;
while let Some(pos) = text[start..].[1](pattern) {
    let index = start + pos;
    println!("Found at index: {}", index);
    start = index + [2];
}

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

Afind

Bcontains

Cpattern.len()

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using contains instead of find which does not return position.

Incrementing start by 1 causing infinite loops or repeated matches.

Use find to get the next occurrence index, then move start by the pattern length to avoid overlapping matches.

5fill in blank

hard

Fill all three blanks to build a HashMap counting occurrences of each pattern in a list of texts.

DSA Rust

use std::collections::HashMap;

let texts = vec!["apple pie", "apple tart", "banana pie"];
let pattern = "pie";
let mut counts = HashMap::new();

for text in texts {
    if text.[1](pattern) {
        *counts.entry(text.[2]()).or_insert(0) += [3];
    }
}
println!("Counts: {:?}", counts);

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

Acontains

Bto_string

C1

Dfind

Attempts:

3 left

💡 Hint

Common Mistakes

Using find instead of contains for boolean check.

Not converting &str to String causing type errors.

Incrementing count by wrong value.

Use contains to check presence, to_string to convert &str to String for HashMap key, and increment count by 1.

Practice

1. What is the main purpose of substring search algorithms in strings?

easy

A. To find if a smaller string exists inside a larger string

B. To sort characters in a string alphabetically

C. To reverse the order of characters in a string

D. To count the total number of characters in a string

Solution

1. Step 1: Understand substring search goal

   Substring search algorithms check if a smaller string (pattern) appears inside a bigger string (text).

2. Step 2: Compare with other string operations

   Sorting, reversing, and counting characters are different operations unrelated to searching for a substring.

3. Final Answer:

   To find if a smaller string exists inside a larger string -> Option A

4. Quick Check:

   Substring search = find smaller string inside bigger string [OK]

Hint: Substring search means finding a smaller string inside a bigger one [OK]

Common Mistakes:

• Confusing substring search with sorting or reversing strings
• Thinking substring search counts characters
• Mixing substring search with string length calculation

2. Which Rust code snippet correctly checks if the string needle is a substring of haystack?

easy

A. if haystack.index_of(needle) { println!("Found"); }

B. if haystack.find(needle) { println!("Found"); }

C. if needle.in(haystack) { println!("Found"); }

D. if haystack.contains(needle) { println!("Found"); }

Solution

1. Step 1: Identify correct Rust substring method

   Rust's standard library provides contains method on strings to check substring presence, returning a boolean.

2. Step 2: Check other options for syntax errors

   find returns an Option, not a boolean; in is not a Rust keyword; index_of does not exist in Rust standard strings.

3. Final Answer:

   if haystack.contains(needle) { println!("Found"); } -> Option D

4. Quick Check:

   Rust substring check uses contains() [OK]

Hint: Use .contains() to check substring presence in Rust strings [OK]

Common Mistakes:

• Using .find() as a boolean without checking Option
• Trying Python or other language syntax like 'in'
• Using non-existent methods like index_of

3. What will be the output of this Rust code?

let text = "hello world";
let pattern = "wor";
if text.contains(pattern) {
    println!("Pattern found");
} else {
    println!("Pattern not found");
}

medium

A. Compilation error

B. Pattern found

C. Pattern not found

D. Runtime panic

Solution

1. Step 1: Check if pattern is substring of text

   The string "hello world" contains "wor" starting at index 6.

2. Step 2: Evaluate the if condition

   Since text.contains(pattern) returns true, the code prints "Pattern found".

3. Final Answer:

   Pattern found -> Option B

4. Quick Check:

   "hello world" contains "wor" = true [OK]

Hint: Check if substring exists literally inside the main string [OK]

Common Mistakes:

• Assuming contains() checks for whole words only
• Confusing contains() with starts_with() or ends_with()
• Expecting compilation or runtime errors without syntax issues

4. Identify the error in this Rust code snippet for substring search:

let text = "rustacean";
let pattern = "ace";
if text.find(pattern) {
    println!("Found");
} else {
    println!("Not found");
}

medium

A. Missing semicolon after let statements

B. Using contains() instead of find()

C. Using find() without handling Option result

D. Pattern string is empty

Solution

1. Step 1: Understand return type of find()

   In Rust, find() returns an Option<usize>, not a boolean.

2. Step 2: Check if condition usage

   The if condition expects a boolean, but text.find(pattern) returns Option, causing a type mismatch error.

3. Final Answer:

   Using find() without handling Option result -> Option C

4. Quick Check:

   find() returns Option, not bool [OK]

Hint: Remember find() returns Option, not boolean; unwrap or check Some [OK]

Common Mistakes:

• Treating find() as boolean directly in if
• Ignoring Option type returned by find()
• Confusing contains() and find() return types

5. Given a large text and multiple patterns, which substring search approach is best to efficiently find all patterns in the text?

hard

A. Using a Trie or Aho-Corasick algorithm to search all patterns simultaneously

B. Naive search checking each pattern separately in the text

C. Sorting all patterns and text then binary searching each pattern

D. Reversing the text and patterns before searching

Solution

1. Step 1: Analyze naive approach inefficiency

   Checking each pattern separately in a large text is slow because it repeats scanning multiple times.

2. Step 2: Understand advanced multi-pattern search

   Trie-based algorithms like Aho-Corasick build a structure to search all patterns at once efficiently.

3. Step 3: Evaluate other options

   Sorting and binary searching patterns is not suitable for substring search; reversing strings does not help search efficiency.

4. Final Answer:

   Using a Trie or Aho-Corasick algorithm to search all patterns simultaneously -> Option A

5. Quick Check:

   Multi-pattern search uses Trie/Aho-Corasick [OK]

Hint: Use Trie or Aho-Corasick for multiple substring searches efficiently [OK]

Common Mistakes:

• Using naive repeated searches for many patterns
• Trying sorting-based methods for substring search
• Thinking reversing strings improves search speed