Binary Search Recursive Approach in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Typescript

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if (left > right) return -1;
  const mid = Math.floor((left [1] right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] < target) return binarySearch(arr, target, mid + 1, right);
  else return binarySearch(arr, target, left, mid - 1);
}

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

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes wrong mid calculation.

Using '*' or '/' between left and right is incorrect.

The middle index is calculated by adding left and right, then dividing by 2. So the operator between left and right is '+'.

2fill in blank

medium

Complete the code to check if the target is found at the middle index.

DSA Typescript

if (arr[[1]] === target) return mid;

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

Aleft

Bright

Cmid

Dtarget

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'left' or 'right' instead of 'mid' causes wrong element check.

Using 'target' as index causes error.

We compare the element at the middle index 'mid' with the target to check if it's found.

3fill in blank

hard

Fix the error in the recursive call when the target is greater than the middle element.

DSA Typescript

else if (arr[mid] < target) return binarySearch(arr, target, [1], right);

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

Amid + 1

Bmid - 1

Cleft

Dright + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'mid - 1' searches the left half incorrectly.

Using 'right + 1' goes out of bounds.

When target is greater than middle element, search in the right half starting from mid + 1.

4fill in blank

hard

Fill both blanks to complete the base case and recursive call for the left half search.

DSA Typescript

if ([1] > right) return -1;
else return binarySearch(arr, target, left, [2]);

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

Aleft

Bright

Cmid - 1

Dmid + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right in base case causes infinite recursion.

Using mid + 1 instead of mid - 1 searches wrong half.

The base case checks if left is greater than right. The recursive call searches left half up to mid - 1.

5fill in blank

hard

Fill all three blanks to complete the recursive binary search function.

DSA Typescript

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if ([1] > right) return -1;
  const mid = Math.floor((left [2] right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] < target) return binarySearch(arr, target, mid [3] 1, right);
  else return binarySearch(arr, target, left, mid - 1);
}

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

Aleft

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' in mid calculation causes wrong index.

Using mid - 1 instead of mid + 1 for right half causes infinite recursion.

Base case checks if left > right. Middle index is (left + right) / 2. Right half search starts at mid + 1.

Practice

1. What is the main idea behind the binary search recursive approach?

easy

A. Search each element one by one from start to end

B. Divide the array into halves and search recursively in the correct half

C. Sort the array after each recursive call

D. Use a queue to store elements for searching

Solution

1. Step 1: Understand binary search logic

   Binary search works by dividing the sorted array into two halves and deciding which half to search next based on the middle element.

2. Step 2: Apply recursion in binary search

   The recursive approach calls the same function on the half where the target might be, reducing the search space each time.

3. Final Answer:

   Divide the array into halves and search recursively in the correct half -> Option B

4. Quick Check:

   Binary search = divide and conquer [OK]

Hint: Remember: binary search splits array, then recurses [OK]

Common Mistakes:

• Thinking binary search checks every element
• Sorting array inside recursion
• Using linear search logic

2. Which of the following is the correct TypeScript function signature for a recursive binary search?

easy

A. function binarySearch(arr: number[], target: string): boolean

B. function binarySearch(arr: string[], target: number): number

C. function binarySearch(arr: number[], target: number, left: number, right: number): number

D. function binarySearch(arr: number[], target: number): void

Solution

1. Step 1: Check parameters needed for recursion

   Recursive binary search needs the array, target, and the current left and right indices to search between.

2. Step 2: Verify return type

   The function returns the index of the target if found, so the return type is number.

3. Final Answer:

   function binarySearch(arr: number[], target: number, left: number, right: number): number -> Option C

4. Quick Check:

   Parameters + return type match recursive binary search [OK]

Hint: Recursive binary search needs left and right indices [OK]

Common Mistakes:

• Missing left and right parameters
• Wrong return type (void or boolean)
• Mismatched array and target types

3. What will be the output of the following TypeScript code?

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if (left > right) return -1;
  const mid = Math.floor((left + right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, target, left, mid - 1);
  else return binarySearch(arr, target, mid + 1, right);
}

const nums = [2, 4, 6, 8, 10];
console.log(binarySearch(nums, 6, 0, nums.length - 1));

medium

A. 2

B. 1

C. -1

D. 3

Solution

1. Step 1: Identify middle index and compare

   Initial call: left=0, right=4, mid=2. arr[2] = 6 matches target 6.

2. Step 2: Return index when found

   Since arr[mid] equals target, function returns mid = 2 immediately.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Target found at index 2 [OK]

Hint: Check middle element first, then recurse [OK]

Common Mistakes:

• Miscomputing mid index
• Returning wrong index
• Confusing array values with indices

4. Find the error in this recursive binary search function:

function binarySearch(arr: number[], target: number, left: number, right: number): number {
  if (left >= right) return -1;
  const mid = Math.floor((left + right) / 2);
  if (arr[mid] === target) return mid;
  else if (arr[mid] > target) return binarySearch(arr, target, left, mid - 1);
  else return binarySearch(arr, target, mid + 1, right);
}

medium

A. The base case condition should be left > right, not left >= right

B. The mid calculation is incorrect

C. The function should return boolean instead of number

D. The recursive calls have wrong parameters

Solution

1. Step 1: Analyze base case condition

   The base case currently returns -1 if left >= right, but it should allow left == right to check that element.

2. Step 2: Correct base case to left > right

   Changing to left > right ensures the search includes the last element before stopping.

3. Final Answer:

   The base case condition should be left > right, not left >= right -> Option A

4. Quick Check:

   Base case must allow left == right [OK]

Hint: Base case stops when left passes right, not equals [OK]

Common Mistakes:

• Stopping search too early with wrong base case
• Miscomputing mid index
• Wrong return type

5. Given a sorted array arr = [1, 3, 5, 7, 9, 11, 13], write a recursive binary search call to find the index of 7. What will be the sequence of mid indices checked?

hard

A. [3, 5]

B. [3, 1]

C. [3, 1, 2]

D. [3]

Solution

1. Step 1: Calculate initial mid index

   left=0, right=6, mid = floor((0+6)/2) = 3. arr[3] = 7 matches target immediately.

2. Step 2: No further recursive calls needed

   Since target found at first mid, no other mid indices are checked.

3. Final Answer:

   [3] -> Option D

4. Quick Check:

   Target found at first mid index 3 [OK]

Hint: First mid often finds target if array is balanced [OK]

Common Mistakes:

• Assuming multiple recursive calls always happen
• Miscomputing mid index
• Confusing indices with values