Search in Rotated Sorted Array in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return -1 if the array is empty.

DSA C

if (numsSize == [1]) return -1;

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

A0

B1

C-1

DnumsSize

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 instead of 0 for empty array size.

Returning numsSize instead of -1.

If the size of the array is 0, it means the array is empty, so we return -1.

2fill in blank

medium

Complete the code to find the middle index between left and right.

DSA C

int mid = left + (right - left) [1] 2;

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

A*

B+

C/

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication instead of division.

Using addition instead of division.

To find the middle index, we add half the distance between left and right to left using division by 2.

3fill in blank

hard

Fix the error in the condition to check if the target is in the left sorted part.

DSA C

if (nums[left] <= nums[mid] && target >= nums[left] && target [1] nums[mid]) {

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

A<=

B>=

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of <= causing wrong range check.

Using >= which reverses the condition.

The target should be less than or equal to nums[mid] to be in the left sorted part.

4fill in blank

hard

Fill both blanks to update left and right pointers correctly.

DSA C

if (target [1] nums[mid]) {
    right = mid [2] 1;
} else {
    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 < in the comparison.

Adding 1 to right pointer instead of subtracting.

If target is less than nums[mid], move right pointer left by one; else move left pointer right.

5fill in blank

hard

Fill all three blanks to complete the search loop and return the target index or -1.

DSA C

while (left <= right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] == [1]) return mid;
    if (nums[left] <= nums[mid]) {
        if (target >= nums[left] && target [2] nums[mid]) {
            right = mid [3] 1;
        } else {
            left = mid + 1;
        }
    } else {
        if (target > nums[mid] && target <= nums[right]) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
}
return -1;

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

Atarget

B<=

C-

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing nums[mid] with wrong variable.

Using > instead of <= in range check.

Adding 1 to right pointer instead of subtracting.

Check if nums[mid] equals target, then check if target is between nums[left] and nums[mid] using <=, and move right pointer left by 1.

Practice

1. What is the main challenge when searching for an element in a rotated sorted array compared to a normal sorted array?

easy

A. The array is not fully sorted, so normal binary search cannot be directly applied

B. The array contains duplicate elements

C. The array size is unknown

D. The array elements are all negative

Solution

1. Step 1: Understand sorted vs rotated sorted array

   A normal sorted array is fully sorted in ascending order, but a rotated sorted array is a sorted array shifted at some pivot point, breaking the full order.

2. Step 2: Impact on binary search

   Binary search requires a fully sorted array to decide which half to search next. In a rotated array, this condition breaks, so normal binary search cannot be directly applied.

3. Final Answer:

   The array is not fully sorted, so normal binary search cannot be directly applied -> Option A

4. Quick Check:

   Rotated array breaks full sort = normal binary search fails [OK]

Hint: Rotated array breaks order; normal binary search fails [OK]

Common Mistakes:

• Assuming array is fully sorted
• Ignoring the pivot point
• Thinking duplicates cause the main issue

2. Which of the following is the correct way to check if the middle element is in the left sorted portion of a rotated sorted array in C?

easy

A. if (arr[mid] > arr[end])

B. if (arr[mid] >= arr[start])

C. if (arr[mid] <= arr[start])

D. if (arr[mid] < arr[end])

Solution

1. Step 1: Understand left sorted portion condition

   If the middle element is greater than or equal to the start element, it means mid is in the left sorted portion because left side is sorted ascending.

2. Step 2: Translate condition to code

   The condition is written as if (arr[mid] >= arr[start]) in C to check this.

3. Final Answer:

   if (arr[mid] >= arr[start]) -> Option B

4. Quick Check:

   Mid >= start means left sorted [OK]

Hint: Check if mid >= start to find left sorted part [OK]

Common Mistakes:

• Using <= instead of > or >=
• Comparing mid with end incorrectly
• Confusing left and right sorted parts

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

int arr[] = {6,7,8,1,2,3,4,5};
int n = 8;
int target = 3;
int start = 0, end = n - 1;
int mid;
while (start <= end) {
    mid = (start + end) / 2;
    if (arr[mid] == target) {
        printf("%d", mid);
        break;
    }
    if (arr[start] <= arr[mid]) {
        if (target >= arr[start] && target < arr[mid])
            end = mid - 1;
        else
            start = mid + 1;
    } else {
        if (target > arr[mid] && target <= arr[end])
            start = mid + 1;
        else
            end = mid - 1;
    }
}

medium

A. 6

B. 3

C. 2

D. 5

Solution

1. Step 1: Trace the binary search on rotated array

   Initial array: [6,7,8,1,2,3,4,5], target=3. Start=0, end=7. - mid=(0+7)/2=3, arr[3]=1, not target. - arr[start]=6 > arr[mid]=1, so right half is sorted. - target=3 > arr[mid]=1 and target <= arr[end]=5, so start=mid+1=4. - Now start=4, end=7. - mid=(4+7)/2=5, arr[5]=3 matches target.

2. Step 2: Output the index

   Index 5 is printed as the target is found at arr[5].

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Target 3 found at index 5 [OK]

Hint: Trace mid and adjust start/end carefully [OK]

Common Mistakes:

• Not updating start/end correctly
• Confusing which half is sorted
• Wrong mid calculation

4. Identify the bug in the following C code snippet that searches for a target in a rotated sorted array:

int search(int arr[], int n, int target) {
    int start = 0, end = n - 1;
    while (start < end) {
        int mid = (start + end) / 2;
        if (arr[mid] == target) return mid;
        if (arr[start] <= arr[mid]) {
            if (target >= arr[start] && target < arr[mid])
                end = mid - 1;
            else
                start = mid + 1;
        } else {
            if (target > arr[mid] && target <= arr[end])
                start = mid + 1;
            else
                end = mid - 1;
        }
    }
    return -1;
}

medium

A. The target comparison should use > instead of >=

B. The mid calculation should be mid = start + (end - start) / 2

C. The loop condition should be start <= end instead of start < end

D. The function should return start instead of -1 when not found

Solution

1. Step 1: Analyze loop condition impact

   The loop uses while (start < end), which misses the case when start == end. This can skip checking the last element, causing incorrect -1 return even if target is present.

2. Step 2: Correct loop condition

   Changing to while (start <= end) ensures the last element is checked, preventing missed targets.

3. Final Answer:

   The loop condition should be start <= end instead of start < end -> Option C

4. Quick Check:

   Loop must include start == end to check all elements [OK]

Hint: Use start <= end to cover all elements [OK]

Common Mistakes:

• Ignoring last element check
• Thinking mid calculation causes bug
• Returning wrong index on failure

5. Given a rotated sorted array with possible duplicates, which modification is necessary to correctly search for a target element?

hard

A. Add extra checks to skip duplicates when arr[start] == arr[mid] == arr[end]

B. Use linear search instead of binary search

C. Ignore duplicates and apply normal rotated array search

D. Sort the array before searching

Solution

1. Step 1: Understand duplicates impact on rotated search

   Duplicates can cause ambiguity in deciding which half is sorted because arr[start], arr[mid], and arr[end] can be equal, breaking the binary search logic.

2. Step 2: Modify search to handle duplicates

   When arr[start] == arr[mid] == arr[end], increment start and decrement end to skip duplicates and continue search safely.

3. Step 3: Avoid linear search or sorting

   Linear search is inefficient; sorting changes array and is not allowed. Proper duplicate handling preserves binary search efficiency.

4. Final Answer:

   Add extra checks to skip duplicates when arr[start] == arr[mid] == arr[end] -> Option A

5. Quick Check:

   Skip duplicates when start=mid=end to continue search [OK]

Hint: Skip duplicates when start, mid, end equal [OK]

Common Mistakes:

• Ignoring duplicates cause wrong half detection
• Switching to linear search unnecessarily
• Sorting array before search