Array Upper Bound - Practice Coding Problems

Array Upper Bound - Problem

JavaScript Easy

Extend the JavaScript Array prototype by implementing an upperBound() method that finds the last occurrence of a target element in a sorted array.

Your task is to enhance all arrays so they have an upperBound(target) method that returns the highest index where the target value appears. If the target is not found, return -1.

Given: A sorted ascending array of numbers that may contain duplicates
Find: The last index of the target number
Return: Index of last occurrence, or -1 if not found

Example: [1, 2, 2, 2, 3].upperBound(2) should return 3 (the last index where 2 appears)

Input & Output

example_1.js — Basic Usage

$ Input: arr = [1, 2, 2, 2, 3], target = 2

› Output: 3

💡 Note: The target 2 appears at indices 1, 2, and 3. The upper bound (last occurrence) is at index 3.

example_2.js — Single Occurrence

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

› Output: 2

💡 Note: The target 3 appears only once at index 2, so the upper bound is also 2.

example_3.js — Target Not Found

$ Input: arr = [1, 3, 5, 7, 9], target = 4

› Output: -1

💡 Note: The target 4 is not present in the array, so we return -1 as specified.

Constraints

1 ≤ arr.length ≤ 10⁴
-10⁴ ≤ arr[i] ≤ 10⁴
arr is sorted in ascending order
-10⁴ ≤ target ≤ 10⁴
Array may contain duplicate elements

Visualization

Tap to expand

Understanding the Visualization

Initialize Search Space

Set left and right pointers to define our search boundaries

Find Middle Element

Calculate the middle index and compare with target

Adjust Search Direction

If target found, save index but continue searching right for later occurrences

Return Last Found Index

When search space is exhausted, return the rightmost occurrence found

Key Takeaway

🎯 Key Insight: The binary search modification continues searching right when target is found, ensuring we locate the rightmost occurrence efficiently in O(log n) time.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses modified binary search to find the upper bound in O(log n) time. When the target is found, we continue searching the right half to find the rightmost occurrence, making it much more efficient than linear search for large sorted arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use modified binary search to find the rightmost occurrence efficiently
Linear Search from End	O(n)	O(1)	Scan array from right to left to find first occurrence of target

Binary Search (Optimal) — Algorithm Steps

Initialize left pointer to 0 and right pointer to length-1
While left <= right, calculate middle index
If middle element equals target, store index and search right half
If middle element < target, search right half
If middle element > target, search left half
Return the last stored index or -1 if not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

Set left=0, right=length-1

Find middle

Calculate mid = (left+right)/2

Compare and adjust

If target found, search right half for later occurrence

Return result

Return the last found index

Code -

solution.c — C

#include <stdio.h>

int upperBound(int arr[], int size, int target) {
    int left = 0, right = size - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            result = mid; // Store this index
            left = mid + 1; // Search right half
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int arr[] = {1, 2, 2, 2, 3};
    int size = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", upperBound(arr, size, 2)); // Output: 3
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search divides the search space in half at each step

⚡ Linearithmic

Space Complexity

O(1)

Iterative implementation uses constant extra space

✓ Linear Space

28.4K Views

Medium-High Frequency

~15 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler