feat: update solutions to lcof problems: 46,48

- 面试题46. 把数字翻译成字符串
- 面试题48. 最长不含重复字符的子字符串

Author: YangFong

lcof/面试题46. 把数字翻译成字符串/README.md

@@ -148,6 +148,27 @@ function translateNum(num: number): number {
 }
 ```
 
+```ts
+function translateNum(num: number): number {
+    const s = num + '';
+    const n = s.length;
+    let res = 1;
+    const dfs = (i: number) => {
+        if (i >= n) {
+            return;
+        }
+        const val = Number(s[i - 1] + s[i]);
+        if (val >= 10 && val <= 25) {
+            res++;
+            dfs(i + 2);
+        }
+        dfs(i + 1);
+    };
+    dfs(1);
+    return res;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -169,6 +190,29 @@ impl Solution {
 }
 ```
 
+```rust
+impl Solution {
+    fn dfs(s: &String, i: usize, res: &mut i32) {
+        if i >= s.len() {
+            return;
+        }
+        let val = s[i - 1..=i].parse::<i32>().unwrap();
+        if val >= 10 && val <= 25 {
+            *res += 1;
+            Self::dfs(s, i + 2, res);
+        }
+        Self::dfs(s, i + 1, res);
+    }
+
+    pub fn translate_num(num: i32) -> i32 {
+        let s = num.to_string();
+        let mut res = 1;
+        Self::dfs(&s, 1, &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

lcof/面试题48. 最长不含重复字符的子字符串/README.md

@@ -160,12 +160,14 @@ var lengthOfLongestSubstring = function (s) {
 
 ```ts
 function lengthOfLongestSubstring(s: string): number {
+    const n = s.length;
+    const set = new Set<string>();
     let res = 0;
-    let l = 0;
-    let set = new Set<string>();
-    for (const c of s) {
+    let i = 0;
+    for (let j = 0; j < n; j++) {
+        const c = s[j];
         while (set.has(c)) {
-            set.delete(s[l++]);
+            set.delete(s[i++]);
         }
         set.add(c);
         res = Math.max(res, set.size);
@@ -174,30 +176,70 @@ function lengthOfLongestSubstring(s: string): number {
 }
 ```
 
+```ts
+function lengthOfLongestSubstring(s: string): number {
+    const map = new Map<string, number>();
+    const n = s.length;
+    let res = 0;
+    let i = -1;
+    for (let j = 0; j < n; j++) {
+        if (map.has(s[j])) {
+            i = Math.max(i, map.get(s[j]));
+        }
+        map.set(s[j], j);
+        res = Math.max(res, j - i);
+    }
+    return res;
+}
+```
+
 ### **Rust**
 
 ```rust
 use std::collections::HashSet;
-
 impl Solution {
     pub fn length_of_longest_substring(s: String) -> i32 {
+        let s = s.as_bytes();
+        let n = s.len();
+        let mut set = HashSet::new();
         let mut res = 0;
         let mut i = 0;
-        let mut set = HashSet::new();
-        let chars = s.chars().collect::<Vec<char>>();
-        for c in chars.iter() {
-            while set.contains(c) {
-                set.remove(&chars[i]);
+        for j in 0..n {
+            while set.contains(&s[j]) {
+                set.remove(&s[i]);
                 i += 1;
             }
-            set.insert(c);
-            res = res.max(set.len())
+            set.insert(s[j]);
+            res = res.max(set.len());
         }
         res as i32
     }
 }
 ```
 
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        let s = s.as_bytes();
+        let n = s.len();
+        let mut map = HashMap::new();
+        let mut res = 0;
+        let mut i = -1;
+        for j in 0..n {
+            let c = s[j];
+            let j = j as i32;
+            if map.contains_key(&c) {
+                i = i.max(*map.get(&c).unwrap());
+            }
+            map.insert(c, j);
+            res = res.max(j - i);
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

lcof/面试题48. 最长不含重复字符的子字符串/Solution.rs

@@ -1,18 +1,18 @@
 use std::collections::HashSet;
-
 impl Solution {
     pub fn length_of_longest_substring(s: String) -> i32 {
+        let s = s.as_bytes();
+        let n = s.len();
+        let mut set = HashSet::new();
         let mut res = 0;
         let mut i = 0;
-        let mut set = HashSet::new();
-        let chars = s.chars().collect::<Vec<char>>();
-        for c in chars.iter() {
-            while set.contains(c) {
-                set.remove(&chars[i]);
+        for j in 0..n {
+            while set.contains(&s[j]) {
+                set.remove(&s[i]);
                 i += 1;
             }
-            set.insert(c);
-            res = res.max(set.len())
+            set.insert(s[j]);
+            res = res.max(set.len());
         }
         res as i32
     }

lcof/面试题48. 最长不含重复字符的子字符串/Solution.ts

@@ -1,10 +1,12 @@
 function lengthOfLongestSubstring(s: string): number {
+    const n = s.length;
+    const set = new Set<string>();
     let res = 0;
-    let l = 0;
-    let set = new Set<string>();
-    for (const c of s) {
+    let i = 0;
+    for (let j = 0; j < n; j++) {
+        const c = s[j];
         while (set.has(c)) {
-            set.delete(s[l++]);
+            set.delete(s[i++]);
         }
         set.add(c);
         res = Math.max(res, set.size);