Two Pointer Technique on Arrays in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the left pointer at the start of the array.

DSA Rust

let mut left = [1];

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

Aarr.len()

B1

C0

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting the pointer at 1 instead of 0.

Using the length of the array as the starting index.

The left pointer should start at index 0, which is the first element of the array.

2fill in blank

medium

Complete the code to initialize the right pointer at the end of the array.

DSA Rust

let mut right = arr.[1]() - 1;

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

Astart

Bindex

Ccapacity

Dlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using start() method which does not exist.

Using capacity() which may be larger than length.

The right pointer should start at the last index, which is length of the array minus one.

3fill in blank

hard

Fix the error in the while loop condition to continue while left is less than right.

DSA Rust

while left [1] right {

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

A<

B>

C>=

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= or <= which causes incorrect loop termination.

Using > which skips the case when pointers are equal.

The loop should run while left pointer is less than right pointer to avoid overlap.

4fill in blank

hard

Fill both blanks to move the left pointer right and the right pointer left inside the loop.

DSA Rust

left [1] 1;
right [2] 1;

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

A+=

B-=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using -= for left pointer which moves it backward.

Using += for right pointer which moves it forward.

The left pointer moves forward by adding 1, the right pointer moves backward by subtracting 1.

5fill in blank

hard

Fill all three blanks to create a two-pointer loop that prints pairs of elements from both ends.

DSA Rust

while [1] < [2] {
    println!("{} - {}", arr[[1]], arr[[2]]);
    [1] += 1;
    [2] -= 1;
}

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

Aleft

Bright

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up left and right pointers in the print statement.

Not updating pointers inside the loop.

The loop uses left and right pointers to print pairs and moves them towards each other.

Practice

1. What is the main idea behind the Two Pointer Technique when used on arrays?

easy

A. Use recursion to divide the array into two parts

B. Use two arrays to store intermediate results

C. Sort the array twice before processing

D. Use two indices to scan the array from different ends or positions simultaneously

Solution

1. Step 1: Understand the technique

   The two pointer technique uses two indices or pointers to traverse the array, often from opposite ends or different positions.

2. Step 2: Identify the purpose

   This helps solve problems like finding pairs, removing duplicates, or partitioning efficiently without extra space.

3. Final Answer:

   Use two indices to scan the array from different ends or positions simultaneously -> Option D

4. Quick Check:

   Two pointers = two indices scanning array [OK]

Hint: Think of two fingers moving on array from different sides [OK]

Common Mistakes:

• Confusing two pointers with two separate arrays
• Assuming sorting is always required
• Thinking recursion is part of two pointer technique

2. Which of the following Rust code snippets correctly initializes two pointers for the two pointer technique on a vector arr?

easy

A. let (left, right) = (arr.len() - 1, 0);

B. let (mut left, mut right) = (0, arr.len() - 1);

C. let (mut left, mut right) = (1, arr.len());

D. let (left, right) = (arr.len(), 0);

Solution

1. Step 1: Check pointer initialization

   Two pointers usually start at the beginning (0) and end (length - 1) of the array.

2. Step 2: Verify mutability and valid indices

   Pointers must be mutable to move, and indices must be within array bounds (0 to len-1).

3. Final Answer:

   let (mut left, mut right) = (0, arr.len() - 1); -> Option B

4. Quick Check:

   Start pointers at 0 and len-1 with mut [OK]

Hint: Start pointers at 0 and last index, make them mutable [OK]

Common Mistakes:

• Using non-mutable pointers when they need to move
• Setting pointers outside array bounds
• Swapping start and end indices

3. What will be the output of the following Rust code using two pointers?

let arr = vec![1, 2, 3, 4, 5];
let (mut left, mut right) = (0, arr.len() - 1);
let mut sum_pairs = Vec::new();
while left < right {
    sum_pairs.push(arr[left] + arr[right]);
    left += 1;
    right -= 1;
}
println!("{:?}", sum_pairs);

medium

A. [6, 6]

B. [6, 7]

C. [6, 5]

D. [5, 7]

Solution

1. Step 1: Trace pointer movements and sums

   Initially, left=0, right=4: sum = 1+5=6; then left=1, right=3: sum = 2+4=6; loop stops when left=2, right=2.

2. Step 2: Collect sums in vector

   The sums collected are [6, 6].

3. Final Answer:

   [6, 6] -> Option A

4. Quick Check:

   Pairs sums = [6, 6] [OK]

Hint: Add elements at left and right, move pointers inward [OK]

Common Mistakes:

• Not stopping loop when pointers meet
• Adding wrong pairs or indices
• Off-by-one errors in pointer updates

4. Identify the bug in this Rust code snippet using two pointers to find if a sorted array contains two numbers that sum to 10:

let arr = vec![1, 2, 3, 7, 8];
let (mut left, mut right) = (0, arr.len());
while left < right {
    let sum = arr[left] + arr[right];
    if sum == 10 {
        println!("Found");
        break;
    } else if sum < 10 {
        left += 1;
    } else {
        right -= 1;
    }
}

medium

A. The loop condition should be left <= right

B. left pointer should start at arr.len() - 1

C. right is initialized to arr.len(), which is out of bounds

D. The sum calculation should use arr[left] - arr[right]

Solution

1. Step 1: Check pointer initialization

   right is set to arr.len(), which is one past the last valid index (arr.len() - 1).

2. Step 2: Understand consequences

   Accessing arr[right] causes an out-of-bounds error and program panic.

3. Final Answer:

   right is initialized to arr.len(), which is out of bounds -> Option C

4. Quick Check:

   Array indices go 0 to len-1 [OK]

Hint: Check if pointers are within valid index range [OK]

Common Mistakes:

• Using arr.len() as index instead of arr.len() - 1
• Incorrect loop condition allowing invalid access
• Mixing addition and subtraction in sum calculation

5. Given a sorted array of integers, write a Rust function using the two pointer technique to return all unique pairs that sum to a target value. Which approach correctly avoids duplicate pairs?

hard

A. Move left and right pointers inward, skipping duplicates after finding a valid pair

B. Use nested loops to check all pairs and store unique pairs in a set

C. Sort the array again inside the loop to remove duplicates

D. Only move the left pointer forward regardless of sum comparison

Solution

1. Step 1: Use two pointers from start and end

   Initialize left at 0 and right at last index, move inward based on sum comparison.

2. Step 2: Skip duplicates after finding a valid pair

   After adding a pair, increment left while next value equals current, decrement right similarly to avoid duplicates.

3. Final Answer:

   Move left and right pointers inward, skipping duplicates after finding a valid pair -> Option A

4. Quick Check:

   Skip duplicates by moving pointers after valid pair [OK]

Hint: After finding pair, skip duplicates by moving pointers [OK]

Common Mistakes:

• Not skipping duplicates causing repeated pairs
• Using nested loops instead of two pointers
• Moving only one pointer regardless of sum