Two Pointer Technique on Arrays in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Two Pointer Technique on Arrays?

It is a method where two pointers move through the array to solve problems efficiently, often from different ends or positions, to reduce time complexity.

beginner

How do the two pointers typically move in the Two Pointer Technique?

Usually, one pointer starts at the beginning and the other at the end of the array. They move towards each other based on conditions until they meet or cross.

intermediate

Why is the Two Pointer Technique efficient compared to nested loops?

Because it often reduces the time complexity from O(n²) to O(n) by avoiding repeated scanning of the array with nested loops.

intermediate

In the Two Pointer Technique, what is a common use case involving sorted arrays?

Finding pairs with a given sum by moving pointers inward based on whether the current sum is less or greater than the target.

beginner

Show a simple C# example of Two Pointer Technique to find if an array has two numbers that add up to a target.

int[] arr = {1, 2, 3, 4, 6}; int target = 6; int left = 0, right = arr.Length - 1; bool found = false; while (left < right) { int sum = arr[left] + arr[right]; if (sum == target) { found = true; break; } else if (sum < target) { left++; } else { right--; } } Console.WriteLine(found ? "Pair found" : "Pair not found");

What is the main advantage of using the Two Pointer Technique on arrays?

A It reduces time complexity by scanning the array once or twice.

B It uses more memory to store pointers.

C It sorts the array automatically.

D It replaces arrays with linked lists.

The Two Pointer Technique reduces time complexity by efficiently scanning the array with two pointers instead of nested loops.

In a sorted array, if the sum of elements at two pointers is greater than the target, what should you do?

A Move the left pointer forward.

B Move the right pointer backward.

C Stop the search immediately.

D Swap the two elements.

If the sum is too large, moving the right pointer backward decreases the sum.

When do the two pointers usually stop moving in the Two Pointer Technique?

A When they meet or cross each other.

B When the array is sorted.

C After one full pass through the array.

D When the array length is odd.

The pointers stop when they meet or cross, meaning all relevant pairs have been checked.

Which problem can be solved using the Two Pointer Technique?

A Sorting an array in ascending order.

B Finding the maximum element in an unsorted array.

C Counting the frequency of elements.

D Finding pairs with a given sum in a sorted array.

Finding pairs with a given sum in a sorted array is a classic use case for the Two Pointer Technique.

What is the initial position of pointers in the Two Pointer Technique on arrays?

A Both pointers start at the beginning.

B Both pointers start at the end.

C One pointer at the start, one at the end.

D Pointers start at random positions.

Typically, one pointer starts at the beginning and the other at the end to scan inward.

Explain the Two Pointer Technique on arrays and how it helps solve problems efficiently.

Think about how two indexes move through the array to find answers faster.

Describe a step-by-step approach to find if a sorted array contains two numbers that add up to a target using the Two Pointer Technique.

Focus on how you adjust pointers based on the sum compared to the target.

Practice

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

easy

A. Use two indices to traverse the array from different ends or positions simultaneously

B. Use one pointer to traverse and another to store values

C. Sort the array first and then use binary search

D. Use recursion to split the array into two parts

Solution

1. Step 1: Understand the two pointer approach

   The technique uses two pointers (indices) to scan the array from different positions, often from start and end. This helps solve problems efficiently by reducing the number of iterations compared to nested loops.

2. Final Answer:

   Use two indices to traverse the array from different ends or positions simultaneously -> Option A

3. Quick Check:

   Two pointers move from different ends = D [OK]

Hint: Two pointers move from start and end to meet in middle [OK]

Common Mistakes:

• Thinking it always requires sorting first
• Using only one pointer instead of two
• Confusing with recursion or binary search

2. Which of the following is the correct syntax to initialize two pointers left and right for an array arr in C#?

easy

A. int left = -1, right = arr.Length + 1;

B. int left = 1, right = arr.Length;

C. int left = arr.Length, right = 0;

D. int left = 0, right = arr.Length - 1;

Solution

1. Step 1: Understand array indexing and initialize pointers correctly

   Arrays start at index 0 and end at index Length - 1. Left pointer starts at 0 (first element), right pointer at Length - 1 (last element).

2. Final Answer:

   int left = 0, right = arr.Length - 1; -> Option D

3. Quick Check:

   Start at 0 and end at Length-1 = A [OK]

Hint: Start left at 0, right at length minus one [OK]

Common Mistakes:

• Starting right pointer at arr.Length (out of bounds)
• Starting left pointer at 1 instead of 0
• Using negative indices

3. What will be the output of the following C# code?

int[] arr = {1, 2, 3, 4, 5, 6};
int left = 0, right = arr.Length - 1;
int sum = 0;
while (left < right) {
    sum += arr[left] + arr[right];
    left++;
    right--;
}
Console.WriteLine(sum);

medium

A. 21

B. 18

C. 20

D. 15

Solution

1. Step 1: Trace the loop iterations

   Pairs added: (1+6)=7, (2+5)=7, (3+4)=7; sum = 7+7+7 = 21. Loop runs while left < right, so stops after these pairs.

2. Final Answer:

   21 -> Option A

3. Quick Check:

   Sum of pairs from ends = 21 [OK]

Hint: Sum pairs from ends until pointers meet [OK]

Common Mistakes:

• Adding elements twice
• Loop running when left equals right
• Incorrect sum calculation

4. Identify the error in the following C# code using two pointers to find if array arr contains two numbers that sum to target.

int left = 0, right = arr.Length - 1;
while (left <= right) {
    int sum = arr[left] + arr[right];
    if (sum == target) return true;
    else if (sum < target) left++;
    else right--;
}
return false;

medium

A. The sum calculation is incorrect

B. The pointers should both start at 0

C. The loop condition should be left < right instead of left <= right

D. The return statements are missing a value

Solution

1. Step 1: Analyze loop condition

   Using left <= right allows pointers to be equal, causing sum of same element twice. Change to left < right to avoid using the same element twice.

2. Final Answer:

   The loop condition should be left < right instead of left <= right -> Option C

3. Quick Check:

   Pointers must not cross or equal for two distinct elements [OK]

Hint: Use left < right to avoid same element twice [OK]

Common Mistakes:

• Allowing pointers to be equal causing wrong sums
• Starting both pointers at 0
• Misplacing return statements

5. Given a sorted array arr and a number k, how can you use the two pointer technique to find if there exists a pair with sum equal to k? Choose the correct approach.

hard

A. Initialize both pointers at start; move both right until sum equals k

B. Initialize two pointers at start and end; move left pointer right if sum < k, else move right pointer left

C. Initialize two pointers at middle; move both outward until sum equals k

D. Sort the array again and use binary search for each element

Solution

1. Step 1: Set pointers and move based on sum

   Left pointer at 0, right pointer at last index. If sum < k, move left right to increase sum; if sum > k, move right left to decrease sum.

2. Final Answer:

   Initialize two pointers at start and end; move left pointer right if sum < k, else move right pointer left -> Option B

3. Quick Check:

   Two pointers adjust to reach target sum efficiently [OK]

Hint: Move pointers inward based on sum comparison [OK]

Common Mistakes:

• Starting both pointers at same side
• Moving pointers in wrong direction
• Sorting array again unnecessarily