---
title: '35. Search Insert Position'
description: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Binary Search", slug: "binary-search" }
video: "K-RYzDZkzCI"
issue: "https://github.com/prdlk/leetcode/issues/63"
companies:
  - { name: "Google", period: "Thirty Days", frequency: 50.2 }
  - { name: "Amazon", period: "Thirty Days", frequency: 39.1 }
  - { name: "Grammarly", period: "Three Months", frequency: 84.8 }
  - { name: "Bloomberg", period: "Three Months", frequency: 54 }
  - { name: "Meta", period: "Three Months", frequency: 49.8 }
  - { name: "tcs", period: "Three Months", frequency: 47.7 }
  - { name: "Microsoft", period: "Three Months", frequency: 42.1 }
  - { name: "Infosys", period: "Six Months", frequency: 56.2 }
sidebar:
  label: 'Search Insert Position'
  badge: 'Easy'
---

::::warning
You must write an algorithm with O(log n) runtime complexity.
::::

### Example 1:
- Input: `nums = [1,3,5,6], target = 5`
- Output: `2`

### Example 2:
- Input: `nums = [1,3,5,6], target = 2`
- Output: `1`

### Example 3:
- Input: `nums = [1,3,5,6], target = 7`
- Output: `4`

### Constraints:

- `1 <= nums.length <= 10^4`
- `-10^4 <= nums[i] <= 10^4`
- `nums` contains distinct values sorted in ascending order.
- `-10^4 <= target <= 10^4`

## Approach

```mermaid
flowchart TD
  S(["searchInsert(nums, target)"]) --> I["l = 0, r = n - 1"]
  I --> W{"l <= r?"}
  W -- yes --> M["m = (l + r) // 2"]
  M --> Q{"nums[m] vs target"}
  Q -- equal --> R(["return m"])
  Q -- "nums[m] < target" --> L["l = m + 1"]
  L --> W
  Q -- "nums[m] > target" --> H["r = m - 1"]
  H --> W
  W -- no --> E(["return (l + r) // 2 + 1 — the insert slot"])
```

## Solution

```py
class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        l, r = 0, len(nums) - 1

        while l <= r:
            m = (l + r) // 2
            if nums[m] == target:
                return m
            elif nums[m] < target:
                l = m + 1
            elif nums[m] > target:
                r = m - 1

        return (l + r) // 2 + 1
```