Search in Rotated Sorted Array in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of search in rotated sorted array

What is the output of the following JavaScript code that searches for a target in a rotated sorted array?

DSA Javascript

function search(nums, target) {
  let left = 0, right = nums.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] === target) return mid;
    if (nums[left] <= nums[mid]) {
      if (nums[left] <= target && target < nums[mid]) {
        right = mid - 1;
      } else {
        left = mid + 1;
      }
    } else {
      if (nums[mid] < target && target <= nums[right]) {
        left = mid + 1;
      } else {
        right = mid - 1;
      }
    }
  }
  return -1;
}

console.log(search([4,5,6,7,0,1,2], 0));

A 0

B 6

C -1

D 4

💡 Hint

Think about how the rotated sorted array is split and how binary search adapts.

The target 0 is at index 4 in the rotated array [4,5,6,7,0,1,2]. The search function correctly finds and returns index 4.

❓ Predict Output

intermediate

Output when target is not in rotated sorted array

What is the output of this code when the target is not present in the rotated sorted array?

DSA Javascript

function search(nums, target) {
  let left = 0, right = nums.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] === target) return mid;
    if (nums[left] <= nums[mid]) {
      if (nums[left] <= target && target < nums[mid]) {
        right = mid - 1;
      } else {
        left = mid + 1;
      }
    } else {
      if (nums[mid] < target && target <= nums[right]) {
        left = mid + 1;
      } else {
        right = mid - 1;
      }
    }
  }
  return -1;
}

console.log(search([4,5,6,7,0,1,2], 3));

A -1

B 2

C 0

D 6

💡 Hint

If the target is not found, what does the function return?

The target 3 is not in the array, so the function returns -1 indicating not found.

🧠 Conceptual

advanced

Why binary search works on rotated sorted arrays

Why can binary search be adapted to work on a rotated sorted array?

A Because the array elements are all unique, so we can search linearly.

B Because the array is fully sorted, so normal binary search applies without changes.

C Because at least one half of the array is always sorted, allowing us to decide which half to search next.

D Because the rotation does not affect the order of elements, so we can ignore it.

💡 Hint

Think about how the array is split by the rotation point.

In a rotated sorted array, one half is always sorted. This property lets us decide which half to discard and which to keep searching, adapting binary search.

🔧 Debug

advanced

Identify the error in this rotated array search code

What error will this code produce when searching in a rotated sorted array?

DSA Javascript

function search(nums, target) {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] === target) return mid;
    if (nums[left] <= nums[mid]) {
      if (nums[left] <= target && target < nums[mid]) {
        right = mid - 1;
      } else {
        left = mid + 1;
      }
    } else {
      if (nums[mid] < target && target <= nums[right]) {
        left = mid + 1;
      } else {
        right = mid - 1;
      }
    }
  }
  return -1;
}

console.log(search([4,5,6,7,0,1,2], 0));

A Returns -1 even if target is present

B SyntaxError due to missing parentheses

C Infinite loop because left and right pointers never meet

D Returns correct index 4

💡 Hint

Check the loop condition and how it affects the search range.

Using 'while (left < right)' misses the case when left equals right, so the target at that position is never checked, causing a wrong -1 return.

🚀 Application

expert

Find minimum element in rotated sorted array

Given a rotated sorted array with no duplicates, which code correctly finds the minimum element?

A

function findMin(nums) {
  let min = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] < min) min = nums[i];
  }
  return min;
}

B

function findMin(nums) {
  let left = 0, right = nums.length - 1;
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] > nums[right]) {
      left = mid + 1;
    } else {
      right = mid;
    }
  }
  return nums[left];
}

C

function findMin(nums) {
  return Math.min(...nums);
}

D

function findMin(nums) {
  let left = 0, right = nums.length - 1;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);
    if (nums[mid] < nums[left]) {
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }
  return nums[left];
}

💡 Hint

Use binary search logic to find the point where order breaks.

Option B uses binary search to find the minimum by comparing mid and right elements, narrowing the search space efficiently.