Поиск в сортированном массиве

public class Solution
{
    public static int Search(List<int> nums, int target)
    {
        // Ответ будет находиться в элементе, указывающем на left
        // Поэтому сдвигаем right на 1 вправо, чтобы left мог принимать
        // значения [0, nums.Count - 1], то есть от первого и до последнего
        // индекса включительно
        int left = 0, right = nums.Count;
        while (right - left > 1)
        {
            int mid = (left + right) / 2;
            if (nums[mid] <= target)
            {
                left = mid;
            }
            else
            {
                right = mid;
            }
        }
        return nums[left] == target ? left : -1;
    }
}

#include <vector>

using namespace std;

int search(const vector<int>& nums, int target) {
    // ответ будет находиться в элементе, указывающем на l
    // поэтому сдвигаем r на 1 вправо, чтобы l мог принимать
    // значения [0, len(nums) - 1], то есть от первого и до последнего
    // индекса включительно
    int l = 0, r = nums.size();
    while (r - l > 1) {
        int m = (l + r) / 2;
        if (nums[m] <= target) {
            l = m;
        } else {
            r = m;
        }
    }
    return nums[l] == target ? l : -1;
}

package main

func search(nums []int, target int) int {
    // ответ будет находиться в элементе, указывающем на l
    // поэтому сдвигаем r на 1 вправо, чтобы l мог принимать
    // значения [0, len(nums) - 1], то есть от первого и до последнего
    // индекса включительно
    l, r := 0, len(nums)
    for r-l > 1 {
        m := (l + r) / 2
        if nums[m] <= target {
            l = m
        } else {
            r = m
        }
    }
    if nums[l] == target {
        return l
    }
    return -1
}

import java.util.List;

public class Solution {
    public int search(List<Integer> nums, int target) {
        // ответ будет находиться в элементе, указывающем на l
        // поэтому сдвигаем r на 1 вправо, чтобы l мог принимать
        // значения [0, nums.size() - 1], то есть от первого и до последнего
        // индекса включительно
        int l = 0, r = nums.size();
        while (r - l > 1) {
            int m = (l + r) / 2;
            if (nums.get(m) <= target) {
                l = m;
            } else {
                r = m;
            }
        }
        return nums.get(l) == target ? l : -1;
    }
}

from typing import *

def search(nums: List[int], target: int) -> int:
    # ответ будет находится в элементе указывающим на l
    # поэтому сдвигаем r на 1 вправо, чтобы l мог принимать
    # значения [0, len(nums) - 1] т е от первого и до последнего
    # индекса включительно
    l, r = 0, len(nums)
    while r - l > 1:
        m = (l + r) // 2
        if nums[m] <= target:
            l = m
        else:
            r = m
    return l if nums[l] == target else -1

export function search(nums, target) {
    // ответ будет находится в элементе указывающим на l
    // поэтому сдвигаем r на 1 вправо, чтобы l мог принимать
    // значения [0, len(nums) - 1] т е от первого и до последнего
    // индекса включительно
    let l = 0;
    let r = nums.length;

    while (r - l > 1) {
        const m = Math.floor((l + r) / 2);
        if (nums[m] <= target) {
            l = m;
        } else {
            r = m;
        }
    }

    return nums[l] === target ? l : -1;
}