Binary Search Variants - Problem

Given a sorted array of integers nums and a target value, implement three binary search variants:

1. Find First Occurrence: Return the index of the first occurrence of target, or -1 if not found

2. Find Last Occurrence: Return the index of the last occurrence of target, or -1 if not found

3. Count Occurrences: Return the total count of target in the array

Your solution should return an array [first, last, count] where:

first is the index of first occurrence
last is the index of last occurrence
count is the total number of occurrences

All three values should be -1, -1, 0 respectively if target is not found.

Input & Output

Example 1 — Multiple Occurrences

$ Input: nums = [5,7,8,8,8,8,9], target = 8

› Output: [2,5,4]

💡 Note: Target 8 first appears at index 2, last appears at index 5, total count is 4 occurrences

Example 2 — Single Occurrence

$ Input: nums = [1,2,3,4,5], target = 3

› Output: [2,2,1]

💡 Note: Target 3 appears only once at index 2, so first=last=2, count=1

Example 3 — Not Found

$ Input: nums = [1,2,3,4,5], target = 6

› Output: [-1,-1,0]

💡 Note: Target 6 is not in the array, so return [-1,-1,0]

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
nums is sorted in non-decreasing order
-10⁹ ≤ target ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 85 G Google 72 M Microsoft 68 f Facebook 45

The key insight is using two specialized binary searches on the sorted array. The optimal approach performs one binary search to find the first occurrence (continuing left when target found) and another to find the last occurrence (continuing right when target found). Count is calculated as last - first + 1. Time: O(log n), Space: O(1)

Common Approaches

✓ Binary Search for First and Last

⏱️ Time: O(log n) Space: O(1)

Perform two separate binary searches: one modified to find the first occurrence by continuing to search left even after finding target, and another to find the last occurrence by continuing to search right. Count is derived as last - first + 1.

Linear Search for All Occurrences

⏱️ Time: O(n) Space: O(1)

Iterate through the entire array from left to right, tracking the first occurrence when we encounter target for the first time, updating the last occurrence every time we see target, and counting total occurrences.

Binary Search for First and Last — Algorithm Steps

Step 1: Binary search for first occurrence (search left when found)
Step 2: Binary search for last occurrence (search right when found)
Step 3: If both found, count = last - first + 1
Step 4: Return [first, last, count]

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First

Binary search pushing left when target found

Find Last

Binary search pushing right when target found

Calculate

Count = last - first + 1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int findFirst(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int first = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            first = mid;
            right = mid - 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return first;
}

int findLast(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    int last = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            last = mid;
            left = mid + 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return last;
}

void solution(int* nums, int numsSize, int target, int* result) {
    int first = findFirst(nums, numsSize, target);
    int last = findLast(nums, numsSize, target);
    
    if (first == -1) {
        result[0] = -1;
        result[1] = -1;
        result[2] = 0;
        return;
    }
    
    result[0] = first;
    result[1] = last;
    result[2] = last - first + 1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    int target;
    scanf("%d", &target);
    
    int result[3];
    solution(nums, numsSize, target, result);
    
    printf("[%d,%d,%d]\n", result[0], result[1], result[2]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Two binary searches, each taking O(log n) time in sorted array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for search boundaries

✓ Linear Space

89.5K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Binary Search Variants - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search for First and Last — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler