Count Occurrences of Element in Sorted Array in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find the first occurrence index of target in the sorted array.

DSA Go

func firstOccurrence(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := left + (right - left) / 2
        if nums[mid] [1] target {
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    if left < len(nums) && nums[left] == target {
        return left
    }
    return -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 incorrect search direction.

Not adjusting pointers properly leads to infinite loops.

We use < to move the right pointer leftwards when nums[mid] is less than target, to find the first occurrence.

2fill in blank

medium

Complete the code to find the last occurrence index of target in the sorted array.

DSA Go

func lastOccurrence(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := left + (right - left) / 2
        if nums[mid] [1] target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    if right >= 0 && nums[right] == target {
        return right
    }
    return -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 incorrect search direction.

Not checking boundary conditions leads to wrong index.

We use >= to move the left pointer rightwards when nums[mid] is greater than or equal to target, to find the last occurrence.

3fill in blank

hard

Fix the error in the countOccurrences function to correctly count target occurrences.

DSA Go

func countOccurrences(nums []int, target int) int {
    first := firstOccurrence(nums, target)
    if first == -1 {
        return 0
    }
    last := lastOccurrence(nums, target)
    return last [1] first + 1
}

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

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of subtraction causes wrong count.

Forgetting to add one leads to off-by-one error.

The count is last index minus first index plus one, so we subtract first from last and add 1.

4fill in blank

hard

Fill both blanks to complete the binary search loop condition and mid calculation.

DSA Go

func binarySearch(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for [1] {
        mid := left [2] (right - left) / 2
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1
}

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

Aleft <= right

Bleft < right

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using left < right misses the case when left equals right.

Calculating mid as left - (right - left)/2 is incorrect.

The loop runs while left is less than or equal to right, and mid is calculated as left plus half the distance to right.

5fill in blank

hard

Fill all three blanks to create a map of element counts using a for loop and condition.

DSA Go

func countElements(nums []int, target int) map[int]int {
    counts := make(map[int]int)
    for _, num := range nums {
        if num [1] target {
            counts[num] [2] counts[num] [3] 1
        }
    }
    return counts
}

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 counting.

Using += directly without assignment causes syntax error.

We check if num equals target, then update counts[num] by assigning it to counts[num] plus one.

Practice

1. What is the main advantage of using a binary search approach to count occurrences of an element in a sorted array?

easy

A. It counts all elements without searching.

B. It sorts the array automatically.

C. It reduces the search time to logarithmic complexity.

D. It works only on unsorted arrays.

Solution

1. Step 1: Understand binary search efficiency

   Binary search divides the search space in half each time, making it faster than linear search.

2. Step 2: Apply to counting occurrences

   By finding the first and last positions of the element, we can count occurrences efficiently.

3. Final Answer:

   It reduces the search time to logarithmic complexity. -> Option C

4. Quick Check:

   Binary search = O(log n) time [OK]

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

Common Mistakes:

• Thinking binary search sorts the array
• Using linear search for counting in sorted array
• Assuming binary search works on unsorted arrays

2. Which Go code snippet correctly declares a function to count occurrences of an integer in a sorted slice?

easy

A. func countOccurrences(arr []int, target int) int { return 0 }

B. func countOccurrences(arr int[], target int) int { return 0 }

C. func countOccurrences(arr []int, target int) string { return "0" }

D. func countOccurrences(arr []int, target int) { return 0 }

Solution

1. Step 1: Check function signature syntax

   In Go, slices are declared as []int, and return type int is correct for count.

2. Step 2: Validate return statement matches return type

   Returning 0 as int matches the return type int.

3. Final Answer:

   func countOccurrences(arr []int, target int) int { return 0 } -> Option A

4. Quick Check:

   Correct Go function syntax [OK]

Hint: Use []int for slices and match return type [OK]

Common Mistakes:

• Using array syntax int[] instead of []int
• Mismatching return type and return value
• Omitting return type in function signature

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

func countOccurrences(arr []int, target int) int {
    left := 0
    right := len(arr) - 1
    first := -1
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            first = mid
            right = mid - 1
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    if first == -1 {
        return 0
    }
    left = 0
    right = len(arr) - 1
    last := -1
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            last = mid
            left = mid + 1
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return last - first + 1
}

func main() {
    arr := []int{1, 2, 2, 2, 3, 4, 5}
    count := countOccurrences(arr, 2)
    fmt.Println(count)
}

medium

A. 2

B. 3

C. 1

D. 0

Solution

1. Step 1: Find first occurrence of 2

   Binary search finds first index of 2 at position 1.

2. Step 2: Find last occurrence of 2

   Binary search finds last index of 2 at position 3.

3. Step 3: Calculate count

   Count = last - first + 1 = 3 - 1 + 1 = 3.

4. Final Answer:

   3 -> Option B

5. Quick Check:

   Occurrences of 2 = 3 [OK]

Hint: Find first and last index, then subtract [OK]

Common Mistakes:

• Returning index instead of count
• Not updating left/right correctly in binary search
• Confusing first and last occurrence indices

4. Identify the bug in the following Go function that counts occurrences of a target in a sorted array:

func countOccurrences(arr []int, target int) int {
    left, right := 0, len(arr)-1
    count := 0
    for left <= right {
        mid := (left + right) / 2
        if arr[mid] == target {
            count++
            break
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return count
}

medium

A. It counts only one occurrence, not all.

B. It causes an infinite loop.

C. It returns the index instead of count.

D. It does not handle empty arrays.

Solution

1. Step 1: Analyze loop behavior

   The loop breaks after finding one occurrence, so count increments only once.

2. Step 2: Understand counting logic

   Counting all occurrences requires searching for first and last positions, not just one match.

3. Final Answer:

   It counts only one occurrence, not all. -> Option A

4. Quick Check:

   Loop breaks early, count = 1 [OK]

Hint: Break stops counting after first match [OK]

Common Mistakes:

• Using break instead of continuing search
• Not searching for first and last indices
• Assuming one match equals total count

5. Given a sorted array with possible duplicates, how would you modify the binary search approach to count occurrences of multiple target values efficiently? Choose the best approach.

hard

A. Perform separate binary searches for first and last occurrences of each target, then sum counts.

B. Use a linear scan for each target to count occurrences.

C. Sort the array again before counting each target.

D. Use a hash map to store counts after one full scan.

Solution

1. Step 1: Consider efficiency for multiple targets

   Binary search per target is O(k log n) for k targets, which can be costly.

2. Step 2: Use hash map after one scan

   A single linear scan builds a map of counts for all elements in O(n), allowing O(1) lookup per target.

3. Step 3: Compare approaches

   Hash map approach is more efficient for multiple queries than repeated binary searches.

4. Final Answer:

   Use a hash map to store counts after one full scan. -> Option D

5. Quick Check:

   Hash map = efficient multiple counts [OK]

Hint: Build counts once, then query fast [OK]

Common Mistakes:

• Repeating binary search for each target
• Sorting array multiple times unnecessarily
• Ignoring hash map for frequency counting