feat: add solutions to lcci problem: No.08.03

No.08.03.Magic Index

Author: YangFong

lcci/08.03.Magic Index/README.md

@@ -151,6 +151,93 @@ func find(nums []int, left, right int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findMagicIndex(nums: number[]): number {
+    const n = nums.length;
+    const find = (l: number, r: number): number => {
+        if (l > r) {
+            return -1;
+        }
+        const mid = l + Math.floor((r - l) / 2);
+        const l_res = find(l, mid - 1);
+        if (l_res !== -1) {
+            return l_res;
+        }
+        if (nums[mid] === mid) {
+            return mid;
+        }
+        const r_res = find(mid + 1, r);
+        if (r_res !== -1) {
+            return r_res;
+        }
+        return -1;
+    };
+    return find(0, n - 1);
+}
+```
+
+```ts
+function findMagicIndex(nums: number[]): number {
+    const n = nums.length;
+    let i = 0;
+    while (i < n) {
+        if (nums[i] === i) {
+            return i;
+        }
+        i = Math.max(nums[i], i + 1);
+    }
+    return -1;
+}
+```
+
+## **Rust**
+
+```rust
+impl Solution {
+    fn find(nums: &Vec<i32>, l: usize, r: usize) -> i32 {
+        if l >= r {
+            return -1;
+        }
+        let mid = l + (r - l) / 2;
+        let l_res = Self::find(nums, l, mid);
+        if l_res != -1 {
+            return l_res;
+        }
+        if nums[mid] == mid as i32 {
+            return mid as i32;
+        }
+        let r_res = Self::find(nums, mid + 1, r);
+        if r_res != -1 {
+            return r_res;
+        }
+        -1
+    }
+
+    pub fn find_magic_index(nums: Vec<i32>) -> i32 {
+        Self::find(&nums, 0, nums.len())
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn find_magic_index(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut i = 0 as i32;
+        while (i as usize) < n {
+            let num = nums[i as usize];
+            if num == i {
+                return i;
+            }
+            i = num.max(i + 1);
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```

lcci/08.03.Magic Index/README_EN.md

@@ -151,6 +151,93 @@ func find(nums []int, left, right int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findMagicIndex(nums: number[]): number {
+    const n = nums.length;
+    const find = (l: number, r: number): number => {
+        if (l > r) {
+            return -1;
+        }
+        const mid = l + Math.floor((r - l) / 2);
+        const l_res = find(l, mid - 1);
+        if (l_res !== -1) {
+            return l_res;
+        }
+        if (nums[mid] === mid) {
+            return mid;
+        }
+        const r_res = find(mid + 1, r);
+        if (r_res !== -1) {
+            return r_res;
+        }
+        return -1;
+    };
+    return find(0, n - 1);
+}
+```
+
+```ts
+function findMagicIndex(nums: number[]): number {
+    const n = nums.length;
+    let i = 0;
+    while (i < n) {
+        if (nums[i] === i) {
+            return i;
+        }
+        i = Math.max(nums[i], i + 1);
+    }
+    return -1;
+}
+```
+
+## **Rust**
+
+```rust
+impl Solution {
+    fn find(nums: &Vec<i32>, l: usize, r: usize) -> i32 {
+        if l >= r {
+            return -1;
+        }
+        let mid = l + (r - l) / 2;
+        let l_res = Self::find(nums, l, mid);
+        if l_res != -1 {
+            return l_res;
+        }
+        if nums[mid] == mid as i32 {
+            return mid as i32;
+        }
+        let r_res = Self::find(nums, mid + 1, r);
+        if r_res != -1 {
+            return r_res;
+        }
+        -1
+    }
+
+    pub fn find_magic_index(nums: Vec<i32>) -> i32 {
+        Self::find(&nums, 0, nums.len())
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn find_magic_index(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut i = 0 as i32;
+        while (i as usize) < n {
+            let num = nums[i as usize];
+            if num == i {
+                return i;
+            }
+            i = num.max(i + 1);
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```

lcci/08.03.Magic Index/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn find_magic_index(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut i = 0 as i32;
+        while (i as usize) < n {
+            let num = nums[i as usize];
+            if num == i {
+                return i;
+            }
+            i = num.max(i + 1);
+        }
+        -1
+    }
+}

lcci/08.03.Magic Index/Solution.ts

@@ -0,0 +1,11 @@
+function findMagicIndex(nums: number[]): number {
+    const n = nums.length;
+    let i = 0;
+    while (i < n) {
+        if (nums[i] === i) {
+            return i;
+        }
+        i = Math.max(nums[i], i + 1);
+    }
+    return -1;
+}