هوسي بلعبة LeetCode 41: غوص عميق في لغز أول عدد موجب مفقود

ⴰⵃⵍⴰⵢⵏ "ⴰⵎⴰⵣⴰⵖ ⴰⵎⵣⵔⴰⵢ ⴰⵎⵣⵡⴰⵔⵓ" ⵏ ⵍⵉⴽⵓⴷ (ⵓⵎⴰⵔ ٤١) ⵢⵓⵛⴽⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⵓⵃⴰⵕⴰ ⵏ ⵓⴽⵓⴷⴰⵢ ⵏⵏⵉ. ⵢⴰⵏ ⴰⵎⵓⵟⵃⴰⵍ ⴰⵎⵖⴰⵔ ⴰⵅⴰⵜⴰⵔ ⵢⴰⵜⵜⴰⵏ ⴰⴷ ⵢⵉⵍⵉ ⴰⵙⵓⵎⵎⴰⵢ ⵏ ⵉⵎⵙⴰⵡⴰⵍⵏ ⵏⵏⵉ، ⴰⵎⵎⴰ ⵉⵛⵛⴰⵕⵏ ⴰⴷ ⵏⵅⵕⵟ ⵜⴰⵎⵓⵃⴰⵕⴰ ⵏⵏⵙ ⴷ ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵎⴰⵣⴰⵖ ⵏ ⵜⴰⵢⴹⴰⵔⵉⴹ ⵏ ⵜⵢⴱⵉⵙⴽⵔⵉⴱⵜ ⴰⵎⵣⵡⴰⵔⵓ ⴰⵎⴽⵏ. ⴰⴷ ⵉⴳ ⵓⵣⵔⴰⵢ ⴰⴷ ⵉⴳ ⵎⴰⵢⴰⴷ ⵅⴼ ⵓⵎⴰⴹⴰⵍ ⵏ ⵜⵉⵎⵓⴽⴽⵓⵍⵏ ⵏ ⵓⴽⵓⴷⴰⵢ (ⵖⴰⵏ ⴰⴷ ⵢⵉⴳ ⵢⴰⵏ ⴰⵎⴰⵏⴹⵓ ⴰⵅⴰⵜⴰⵔ). ⵢⵉⴳ ⵅⴼ ⵓⵙⴰⵡⵔ ⴰⵎⴰⵖⴰⵏ ⵏ ⵓⵙⵎⵙⵙⵓⵜ, ⵜⴰⵎⵔⵓⵔⵜ ⵏ ⵜⴰⵎⵙⵙⵓⵍⵜ, ⴷ ⵜⴰⵎⵓⵖⴰⵕⵜ ⵜⴰⵎⴰⵖⴰⵏⵜ ⵏ ⵓⴽⵓⴷ ⴰⵎⵣⵡⴰⵔⵓ. ⴷ ⴰⵃⴰⵢ ⴰⴷ ⵉⴳ ⵢⴰⵏ ⴰⵎⵖⴰⵔ ⵏ ⵜⵎⴰⵜⵉⵖⵜ, ⴰⴷ ⵏⵙⵙⵓⵜⵔ ⵓⴹⴰⵕⴰⵏ ⵜⴰⵎⴰⵜⵉⵖⵉⵜ ⵏ ⵓⵎⴰⵣⴰⵖ.

ⴰⵎⵓⵟⵃⴰⵍ: ⴰⵏⴰⵎⵓⵔ ⴳ ⵜⴰⵎⵔⵎⵜ ⵏ ⵉⵏⵖⵔⴰⵏ

ⴰⵎⵓⵟⵃⴰⵍ ⵢⵓⵛⴽⴰ ⵢⴰⵏ ⴰⵖⴰⵔ ⴰⵎⴰⵔⵔⵓ ⵏ ⵉⵎⵣⵔⴰⵢⵏ. ⵜⴰⵅⴰⵕⴰ ⵏⵏⴽ: ⴰⴷ ⵜⵅⵜⴰⵔ ⴰⵎⵣⵔⴰⵢ ⴰⵎⵣⵡⴰⵔⵓ ⴰⵎⵎⵖⵓⵔ. ⵢⴰⵜⵜⴰⵏ ⴰⴷ ⵢⵉⴳ ⴰⵙⵙⵓⵎⴰⵢ ? ⵅⴼ ⵜⴰⴹⵕⴰⵢⵜ ⵏ ⵓⵣⵎⴰⵏ $O(n)$ ⴷ ⴰⵎⵓⵙⵙⵓⵔ $O(1)$ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵜⴰⴷⵔⵉⵎⵉⵜ ⵜⴰⵎⴰⵙⵙⵓⵍⵜ ⴰⴷ ⵉⴳ ⵢⴰⵏ ⵓⵎⵓⵟⵃⴰⵍ ⴰⵎⴰⵙⵜⴳⴰⵔ ⵏ ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ.

ⵉⵎⴰⵖⵓⵔⵏ ⴰⵎⵣⵡⴰⵔⵓⵏ: ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵙⵍⴰⵖ

ⵉⵎⴰⵖⵓⵔⵏ ⵏⵏⵉ ⴰⵎⵣⵡⴰⵔⵓⵏ ⵢⵓⵛⴽⴰⵏ ⴰⵙⵙⵍⴰⵖ (ⵎⴰ ⵢⵉⴳ ⴰⵎⵓⵟⵃⴰⵍ ⵏ ⵓⵣⵎⴰⵏ $O(n)$) ⴷ ⵜⴰⴹⵕⴰⵢⵜ ⵏ ⵜⴰⴹⴰⵔⵉⴹ (ⵎⴰ ⵢⵉⵖⵔ ⴰⵎⵓⵙⵙⵓⵔ $O(1)$). ⵙⴰⵖⵜ, ⵢⴰⵏ ⵓⵎⵙⴰⵡⴰⵍ ⴰⵎⵣⵡⴰⵔⵓ ⵢⴰⵊⵔⴰ ⵢⴰⵏ ⵓⵙⵎⵙⵙⵓⵜ ⴰⵎⴰⵙⵜⴳⴰⵔ.

ⵜⴰⵟⵟⵕⵜ ⵜⴰⵅⵕⵟⴰⵏⵜ: ⵜⴰⵎⵙⵙⴰⵔⵜ ⴳ ⵓⵣⴰⴳⵖ

ⵜⴰⵎⴰⵟⵟⵕⵜ ⵜⴰⵅⵕⵟⴰⵏⵜ ⵜⵉⴳⵉ ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵖⴰⵔ ⴰⵎⵖⴰⵔⵓ ⴰⵎⵎⴰ ⵢⴰⵏ ⵜⴰⵖⵉⵍⵜ ⵏ ⵜⴰⵎⵙⵜⴰⵔⵜ. ⵅⴼ ⵓⵙⵙⵓⴹⵓⵕ ⵉⵎⵏⵣⴰⵖⵏ, ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵎⵣⵔⴰⵢ $x$ ⴳ ⴰⵎⵎⴰⵙ $x - 1$ (ⵢⴰⵊ ⴰⴷ $1 \le x \le n$, ⵎⴰ ⵢⵉⴳ $n$ ⵜⴰⴹⴰⵔⴰⵢⵜ ⵏ ⴰⵖⴰⵔ). ⵜⴰⵎⵙⵙⴰⵔⵜ ⴳ ⵓⵣⴰⴳⵖ ⵜⵓⴹⴰⵖⵔ ⴰⵙⴰⵖ ⴰⴷ ⵢⵉⴳ ⵢⴰⵏ ⵓⵎⴰⵣⴰⵖ ⴰⵎⵣⵡⴰⵔⵓ.

ⵜⴰⵎⴰⵔⵓⵜ ⵏ ⵓⴽⵓⴷ: ⵢⴰⵏ ⴰⵙⵙⴰⵔⴰⵢ ⵏ ⵜⵢⴱⵉⵙⴽⵔⵉⴱⵜ

ⴷⴰ ⵉⴳ ⴰⵙⵎⴰⵍ ⵏ ⵜⴰⵎⴰⵔⵓⵜ ⵏ ⵓⴽⵓⴷ ⵏⵏⵉ, ⵙ ⵜⵉⴹⴰⵔⵉⵏ ⵉⵎⵣⵔⴰⵢⵏ ⴷ ⵜⵉⵎⴰⵜⵉⵖⵉⵏ ⵜⴰⵎⴰⵜⵉⵖⵉⵜ:

ⵜⴰⵎⵓⵔⵉ 1: ⵓⵎⵙⴰⵡⴰⵍ ⴰⵎⴰⵢⴰⴷ (ⵙ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ)

function firstMissingPositive(nums: number[]): number {
  const n = nums.length

  // ⴰⴷ ⵏⵅⵜⴰⵔ ⴽⵓ ⴰⵎⵣⵔⴰⵢ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙ ⴰⵎⵖⴰⵔ ⵢⴰⵊ ⴰⴷ ⵉⴳ ⴳ ⵓⵎⴰⵙⵙⴰ ⵏ [1, n]
  for (let i = 0; i < n; i++) {
    while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]) {
      const correctIndex = nums[i] - 1
      ;[nums[i], nums[correctIndex]] = [nums[correctIndex], nums[i]] // ⴰⵙⵙⵓⴹⵓⵕ
    }
  }

  // ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ
  for (let i = 0; i < n; i++) {
    if (nums[i] !== i + 1) {
      return i + 1
    }
  }

  // ⵢⴰⵊ ⴽⵓ ⵉⵎⵣⵔⴰⵢⵏ ⴳⵉⵙⵏ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙⵏ ⵉⵎⵖⴰⵔⵏ, ⴰⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⵢⴳⴰⵏ n + 1
  return n + 1
}

ⵜⴰⵎⵓⵔⵉ ⴰⴷ, ⵎⴰⵛⴰ ⵢⵉⴳ ⴰⵎⵖⵔⴰⵏ, ⵜⵛⵛⴰⵔ ⵙ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ. ⴰⵎⴰⵔ ⵏ ⵉⵎⵙⵓⵍⵍⴰⵏ ⴳ ⵓⵣⵎⴰⵏ ⴰⵎⴰⵖⵓⵔ ⵢⵓⵛⴽⴰ ⴰⴷ ⵢⵉⴳ $O(n^2)$, ⵎⴰⵛⴰ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ ⵜⵉⴳⵉ ⴰⴷ ⵜⵢⵉⵍⵉ ⴰⴷ ⵢⵉⴳ $O(n)$.

ⵜⵉⴹⴰⵔⵉⵏ:

1. ⴰⵙⵙⵓⴹⵓⵕ ⴰⵖⴰⵔ: ⴽⵓ ⴰⵎⵣⵔⴰⵢ nums[i] ⵢⵉⴳ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙ "ⴰⵎⵖⴰⵔ" (nums[i] - 1) ⵢⴰⵊ ⴰⴷ ⵉⴳ ⴳ ⵓⵎⴰⵙⵙⴰ ⵏ [1, n] ⴷ ⵎⴰ ⵉⴳ ⴳ ⵓⵣⵣⵓⵔⴰ ⴰⵎⵖⴰⵔ.

2. ⴰⵙⵙⵓⵙⵔ ⵏ ⵓⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ: ⴼⴰⵕ ⴰⵙⵙⵓⴹⵓⵕ, ⴰⵎⵎⴰⵙ ⴰⵎⵣⵡⴰⵔⵓ i ⵎⴰ ⵢⵉⴳ nums[i] !== i + 1 ⵢⵓⵔⵉ ⴰⴷ i + 1 ⵢⴳⴰⵏ ⵓⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⴰⵎⵎⵖⵓⵔ.

3. ⴰⴷ ⵜⵅⵜⴰⵔ n + 1 ⵢⴰⵊ ⵉⵊⵔⴰ: ⵢⴰⵊ ⴽⵓ ⵉⵎⵣⵔⴰⵢⵏ ⵙⴳ 1 ⴰⵔ n ⴳⵉⵙⵏ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙⵏ ⵉⵎⵖⴰⵔⵏ, ⴰⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⵢⴳⴰⵏ n + 1.

ⵉⵎⴰⵏⵉⵏ ⵉⵎⵖⴰⵔⵏ:

• ⴰⵙⵙⵓⴹⵓⵕ ⴳ ⵓⵣⴰⴳⵖ: ⵏⵙⵙⵓⴹⵓⵔ ⴰⵖⴰⵔ ⴰⵎⵎⴰ ⴰⴷ ⵏⵙⵙⵓⵜⵔ ⴰⵙⵉⵎⵏ.
• ⵜⴰⵎⵙⵙⵓⵍⵜ: ⴽⵓ ⵓⵙⵙⵓⴹⵓⵕ ⴷ ⵓⵙⴽⴽⴰⵎ ⴰⵎⵣⵡⴰⵔⵓ ⵢⵉⴳⵏ $O(n)$ ⵓⵣⵎⴰⵏ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵜⴰⵎⵙⵙⵓⵍⵜ ⵜⴰⵎⵣⵡⴰⵔⵓⵜ.

ⵜⴰⵎⵓⵔⵉ 2: ⵜⴰⵎⵙⵙⵓⵍⵜ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ (ⴰⵙⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ)

function firstMissingPositive(nums: number[]): number {
  const n = nums.length
  let idx = 0

  // ⴰⴷ ⵏⵙⵙⵓⴹⵓⵕ ⵉⵎⵣⵔⴰⵢⵏ ⴰⵔ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙⵏ ⵉⵎⵖⴰⵔⵏ ⵢⴰⵊ ⵉⵎⴽⵏ
  while (idx < n) {
    const correctIdx = nums[idx] - 1
    if (correctIdx >= 0 && correctIdx < n && nums[idx] !== nums[correctIdx]) {
      // ⴰⵙⵙⵓⴹⵓⵕ ⴼⴰⵕ ⵓⵙⵙⵓⵜⵔ ⵢⴰⵏ ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⴰⵢⴰⴷ
      ;[nums[idx], nums[correctIdx]] = [nums[correctIdx], nums[idx]]
    } else {
      idx++
    }
  }

  // ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ
  for (let i = 0; i < n; i++) {
    if (nums[i] !== i + 1) {
      return i + 1
    }
  }

  return n + 1
}

ⵜⵉⴹⴰⵔⵉⵏ:

1. ⴰⵙⵙⵓⴹⵓⵕ ⴰⵎⵣⵔⵔⴰⵢ:

   • ⵜⴰⴹⴰⵔⴰⵢⵜ while ⵜⵙⵙⵓⴹⵓⵔ ⵉⵎⵏⵣⴰⵖⵏ ⴰⵔ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙⵏ ⵉⵎⵖⴰⵔⵏ (nums[idx] - 1) ⵎⴰⵊ ⴰⵎⵣⵔⴰⵢ ⴳ ⵓⵎⴰⵙⵙⴰ ⴰⵎⵖⴰⵔ [1, n] ⴷ ⵎⴰ ⵉⴳ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙ ⴰⵎⵖⴰⵔ.
   • ⴰⴹⵕⴰⵢⵜ if ⵜⵓⵛⵛⴰⵔ ⵉⵎⵣⵔⴰⵢⵏ ⵉⵎⴰⵢⴰⴷⵏ ⵓ ⵉⵎⵖⴰⵔⵏ ⴼⴰⵕ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ.

2. ⴰⵙⵙⵓⵙⵔ ⵏ ⵉⵎⵎⴰⵙⵏ ⵉⵎⵖⴰⵔⵏ:

   • ⴳ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵙⵙⵓⴹⵓⵕ, ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ ⴷ ⵜⵉⵡⵡⵓⵔⵉⵏ ⵜⵉⵎⵖⵓⵔⵏ ⵜⵉⴳⵉⵏ ⵜⵉⴹⴰⵕⵏ ⴼⴰⵕ ⵓⵙⵙⵓⵙⵔ ⵏ ⵓⵎⴰⵙⵙⴰ ⴷ ⵜⴰⵏⵜⴰ ⵏ nums[idx].

3. ⴰⵙⵙⵓⴹⵓⵕ ⴰⵎⵣⵡⴰⵔⵓ ⴳ ⵓⵎⵓⵙⵙⵓⵔ:

   • ⴰⵙⵙⵓⵜⵔ ⵏ ⵜⴰⵙⵙⵓⴹⵓⵔⵜ ([nums[idx], nums[correctIdx]] = [nums[correctIdx], nums[idx]]) ⵢⵓⵛⵛⴰⵔ ⴰⴷ ⵢⵉⴳ ⵢⴰⵏ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⴰⵢⴰⴷ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ.

4. ⵜⴰⴹⴰⵔⴰⵢⵜⵏ ⵉⵎⵖⴰⵔⵏ:

   • ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⵜⵙⵙⵓⵜⵔ ⵎⴰⵊ ⵢⴰⵏⵏ ⵜⴰⴹⴰⵔⴰⵢⵜⵏ ⵉⵎⵖⴰⵔⵏ:
     • ⵢⴰⵜ ⴰⴷ ⵜⵙⵙⵓⴹⵓⵕ ⴰⵖⴰⵔ ⴳ ⵓⵣⴰⴳⵖ.
     • ⵢⴰⵜ ⵢⴰⴹⴰ ⴰⴷ ⵏⵅⵜⴰⵔ ⴰⵎⵣⵔⴰⵢ ⴰⵎⵎⵖⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ.

ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⵏ ⵜⴰⵎⵙⴰⵙⵜⴰ:

• ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵣⵎⴰⵏ:
  • ⵜⴰⴹⴰⵔⴰⵢⵜ while ⴷ ⵜⴰⴹⴰⵔⴰⵢⵜ for ⵜⵉⴳⵉⵏ $O(n)$, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⴳ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ ⵏ ⵓⵣⵎⴰⵏ $O(n)$.
• ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ:
  • ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⵜⵙⵙⵓⵜⵔ ⴳ ⵓⵣⴰⴳⵖ ⴼⴰⵕ ⵓⵙⵙⵓⵜⵔ ⴰⵢⵏ ⵓⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ, ⵎⴰⵊ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ ⵜⵉⴳⵉ $O(1)$.

ⵎⴰⵙⵙⴰ ⴰⴷ ⵉⴳ ⵓⴽⵓⴷ ⴰⵎⵣⵡⴰⵔⵓ:

• ⵜⴰⵎⵙⵙⵓⵍⵜ: ⵜⴰⴹⴰⵔⴰⵢⵜ while ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⵜⵓⵛⵛⴰⵔ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵜⴰⵎⵙⵙⵓⵍⵜ.
• ⵜⴰⵎⵙⵎⵓⵔⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ: ⴰⵙⵙⵓⵜⵔ ⵏ ⵓⵙⵙⵓⴹⵓⵕ ⴳ ⵓⵣⴰⴳⵖ ⴷ ⵓⵙⵙⵓⵜⵔ ⵏ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ ⵜⵓⵛⵛⴰⵔ ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⴰⵎⴽⵏ.

ⵜⴰⵎⵓⵔⵉ 3: ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⵅⴼ ⵓⵎⵓⵙⵙⵓⵔ (ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ)

function firstMissingPositive(nums: number[]): number {
  const n = nums.length
  let idx = 0

  while (idx < n) {
    const correctIdx = nums[idx] - 1

    if (correctIdx >= 0 && correctIdx < n && nums[idx] !== nums[correctIdx]) {
      nums[idx] = nums[correctIdx]
      nums[correctIdx] = correctIdx + 1
    } else {
      idx++
    }
  }

  for (let idx = 0; idx < n; idx++) {
    if (nums[idx] !== idx + 1) {
      return idx + 1
    }
  }

  return nums.length + 1
}

ⵜⵉⵎⵣⵔⵔⴰⵢⵜⵏ ⵉⵎⵖⴰⵔⵏ ⵏ ⵓⵎⵓⵙⵙⵓⵔ:

1. ⵜⵉⴹⴰⵔⵉⵏ ⴳ ⵓⵣⴰⴳⵖ ⵙ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ:

   • ⴼⴰⵕ ⵓⵙⵙⵓⵜⵔ ⵢⴰⵏ ⵓⵎⵓⵙⵙⵓⵔ temp ⵅⴼ ⴰⵙⵙⵓⴹⵓⵕ, ⵓⴽⵓⴷ ⴰⴷ ⵢⴰⵙⵙⵓⴹⵓⵔ ⴰⵖⴰⵔ ⵙ ⵓⵣⵣⵓⵔⴰ nums[idx] = nums[correctIdx]; nums[correctIdx] = correctIdx + 1.
   • ⴰⴷ ⵢⵓⵛⵛⴰⵔ ⴰⴷ ⵢⵉⴳ ⵢⴰⵏ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⴰⵢⴰⴷ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⵅⴼ ⵢⴰⵏ ⴰⵎⴰⵔ.

2. ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ ⴳ ⵜⴰⴹⴰⵔⴰⵢⵜ:

   • ⵓⴽⵓⴷ ⵢⵉⵙⴽⴰⵍⴽⵓⵍ ⴰⴷ correctIdx ⴳ ⵜⴰⴹⴰⵔⴰⵢⵜ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⴷ ⵢⵉⴳ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ ⴼⴰⵕ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ.
   • ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ ⵢⵉⴳⵏ ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⵅⴼ ⴽⵓ ⵜⴰⵙⵜⵉⵔⵉ.

3. ⵢⴰⵜ ⵜⴰⴹⴰⵔⴰⵢⵜ ⵅⴼ ⵓⵙⵙⵓⴹⵓⵕ:

   • ⴼⴰⵕ ⵓⴽⵓⴷ ⴰⵎⵣⵡⴰⵔⵓ ⵎⴰ ⵢⵉⴳ ⵓⵙⵙⵓⵜⵔ ⵉⵎⴰⵢⴰⴷⵏ ⴳ ⵜⴰⴹⴰⵔⴰⵢⵜ while, ⵜⴰⵎⵙⵙⴰⵔⵜ ⴰⴷ ⵜⴰⵙⴽⵔ ⵜⵉⵙⵙⵓⴹⵓⵔⵏ ⵓ ⵜⴰⵥⴹⴰⵕⵜ ⵏ ⴰⵎⵎⴰⵙ ⵙ ⵢⴰⵏ ⵓⵙⴰⵡⵔ ⴰⵎⵣⵔⵔⴰⵢ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴰⵎⴰⵕ ⵏ ⵓⵙⴽⴽⴰⵎ ⵏ ⵓⵙⵜⵔⴰⴽ ⴷ ⵓⵎⵓⵙⵙⵓⵔ.
   • ⵜⴰⵙⵎⴰⵍⵜ ⵏ ⵜⴰⴹⴰⵔⴰⵢⵜ (while ⵙ ⵢⴰⵏ ⵓⵣⵔⵓⵢ ⵓ ⵢⴰⵏ ⵓⵙⵙⵓⴹⵓⵕ) ⵜⵉⴳⵉ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ.

4. ⵎⴰ ⵉⴳ ⵉⵙⵙⵓⵙⵔⵏ ⵉⵎⵖⵓⵔⵏ:

   • ⵉⵙⵙⵓⵙⵔⵏ ⵅⴼ correctIdx >= 0 && correctIdx < n && nums[idx] !== nums[correctIdx] ⵜⵉⴳⵉⵏ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⴷ ⵜⵓⵛⵛⴰⵔ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ ⵎⴰ ⵢⵉⴳ ⴰⴷ ⵢⵉⵍⵉⵏ ⴰⴷ ⵢⵉⵙⵙⵓⵜⵔⵏ ⵓⵎⵓⵙⵙⵓⵔ ⵏ ⵜⴰⵙⵜⴽⴰⵎ ⵓ ⵜⴰⵖⵉⵍⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ ⵏ ⵓⵙⴽⴽⴰⵎ.
   • ⴰⴷ ⵢⵓⵛⵛⴰⵔ ⴰⴷ ⵢⵉⴳ ⴰⴷ ⵢⵉⵍⵉ ⴰⴷ ⵢⵉⵙⵙⵓⵜⵔⵏ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ ⵅⴼ ⵜⵉⵡⵡⵓⵔⵉⵏ ⵎⴰ ⵢⵉⴳ ⴰⴷ ⵉⴳⵏ ⴰⴷ ⵉⵙⵎⵙⵍⵏ ⴰⵔ ⵜⴰⵏⵜⴰ.

ⵎⴰⵙⵙⴰ ⴰⴷ ⵢⵉⴳ ⴰⴷ ⵢⵉⵍⵉ ⵢⴰⵏ ⵓⴹⴰⵕⴰⵏ ⴳ ⵓⵎⵓⵙⵙⵓⵔ:

• ⴰⵙⵙⵓⵜⵔ ⵏ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ: ⴼⴰⵕ ⴰⴷ ⵢⵉⴳ ⵢⴰⵏ ⵓⵎⵓⵙⵙⵓⵔ temp ⴷ ⴰⴷ ⵢⵉⵙⴽⴰⵍⴽⵓⵍ ⵜⵉⵡⵡⵓⵔⵉⵏ ⵉⵎⴰⵢⴰⴷⵏ, ⴰⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⵢⴳⴰⵏ ⴰⵎⵣⵡⴰⵔⵓ.
• ⵜⴰⵙⵜⵉⵔⵉ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ: ⵜⴰⵙⵜⵉⵔⵉⵏ ⵉⵎⴰⵢⴰⴷⵏ ⴷ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵜⴰⵎⴰⵖⴰⵏⵜ ⵜⵉⴳⵉⵏ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⵅⴼ ⴽⵓ ⵜⴰⵙⵜⵉⵔⵉ.
• ⵜⴰⵎⵙⵙⵓⵍⵜ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⵏ ⵓⵙⴽⴽⴰⵎ: ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⵏ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ ⵏ ⴰⵙⵙⵓⵙⵔ ⵜⴰⵎⴰⵖⴰⵏⵜ, ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵙⵙⵓⵙⵔ ⵏ ⵓⵙⴽⴽⴰⵎ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ, ⵜⴰⴷⵔⵉⵎⵉⵜ ⵜⵓⵛⵛⴰⵔ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ.

ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⴰⴷ ⵜⵉⴳⵉ ⴰⵙⵙⵓⵍ ⵅⴼ ⵜⵉⴹⴰⵔⵉⵏ ⵏ ⵓⵙⵙⵓⴹⵓⵕ ⴳ ⵓⵣⴰⴳⵖ, ⵓⵙⵙⵓⵜⵔ ⵏ ⵉⵎⵓⵙⵙⵓⵔⵏ ⵉⵎⴰⵢⴰⴷⵏ, ⴷ ⵜⴰⵎⵙⵙⵓⵍⵜ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⵏ ⵓⵙⴽⴽⴰⵎ ⵜⵉⴳⵉ ⵜⴰⵎⵣⵡⴰⵔⵓⵜ ⴳ ⵜⴰⵎⵙⵎⵓⵔⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ. ⵎⴰⵛⴰ ⴰⴷ ⵢⵉⴳⵏ ⵜⴰⵎⵖⵓⵔⵉⵏ ⵜⵉⴳⵉⵏ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ ($O(1)$), ⵜⵉⴳⵉⵏ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ ⴰⴷ ⵜⵉⵙⵎⵙⵍⵏ ⴳ ⵉⵎⴰⴽⵏ ⵓⵎⵖⴰⵔⵏ ⴰⵎⵎⴰ ⵍⵉⴽⵓⴷ, ⵖⴰⵏ ⵅⴼ ⵉⵎⴰⵙⵙⴰⵏ ⵉⵖⴰⵔⵏ.

ⵜⴰⵎⵓⵔⵉ 4: ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⵜⴰⵎⵣⵔⵔⴰⵢⵜ (ⴰⵙⵙⵓⴹⵓⵕ ⴳ ⵓⵣⴰⴳⵖ, ⵎⴰ ⵉⴳ ⵜⴰⵎⵓⵙⵙⵓⵔ)

function firstMissingPositive(nums: number[]): number {
  for (let i = 0; i < nums.length; i++) {
    while (nums[i] !== i + 1) {
      if (nums[i] <= 0 || nums[i] > nums.length || nums[i] === nums[nums[i] - 1]) {
        break
      }

      const temp = nums[i]
      nums[i] = nums[temp - 1]
      nums[temp - 1] = temp
    }
  }

  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== i + 1) {
      return i + 1
    }
  }

  return nums.length + 1
}

ⵜⴰⵎⵓⵔⵉ ⴰⵎⵣⵡⴰⵔⵓ ⴰⴷ ⵜⵓⵛⵛⴰⵔ ⴽⵓ ⵜⴰⵎⵙⵙⵓⵍⵜ ⵜⴰⵎⵣⵡⴰⵔⵓⵜ ⴷ ⵓⵎⵓⵙⵙⵓⵔ ⴰⵎⵣⵡⴰⵔⵓ ⵅⴼ ⴰⵙⵙⵓⴹⵓⵕ ⴰⵎⵣⵔⵔⴰⵢ ⴳ ⵓⵣⴰⴳⵖ ⴼⴰⵕ ⵢⴰⵏ ⵓⵎⵓⵙⵙⵓⵔ. ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵣⵎⴰⵏ ⵜⵉⴳⵉ ⴰⴷ ⵢⵉⴳ $O(n)$, ⴷ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵎⵓⵙⵙⵓⵔ ⵜⵉⴳⵉ $O(1)$, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⴽⵓ ⵉⵎⵖⵔⴰⵏ. ⴳ ⵜⵎⴰⵜⵉⵖⵜ, ⵏⵙⵙⵓⵜⵔⵏ ⵢⴰⵏ ⵓⵖⴰⵔ ⵏ ⵜⴰⵎⴰⵙⵜⴳⴰⵔⵜ ⴳ ⴰⵖⴰⵔ ⴰⴷ ⵏⵅⵜⴰⵔ ⵉⵎⵏⵣⴰⵖⵏ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙⵏ "ⵉⵎⵖⴰⵔⵏ".

ⵅⴼ ⵓⵙⵙⵓⴹⵓⵕ ⵢⴰⵏ ⵓⵙⵙⵓⵙⵔ (nums[i] === nums[nums[i] - 1]), ⵏⵙⵙⵓⴹⵓⵔ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ. ⴰⴷ ⵢⵉⴳ ⴰⴷ ⵢⵉⵙⵙⵓⵍⵜ ⵜⴰⵎⵙⵙⵓⵍⵜ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵜⴰⴹⴰⵕⴰⵢⵜ ⵏ ⵓⵣⵎⴰⵏ ⴰⴷ ⵜⵢⵉⵍⵉ ⴰⵔ ⴰⵎⵖⵔⴰⵏ ⴰⵎⵣⵡⴰⵔⵓ $O(n)$.

ⵉⵎⵖⵔⴰⵏ ⵉⵎⵖⴰⵔⵏ ⴳ ⵜⴰⵎⵙⵙⴰⵔⵜ:

1. ⴰⵙⵙⵓⵜⵔ ⵏ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ:

   • ⵓⴽⵓⴷ ⴰⴷ ⵢⵓⵔⵉ ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⴳ nums[i] === nums[nums[i] - 1] ⴼⴰⵕ ⴰⴷ ⵢⵉⴳ ⴰⵙⵙⵓⴹⵓⵕ. ⴰⴷ ⵢⵓⵛⵛⴰⵔ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ ⵎⴰ ⵢⵉⴳ ⴰⵎⵣⵔⴰⵢ ⴳ ⵓⵣⵣⵓⵔⴰ ⴰⵎⵖⴰⵔ ⵓ ⵉⵎⵖⵓⵔⵏ ⵉⵍⵍⴰⵏ.
   • ⴳ ⵜⴰⵎⵙⵙⴰⵔⵜ ⴰⵎⵣⵡⴰⵔⵓ, ⴰⵙⵙⵓⵙⵔ ⴰⴷ ⵢⵉⴳ ⴰⵎⵎⵖⵓⵔ, ⴰⵎⵎⴰ ⴰⴷ ⵢⵉⵍⵉ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ ⵎⴰ ⵢⵉⴳ ⵉⵎⵖⵓⵔⵏ. ⴽⵓ ⴰⵙⵙⵓⴹⵓⵕ ⴰⵎⴰⵢⴰⴷ ⵢⴰⵖⵔ ⵜⴰⵡⵡⵓⵔⵉ, ⵖⴰⵏ ⵅⴼ ⵉⵎⴰⵙⵙⴰⵏ ⵉⵖⴰⵔⵏ.

2. ⴰⵙⵙⵓⵙⵔ ⵏ ⵓⵎⴰⵙⵙⴰ ⵉⵎⵖⴰⵔⵏ:

   • ⵓⴽⵓⴷ ⴰⴷ ⵢⵉⵙⵙⵓⵜⵔ while (nums[i] !== i + 1) ⴰⴷ ⵢⵉⴳ ⴰⵎⵣⵔⴰⵢ ⵢⵉⵙⵙⵓⴹⵓⵔ ⴳ ⵓⵣⵣⵓⵔⴰ ⵏⵏⵙ ⴰⵎⵖⴰⵔ ⴰⵔ ⴰⴷ ⵢⵉⴳ ⴳ ⵓⵣⵣⵓⵔⴰ ⴰⵎⵖⴰⵔ ⵓ ⵢⴰⵏ ⵓⴹⵕⴰⵢ ⴰⵎⴰⵢⴰⴷ ⵉⵍⵍⴰ. ⴰⴷ ⵢⵓⵛⵛⴰⵔ ⵜⵉⵡⵡⵓⵔⵉⵏ ⵜⵉⵎⵖⵓⵔⵏ ⵏ ⵜⴰⴹⴰⵔⴰⵢⵜ.
   • ⵓⴽⵓⴷ ⴰⵎⵣⵡⴰⵔⵓ ⵎⴰ ⵢⵉⴳ ⴰⴷ ⵢⵉⵙⵙⵓⵙⵔ ⴰⵎⵣⵔⴰⵢ ⴰⵔ ⴰⵎⵎⴰⵙ ⵏⵏⵙ ⴰⵎⵖⴰⵔ ⴳ ⵓⴹⵕⴰⵢⵜ ⵏ ⵜⴰⴹⴰⵔⴰⵢⵜ. ⴰⴷ ⵢⵉⵙⵙⵓⵜⵔ ⴰⵎⴰⵔ ⵏ ⵜⵉⵡⵡⵓⵔⵉⵏ ⴳ ⵉⵎⴰⵙⵙⴰⵏ ⵎⴰ ⵢⵉⵖⵔⵏ ⵜⵉⵎⵙⴹⵓⵕⵏ.

3. ⵉⵙⵙⵓⵙⵔⵏ ⵉⵎⵖⴰⵔⵏ ⵉⵎⵖⴰⵔⵏ:

   • ⵅⴼ ⵓⵙⵙⵓⴹⵓⵕ ⵉⴹⵕⴰⵢⵜⵏ ⴳ ⵢⴰⵜ if (ⵎⴰⵊ nums[i] <= 0 || nums[i] > nums.length || nums[i] === nums[nums[i] - 1]), ⵓⴽⵓⴷ ⴰⴷ ⵢⵓⵛⵛⴰⵔ ⵜⴰⵡⵡⵓⵔⵉ ⵜⵉⵎⵖⵓⵔⵏ ⵙⴳ ⵉⵙⵙⵓⵙⵔⵏ ⵓ ⵜⵉⵙⴽⴰⵍⴽⵓⵍⵉⵏ ⵉⵎⵖⵓⵔⵏ.

ⵎⴰⵙⵙⴰ ⴰⴷ ⵢⵉⴳ ⴰⴷ ⵢⵉⵍⵉ ⴳ ⵍⵉⴽⵓⴷ:

• ⵜⴰⵎⵙⵎⵓⵔⵜ ⵜⴰⵎⴰⵙⵙⴰⵏⵜ:

  • ⵜⴰⵎⵙⵎⵓⵔⵜ ⵏ ⵓⵣⵎⴰⵏ ⵏ ⵍⵉⴽⵓⴷ ⵜⵉⴳⵉ ⵜⴰⵎⵙⵜⴳⴰⵔⵜ ⴰⵔ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ, ⵎⴰⵊ ⵉⵎⵙⵓⵍⵍⴰⵏ ⵉⵎⵖⵓⵔⵏ ⵓ ⵉⵙⵙⵓⵙⵔⵏ