Maximum Value of a String in an Array solution and explanation

def maximum_value_of_string_in_array(strs):
    max_value = 0
    for s in strs:
        # Check if the string is purely numeric
        if s.isdigit():
            value = int(s)
        else:
            value = len(s)
        # Update max_value if current value is larger
        max_value = max(max_value, value)
    return max_value

# Example usage
print(maximum_value_of_string_in_array(["alic3","bob","3","4","00000"]))  # Output: 5

public class MaxValueString {
    public static int maximumValue(String[] strs) {
        int maxValue = 0;
        for (String s : strs) {
            int value = s.matches("\\d+") ? Integer.parseInt(s) : s.length();
            maxValue = Math.max(maxValue, value);
        }
        return maxValue;
    }

    public static void main(String[] args) {
        String[] strs = {"alic3","bob","3","4","00000"};
        System.out.println(maximumValue(strs)); // Output: 5
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

int maximumValue(const std::vector<std::string>& strs) {
    int maxValue = 0;
    for (const std::string& s : strs) {
        int value = std::all_of(s.begin(), s.end(), ::isdigit) ? std::stoi(s) : s.length();
        maxValue = std::max(maxValue, value);
    }
    return maxValue;
}

int main() {
    std::vector<std::string> strs = {"alic3","bob","3","4","00000"};
    std::cout << maximumValue(strs) << std::endl;  // Output: 5
    return 0;
}

function maximumValue(strs) {
    let maxValue = 0;
    for (let s of strs) {
        let value = /^[0-9]+$/.test(s) ? parseInt(s, 10) : s.length;
        maxValue = Math.max(maxValue, value);
    }
    return maxValue;
}

// Example usage
console.log(maximumValue(["alic3","bob","3","4","00000"])); // Output: 5

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

int maximumValue(char* strs[], int n) {
    int maxValue = 0;
    for (int i = 0; i < n; ++i) {
        int isNumeric = 1;
        for (int j = 0; j < strlen(strs[i]); ++j) {
            if (!isdigit(strs[i][j])) {
                isNumeric = 0;
                break;
            }
        }
        int value = isNumeric ? atoi(strs[i]) : strlen(strs[i]);
        if (value > maxValue) {
            maxValue = value;
        }
    }
    return maxValue;
}

int main() {
    char* strs[] = {"alic3","bob","3","4","00000"};
    int n = sizeof(strs) / sizeof(strs[0]);
    printf("%d\n", maximumValue(strs, n)); // Output: 5
    return 0;
}

using System;

class MaxValueString {
    public static int MaximumValue(string[] strs) {
        int maxValue = 0;
        foreach (string s in strs) {
            int value = int.TryParse(s, out int num) ? num : s.Length;
            maxValue = Math.Max(maxValue, value);
        }
        return maxValue;
    }

    static void Main(string[] args) {
        string[] strs = {"alic3","bob","3","4","00000"};
        Console.WriteLine(MaximumValue(strs)); // Output: 5
    }
}

def is_numeric(s):
    return s.isdigit()


def string_value(s):
    return int(s) if is_numeric(s) else len(s)


def maximum_value_of_string_in_array(strs):
    return max(map(string_value, strs))


# Example usage
print(maximum_value_of_string_in_array(["alic3", "bob", "3", "4", "00000"]))  # Output: 5

function isNumeric(s) {
    return /^[0-9]+$/.test(s);
}

function getStringValue(s) {
    return isNumeric(s) ? parseInt(s, 10) : s.length;
}

function maximumValue(strs) {
    return Math.max(...strs.map(getStringValue));
}

// Example usage
console.log(maximumValue(["alic3","bob","3","4","00000"])); // Output: 5

function maximumValue(strs: string[]): number {
    const f = (s: string) => (Number.isNaN(Number(s)) ? s.length : Number(s));
    return Math.max(...strs.map(f));
}

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
}

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
    }
}