update 0005 ~ 0007

Author: ruoru

Algorithms/0005.longest_palindromic_substring/README.md

@@ -17,17 +17,18 @@ Output: "bb"
 ## 解题思路
 题目要求寻找字符串中的最长回文。
 当然，我们可以使用下面的程序判断字符串s[i:j+1]是否是回文。
-```go
-func isPalindromic(s *string, i, j int ) bool {
-    for  i< j {
-        if (*s)[i] != (*s)[j] {
-            return false
-        } 
-        i++
-        j--
+```rust
+let expand_around_center = |left: i32, right: i32| -> (usize, usize) {
+    let mut l = left;
+    let mut r = right;
+
+    while l >= 0 && r < n as i32 && s_chars[l as usize] == s_chars[r as usize] {
+        l -= 1;
+        r += 1;
     }
-    return true
-}
+
+    ((l + 1) as usize, (r - l - 1) as usize)
+};
 ```
 但是，这样就没有利用回文的一下特点，假定回文的长度为l，x为任意字符
 1. 当l为奇数时，回文的`正中间段`只会是，“x”，或“xxx”，或“xxxxx”，或...

Algorithms/0005.longest_palindromic_substring/longest_palindromic_substring.rs

@@ -1,54 +1,37 @@
-package problem0005
-
-func longestPalindrome(s string) string {
-	if len(s) < 2 { // 肯定是回文，直接返回
-		return s
-	}
-
-	// 最长回文的首字符索引，和最长回文的长度
-	begin, maxLen := 0, 1
-
-	// 在 for 循环中
-	// b 代表回文的**首**字符索引号，
-	// e 代表回文的**尾**字符索引号，
-	// i 代表回文`正中间段`首字符的索引号
-	// 在每一次for循环中
-	// 先从i开始，利用`正中间段`所有字符相同的特性，让b，e分别指向`正中间段`的首尾
-	// 再从`正中间段`向两边扩张，让b，e分别指向此`正中间段`为中心的最长回文的首尾
-	for i := 0; i < len(s); { // 以s[i]为`正中间段`首字符开始寻找最长回文。
-		if len(s)-i <= maxLen/2 {
-			// 因为i是回文`正中间段`首字符的索引号
-			// 假设此时能找到的最长回文的长度为l, 则，l <= (len(s)-i)*2 - 1
-			// 如果，len(s)-i <= maxLen/2 成立
-			// 则，l <= maxLen - 1
-			// 则，l < maxLen
-			// 所以，无需再找下去了。
-			break
-		}
-
-		b, e := i, i
-		for e < len(s)-1 && s[e+1] == s[e] {
-			e++
-			// 循环结束后，s[b:e+1]是一串相同的字符串
-		}
-
-		// 下一个回文的`正中间段`的首字符只会是s[e+1]
-		// 为下一次循环做准备
-		i = e + 1
-
-		for e < len(s)-1 && b > 0 && s[e+1] == s[b-1] {
-			e++
-			b--
-			// 循环结束后，s[b:e+1]是这次能找到的最长回文。
-		}
-
-		newLen := e + 1 - b
-		// 创新记录的话，就更新记录
-		if newLen > maxLen {
-			begin = b
-			maxLen = newLen
-		}
-	}
-
-	return s[begin : begin+maxLen]
-}
+impl Solution {
+    pub fn longest_palindrome(s: String) -> String {
+
+        let n = s.len();
+        if n < 2 {
+            return s;
+        }
+
+        let chars: Vec<char> = s.chars().collect();
+        let mut start = 0;
+        let mut max_len = 1;
+
+        let expand_around_center = |left: i32, right: i32| -> (usize, usize) {
+            let mut l = left;
+            let mut r = right;
+
+            while l >= 0 && r < n as i32 && s_chars[l as usize] == s_chars[r as usize] {
+                l -= 1;
+                r += 1;
+            }
+
+            ((l + 1) as usize, (r - l - 1) as usize)
+        };
+
+        for i in 0..n {
+            let (start1, len1) = expand_around_center(i as i32, i as i32);
+            let (start2, len2) = expand_around_center(i as i32, (i + 1) as i32);
+
+            if len1 > max_len {
+                start = start1;
+                max_len = len1;
+            }
+        }
+        
+        s[start..start + max_len].to_string()
+    }
+}

Algorithms/0005.longest_palindromic_substring/longest_palindromic_substring_test.rs

@@ -1,64 +1,47 @@
-package problem0005
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type para struct {
-	one string
-}
-
-type ans struct {
-	one string
+struct Solution;
+
+impl Solution {
+    pub fn longest_palindrome(s: String) -> String {
+        if s.is_empty() {
+            return String::new();
+        }
+
+        let chars: Vec<char> = s.chars().collect();
+        let n = chars.len();
+        let mut start = 0;
+        let mut max_len = 1;
+
+        // 动态规划数组，dp[i][j] 表示 s[i..=j] 是否为回文串
+        let mut dp = vec![vec![false; n]; n];
+
+        // 所有长度为 1 的子串都是回文串
+        for i in 0..n {
+            dp[i][i] = true;
+        }
+
+        // 检查长度为 2 及以上的子串
+        for len in 2..=n {
+            for i in 0..n - len + 1 {
+                let j = i + len - 1;
+                if len == 2 {
+                    dp[i][j] = chars[i] == chars[j];
+                } else {
+                    dp[i][j] = dp[i + 1][j - 1] && chars[i] == chars[j];
+                }
+
+                if dp[i][j] && len > max_len {
+                    start = i;
+                    max_len = len;
+                }
+            }
+        }
+
+        chars[start..start + max_len].iter().collect()
+    }
 }
 
-type question struct {
-	p para
-	a ans
-}
-
-func Test_OK(t *testing.T) {
-	ast := assert.New(t)
-
-	qs := []question{
-		question{
-			p: para{
-				one: "babad",
-			},
-			a: ans{
-				one: "bab",
-			},
-		},
-		question{
-			p: para{
-				one: "cbbd",
-			},
-			a: ans{
-				one: "bb",
-			},
-		},
-		question{
-			p: para{
-				one: "abbcccddcccbba",
-			},
-			a: ans{
-				one: "abbcccddcccbba",
-			},
-		},
-		question{
-			p: para{
-				one: "a",
-			},
-			a: ans{
-				one: "a",
-			},
-		},
-	}
-
-	for _, q := range qs {
-		a, p := q.a, q.p
-		ast.Equal(a.one, longestPalindrome(p.one), "输入:%v", p)
-	}
+fn main() {
+    let result = Solution::longest_palindrome("babad".to_string());
+    let result2 = Solution::longest_palindrome("abbcccddcccbba".to_string());
+    println!("{}, {}", result, result2);
 }

Algorithms/0006.zigzag_conversion/README.md

@@ -13,10 +13,6 @@ Y   I   R
 And then read line by line: "PAHNAPLSIIGYIR"
 Write the code that will take a string and make this conversion given a number of rows:
 
-```go
-func convert(text string, nRows int) string
-```
-
 convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".
 
 ## 解题思路

Algorithms/0006.zigzag_conversion/zigzag_conversion.rs

@@ -1,40 +1,23 @@
-package problem0006
-
-import (
-	"bytes"
-)
-
-func convert(s string, numRows int) string {
-	if numRows == 1 || len(s) <= numRows {
-		return s
-	}
-
-	res := bytes.Buffer{}
-	// p pace 步距
-	p := numRows*2 - 2
-
-	// 处理第一行
-	for i := 0; i < len(s); i += p {
-		res.WriteByte(s[i])
-	}
-
-	// 处理中间的行
-	for r := 1; r <= numRows-2; r++ {
-		// 添加r行的第一个字符
-		res.WriteByte(s[r])
-
-		for k := p; k-r < len(s); k += p {
-			res.WriteByte(s[k-r])
-			if k+r < len(s) {
-				res.WriteByte(s[k+r])
-			}
-		}
-	}
-
-	// 处理最后一行
-	for i := numRows - 1; i < len(s); i += p {
-		res.WriteByte(s[i])
-	}
-
-	return res.String()
-}
+impl Solution {
+    pub fn convert(s: String, num_rows: i32) -> String {
+        let num_rows = num_rows as usize;
+        if num_rows <= 1 || s.len() <= num_rows {
+            return s;
+        }
+
+        let mut rows: Vec<String> = vec![String::new(); num_rows];
+        let mut row_index = 0;
+        let mut direction = 1;
+
+        for c in s.chars() {
+            rows[row_index].push(c);
+            row_index = (row_index as i32 + direction) as usize;
+
+            if row_index == 0 || row_index == num_rows - 1 {
+                direction *= -1;
+            }
+        }
+
+        rows.concat()
+    }
+}