Fixed chars for length_of_longest_substring

Author: u2

src/length_of_longest_substring.rs

@@ -3,14 +3,14 @@
 
 use std::collections::VecDeque;
 
-pub fn length_of_longest_substring(s: String) -> usize {
-    let array = s.as_bytes();
-    let mut c: VecDeque<u8> = VecDeque::with_capacity(array.len());
+pub fn length_of_longest_substring(s: &str) -> usize {
+    let array: Vec<(char)> = s.char_indices().map(|i| i.1).collect::<Vec<_>>();
+    let mut c: VecDeque<(char)> = VecDeque::with_capacity(s.char_indices().count());
     let mut max: usize = 0;
 
     for x in array.iter() {
         if c.contains(x) {
-            let mut z: Option<u8> = c.pop_front();
+            let mut z: Option<char> = c.pop_front();
             while z != Some(*x) {
                 z = c.pop_front();
             }
@@ -35,9 +35,9 @@ pub fn length_of_longest_substring(s: String) -> usize {
 
 use std::collections::HashMap;
 
-pub fn approach_two(s: String) -> usize {
-    let array = s.as_bytes();
-    let mut reviews: HashMap<&u8, usize> = HashMap::with_capacity(array.len());
+pub fn approach_two(s: &str) -> usize {
+    let array: Vec<(char)> = s.char_indices().map(|i| i.1).collect::<Vec<_>>();
+    let mut reviews: HashMap<&char, usize> = HashMap::with_capacity(s.char_indices().count());
     let mut i: usize = 0;
     let mut index: usize = 0;
     let mut max: usize = 0;
@@ -62,54 +62,58 @@ mod test {
 
     #[test]
     fn test_length_of_longest_substring() {
-        assert_eq!(length_of_longest_substring(String::from("world")), 5);
+        assert_eq!(length_of_longest_substring("world"), 5);
 
-        assert_eq!(length_of_longest_substring(String::from("hello world")), 6);
+        assert_eq!(length_of_longest_substring("hello world"), 6);
 
-        assert_eq!(length_of_longest_substring(String::from("helloworld")), 5);
+        assert_eq!(length_of_longest_substring("helloworld"), 5);
 
-        assert_eq!(length_of_longest_substring(String::from("abcabcbb")), 3);
+        assert_eq!(length_of_longest_substring("abcabcbb"), 3);
 
-        assert_eq!(length_of_longest_substring(String::from("bbbbb")), 1);
+        assert_eq!(length_of_longest_substring("bbbbb"), 1);
 
-        assert_eq!(length_of_longest_substring(String::from("pwwkew")), 3);
+        assert_eq!(length_of_longest_substring("pwwkew"), 3);
 
-        assert_eq!(length_of_longest_substring(String::from("b")), 1);
+        assert_eq!(length_of_longest_substring("b"), 1);
 
-        assert_eq!(length_of_longest_substring(String::from("")), 0);
+        assert_eq!(length_of_longest_substring(""), 0);
+
+        assert_eq!(length_of_longest_substring("大大小小"), 2);
     }
 
     use super::approach_two;
 
     #[test]
     fn test_approach_two() {
-        assert_eq!(approach_two(String::from("world")), 5);
+        assert_eq!(approach_two("world"), 5);
+
+        assert_eq!(approach_two("hello world"), 6);
 
-        assert_eq!(approach_two(String::from("hello world")), 6);
+        assert_eq!(approach_two("helloworld"), 5);
 
-        assert_eq!(approach_two(String::from("helloworld")), 5);
+        assert_eq!(approach_two("abcabcbb"), 3);
 
-        assert_eq!(approach_two(String::from("abcabcbb")), 3);
+        assert_eq!(approach_two("bbbbb"), 1);
 
-        assert_eq!(approach_two(String::from("bbbbb")), 1);
+        assert_eq!(approach_two("pwwkew"), 3);
 
-        assert_eq!(approach_two(String::from("pwwkew")), 3);
+        assert_eq!(approach_two("b"), 1);
 
-        assert_eq!(approach_two(String::from("b")), 1);
+        assert_eq!(approach_two(""), 0);
 
-        assert_eq!(approach_two(String::from("")), 0);
+        assert_eq!(approach_two("大大小小"), 2);
     }
 
     use test::Bencher;
     // 96 ns/iter (+/- 26)
     #[bench]
     fn bench_length_of_longest_substring(b: &mut Bencher) {
-        b.iter(|| length_of_longest_substring(String::from("hello world")));
+        b.iter(|| length_of_longest_substring("hello world"));
     }
 
     // 561 ns/iter (+/- 180)
     #[bench]
     fn bench_approach_two(b: &mut Bencher) {
-        b.iter(|| approach_two(String::from("hello world")));
+        b.iter(|| approach_two("hello world"));
     }
 }