Binary Search as Divide and Conquer in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the middle index in binary search.

DSA C++

int mid = low + (high - low) / [1];

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

A4

B2

C3

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 3 or 4 instead of 2 causes incorrect mid calculation.

The middle index is found by dividing the range by 2.

2fill in blank

medium

Complete the code to check if the middle element is the target.

DSA C++

if (arr[mid] == [1]) {
    return mid;
}

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

Atarget

Blow

Chigh

Dmid

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with mid index or low/high indices instead of target.

We compare the middle element with the target value we are searching for.

3fill in blank

hard

Fix the error in the condition to search the left half when target is smaller.

DSA C++

else if (arr[mid] [1] target) {
    high = mid - 1;
}

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

A<

B==

C>

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' reverses the search direction causing infinite loop.

If the middle element is greater than the target, search the left half by moving high.

4fill in blank

hard

Fill both blanks to search the right half when target is greater.

DSA C++

else {
    [1] = mid + 1;
    [2] = high;
}

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

Alow

Bmid

Chigh

Dtarget

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping low and high causes wrong search range.

When target is greater, move low to mid + 1 and keep high unchanged.

5fill in blank

hard

Fill all three blanks to complete the binary search function.

DSA C++

int binarySearch(int arr[], int [1], int [2], int target) {
    while ([1] <= [2]) {
        int mid = [1] + ([2] - [1]) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] > target) [2] = mid - 1;
        else [1] = mid + 1;
    }
    return -1;
}

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

Alow

Bhigh

Dmid

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names causes compilation errors.

The function uses low and high as the search boundaries and updates them correctly.

Practice

1. What is the main idea behind Binary Search as a divide and conquer algorithm?

easy

A. It divides the search space into two halves and discards one half each time.

B. It searches every element one by one until it finds the target.

C. It sorts the array before searching for the element.

D. It uses recursion to add elements to the array.

Solution

1. Step 1: Understand divide and conquer in binary search

   Binary search splits the array into two halves and decides which half to continue searching based on the middle element.

2. Step 2: Identify the main action in binary search

   It discards the half where the target cannot be, reducing the search space quickly.

3. Final Answer:

   It divides the search space into two halves and discards one half each time. -> Option A

4. Quick Check:

   Divide and conquer = split and discard half [OK]

Hint: Binary search halves the search space each step [OK]

Common Mistakes:

• Thinking binary search checks every element
• Confusing binary search with linear search
• Assuming binary search sorts the array

2. Which of the following is the correct syntax to calculate the middle index in binary search in C++?

easy

A. int mid = (low + high) / 2;

B. int mid = (low * high) / 2;

C. int mid = low + (high - low) / 2;

D. int mid = (low - high) / 2;

Solution

1. Step 1: Understand why to avoid overflow

   Using (low + high) / 2 can cause overflow if low and high are large integers.

2. Step 2: Use safe middle calculation

   Calculating mid as low + (high - low) / 2 avoids overflow by subtracting before adding.

3. Final Answer:

   int mid = low + (high - low) / 2; -> Option C

4. Quick Check:

   Safe mid calculation = low + (high - low)/2 [OK]

Hint: Use low + (high - low)/2 to avoid overflow [OK]

Common Mistakes:

• Using (low + high)/2 causing overflow
• Using subtraction incorrectly in mid calculation
• Multiplying low and high instead of adding

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

int binarySearch(int arr[], int low, int high, int x) {
    if (low > high) return -1;
    int mid = low + (high - low) / 2;
    if (arr[mid] == x) return mid;
    else if (arr[mid] > x) return binarySearch(arr, low, mid - 1, x);
    else return binarySearch(arr, mid + 1, high, x);
}

int main() {
    int arr[] = {2, 4, 6, 8, 10};
    int n = 5;
    int result = binarySearch(arr, 0, n - 1, 6);
    std::cout << result;
    return 0;
}

medium

A. 3

B. 4

C. -1

D. 2

Solution

1. Step 1: Trace the binary search calls

   Initial call: low=0, high=4, mid=2, arr[2]=6 matches target 6, so return 2.

2. Step 2: Return the index found

   Since arr[2] == 6, the function returns 2 immediately.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Index of 6 in array = 2 [OK]

Hint: Check middle element first to find index quickly [OK]

Common Mistakes:

• Confusing index with value
• Not updating mid correctly
• Returning -1 when element is present

4. Find the error in the following binary search code snippet:

int binarySearch(int arr[], int low, int high, int x) {
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) return mid;
        else if (arr[mid] < x) low = mid;
        else high = mid - 1;
    }
    return -1;
}

medium

A. The update low = mid should be low = mid + 1.

B. The loop condition should be low < high.

C. The mid calculation can cause overflow.

D. The function should return mid + 1 instead of mid.

Solution

1. Step 1: Analyze the update of low pointer

   When arr[mid] < x, low should move to mid + 1 to avoid infinite loop.

2. Step 2: Identify the infinite loop cause

   Setting low = mid keeps low same if mid equals low, causing infinite loop.

3. Final Answer:

   The update low = mid should be low = mid + 1. -> Option A

4. Quick Check:

   Increment low past mid to avoid infinite loop [OK]

Hint: Increment low by 1 after mid when moving right [OK]

Common Mistakes:

• Not incrementing low causing infinite loop
• Using wrong loop condition
• Ignoring overflow in mid calculation

5. You have a sorted array with duplicate elements: {1, 2, 2, 2, 3, 4}. How can you modify binary search to find the first occurrence of 2?

hard

A. Return immediately when 2 is found.

B. Keep searching left half even after finding 2 to find first occurrence.

C. Search right half after finding 2 to find last occurrence.

D. Use linear search instead of binary search.

Solution

1. Step 1: Understand duplicates in binary search

   Standard binary search returns any occurrence, not necessarily the first.

2. Step 2: Modify search to find first occurrence

   When arr[mid] == target, continue searching left half to find earlier occurrence.

3. Step 3: Stop when mid is first or left element is different

   Return mid if it is first element or previous element is different.

4. Final Answer:

   Keep searching left half even after finding 2 to find first occurrence. -> Option B

5. Quick Check:

   Find first occurrence by searching left after match [OK]

Hint: After match, move left to find first duplicate [OK]

Common Mistakes:

• Returning first found index without checking left
• Searching right half after finding target
• Using linear search unnecessarily