Count Occurrences of Element in Sorted Array in DSA Go - Execution Trace

Concept Flow - Count Occurrences of Element in Sorted Array

Start

↓

Find first occurrence of target using binary search

↓

Find last occurrence of target using binary search

↓

Calculate count = last_index - first_index + 1

↓

Return count

↓

End

We use two binary searches to find the first and last positions of the target, then count how many times it appears.

Execution Sample

DSA Go

func countOccurrences(arr []int, target int) int {
  first := findFirst(arr, target)
  if first == -1 {
    return 0
  }
  last := findLast(arr, target)
  return last - first + 1
}

This code finds the first and last positions of the target in a sorted array and returns how many times it occurs.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Start binary search for first occurrence	[1,2,2,2,3,4,5]	low=0, high=6	Array unchanged
2	Mid calculation	[1,2,2,2,3,4,5]	mid=3 (value=2)	Check mid value
3	Check if mid is first occurrence	Same	mid=3, mid-1=2 (value=2)	Not first, move high to mid-1=2
4	Update pointers	Same	low=0, high=2	Narrow search to left half
5	Mid calculation	Same	mid=1 (value=2)	Check mid value
6	Check if mid is first occurrence	Same	mid=1, mid-1=0 (value=1)	Yes, first occurrence found at index 1
7	Start binary search for last occurrence	Same	low=0, high=6	Array unchanged
8	Mid calculation	Same	mid=3 (value=2)	Check mid value
9	Check if mid is last occurrence	Same	mid=3, mid+1=4 (value=3)	Yes, last occurrence found at index 3
10	Calculate count	Same	count = 3 - 1 + 1 = 3	Count of target is 3
11	Return count	Same	Return 3	Done
12	Exit	Same	-	Target count returned

💡 Binary searches complete, count calculated and returned

Variable Tracker

Variable	Start	After Step 3	After Step 6	After Step 9	Final
low	0	0	0	0	0
high	6	2	2	6	6
mid	-	3	1	3	3
first	-1	-1	1	1	1
last	-1	-1	-1	3	3
count	-	-	-	-	3

Key Moments - 3 Insights

Why do we need two separate binary searches for first and last occurrences?

Because the target can appear multiple times, one search finds the earliest index, the other finds the latest. See steps 3-6 for first occurrence and 8-9 for last occurrence.

What if the target is not in the array?

The first binary search returns -1 (step 6), so the function returns 0 immediately (step 3 in code).

Why do we check mid-1 and mid+1 values during binary search?

To confirm if mid is the first or last occurrence by checking neighbors. If neighbors are different, mid is boundary. See steps 3 and 9.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'mid' at step 6?

A 1

B 3

C 0

D 2

💡 Hint

Check the 'Pointer Changes' column at step 6 in the execution table.

At which step does the binary search find the last occurrence of the target?

A Step 3

B Step 6

C Step 9

D Step 2

💡 Hint

Look for 'last occurrence found' in the 'Operation' column.

If the target is not found, what does the function return according to the execution flow?

A 1

B 0

C -1

D Array length

💡 Hint

See the code snippet and key moment about target absence.

Concept Snapshot

Count Occurrences in Sorted Array:
- Use binary search twice: find first and last index of target
- First occurrence: move left if duplicates found
- Last occurrence: move right if duplicates found
- Count = last_index - first_index + 1
- Return 0 if target not found

Full Transcript

To count how many times a number appears in a sorted array, we do two binary searches. First, we find the earliest place the number appears. Then, we find the latest place it appears. The count is the difference between these two positions plus one. If the number is not found, we return zero. This method is fast because binary search quickly narrows down the search area by checking the middle element and moving left or right accordingly.

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