doocs
diff --git a/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/README.md‎
Lines changed: 57 additions & 18 deletions b/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/README.md‎
Lines changed: 57 additions & 18 deletions
diff --git a/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/README_EN.md‎
Lines changed: 57 additions & 18 deletions b/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/README_EN.md‎
Lines changed: 57 additions & 18 deletions
diff --git a/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.cpp‎
Lines changed: 4 additions & 4 deletions b/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.cpp‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.go‎
Lines changed: 8 additions & 4 deletions b/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.go‎
Lines changed: 8 additions & 4 deletions
diff --git a/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.java‎
Lines changed: 4 additions & 4 deletions b/‎solution/3000-3099/3043.Find the Length of the Longest Common Prefix/Solution.java‎
Lines changed: 4 additions & 4 deletions
@@ -87,14 +87,14 @@ class Solution:
             while x:
                 s.add(x)
                 x //= 10
-        ans = 0
+        mx = 0
         for x in arr2:
             while x:
                 if x in s:
-                    ans = max(ans, len(str(x)))
+                    mx = max(mx, x)
                     break
                 x //= 10
-        return ans
+        return len(str(mx)) if mx else 0
 ```
 
 #### Java
@@ -108,16 +108,16 @@ class Solution {
                 s.add(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x > 0; x /= 10) {
                 if (s.contains(x)) {
-                    ans = Math.max(ans, String.valueOf(x).length());
+                    mx = Math.max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? String.valueOf(mx).length() : 0;
     }
 }
 ```
@@ -134,39 +134,43 @@ public:
                 s.insert(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x; x /= 10) {
                 if (s.count(x)) {
-                    ans = max(ans, (int) log10(x) + 1);
+                    mx = max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? (int) log10(mx) + 1 : 0;
     }
 };
 ```
 
 #### Go
 
 ```go
-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {
+func longestCommonPrefix(arr1 []int, arr2 []int) int {
 	s := map[int]bool{}
 	for _, x := range arr1 {
 		for ; x > 0; x /= 10 {
 			s[x] = true
 		}
 	}
+	mx := 0
 	for _, x := range arr2 {
 		for ; x > 0; x /= 10 {
 			if s[x] {
-				ans = max(ans, int(math.Log10(float64(x)))+1)
+				mx = max(mx, x)
 				break
 			}
 		}
 	}
-	return
+	if mx > 0 {
+		return len(strconv.Itoa(mx))
+	}
+	return 0
 }
 ```
 
@@ -180,15 +184,49 @@ function longestCommonPrefix(arr1: number[], arr2: number[]): number {
             s.add(x);
         }
     }
-    let ans: number = 0;
+    let mx: number = 0;
     for (let x of arr2) {
         for (; x; x = Math.floor(x / 10)) {
             if (s.has(x)) {
-                ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);
+                mx = Math.max(mx, x);
+                break;
+            }
+        }
+    }
+    return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn longest_common_prefix(arr1: Vec<i32>, arr2: Vec<i32>) -> i32 {
+        let mut s = std::collections::HashSet::new();
+        for x in arr1 {
+            let mut y = x;
+            while y > 0 {
+                s.insert(y);
+                y /= 10;
+            }
+        }
+        let mut mx = 0;
+        for x in arr2 {
+            let mut y = x;
+            while y > 0 {
+                if s.contains(&y) {
+                    mx = mx.max(y);
+                    break;
+                }
+                y /= 10;
             }
         }
+        if mx > 0 {
+            (mx as f64).log10().floor() as i32 + 1
+        } else {
+            0
+        }
     }
-    return ans;
 }
 ```
 
@@ -207,15 +245,16 @@ var longestCommonPrefix = function (arr1, arr2) {
             s.add(x);
         }
     }
-    let ans = 0;
+    let mx = 0;
     for (let x of arr2) {
         for (; x; x = Math.floor(x / 10)) {
             if (s.has(x)) {
-                ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);
+                mx = Math.max(mx, x);
+                break;
             }
         }
     }
-    return ans;
+    return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;
 };
 ```
 
 
@@ -85,14 +85,14 @@ class Solution:
             while x:
                 s.add(x)
                 x //= 10
-        ans = 0
+        mx = 0
         for x in arr2:
             while x:
                 if x in s:
-                    ans = max(ans, len(str(x)))
+                    mx = max(mx, x)
                     break
                 x //= 10
-        return ans
+        return len(str(mx)) if mx else 0
 ```
 
 #### Java
@@ -106,16 +106,16 @@ class Solution {
                 s.add(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x > 0; x /= 10) {
                 if (s.contains(x)) {
-                    ans = Math.max(ans, String.valueOf(x).length());
+                    mx = Math.max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? String.valueOf(mx).length() : 0;
     }
 }
 ```
@@ -132,39 +132,43 @@ public:
                 s.insert(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x; x /= 10) {
                 if (s.count(x)) {
-                    ans = max(ans, (int) log10(x) + 1);
+                    mx = max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? (int) log10(mx) + 1 : 0;
     }
 };
 ```
 
 #### Go
 
 ```go
-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {
+func longestCommonPrefix(arr1 []int, arr2 []int) int {
 	s := map[int]bool{}
 	for _, x := range arr1 {
 		for ; x > 0; x /= 10 {
 			s[x] = true
 		}
 	}
+	mx := 0
 	for _, x := range arr2 {
 		for ; x > 0; x /= 10 {
 			if s[x] {
-				ans = max(ans, int(math.Log10(float64(x)))+1)
+				mx = max(mx, x)
 				break
 			}
 		}
 	}
-	return
+	if mx > 0 {
+		return len(strconv.Itoa(mx))
+	}
+	return 0
 }
 ```
 
@@ -178,15 +182,49 @@ function longestCommonPrefix(arr1: number[], arr2: number[]): number {
             s.add(x);
         }
     }
-    let ans: number = 0;
+    let mx: number = 0;
     for (let x of arr2) {
         for (; x; x = Math.floor(x / 10)) {
             if (s.has(x)) {
-                ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);
+                mx = Math.max(mx, x);
+                break;
+            }
+        }
+    }
+    return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn longest_common_prefix(arr1: Vec<i32>, arr2: Vec<i32>) -> i32 {
+        let mut s = std::collections::HashSet::new();
+        for x in arr1 {
+            let mut y = x;
+            while y > 0 {
+                s.insert(y);
+                y /= 10;
+            }
+        }
+        let mut mx = 0;
+        for x in arr2 {
+            let mut y = x;
+            while y > 0 {
+                if s.contains(&y) {
+                    mx = mx.max(y);
+                    break;
+                }
+                y /= 10;
             }
         }
+        if mx > 0 {
+            (mx as f64).log10().floor() as i32 + 1
+        } else {
+            0
+        }
     }
-    return ans;
 }
 ```
 
@@ -205,15 +243,16 @@ var longestCommonPrefix = function (arr1, arr2) {
             s.add(x);
         }
     }
-    let ans = 0;
+    let mx = 0;
     for (let x of arr2) {
         for (; x; x = Math.floor(x / 10)) {
             if (s.has(x)) {
-                ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);
+                mx = Math.max(mx, x);
+                break;
             }
         }
     }
-    return ans;
+    return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;
 };
 ```
 
 
@@ -7,15 +7,15 @@ class Solution {
                 s.insert(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x; x /= 10) {
                 if (s.count(x)) {
-                    ans = max(ans, (int) log10(x) + 1);
+                    mx = max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? (int) log10(mx) + 1 : 0;
     }
-};
+};
@@ -1,17 +1,21 @@
-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {
+func longestCommonPrefix(arr1 []int, arr2 []int) int {
 	s := map[int]bool{}
 	for _, x := range arr1 {
 		for ; x > 0; x /= 10 {
 			s[x] = true
 		}
 	}
+	mx := 0
 	for _, x := range arr2 {
 		for ; x > 0; x /= 10 {
 			if s[x] {
-				ans = max(ans, int(math.Log10(float64(x)))+1)
+				mx = max(mx, x)
 				break
 			}
 		}
 	}
-	return
-}
+	if mx > 0 {
+		return len(strconv.Itoa(mx))
+	}
+	return 0
+}
@@ -6,15 +6,15 @@ public int longestCommonPrefix(int[] arr1, int[] arr2) {
                 s.add(x);
             }
         }
-        int ans = 0;
+        int mx = 0;
         for (int x : arr2) {
             for (; x > 0; x /= 10) {
                 if (s.contains(x)) {
-                    ans = Math.max(ans, String.valueOf(x).length());
+                    mx = Math.max(mx, x);
                     break;
                 }
             }
         }
-        return ans;
+        return mx > 0 ? String.valueOf(mx).length() : 0;
     }
-}
+}
Original file line number	Diff line number	Diff line change
`@@ -87,14 +87,14 @@ class Solution:`
`87`	`87`	`while x:`
`88`	`88`	`s.add(x)`
`89`	`89`	`x //= 10`
`90`		`- ans = 0`
	`90`	`+ mx = 0`
`91`	`91`	`for x in arr2:`
`92`	`92`	`while x:`
`93`	`93`	`if x in s:`
`94`		`- ans = max(ans, len(str(x)))`
	`94`	`+ mx = max(mx, x)`
`95`	`95`	`break`
`96`	`96`	`x //= 10`
`97`		`- return ans`
	`97`	`+ return len(str(mx)) if mx else 0`
`98`	`98`	```
`99`	`99`
`100`	`100`	`#### Java`
`@@ -108,16 +108,16 @@ class Solution {`
`108`	`108`	`s.add(x);`
`109`	`109`	`}`
`110`	`110`	`}`
`111`		`- int ans = 0;`
	`111`	`+ int mx = 0;`
`112`	`112`	`for (int x : arr2) {`
`113`	`113`	`for (; x > 0; x /= 10) {`
`114`	`114`	`if (s.contains(x)) {`
`115`		`- ans = Math.max(ans, String.valueOf(x).length());`
	`115`	`+ mx = Math.max(mx, x);`
`116`	`116`	`break;`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`120`		`- return ans;`
	`120`	`+ return mx > 0 ? String.valueOf(mx).length() : 0;`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	```
`@@ -134,39 +134,43 @@ public:`
`134`	`134`	`s.insert(x);`
`135`	`135`	`}`
`136`	`136`	`}`
`137`		`- int ans = 0;`
	`137`	`+ int mx = 0;`
`138`	`138`	`for (int x : arr2) {`
`139`	`139`	`for (; x; x /= 10) {`
`140`	`140`	`if (s.count(x)) {`
`141`		`- ans = max(ans, (int) log10(x) + 1);`
	`141`	`+ mx = max(mx, x);`
`142`	`142`	`break;`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`	`}`
`146`		`- return ans;`
	`146`	`+ return mx > 0 ? (int) log10(mx) + 1 : 0;`
`147`	`147`	`}`
`148`	`148`	`};`
`149`	`149`	```
`150`	`150`
`151`	`151`	`#### Go`
`152`	`152`
`153`	`153`	```go
`154`		`-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {`
	`154`	`+func longestCommonPrefix(arr1 []int, arr2 []int) int {`
`155`	`155`	`s := map[int]bool{}`
`156`	`156`	`for _, x := range arr1 {`
`157`	`157`	`for ; x > 0; x /= 10 {`
`158`	`158`	`s[x] = true`
`159`	`159`	`}`
`160`	`160`	`}`
	`161`	`+ mx := 0`
`161`	`162`	`for _, x := range arr2 {`
`162`	`163`	`for ; x > 0; x /= 10 {`
`163`	`164`	`if s[x] {`
`164`		`- ans = max(ans, int(math.Log10(float64(x)))+1)`
	`165`	`+ mx = max(mx, x)`
`165`	`166`	`break`
`166`	`167`	`}`
`167`	`168`	`}`
`168`	`169`	`}`
`169`		`- return`
	`170`	`+ if mx > 0 {`
	`171`	`+ return len(strconv.Itoa(mx))`
	`172`	`+ }`
	`173`	`+ return 0`
`170`	`174`	`}`
`171`	`175`	```
`172`	`176`
`@@ -180,15 +184,49 @@ function longestCommonPrefix(arr1: number[], arr2: number[]): number {`
`180`	`184`	`s.add(x);`
`181`	`185`	`}`
`182`	`186`	`}`
`183`		`- let ans: number = 0;`
	`187`	`+ let mx: number = 0;`
`184`	`188`	`for (let x of arr2) {`
`185`	`189`	`for (; x; x = Math.floor(x / 10)) {`
`186`	`190`	`if (s.has(x)) {`
`187`		`- ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);`
	`191`	`+ mx = Math.max(mx, x);`
	`192`	`+ break;`
	`193`	`+ }`
	`194`	`+ }`
	`195`	`+ }`
	`196`	`+ return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;`
	`197`	`+}`
	`198`	+```
	`199`	`+`
	`200`	`+#### Rust`
	`201`	`+`
	`202`	+```rust
	`203`	`+impl Solution {`
	`204`	`+ pub fn longest_common_prefix(arr1: Vec<i32>, arr2: Vec<i32>) -> i32 {`
	`205`	`+ let mut s = std::collections::HashSet::new();`
	`206`	`+ for x in arr1 {`
	`207`	`+ let mut y = x;`
	`208`	`+ while y > 0 {`
	`209`	`+ s.insert(y);`
	`210`	`+ y /= 10;`
	`211`	`+ }`
	`212`	`+ }`
	`213`	`+ let mut mx = 0;`
	`214`	`+ for x in arr2 {`
	`215`	`+ let mut y = x;`
	`216`	`+ while y > 0 {`
	`217`	`+ if s.contains(&y) {`
	`218`	`+ mx = mx.max(y);`
	`219`	`+ break;`
	`220`	`+ }`
	`221`	`+ y /= 10;`
`188`	`222`	`}`
`189`	`223`	`}`
	`224`	`+ if mx > 0 {`
	`225`	`+ (mx as f64).log10().floor() as i32 + 1`
	`226`	`+ } else {`
	`227`	`+ 0`
	`228`	`+ }`
`190`	`229`	`}`
`191`		`- return ans;`
`192`	`230`	`}`
`193`	`231`	```
`194`	`232`
`@@ -207,15 +245,16 @@ var longestCommonPrefix = function (arr1, arr2) {`
`207`	`245`	`s.add(x);`
`208`	`246`	`}`
`209`	`247`	`}`
`210`		`- let ans = 0;`
	`248`	`+ let mx = 0;`
`211`	`249`	`for (let x of arr2) {`
`212`	`250`	`for (; x; x = Math.floor(x / 10)) {`
`213`	`251`	`if (s.has(x)) {`
`214`		`- ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);`
	`252`	`+ mx = Math.max(mx, x);`
	`253`	`+ break;`
`215`	`254`	`}`
`216`	`255`	`}`
`217`	`256`	`}`
`218`		`- return ans;`
	`257`	`+ return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;`
`219`	`258`	`};`
`220`	`259`	```
`221`	`260`
Original file line number	Diff line number	Diff line change
`@@ -85,14 +85,14 @@ class Solution:`
`85`	`85`	`while x:`
`86`	`86`	`s.add(x)`
`87`	`87`	`x //= 10`
`88`		`- ans = 0`
	`88`	`+ mx = 0`
`89`	`89`	`for x in arr2:`
`90`	`90`	`while x:`
`91`	`91`	`if x in s:`
`92`		`- ans = max(ans, len(str(x)))`
	`92`	`+ mx = max(mx, x)`
`93`	`93`	`break`
`94`	`94`	`x //= 10`
`95`		`- return ans`
	`95`	`+ return len(str(mx)) if mx else 0`
`96`	`96`	```
`97`	`97`
`98`	`98`	`#### Java`
`@@ -106,16 +106,16 @@ class Solution {`
`106`	`106`	`s.add(x);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`		`- int ans = 0;`
	`109`	`+ int mx = 0;`
`110`	`110`	`for (int x : arr2) {`
`111`	`111`	`for (; x > 0; x /= 10) {`
`112`	`112`	`if (s.contains(x)) {`
`113`		`- ans = Math.max(ans, String.valueOf(x).length());`
	`113`	`+ mx = Math.max(mx, x);`
`114`	`114`	`break;`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`}`
`118`		`- return ans;`
	`118`	`+ return mx > 0 ? String.valueOf(mx).length() : 0;`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	```
`@@ -132,39 +132,43 @@ public:`
`132`	`132`	`s.insert(x);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`		`- int ans = 0;`
	`135`	`+ int mx = 0;`
`136`	`136`	`for (int x : arr2) {`
`137`	`137`	`for (; x; x /= 10) {`
`138`	`138`	`if (s.count(x)) {`
`139`		`- ans = max(ans, (int) log10(x) + 1);`
	`139`	`+ mx = max(mx, x);`
`140`	`140`	`break;`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`	`}`
`144`		`- return ans;`
	`144`	`+ return mx > 0 ? (int) log10(mx) + 1 : 0;`
`145`	`145`	`}`
`146`	`146`	`};`
`147`	`147`	```
`148`	`148`
`149`	`149`	`#### Go`
`150`	`150`
`151`	`151`	```go
`152`		`-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {`
	`152`	`+func longestCommonPrefix(arr1 []int, arr2 []int) int {`
`153`	`153`	`s := map[int]bool{}`
`154`	`154`	`for _, x := range arr1 {`
`155`	`155`	`for ; x > 0; x /= 10 {`
`156`	`156`	`s[x] = true`
`157`	`157`	`}`
`158`	`158`	`}`
	`159`	`+ mx := 0`
`159`	`160`	`for _, x := range arr2 {`
`160`	`161`	`for ; x > 0; x /= 10 {`
`161`	`162`	`if s[x] {`
`162`		`- ans = max(ans, int(math.Log10(float64(x)))+1)`
	`163`	`+ mx = max(mx, x)`
`163`	`164`	`break`
`164`	`165`	`}`
`165`	`166`	`}`
`166`	`167`	`}`
`167`		`- return`
	`168`	`+ if mx > 0 {`
	`169`	`+ return len(strconv.Itoa(mx))`
	`170`	`+ }`
	`171`	`+ return 0`
`168`	`172`	`}`
`169`	`173`	```
`170`	`174`
`@@ -178,15 +182,49 @@ function longestCommonPrefix(arr1: number[], arr2: number[]): number {`
`178`	`182`	`s.add(x);`
`179`	`183`	`}`
`180`	`184`	`}`
`181`		`- let ans: number = 0;`
	`185`	`+ let mx: number = 0;`
`182`	`186`	`for (let x of arr2) {`
`183`	`187`	`for (; x; x = Math.floor(x / 10)) {`
`184`	`188`	`if (s.has(x)) {`
`185`		`- ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);`
	`189`	`+ mx = Math.max(mx, x);`
	`190`	`+ break;`
	`191`	`+ }`
	`192`	`+ }`
	`193`	`+ }`
	`194`	`+ return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;`
	`195`	`+}`
	`196`	+```
	`197`	`+`
	`198`	`+#### Rust`
	`199`	`+`
	`200`	+```rust
	`201`	`+impl Solution {`
	`202`	`+ pub fn longest_common_prefix(arr1: Vec<i32>, arr2: Vec<i32>) -> i32 {`
	`203`	`+ let mut s = std::collections::HashSet::new();`
	`204`	`+ for x in arr1 {`
	`205`	`+ let mut y = x;`
	`206`	`+ while y > 0 {`
	`207`	`+ s.insert(y);`
	`208`	`+ y /= 10;`
	`209`	`+ }`
	`210`	`+ }`
	`211`	`+ let mut mx = 0;`
	`212`	`+ for x in arr2 {`
	`213`	`+ let mut y = x;`
	`214`	`+ while y > 0 {`
	`215`	`+ if s.contains(&y) {`
	`216`	`+ mx = mx.max(y);`
	`217`	`+ break;`
	`218`	`+ }`
	`219`	`+ y /= 10;`
`186`	`220`	`}`
`187`	`221`	`}`
	`222`	`+ if mx > 0 {`
	`223`	`+ (mx as f64).log10().floor() as i32 + 1`
	`224`	`+ } else {`
	`225`	`+ 0`
	`226`	`+ }`
`188`	`227`	`}`
`189`		`- return ans;`
`190`	`228`	`}`
`191`	`229`	```
`192`	`230`
`@@ -205,15 +243,16 @@ var longestCommonPrefix = function (arr1, arr2) {`
`205`	`243`	`s.add(x);`
`206`	`244`	`}`
`207`	`245`	`}`
`208`		`- let ans = 0;`
	`246`	`+ let mx = 0;`
`209`	`247`	`for (let x of arr2) {`
`210`	`248`	`for (; x; x = Math.floor(x / 10)) {`
`211`	`249`	`if (s.has(x)) {`
`212`		`- ans = Math.max(ans, Math.floor(Math.log10(x)) + 1);`
	`250`	`+ mx = Math.max(mx, x);`
	`251`	`+ break;`
`213`	`252`	`}`
`214`	`253`	`}`
`215`	`254`	`}`
`216`		`- return ans;`
	`255`	`+ return mx > 0 ? Math.floor(Math.log10(mx)) + 1 : 0;`
`217`	`256`	`};`
`218`	`257`	```
`219`	`258`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,15 @@ class Solution {`
`7`	`7`	`s.insert(x);`
`8`	`8`	`}`
`9`	`9`	`}`
`10`		`- int ans = 0;`
	`10`	`+ int mx = 0;`
`11`	`11`	`for (int x : arr2) {`
`12`	`12`	`for (; x; x /= 10) {`
`13`	`13`	`if (s.count(x)) {`
`14`		`- ans = max(ans, (int) log10(x) + 1);`
	`14`	`+ mx = max(mx, x);`
`15`	`15`	`break;`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`	`}`
`19`		`- return ans;`
	`19`	`+ return mx > 0 ? (int) log10(mx) + 1 : 0;`
`20`	`20`	`}`
`21`		`-};`
	`21`	`+};`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,21 @@`
`1`		`-func longestCommonPrefix(arr1 []int, arr2 []int) (ans int) {`
	`1`	`+func longestCommonPrefix(arr1 []int, arr2 []int) int {`
`2`	`2`	`s := map[int]bool{}`
`3`	`3`	`for _, x := range arr1 {`
`4`	`4`	`for ; x > 0; x /= 10 {`
`5`	`5`	`s[x] = true`
`6`	`6`	`}`
`7`	`7`	`}`
	`8`	`+ mx := 0`
`8`	`9`	`for _, x := range arr2 {`
`9`	`10`	`for ; x > 0; x /= 10 {`
`10`	`11`	`if s[x] {`
`11`		`- ans = max(ans, int(math.Log10(float64(x)))+1)`
	`12`	`+ mx = max(mx, x)`
`12`	`13`	`break`
`13`	`14`	`}`
`14`	`15`	`}`
`15`	`16`	`}`
`16`		`- return`
`17`		`-}`
	`17`	`+ if mx > 0 {`
	`18`	`+ return len(strconv.Itoa(mx))`
	`19`	`+ }`
	`20`	`+ return 0`
	`21`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -6,15 +6,15 @@ public int longestCommonPrefix(int[] arr1, int[] arr2) {`
`6`	`6`	`s.add(x);`
`7`	`7`	`}`
`8`	`8`	`}`
`9`		`- int ans = 0;`
	`9`	`+ int mx = 0;`
`10`	`10`	`for (int x : arr2) {`
`11`	`11`	`for (; x > 0; x /= 10) {`
`12`	`12`	`if (s.contains(x)) {`
`13`		`- ans = Math.max(ans, String.valueOf(x).length());`
	`13`	`+ mx = Math.max(mx, x);`
`14`	`14`	`break;`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`	`}`
`18`		`- return ans;`
	`18`	`+ return mx > 0 ? String.valueOf(mx).length() : 0;`
`19`	`19`	`}`
`20`		`-}`
	`20`	`+}`