Two-pointer technique in Data Structures Theory - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize two pointers at the start and end of the list.

Data Structures Theory

left = 0
right = [1]

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

Alen(arr) - 1

B0

Clen(arr)

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting right pointer to len(arr) causes index out of range error.

Setting right pointer to 0 makes both pointers start at the same position.

The right pointer should start at the last index, which is len(arr) - 1.

2fill in blank

medium

Complete the code to move the left pointer one step to the right.

Data Structures Theory

left = left [1] 1

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

A-

B+

C*

D//

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' moves the pointer left instead of right.

Using '*' or '//' does not correctly move the pointer by one step.

To move the left pointer right, add 1 to its current position.

3fill in blank

hard

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

Data Structures Theory

while left [1] right:
    # process elements

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

A<=

B>

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' or '<=' causes the pointers to overlap or cross incorrectly.

Using '>' reverses the logic and may cause the loop to never run.

The loop should run while left < right to avoid pointers crossing.

4fill in blank

hard

Fill both blanks to correctly move the pointers towards each other.

Data Structures Theory

left = left [1] 1
right = 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 moves it left instead of right.

Using '+' for right pointer moves it right instead of left.

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

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each word to its length if length is greater than 3.

Data Structures Theory

result = [1]: [2] for word in words if len(word) [3] 3

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

Aword

Blen(word)

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' filters wrong words.

Swapping keys and values causes incorrect dictionary structure.

The dictionary keys are words, values are their lengths, and the condition filters words longer than 3 characters.

Practice

1. What is the main purpose of the two-pointer technique in data structures?

easy

A. To store data in two separate arrays

B. To use two markers to scan data efficiently

C. To sort data using two different algorithms

D. To create two copies of the data for backup

Solution

1. Step 1: Recall the main purpose of the two-pointer technique

   The two-pointer technique uses two markers or pointers to scan through data efficiently, reducing unnecessary checks.

2. Step 2: Compare with other options

   The other options describe unrelated actions like storing data in separate arrays, sorting data, or creating backups, which are not the main purpose of this technique.

3. Final Answer:

   To use two markers to scan data efficiently -> Option B

4. Quick Check:

   Two-pointer technique = efficient scanning [OK]

Hint: Two pointers scan data fast by moving through it together [OK]

Common Mistakes:

• Confusing two-pointer with sorting algorithms
• Thinking it copies data instead of scanning
• Assuming it stores data separately

2. Which of the following is the correct way to initialize two pointers left and right for scanning an array arr from both ends?

easy

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

B. left = 1; right = len(arr)

C. left = len(arr); right = 0

D. left = -1; right = len(arr) + 1

Solution

1. Step 1: Identify valid pointer positions

   For scanning from both ends, left starts at 0 (first index) and right at len(arr) - 1 (last index).

2. Step 2: Check other options for errors

   The other options use invalid indices like starting at 1 or beyond array length, which cause errors or miss elements.

3. Final Answer:

   left = 0; right = len(arr) - 1 -> Option A

4. Quick Check:

   Start pointers at array ends = left = 0; right = len(arr) - 1 [OK]

Hint: Start left at 0 and right at last index for two-pointer scan [OK]

Common Mistakes:

• Starting pointers outside array bounds
• Using length instead of length minus one
• Swapping left and right initial values

3. Consider the following code using the two-pointer technique to check if a string is a palindrome:

def is_palindrome(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome('radar'))

What will be the output?

medium

A. True

B. None

C. Error

D. False

Solution

1. Step 1: Understand the palindrome check logic

   The code compares characters from the start and end moving inward. If any pair differs, it returns False; otherwise, True.

2. Step 2: Apply to 'radar'

   Characters match at all pairs: 'r'=='r', 'a'=='a', middle 'd' ignored. So, it returns True.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Palindrome check for 'radar' = True [OK]

Hint: Check characters from ends moving inward for palindrome [OK]

Common Mistakes:

• Confusing return values for palindrome
• Not updating pointers correctly
• Ignoring middle character in odd length strings

4. The following code attempts to find if there exists a pair in a sorted array arr that sums to target using the two-pointer technique:

def has_pair(arr, target):
    left, right = 0, len(arr)
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target:
            return True
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return False

What is the error in this code?

medium

A. The function should return True at the end

B. The loop condition should be while left <= right

C. The current_sum calculation is wrong

D. The right pointer is initialized incorrectly

Solution

1. Step 1: Check pointer initialization

   The right pointer is set to len(arr), which is outside valid index range (max index is len(arr)-1).

2. Step 2: Identify correct initialization

   Right pointer should be len(arr) - 1 to point to the last element.

3. Final Answer:

   The right pointer is initialized incorrectly -> Option D

4. Quick Check:

   Right pointer must be last index, not length [OK]

Hint: Right pointer = last index, not array length [OK]

Common Mistakes:

• Setting right pointer to array length
• Using wrong loop condition
• Miscomputing sum inside loop

5. You have two sorted arrays A and B. Using the two-pointer technique, how can you efficiently find all pairs (a, b) such that a + b = target? Choose the best approach.

hard

A. Use nested loops to check every pair from A and B

B. Sort both arrays again and then check pairs

C. Use one pointer on A starting at 0 and one on B starting at end, move pointers based on sum comparison

D. Use a hash map to store sums of all pairs

Solution

1. Step 1: Understand two-pointer approach for two sorted arrays

   Start pointer i at beginning of A and pointer j at end of B. Calculate sum A[i]+B[j].

2. Step 2: Move pointers based on sum

   If sum equals target, record pair and move pointers. If sum less than target, move i forward; if greater, move j backward. This avoids nested loops and is efficient.

3. Final Answer:

   Use one pointer on A starting at 0 and one on B starting at end, move pointers based on sum comparison -> Option C

4. Quick Check:

   Two-pointer on sorted arrays finds pairs efficiently [OK]

Hint: One pointer start, one pointer end; move based on sum [OK]

Common Mistakes:

• Using nested loops causing slow performance
• Resorting already sorted arrays unnecessarily
• Using hash map instead of two-pointer for sorted arrays