33. Search in rotated array

int search(int *nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

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

        if (nums[mid] >= nums[left]) {
            if (target < nums[mid] && target >= nums[left])
                right = mid - 1;
            else
                left = mid + 1;
        } else {
            if (target <= nums[right] && target > nums[mid])
                left = mid + 1;
            else
                right = mid - 1;
        }
    }

    return -1;
}

33_solution1.cpp

#include <vector>
using namespace std;

class Solution {
public:
  int search(vector<int> &nums, int target) {
    int left = 0, right = nums.size() - 1;

    while (left <= right) {
      int mid = left + (right - left) / 2;

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

      if (nums[mid] >= nums[left]) {
        if (target < nums[mid] && target >= nums[left])
          right = mid - 1;
        else
          left = mid + 1;
      } else {
        if (target <= nums[right] && target > nums[mid])
          left = mid + 1;
        else
          right = mid - 1;
      }
    }

    return -1;
  }
};

33_solution2.cpp

#include <vector>
using namespace std;

class Solution {
public:
  int search(vector<int> &nums, int target) {
    int left = 0, right = nums.size() - 1;

    while (left <= right) {
      int mid = left + (right - left) / 2;

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

      if (nums[mid] > nums[right]) {
        if (target <= nums[right] || target > nums[mid]) {
          left = mid + 1;
        } else {
          right = mid - 1;
        }
      } else {
        if (target <= nums[right] && target > nums[mid])
          left = mid + 1;
        else
          right = mid - 1;
      }
    }

    return -1;
  }
};

package main

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1

    for left <= right {
        mid := left + (right-left)/2

        if nums[mid] == target {
            return mid
        }

        if nums[mid] >= nums[left] {
            if target < nums[mid] && target >= nums[left] {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else {
            if target <= nums[right] && target > nums[mid] {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }

    return -1
}

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

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

            if (nums[mid] >= nums[left]) {
                if (target < nums[mid] && target >= nums[left])
                    right = mid - 1;
                else
                    left = mid + 1;
            } else {
                if (target <= nums[right] && target > nums[mid])
                    left = mid + 1;
                else
                    right = mid - 1;
            }
        }

        return -1;
    }
}

class Solution {
  search(nums, target) {
    let left = 0, right = nums.length - 1;

    while (left <= right) {
      const mid = left + Math.floor((right - left) / 2);

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

      if (nums[mid] >= nums[left]) {
        if (target < nums[mid] && target >= nums[left]) right = mid - 1;
        else left = mid + 1;
      } else {
        if (target <= nums[right] && target > nums[mid]) left = mid + 1;
        else right = mid - 1;
      }
    }
    return -1;
  }
}

class Solution:
    def search(self, nums: list[int], target: int) -> int:
        left, right = 0, len(nums) - 1

        while left <= right:
            mid = left + (right - left) // 2

            if nums[mid] == target:
                return mid

            if nums[mid] >= nums[left]:
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1

        return -1

struct Solution;

impl Solution {
    fn search(nums: Vec<i32>, target: i32) -> i32 {
        let mut left = 0i32;
        let mut right = nums.len() as i32 - 1;

        while left <= right {
            let mid = left + (right - left) / 2;
            let (l, m) = (left as usize, mid as usize);

            if nums[m] == target {
                return mid;
            }

            if nums[m] >= nums[l] {
                if target < nums[m] && target >= nums[l] {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                let r = right as usize;
                if target <= nums[r] && target > nums[m] {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }

        -1
    }
}