Two Pointer Technique on Arrays in DSA Rust - Build from Scratch

Two Pointer Technique on Arrays

📖 Scenario: You are working with a list of numbers representing daily temperatures. You want to find pairs of days where the temperature difference is exactly a certain value.

🎯 Goal: Build a Rust program that uses the two pointer technique on an array to find all pairs of numbers with a specific difference.

📋 What You'll Learn

Create an array called temperatures with the exact values: [30, 40, 50, 60, 70, 80]

Create a variable called target_diff and set it to 20

Use two pointers left and right to find all pairs in temperatures where the difference between the numbers is target_diff

Print each pair found in the format: (left_value, right_value)

💡 Why This Matters

🌍 Real World

Finding pairs of values with a specific difference is useful in temperature analysis, stock price changes, or matching data points in time series.

💼 Career

Two pointer technique is a common pattern in coding interviews and real-world problems involving arrays and sequences.

1

Create the array of temperatures

Create an array called temperatures with the exact values [30, 40, 50, 60, 70, 80]

DSA Rust

# Create the array temperatures with values [30, 40, 50, 60, 70, 80]
// Your code here

Hint

Use let temperatures = [30, 40, 50, 60, 70, 80]; to create the array.

2

Set the target difference

Create a variable called target_diff and set it to 20

DSA Rust

fn main() {
    let temperatures = [30, 40, 50, 60, 70, 80];
    // Create target_diff variable and set it to 20
    // Your code here
}

Hint

Use let target_diff = 20; to create the variable.

3

Use two pointers to find pairs with the target difference

Use two variables left and right as pointers starting at 0 and 1 respectively. Use a while loop to move the pointers through temperatures and find all pairs where temperatures[right] - temperatures[left] == target_diff. Print each pair using println!("({}, {})", temperatures[left], temperatures[right]) inside the loop.

DSA Rust

fn main() {
    let temperatures = [30, 40, 50, 60, 70, 80];
    let target_diff = 20;
    // Initialize left and right pointers
    // Use a while loop to find pairs with difference target_diff
    // Print each pair found
    // Your code here
}

Hint

Use while right < temperatures.len() and adjust left and right pointers based on the difference.

4

Print the pairs found

Run the program to print all pairs of temperatures where the difference is exactly target_diff. The output should show each pair on its own line in the format (left_value, right_value).

DSA Rust

fn main() {
    let temperatures = [30, 40, 50, 60, 70, 80];
    let target_diff = 20;
    let mut left = 0;
    let mut right = 1;
    while right < temperatures.len() {
        let diff = temperatures[right] - temperatures[left];
        if diff == target_diff {
            // Print the pair
            // Your code here
        } else if diff < target_diff {
            right += 1;
        } else {
            left += 1;
            if left == right {
                right += 1;
            }
        }
    }
}

Hint

Run the program and check the output matches the expected pairs.

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