Implemented problem 14, improved readability of problems 3 and 4

src/bin/14_longest_common_prefix.rs

@@ -2,15 +2,18 @@ fn main() {
 
 }
 
-// TODO: imlpement
 pub fn longest_common_prefix(strs: Vec<String>) -> String {
     let mut result = String::with_capacity(200);
-    let index = 0;
+    let first_str = strs[0].as_bytes();
-    loop {
+    if first_str.is_empty() { return result; }
-        let c = strs[0].as_bytes()[index];
+    for i in 0..first_str.len() {
-        for str in strs.iter() {
+        let c = first_str[i];
-
+        for j in 1..strs.len() {
+            if i >= strs[j].len() || c != strs[j].as_bytes()[i] {
+                return result;
+            }
         }
+        result.push(c as char);
     }
     return result;
-}
+}

src/bin/15_3sum.rs

@@ -0,0 +1,8 @@
+fn main() {
+
+}
+
+pub fn three_sum(nums: Vec<i32>) -> Vec<Vec<i32>> {
+    
+    return vec![];
+}

src/bin/3_longest_substring_without_repeating_characters.rs

@@ -6,15 +6,15 @@ fn main() {
 
 pub fn length_of_longest_substring(s: String) -> i32 {
     let mut seen: HashMap<char, usize> = HashMap::with_capacity(80);
-    let (mut start_index, mut max_length) = (0usize, 0i32);
+    let (mut start_index, mut max_length) = (0usize, 0usize);
     for (i, c) in s.chars().enumerate() {
         if let Some(index) = seen.get(&c) {
-            max_length = max_length.max((i - start_index) as i32);
+            max_length = max_length.max(i - start_index);
             start_index = *index + 1;
             seen.retain(|_, i| *i >= start_index);
         }
         seen.insert(c, i);
     }
-    max_length = max_length.max((s.len() - start_index) as i32);
+    max_length = max_length.max(s.len() - start_index);
-    return max_length;
+    return max_length as i32;
 }

src/bin/4_median_of_two_sorted_arrays.rs

@@ -18,7 +18,5 @@ pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
             n += 1;
         }
     }
-    let mut result = nums3[length / 2] as f64;
+    return (nums3[(length - 1) / 2] + nums3[length / 2]) as f64 / 2.0;
-    if length % 2 == 0 { result = (result + nums3[length / 2 - 1] as f64) / 2.0; }
-    return result;
 }