q34

Author: OhBonsai

.gitignore

@@ -1,2 +1,3 @@
 .idea
-target
+target
+venv

Cargo.lock

@@ -7,3 +7,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+array = {path="./array"}

Cargo.toml

@@ -0,0 +1,64 @@
+import pytest
+from typing import List
+
+
+def search_range(nums: List[int], target: int) -> List[int]:
+    if len(nums) == 0:
+        return [-1, -1]
+
+    if len(nums) == 1:
+        if nums[0] == target:
+            return [0, 0]
+        else:
+            return [-1, -1]
+
+
+    left, right, pos = 0, len(nums) - 1, len(nums)
+
+    while left <= right:
+        mid = int((left + right) / 2 )
+
+        if nums[mid] > target:
+            right = mid - 1
+        elif nums[mid] < target:
+            left = mid + 1
+        else:
+            pos = mid
+            break
+
+    
+    if pos > len(nums) - 1 or nums[pos] != target:
+        return [-1, -1]
+
+    
+    start, end = pos, pos
+
+    while start > 0 and nums[start] == target:
+        start -= 1
+
+    if nums[0] == target:
+        start = 0
+    else:
+        start += 1
+
+    while end < len(nums) and nums[end] == target:
+        end += 1
+
+    if nums[-1] == target:
+        end = len(nums) - 1
+    else:
+        end -= 1
+
+    return [start, end]
+
+
+def test_1():
+    assert search_range([5, 7, 7, 8, 8, 10], 8) == [3,4]
+    assert search_range([5, 7, 7, 8, 8, 10], 6) == [-1, -1]
+    assert search_range([2, 2], 1) == [-1, -1]
+    assert search_range([1, 2, 3], 1) == [0, 0]
+    assert search_range([1, 4], 4) == [1, 1]
+
+
+if __name__ == '__main__':
+    pytest.main(["./q34.py", "-v", "-s"])

array/src/q34.py

@@ -0,0 +1,101 @@
+use std::io::{self, Write};
+
+struct Solution ();
+impl Solution {
+
+    pub fn helper(nums: &Vec<i32>, target: i32) -> usize {
+
+        if nums[0] == target {
+            return 0
+        }
+
+        let mut l = 0;
+        let mut r = nums.len() - 1;
+        let mut a = nums.len();
+
+        while l <= r && r != 0 {
+            let m = (l + r) / 2;
+            println!("{} {} {}", l, m ,r);
+            if nums[m] > target {
+                r = if m >= 1 { m - 1 } else { 0  };
+            } else if nums[m] < target {
+                l = m + 1;
+            } else {
+                a = m;
+                break
+            }
+        }
+
+        if r == 0 && nums.last().unwrap() == &target {
+            nums.len() - 1
+        } else {
+            a
+        }
+    }
+
+    pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        match nums.len() {
+            0 => vec![-1, -1],
+            1 if nums[0] == target => vec![0, 0],
+            1 => vec![-1, -1],
+            _ => {
+                let hit = Solution::helper(&nums, target);
+                println!("{}", hit);
+                if  hit < nums.len() && nums[hit] == target {
+                    let mut s = hit;
+                    let mut e = hit;
+
+                    while s >0 && nums[s] == target {
+                        s = s - 1
+                    }
+                    if nums[0] == target {
+                        s = 0
+                    } else {
+                        s = s + 1
+                    }
+
+                    while e < nums.len() && nums[e] == target {
+                        e = e + 1
+                    }
+                    if nums.last().unwrap() == &target {
+                        e = nums.len() - 1
+                    } else {
+                        e = e - 1
+                    }
+
+                    vec![s as i32, e as i32]
+                } else {
+                    vec![-1, -1]
+                }
+            }
+        }
+
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test] fn test_1() {
+        println!("hello");
+        // assert_eq!(Solution::search_range(
+        //     vec![5,7,7,8,8,10], 8
+        // ), vec![3, 4]);
+        // assert_eq!(Solution::search_range(
+        //     vec![5,7,7,8,8,10], 6
+        // ), vec![-1, -1]);
+        // assert_eq!(Solution::search_range(
+        //     vec![2, 2], 1
+        // ), vec![-1, -1]);
+        //
+        // assert_eq!(Solution::search_range(
+        //     vec![1,2,3], 1
+        // ), vec![0, 0]);
+
+        assert_eq!(Solution::search_range(
+            vec![1,4], 4
+        ), vec![1, 1])
+    }
+}