class Solution {

   public int[] searchRange(int[] nums, int target) {

    int si=0;

    int ei=nums.length-1;

    int[] ans=new int[]{-1,-1};

while(si<=ei){

    int mid=si+(ei-si)/2;

    if(nums[mid]==target){

        si=mid-1;ei=mid+1;

        // search for first index with while loop in -ve  direction

        while(si>=0&&nums[si]==target){si--;}

        ans[0]=si+1;

        // search for ending index in +ve direction

        while(ei<nums.length&&nums[ei]==target){ei++;}

        ans[1]=ei-1;

        return ans;

    }

    else if(target>nums[mid]){

        si=mid+1;

    }

    else ei=mid-1;

}

    return ans;

}

}

class Solution {

    public int[] searchRange(int[] array, int target){

      int[] index = {-1, -1};

      int start = 0;

      int end = array.length-1;

      while (start <= end) {

          int mid = start + (end - start) / 2;

          if (array[mid] >= target) end = mid - 1;

          else start = mid + 1;

          if (array[mid] == target) index[0] = mid;

      }

​

      // resetting the start and end

      start = 0;

      end = array.length-1;

      while (start <= end){

          int mid = start  + (end-start) / 2;

          if (array[mid] <= target) start = mid+1;

          else end = mid-1;

          if (array[mid] == target) index[1] = mid;

      }

      return index;

    }

}

class Solution {

    public int[] searchRange(int[] nums, int target){

        int[] ans = new int[2];

        ans[0] = searchElementIndex(nums, target, true);

        ans[1] = searchElementIndex(nums, target, false);

        return ans;

    }

​

    public int searchElementIndex(int[] nums, int target, boolean findFirstIndex){

        int index = -1;

        int start = 0;

        int end = nums.length-1;

​

        while (start <= end) {

            int mid = start + (end-start) / 2;

​

            if (findFirstIndex){

                if (nums[mid] >= target) end = mid-1;

                else start = mid+1;

            }else {

                if (nums[mid] <= target) start = mid+1;

                else end = mid-1;

            }

            if (nums[mid]==target) index = mid;

        }

        return index;

    }

}

class Solution {

public:

    vector<int> searchRange(vector<int>& nums, int target) {

    }

};

class Solution {

    public int[] searchRange(int[] nums, int target) {

    }

}

​

/**

 * Note: The returned array must be malloced, assume caller calls free().

 */

int* searchRange(int* nums, int numsSize, int target, int* returnSize){

​

}

public class Solution {

    public int[] SearchRange(int[] nums, int target) {

    }

}

/**

 * @param {number[]} nums

 * @param {number} target

 * @return {number[]}

 */

var searchRange = function(nums, target) {

};

# @param {Integer[]} nums

# @param {Integer} target

# @return {Integer[]}

def search_range(nums, target)

end

class Solution {

    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {

    }

}

class Solution {

​

    /**

     * @param Integer[] $nums

     * @param Integer $target

     * @return Integer[]

     */

    function searchRange($nums, $target) {

    }

}