solve problem aylei#5

Author: aylei

src/lib.rs

@@ -2,3 +2,4 @@ mod n0001_two_sum;
 mod n0002_add_two_numbers;
 mod n0003_longest_substring;
 mod n0004_median_of_two_sorted_arrays;
+mod n0005_longest_palindromic_substring;

src/main.rs

@@ -69,7 +69,8 @@ fn build_desc(content: &str) -> String {
         .replace("</b>", "")
         .replace("</pre>", "")
         .replace("<pre>", "")
-        .replace("&nbsp;", "")
+        .replace("&nbsp;", " ")
+        .replace("&quot;", "\"")
         .replace("\n\n", "\n")
         .replace("\n", "\n * ")
 }

src/n0003_longest_substring.rs

@@ -1,12 +1,7 @@
 /**
  * [3] Longest Substring Without Repeating Characters
  *
- * You are given two non-empty linked lists representing two non-negative
- * integers. The digits are stored in reverse order and each of their nodes
- * contain a single digit. Add the two numbers and return it as a linked list.
- *
- * You may assume the two numbers do not contain any leading zero, except the
- * number 0 itself.
+ * Given a string, find the length of the longest substring without repeating characters.
  *
  * Example:
  *
@@ -21,7 +16,22 @@ pub struct Solution {}
 
 impl Solution {
     pub fn length_of_longest_substring(s: String) -> i32 {
+        let seq: Vec<char> = s.chars().collect();
+        let len = seq.len();
+        let (mut start, mut end, mut max) = (0, 0, 0);
 
+        while end < len {
+            for idx in start..end {
+                if seq[end] == seq[idx] {
+                    start = idx + 1;
+                    break
+                }
+            }
+            let curr = end - start + 1;
+            if curr > max { max = curr }
+            end += 1
+        }
+        max as i32
     }
 }
 

src/n0004_median_of_two_sorted_arrays.rs

@@ -5,7 +5,7 @@
  * 
  * Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
  * 
- * You may assume nums1 and nums2cannot be both empty.
+ * You may assume nums1 and nums2 cannot be both empty.
  * 
  * Example 1:
  * 
@@ -32,7 +32,7 @@ pub struct Solution {}
 
 impl Solution {
     pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
-        
+        1.0
     }
 }
 
@@ -44,5 +44,7 @@ mod tests {
 
     #[test]
     fn test_4() {
+        assert_eq!(Solution::find_median_sorted_arrays(vec![1, 3], vec![2]), 2.0);
+        assert_eq!(Solution::find_median_sorted_arrays(vec![1, 2], vec![3, 4]), 2.5);
     }
 }

src/n0005_longest_palindromic_substring.rs

@@ -0,0 +1,70 @@
+/**
+ * [5] Longest Palindromic Substring
+ *
+ * Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: "babad"
+ * Output: "bab"
+ * Note: "aba" is also a valid answer.
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: "cbbd"
+ * Output: "bb"
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn longest_palindrome(s: String) -> String {
+        let seq: Vec<char> = s.chars().collect();
+        let len = seq.len();
+        if len < 1 {return s}
+        let (mut idx, mut curr_len, mut curr_start, mut curr_end) = (0, 0, 0, 0);
+        while idx < len {
+            let (mut i, mut j) = (idx, idx);
+            let ch = seq[idx];
+            // handle same char
+            while i > 0 && seq[i - 1] == ch { i -= 1 };
+            while j < len - 1 && seq[j + 1] == ch { j += 1 };
+            idx = j + 1;
+            while i > 0 && j < len - 1 && seq[i - 1] == seq[j + 1] {
+                i -= 1; j +=1;
+            }
+            let max_len = j - i + 1;
+            if max_len > curr_len {
+                curr_len = max_len; curr_start = i; curr_end = j;
+            }
+            if max_len >= len - 1 {
+                break;
+            }
+        }
+
+        s[curr_start..curr_end+1].to_owned()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_5() {
+        assert_eq!(Solution::longest_palindrome("aaaaa".to_owned()), "aaaaa");
+        assert_eq!(Solution::longest_palindrome("babab".to_owned()), "babab");
+        assert_eq!(Solution::longest_palindrome("babcd".to_owned()), "bab");
+        assert_eq!(Solution::longest_palindrome("cbbd".to_owned()), "bb");
+        assert_eq!(Solution::longest_palindrome("bb".to_owned()), "bb");
+        assert_eq!(Solution::longest_palindrome("".to_owned()), "");
+    }
+}