Why Divide and Conquer and What It Gives You in DSA Rust - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to split the array into two halves.

DSA Rust

let mid = arr.len() [1] 2;

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

A+

B/

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or multiplication instead of division.

We divide the length by 2 to find the middle index for splitting.

2fill in blank

medium

Complete the code to recursively call divide_and_conquer on the left half.

DSA Rust

divide_and_conquer(&arr[[1]..mid]);

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

A1

Bmid

C0

Darr.len()

Attempts:

3 left

💡 Hint

Common Mistakes

Using mid or 1 as the start index for the left half.

The left half starts at index 0 and goes up to mid.

3fill in blank

hard

Fix the error in the recursive call for the right half.

DSA Rust

divide_and_conquer(&arr[mid [1]]);

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

A..

B..=

C...

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '...' which is not valid Rust syntax for slicing.

Use the range syntax '..' to slice from mid to the end.

4fill in blank

hard

Fill both blanks to combine results from left and right halves.

DSA Rust

let result = left_result [1] right_result;

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

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication or subtraction which changes the meaning.

We add the results from left and right halves to combine them.

5fill in blank

hard

Fill all three blanks to complete the divide and conquer function.

DSA Rust

fn divide_and_conquer(arr: &[i32]) -> i32 {
    if arr.len() <= [1] {
        return arr[0];
    }
    let mid = arr.len() [2] 2;
    let left_result = divide_and_conquer(&arr[0..mid]);
    let right_result = divide_and_conquer(&arr[mid..]);
    left_result [3] right_result
}

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

A1

B/

C+

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as base case length, using multiplication instead of division, or subtracting results.

We stop dividing when length is 1, divide length by 2 to find mid, and add results.

Practice

1. What is the main advantage of using the divide and conquer approach in algorithms?

easy

A. It avoids recursion completely

B. It solves the problem by trying all possible solutions at once

C. It uses a single loop to solve the entire problem

D. It breaks a problem into smaller subproblems to solve them independently

Solution

1. Step 1: Understand divide and conquer concept

   Divide and conquer splits a big problem into smaller parts that are easier to solve.

2. Step 2: Identify the main advantage

   Solving smaller subproblems independently often leads to simpler and faster solutions.

3. Final Answer:

   It breaks a problem into smaller subproblems to solve them independently -> Option D

4. Quick Check:

   Divide and conquer = splitting problem [OK]

Hint: Divide and conquer means split and solve smaller parts [OK]

Common Mistakes:

• Thinking it tries all solutions at once
• Confusing it with iterative loops
• Believing it avoids recursion

2. Which of the following is the correct Rust syntax to call a recursive divide and conquer function named divide_and_conquer with parameter n?

easy

A. divide_and_conquer(n);

B. divide_and_conquer n;

C. divide_and_conquer->n();

D. call divide_and_conquer(n);

Solution

1. Step 1: Recall Rust function call syntax

   In Rust, functions are called by writing the name followed by parentheses with arguments inside.

2. Step 2: Match syntax to options

   divide_and_conquer(n); uses correct syntax: function_name(argument); others are invalid in Rust.

3. Final Answer:

   divide_and_conquer(n); -> Option A

4. Quick Check:

   Rust function call = name(args) [OK]

Hint: Rust calls functions with name(args); [OK]

Common Mistakes:

• Omitting parentheses in function call
• Using arrow syntax which is invalid
• Adding extra keywords like 'call'

3. Consider this Rust code using divide and conquer to sum elements of a slice:

fn sum_slice(arr: &[i32]) -> i32 {
    if arr.len() == 1 {
        arr[0]
    } else {
        let mid = arr.len() / 2;
        sum_slice(&arr[..mid]) + sum_slice(&arr[mid..])
    }
}

fn main() {
    let numbers = [2, 4, 6, 8];
    println!("{}", sum_slice(&numbers));
}

What is the printed output?

medium

A. 24

B. 20

C. 10

D. Runtime error

Solution

1. Step 1: Understand the base case and recursion

   If slice length is 1, return that element. Otherwise, split slice and sum recursively.

2. Step 2: Calculate sum for [2,4,6,8]

   Split into [2,4] and [6,8]. sum_slice([2,4]) = 2+4=6, sum_slice([6,8])=6+8=14. Total = 6+14=20.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   2+4+6+8 = 20 [OK]

Hint: Sum = add halves recursively [OK]

Common Mistakes:

• Confusing slice ranges causing wrong sums
• Forgetting base case returns single element
• Assuming runtime error due to slicing

4. This Rust function aims to find the maximum element using divide and conquer:

fn max_element(arr: &[i32]) -> i32 {
    if arr.len() == 1 {
        arr[0]
    } else {
        let mid = arr.len() / 2;
        let left_max = max_element(&arr[..mid]);
        let right_max = max_element(&arr[mid..]);
        if left_max > right_max {
            left_max
        } else {
            right_max
        }
    }
}

But when called with an empty slice, it panics. How to fix it?

medium

A. Add a check for empty slice and return a default or Option

B. Remove the base case and always split the slice

C. Change the function to return i32::MIN unconditionally

D. Use a loop instead of recursion

Solution

1. Step 1: Identify cause of panic

   With an empty slice (arr.len() == 0), the base case (len == 1) is skipped, mid = 0, and it recurses on two empty slices, causing infinite recursion and stack overflow panic.

2. Step 2: Fix by checking empty slice

   Add a condition to handle empty slice, e.g., return Option<i32> or a default value.

3. Final Answer:

   Add a check for empty slice and return a default or Option -> Option A

4. Quick Check:

   Empty slice needs special handling [OK]

Hint: Check for empty input before accessing elements [OK]

Common Mistakes:

• Ignoring empty slice case
• Removing base case causing infinite recursion
• Returning fixed min value without condition

5. You want to use divide and conquer to count how many numbers in a large array are greater than 10. Which approach best uses divide and conquer benefits?

hard

A. Sort the array first, then count numbers > 10 using binary search

B. Iterate the entire array once and count numbers > 10

C. Split the array into halves, count in each half recursively, then sum counts

D. Use a loop to check each element without splitting

Solution

1. Step 1: Understand divide and conquer for counting

   Divide array into smaller parts, count in each, then combine results.

2. Step 2: Compare options

   Split the array into halves, count in each half recursively, then sum counts uses divide and conquer by splitting and summing counts. Others do not split or use different methods.

3. Final Answer:

   Split the array into halves, count in each half recursively, then sum counts -> Option C

4. Quick Check:

   Divide and conquer = split, solve, combine [OK]

Hint: Divide problem, count parts, then add results [OK]

Common Mistakes:

• Choosing simple iteration ignoring divide and conquer
• Sorting unnecessarily before counting
• Not combining results after splitting