Approach: Two binary searches

def searchRange(nums, target):
    def bound(lo_bias):
        lo, hi, res = 0, len(nums)-1, -1
        while lo <= hi:
            mid = (lo+hi)//2
            if nums[mid] == target:
                res = mid
                if lo_bias: hi = mid-1
                else: lo = mid+1
            elif nums[mid] < target: lo = mid+1
            else: hi = mid-1
        return res
    return [bound(True), bound(False)]

Complexity: O(log n) time, O(1) space.

Full Solution — all languages

class Solution:
    def searchRange(self, nums, target):
        def bound(low):
            lo, hi, res = 0, len(nums) - 1, -1
            while lo <= hi:
                mid = (lo + hi) // 2
                if nums[mid] == target:
                    res = mid
                    if low:
                        hi = mid - 1
                    else:
                        lo = mid + 1
                elif nums[mid] < target:
                    lo = mid + 1
                else:
                    hi = mid - 1
            return res
        return [bound(True), bound(False)]

import java.util.*;
class Solution {
    public int[] searchRange(int[] nums, int target) {
        return new int[]{bound(nums, target, true), bound(nums, target, false)};
    }
    int bound(int[] nums, int target, boolean low) {
        int lo = 0, hi = nums.length - 1, res = -1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (nums[mid] == target) {
                res = mid;
                if (low) hi = mid - 1;
                else lo = mid + 1;
            } else if (nums[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return res;
    }
}

#include <bits/stdc++.h> using namespace std;
class Solution {
    public: vector<int> searchRange(vector<int>& nums, int target) {
        auto bound = [&](bool low) {
            int lo = 0, hi = (int)nums.size() - 1, res = -1;
            while (lo <= hi) {
                int mid = (lo + hi) / 2;
                if (nums[mid] == target) {
                    res = mid;
                    if (low) hi = mid - 1;
                    else lo = mid + 1;
                } else if (nums[mid] < target) lo = mid + 1;
                else hi = mid - 1;
            }
            return res;
        };
        return {
            bound(true), bound(false)
        };
    }
};

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */ var searchRange = function(nums, target) {
    const bound = (low) => {
        let lo = 0, hi = nums.length - 1, res = -1;
        while (lo <= hi) {
            const mid = (lo + hi) >> 1;
            if (nums[mid] === target) {
                res = mid;
                if (low) hi = mid - 1;
                else lo = mid + 1;
            } else if (nums[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return res;
    };
    return [bound(true), bound(false)];
};

Find First and Last Position of Element in Sorted Array

Example 1

Example 2

Constraints