الفرز والبحث

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

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (nums[mid] === target) {
      return mid;
    } else if (nums[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return -1;
}

var solution = function (isBadVersion) {
  return function (n) {
    let left = 1;
    let right = n;

    while (left < right) {
      const mid = left + Math.floor((right - left) / 2);
      if (isBadVersion(mid)) {
        right = mid;
      } else {
        left = mid + 1;
      }
    }

    return left;
  };
};

function isPerfectSquare(num) {
  if (num < 2) return true;

  let left = 2;
  let right = Math.floor(num / 2);

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

    if (square === num) {
      return true;
    } else if (square < num) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return false;
}

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

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

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

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

  return -1;
}

function findPeakElement(nums) {
  let left = 0;
  let right = nums.length - 1;

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

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

  return left;
}

function minEatingSpeed(piles, h) {
  let left = 1;
  let right = Math.max(...piles);

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

    for (const pile of piles) {
      totalHours += Math.ceil(pile / mid);
    }

    if (totalHours <= h) {
      right = mid;
    } else {
      left = mid + 1;
    }
  }

  return left;
}

function searchMatrix(matrix, target) {
  const rows = matrix.length;
  const cols = matrix[0].length;
  let left = 0;
  let right = rows * cols - 1;

  while (left <= right) {
    const mid = left + Math.floor((right - left) / 2);
    const midValue = matrix[Math.floor(mid / cols)][mid % cols];

    if (midValue === target) {
      return true;
    } else if (midValue < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return false;
}

var TimeMap = function () {
  this.map = new Map();
};

TimeMap.prototype.set = function (key, value, timestamp) {
  if (!this.map.has(key)) {
    this.map.set(key, []);
  }
  this.map.get(key).push([value, timestamp]);
};

TimeMap.prototype.get = function (key, timestamp) {
  if (!this.map.has(key)) return "";

  const entries = this.map.get(key);
  let left = 0;
  let right = entries.length - 1;
  let result = "";

  while (left <= right) {
    const mid = left + Math.floor((right - left) / 2);
    if (entries[mid][1] <= timestamp) {
      result = entries[mid][0];
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return result;
};

function findMedianSortedArrays(nums1, nums2) {
  if (nums1.length > nums2.length) {
    [nums1, nums2] = [nums2, nums1];
  }

  const m = nums1.length;
  const n = nums2.length;
  let left = 0;
  let right = m;

  while (left <= right) {
    const partitionX = Math.floor((left + right) / 2);
    const partitionY = Math.floor((m + n + 1) / 2) - partitionX;

    const maxX =
      partitionX === 0 ? -Infinity : nums1[partitionX - 1];
    const minX =
      partitionX === m ? Infinity : nums1[partitionX];
    const maxY =
      partitionY === 0 ? -Infinity : nums2[partitionY - 1];
    const minY =
      partitionY === n ? Infinity : nums2[partitionY];

    if (maxX <= minY && maxY <= minX) {
      if ((m + n) % 2 === 0) {
        return (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2;
      } else {
        return Math.max(maxX, maxY);
      }
    } else if (maxX > minY) {
      right = partitionX - 1;
    } else {
      left = partitionX + 1;
    }
  }

  throw new Error("Input arrays are not sorted");
}

function maxDistance(position, m) {
  position.sort((a, b) => a - b);

  let left = 1;
  let right = Math.floor(
    (position[position.length - 1] - position[0]) / (m - 1)
  );

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

    if (canPlaceBalls(position, m, mid)) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return right;
}

function canPlaceBalls(position, m, minForce) {
  let count = 1;
  let lastPosition = position[0];

  for (let i = 1; i < position.length; i++) {
    if (position[i] - lastPosition >= minForce) {
      count++;
      lastPosition = position[i];
      if (count >= m) return true;
    }
  }

  return false;
}