Search in Rotated Sorted Array in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Go

if len(nums) == 0 {
    return [1]
}

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

A1

B-1

C0

Dlen(nums)

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 0 which could be confused with a valid index.

Returning length of the array which is out of index range.

Returning -1 indicates the target is not found when the array is empty.

2fill in blank

medium

Complete the code to calculate the middle index correctly.

DSA Go

mid := [1] + (high - low) / 2

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

Ahigh

Blen(nums)

Clow

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using high directly which can cause index out of range.

Using 0 which ignores the current search range.

The middle index is calculated by adding low to half the distance between high and low.

3fill in blank

hard

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

DSA Go

if nums[[1]] <= nums[mid] {

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

Ahigh

B0

Cmid

Dlow

Attempts:

3 left

💡 Hint

Common Mistakes

Using high or mid index incorrectly in the condition.

Using 0 which may not be the current low index.

We compare nums[low] with nums[mid] to check if the left half is sorted.

4fill in blank

hard

Fill both blanks to check if the target is in the left sorted half.

DSA Go

if target >= nums[[1]] && target < nums[[2]] {
    high = mid - 1
} else {
    low = mid + 1
}

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

Alow

Bmid

Chigh

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using high instead of mid in the second comparison.

Using 0 which may not be the current low index.

We check if target is between nums[low] and nums[mid] to decide the search range.

5fill in blank

hard

Fill all three blanks to check if the target is in the right sorted half.

DSA Go

if target > nums[[1]] && target <= nums[[2]] {
    [3] = mid + 1
} else {
    high = mid - 1
}

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

Alow

Bmid

Chigh

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using low instead of mid or high in comparisons.

Updating wrong variable in the assignment.

We check if target is between nums[mid+1] and nums[high], then update low to mid+1.

Practice

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

easy

A. The array size is unknown

B. The array contains duplicate elements

C. The array is unsorted

D. The array is split into two sorted parts, making direct binary search tricky

Solution

1. Step 1: Understand the array structure

   A rotated sorted array is originally sorted but then rotated at some pivot, splitting it into two sorted parts.

2. Step 2: Identify the search challenge

   Because of the rotation, a simple binary search cannot be applied directly as the array is not fully sorted in one sequence.

3. Final Answer:

   The array is split into two sorted parts, making direct binary search tricky -> Option D

4. Quick Check:

   Rotation splits array = search challenge [OK]

Hint: Look for the pivot splitting the array into two sorted halves [OK]

Common Mistakes:

• Assuming the array is fully sorted
• Ignoring the rotation pivot
• Trying linear search only

2. Which of the following Go function signatures correctly represents a binary search in a rotated sorted array?

easy

A. func search(nums []int, target int) int

B. func search(nums int, target int) int

C. func search(nums []int, target string) int

D. func search(nums []int, target int) bool

Solution

1. Step 1: Check parameter types

   The function should accept a slice of integers and an integer target to search for.

2. Step 2: Check return type

   The function returns an integer index of the target or -1 if not found, so return type int is correct.

3. Final Answer:

   func search(nums []int, target int) int -> Option A

4. Quick Check:

   Correct params and return type = func search(nums []int, target int) int [OK]

Hint: Function takes []int and int target, returns int index [OK]

Common Mistakes:

• Using wrong parameter types
• Returning bool instead of index
• Using string target instead of int

3. What is the output of the following Go code snippet?

nums := []int{4,5,6,7,0,1,2}
target := 0
fmt.Println(search(nums, target))

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := (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
}

medium

A. -1

B. 0

C. 4

D. 6

Solution

1. Step 1: Identify target and array

   Target is 0, array is rotated sorted: [4,5,6,7,0,1,2].

2. Step 2: Trace binary search steps

   Mid starts at index 3 (value 7), target 0 is not equal. Left half [4..7] is sorted. Target 0 is not in left half, so move left to mid+1=4. Now left=4, right=6. Mid=5 (value 1). Target 0 < 1, right=mid-1=4. Now left=4, right=4. Mid=4 (value 0), found target at index 4.

3. Final Answer:

   4 -> Option C

4. Quick Check:

   Target 0 found at index 4 [OK]

Hint: Check mid, decide which half is sorted, adjust search [OK]

Common Mistakes:

• Not updating left/right correctly
• Confusing sorted half
• Returning wrong index

4. The following Go code attempts to search a target in a rotated sorted array but has a bug. What is the bug?

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := (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
}

medium

A. The function does not return the index

B. The loop condition should be 'left <= right' instead of 'left < right'

C. The target comparison uses wrong operators

D. The mid calculation is incorrect

Solution

1. Step 1: Analyze loop condition

   The loop uses 'left < right', which stops when left == right, possibly missing the last element check.

2. Step 2: Correct loop condition

   Changing to 'left <= right' ensures the last element is checked, preventing missed target.

3. Final Answer:

   The loop condition should be 'left <= right' instead of 'left < right' -> Option B

4. Quick Check:

   Loop must include equal to check [OK]

Hint: Use 'left <= right' to cover all elements in binary search [OK]

Common Mistakes:

• Using 'left < right' and missing last element
• Incorrect mid calculation
• Wrong comparison operators

5. Given a rotated sorted array with possible duplicates, which modification is needed in the binary search to correctly find the target?

nums := []int{2,5,6,0,0,1,2}
target := 0

hard

A. Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right]

B. Use linear search instead of binary search

C. Ignore duplicates and apply normal rotated binary search

D. Sort the array before searching

Solution

1. Step 1: Understand duplicates effect

   Duplicates can cause ambiguity in deciding which half is sorted when nums[left] == nums[mid] == nums[right].

2. Step 2: Modify search to skip duplicates

   When duplicates appear at left, mid, and right, increment left and decrement right to skip duplicates and continue search.

3. Final Answer:

   Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right] -> Option A

4. Quick Check:

   Skip duplicates to avoid ambiguity [OK]

Hint: Skip duplicates at edges when equal to mid [OK]

Common Mistakes:

• Ignoring duplicates causing wrong half detection
• Switching to linear search unnecessarily
• Sorting array breaks problem constraints