update 0088 0118

Author: xiyou

Algorithms/0003.longest_substring_without_repeating_characters/longest_substring_without_repeating_characters.rs

@@ -1,7 +1,7 @@
 use std::cmp::max;
 
-pub fn longest_substring_without_repeating_characters (s: String) -> usize {
-
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
     let mut start = 0;
     let mut end = 0;
 
@@ -34,9 +34,12 @@ pub fn longest_substring_without_repeating_characters (s: String) -> usize {
         result = max(result, end - start);
     }
 
-    return result;
+    return result as i32;
+    }
 }
 
+
+
 fn main() {
     let s = String::from("Hello world");
     let result = longest_substring_without_repeating_characters(s);

Algorithms/0004.median_of_two_sorted_arrays/median_of_two_sorted_arrays.rs

@@ -1,60 +1,62 @@
 use std::cmp;
 use std::mem;
 
-pub fn median_of_two_sorted_arrays (v1: Vec<i32>, v2: Vec<i32>) -> f32 {
+impl Solution {
+    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
+        let mut vec1 = nums1;
+        let mut vec2 = nums2;
 
-    let mut vec1 = v1;
-    let mut vec2 = v2;
-
-    if vec1.len() > vec2.len() {
-        mem::swap(&mut vec1, &mut vec2);
-    }
+        if vec1.len() > vec2.len() {
+            mem::swap(&mut vec1, &mut vec2);
+        }
 
-    let len1 = vec1.len();
-    let len2 = vec2.len();
+        let len1 = vec1.len();
+        let len2 = vec2.len();
 
-    let half_len = (len1 + len2 + 1) / 2;
-    let mut index_min = 0;
-    let mut index_max = len1;
+        let half_len = (len1 + len2 + 1) / 2;
+        let mut index_min = 0;
+        let mut index_max = len1;
 
-    while index_min <= index_max {
-        let i = (index_min + index_max) / 2;
-        let j = half_len - i;
+        while index_min <= index_max {
+            let i = (index_min + index_max) / 2;
+            let j = half_len - i;
 
-        if i < len1 && vec1[i] < vec2[j - 1] {
-            index_min = i + 1;
-        } else if i > 0 && vec1[i-1] > vec2[j] {
-            index_max = i - 1;
-        } else {
-            let left_max;
-            let right_min;
-            if i == 0 {
-                left_max = vec2[j - 1];
-            } else if j == 0 {
-                left_max = vec1[i-1];
+            if i < len1 && vec1[i] < vec2[j - 1] {
+                index_min = i + 1;
+            } else if i > 0 && vec1[i-1] > vec2[j] {
+                index_max = i - 1;
             } else {
-                left_max = cmp::max(vec1[i-1], vec2[j-1]);
-            }
+                let left_max;
+                let right_min;
+                if i == 0 {
+                    left_max = vec2[j - 1];
+                } else if j == 0 {
+                    left_max = vec1[i-1];
+                } else {
+                    left_max = cmp::max(vec1[i-1], vec2[j-1]);
+                }
 
-            if (len1 + len2) % 2 == 1 {
-                return left_max as f32;
-            }
+                if (len1 + len2) % 2 == 1 {
+                    return left_max as f64;
+                }
 
-            if i == len1 {
-                right_min = vec2[j];
-            } else if j == len2 {
-                right_min = vec1[i];
-            } else {
-                right_min = cmp::min(vec1[i], vec2[j]);
-            }
+                if i == len1 {
+                    right_min = vec2[j];
+                } else if j == len2 {
+                    right_min = vec1[i];
+                } else {
+                    right_min = cmp::min(vec1[i], vec2[j]);
+                }
 
-            return (left_max + right_min) as f32 / 2.0
+                return (left_max + right_min) as f64 / 2.0
+            }
         }
-    }
 
-    return 0.0;
+        return 0.0;
+    }
 }
 
+
 fn main() {
     let vec1 = vec![9, 13, 17, 19];
 	let vec2 = vec![2, 7, 9, 14, 15, 24, 28, 38];

Algorithms/0088.merge_sorted_array/merge_sorted_array.rs

@@ -1,32 +1,49 @@
-package problem0088
+pub struct Solution {}
 
-// 本题的要求是，把nums1的前m项和nums2的前n项合并，放入nums1中。
-func merge(nums1 []int, m int, nums2 []int, n int) {
-	// 深度复制 nums1
-	temp := make([]int, m)
-	copy(temp, nums1)
+impl Solution {
+    pub fn merge(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) {
+        let mut v = vec![];
+        let mut i: usize = 0;
+        let mut j: usize = 0;
+        let _m: usize = if m as usize > nums1.len() {
+            nums1.len()
+        } else {
+            m as usize
+        };
+        let _n: usize = if n as usize > nums2.len() {
+            nums2.len()
+        } else {
+            n as usize
+        };
 
-	j, k := 0, 0
-	for i := 0; i < len(nums1); i++ {
-		// nums2用完了
-		if k >= n {
-			nums1[i] = temp[j]
-			j++
-			continue
-		}
-		// temp 用完了
-		if j >= m {
-			nums1[i] = nums2[k]
-			k++
-			continue
-		}
-		// 比较后，放入
-		if temp[j] < nums2[k] {
-			nums1[i] = temp[j]
-			j++
-		} else {
-			nums1[i] = nums2[k]
-			k++
-		}
-	}
+        while i < _m || j < _n {
+            if i == _m && j < _n {
+                v.push(nums2[j]);
+                j += 1;
+                continue;
+            } else if i < _m && j == _n {
+                v.push(nums1[i]);
+                i += 1;
+                continue;
+            }
+
+            let v1 = nums1[i];
+            let v2 = nums2[j];
+
+            if v1 < v2 {
+                i += 1;
+                v.push(v1);
+            } else if v1 > v2 {
+                j += 1;
+                v.push(v2);
+            } else {
+                i += 1;
+                j += 1;
+                v.push(v1);
+                v.push(v2);
+            }
+        }
+
+        *nums1 = v;
+    }
 }

Algorithms/0088.merge_sorted_array/merge_sorted_array_test.rs

@@ -1,70 +1,10 @@
-package problem0088
+mod merge_sorted_array;
+use merge_sorted_array::Solution;
 
-import (
-	"fmt"
-	"testing"
+fn main() {
+    let mut vec1 = vec![9, 13, 17, 19];
+    let mut vec2 = vec![2, 7, 9, 14, 15, 24, 28, 38];
 
-	"github.com/stretchr/testify/assert"
-)
-
-type question struct {
-	para
-	ans
-}
-
-// para 是参数
-// one 代表第一个参数
-type para struct {
-	one []int
-	m   int
-	two []int
-	n   int
-}
-
-// ans 是答案
-// one 代表第一个答案
-type ans struct {
-	one []int
-}
-
-func Test_Problem0088(t *testing.T) {
-	ast := assert.New(t)
-
-	qs := []question{
-
-		question{
-			para{[]int{0}, 0, []int{1}, 1},
-			ans{[]int{1}},
-		},
-
-		question{
-			para{[]int{1, 0}, 1, []int{2}, 1},
-			ans{[]int{1, 2}},
-		},
-
-		question{
-			para{[]int{}, 0, []int{1}, 1},
-			ans{[]int{}},
-		},
-
-		question{
-			para{[]int{1, 3, 5, 7}, 4, []int{2, 4}, 2},
-			ans{[]int{1, 2, 3, 4}},
-		},
-
-		question{
-			para{[]int{1, 3, 5, 7}, 4, []int{2, 2}, 2},
-			ans{[]int{1, 2, 2, 3}},
-		},
-
-		// 如需多个测试，可以复制上方元素。
-	}
-
-	for _, q := range qs {
-		a, p := q.ans, q.para
-		fmt.Printf("~~%v~~\n", p)
-
-		merge(p.one, p.m, p.two, p.n)
-		ast.Equal(a.one, p.one, "输入:%v", p)
-	}
+    Solution::merge(&mut vec1, 4,&mut vec2, 5);
+    println!("{:?}", vec1);
 }

Algorithms/0118.pascals_triangle/pascals_triangle.rs

@@ -1,30 +1,51 @@
-package problem0118
+pub struct Solution {}
 
-func generate(numRows int) [][]int {
-	res := [][]int{}
-	if numRows == 0 {
-		return res
-	}
+// fn factorial(num: i32) -> i32 {
+//     if num == 0 {
+//         return 1;
+//     }
 
-	res = append(res, []int{1})
-	if numRows == 1 {
-		return res
-	}
+//     let mut result = 1;
+//     for i in 1..(num + 1) {
+//         result *= i;
+//     }
 
-	for i := 1; i < numRows; i++ {
-		res = append(res, genNext(res[i-1]))
-	}
+//     return result;
+// }
 
-	return res
-}
+//fn combination(c: i32, m: i32) -> i32 {
+//    return factorial(c) / (factorial(c - m) * factorial(m));
+//}
 
-func genNext(p []int) []int {
-	res := make([]int, 1, len(p)+1)
-	res = append(res, p...)
+fn combination(c: i32, m: i32) -> i32 {
+    let mut cv: u128 = 1;
+    let mut mv: u128 = 1;
+    for i in (c - m + 1)..(c + 1) {
+        cv *= i as u128;
+    }
 
-	for i := 0; i < len(res)-1; i++ {
-		res[i] += res[i+1]
-	}
+    for i in 1..(m + 1) {
+        mv *= i as u128;
+    }
 
-	return res
+    let r = cv / mv;
+    return r as i32;
 }
+
+impl Solution {
+    pub fn generate(num_rows: i32) -> Vec<Vec<i32>> {
+        let mut v = vec![];
+
+        let _numrows = num_rows + 1;
+
+        for i in 0..num_rows {
+            let mut sv : Vec<i32> = Vec::new();
+            for j in 0..(i+1) {
+                sv.push(combination(i, j));
+            }
+            v.push(sv);
+        }
+
+        return v;
+    }
+}