Description#
The value of an alphanumeric string can be defined as:
- The numeric representation of the string in base
10, if it comprises of digits only. - The length of the string, otherwise.
Given an array strs of alphanumeric strings, return the maximum value of any string in strs.
Example 1:
Input: strs = ["alic3","bob","3","4","00000"]
Output: 5
Explanation:
- "alic3" consists of both letters and digits, so its value is its length, i.e. 5.
- "bob" consists only of letters, so its value is also its length, i.e. 3.
- "3" consists only of digits, so its value is its numeric equivalent, i.e. 3.
- "4" also consists only of digits, so its value is 4.
- "00000" consists only of digits, so its value is 0.
Hence, the maximum value is 5, of "alic3".
Example 2:
Input: strs = ["1","01","001","0001"]
Output: 1
Explanation:
Each string in the array has value 1. Hence, we return 1.
Constraints:
1 <= strs.length <= 1001 <= strs[i].length <= 9strs[i] consists of only lowercase English letters and digits.
Solutions#
Solution 1#
1
2
3
4
5
6
| class Solution:
def maximumValue(self, strs: List[str]) -> int:
def f(s: str) -> int:
return int(s) if all(c.isdigit() for c in s) else len(s)
return max(f(s) for s in strs)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| class Solution {
public int maximumValue(String[] strs) {
int ans = 0;
for (var s : strs) {
ans = Math.max(ans, f(s));
}
return ans;
}
private int f(String s) {
int x = 0;
for (int i = 0, n = s.length(); i < n; ++i) {
char c = s.charAt(i);
if (Character.isLetter(c)) {
return n;
}
x = x * 10 + (c - '0');
}
return x;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class Solution {
public:
int maximumValue(vector<string>& strs) {
auto f = [](string& s) {
int x = 0;
for (char& c : s) {
if (!isdigit(c)) {
return (int) s.size();
}
x = x * 10 + c - '0';
}
return x;
};
int ans = 0;
for (auto& s : strs) {
ans = max(ans, f(s));
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| func maximumValue(strs []string) (ans int) {
f := func(s string) (x int) {
for _, c := range s {
if c >= 'a' && c <= 'z' {
return len(s)
}
x = x*10 + int(c-'0')
}
return
}
for _, s := range strs {
if x := f(s); ans < x {
ans = x
}
}
return
}
|
1
2
3
4
| function maximumValue(strs: string[]): number {
const f = (s: string) => (Number.isNaN(Number(s)) ? s.length : Number(s));
return Math.max(...strs.map(f));
}
|
1
2
3
4
5
6
7
8
9
10
| impl Solution {
pub fn maximum_value(strs: Vec<String>) -> i32 {
let mut ans = 0;
for s in strs.iter() {
let num = s.parse().unwrap_or(s.len());
ans = ans.max(num);
}
ans as i32
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class Solution {
public int MaximumValue(string[] strs) {
return strs.Max(f);
}
private int f(string s) {
int x = 0;
foreach (var c in s) {
if (c >= 'a') {
return s.Length;
}
x = x * 10 + (c - '0');
}
return x;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| #define max(a, b) (((a) > (b)) ? (a) : (b))
int parseInt(char* s) {
int n = strlen(s);
int res = 0;
for (int i = 0; i < n; i++) {
if (!isdigit(s[i])) {
return n;
}
res = res * 10 + s[i] - '0';
}
return res;
}
int maximumValue(char** strs, int strsSize) {
int ans = 0;
for (int i = 0; i < strsSize; i++) {
int num = parseInt(strs[i]);
ans = max(ans, num);
}
return ans;
}
|
Solution 2#
1
2
3
4
5
6
7
8
9
10
11
| class Solution:
def maximumValue(self, strs: List[str]) -> int:
def f(s: str) -> int:
x = 0
for c in s:
if c.isalpha():
return len(s)
x = x * 10 + ord(c) - ord("0")
return x
return max(f(s) for s in strs)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| impl Solution {
pub fn maximum_value(strs: Vec<String>) -> i32 {
let parse = |s: String| -> i32 {
let mut x = 0;
for c in s.chars() {
if c >= 'a' && c <= 'z' {
x = s.len();
break;
}
x = x * 10 + (((c as u8) - b'0') as usize);
}
x as i32
};
let mut ans = 0;
for s in strs {
let v = parse(s);
if v > ans {
ans = v;
}
}
ans
}
}
|
Solution 3#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| use std::cmp::max;
impl Solution {
pub fn maximum_value(strs: Vec<String>) -> i32 {
let mut ans = 0;
for s in strs {
match s.parse::<i32>() {
Ok(v) => {
ans = max(ans, v);
}
Err(_) => {
ans = max(ans, s.len() as i32);
}
}
}
ans
}
}
|
