Find First and Last Position of Element in Sorted Array

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        auto lo = lower_bound(nums.begin(), nums.end(), target);
        if (lo == nums.end() || *lo != target) return {-1, -1};
        auto hi = upper_bound(nums.begin(), nums.end(), target);
        return {(int)(lo - nums.begin()), (int)(hi - nums.begin()) - 1};
    }
};

import "sort"

func searchRange(nums []int, target int) []int {
    lo := sort.SearchInts(nums, target)
    if lo == len(nums) || nums[lo] != target {
        return []int{-1, -1}
    }
    hi := sort.SearchInts(nums, target+1)
    return []int{lo, hi - 1}
}

import bisect
from typing import List

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        lo = bisect.bisect_left(nums, target)
        if lo == len(nums) or nums[lo] != target:
            return [-1, -1]
        hi = bisect.bisect_right(nums, target)
        return [lo, hi - 1]

function searchRange(nums, target) {
    const n = nums.length;
    const lowerBound = (t) => {
        let lo = 0, hi = n;
        while (lo < hi) {
            const m = (lo + hi) >> 1;
            if (nums[m] < t) lo = m + 1;
            else hi = m;
        }
        return lo;
    };
    const lo = lowerBound(target);
    if (lo === n || nums[lo] !== target) return [-1, -1];
    const hi = lowerBound(target + 1);
    return [lo, hi - 1];
}

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int lo = lowerBound(nums, target);
        if (lo == nums.length || nums[lo] != target) return new int[]{-1, -1};
        int hi = lowerBound(nums, target + 1);
        return new int[]{lo, hi - 1};
    }

    private int lowerBound(int[] nums, int t) {
        int lo = 0, hi = nums.length;
        while (lo < hi) {
            int m = (lo + hi) >>> 1;
            if (nums[m] < t) lo = m + 1;
            else hi = m;
        }
        return lo;
    }
}

function searchRange(nums: number[], target: number): number[] {
    const n = nums.length;
    const lowerBound = (t: number): number => {
        let lo = 0, hi = n;
        while (lo < hi) {
            const m = (lo + hi) >> 1;
            if (nums[m] < t) lo = m + 1;
            else hi = m;
        }
        return lo;
    };
    const lo = lowerBound(target);
    if (lo === n || nums[lo] !== target) return [-1, -1];
    const hi = lowerBound(target + 1);
    return [lo, hi - 1];
}