Extrae el valor numérico máximo de una string determinada | Conjunto 2 (enfoque Regex)

Dada una string alfanumérica, extraiga el valor numérico máximo de esa string. Ejemplos:

Input : 100klh564abc365bg
Output : 564
Maximum numeric value among 100, 564 
and 365 is 564.
Input : abchsd0365sdhs
Output : 365

En el Conjunto 1 , hemos discutido el enfoque general para extraer el valor numérico de una string dada. En esta publicación, discutiremos el enfoque de expresión regular para el mismo. A continuación se muestra una de las expresiones regulares para al menos un dígito numérico.

\d+

Entonces la solución Regex es simple:

1. Inicializar MAX = 0
2. Ejecute el bucle sobre el comparador, cada vez que se encuentre una coincidencia, convierta la string numérica en un número entero y compárelo con MAX.
   • Si el número es mayor que MAX, actualice MAX a número.
3. Devuelve MAX al final.

Implementación:

// Java regex program to extract the maximum value
 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
class GFG
{
    // Method to extract the maximum value
    static int extractMaximum(String str)
    {
        // regular expression for atleast one numeric digit
        String regex = "\\d+";
         
        // compiling regex
        Pattern p = Pattern.compile(regex);
         
        // Matcher object
        Matcher m = p.matcher(str);
         
        // initialize MAX = 0
        int MAX = 0;
         
        // loop over matcher
        while(m.find())
        {
            // convert numeric string to integer
            int num = Integer.parseInt(m.group());
             
            // compare num with MAX, update MAX if num > MAX
            if(num > MAX)
                MAX = num;
        }
         
        return MAX;
    }
 
    public static void main (String[] args)
    {
        String str = "100klh564abc365bg";
         
        System.out.println(extractMaximum(str));
    }
}

// C# regex program to extract the maximum value
using System;
using System.Text.RegularExpressions;
 
class GFG
{
  // Method to extract the maximum value
  static int extractMaximum(string str)
  {
 
    // Regex object
    Regex regex = new Regex(@"\d+");
 
 
    // initialize MAX = 0
    int MAX = 0;
 
    // loop over matcher
    foreach (Match ItemMatch in regex.Matches(str))
    {
      // convert numeric string to integer
      int num = Int32.Parse(ItemMatch.Value);
 
      // compare num with MAX, update MAX if num > MAX
      if(num > MAX)
        MAX = num;
    }
 
    return MAX;   
  }
 
  static public void Main ()
  {
    string str = "100klh564abc365bg"; 
    Console.WriteLine(extractMaximum(str));
  }
}
 
// This code is contributed by kothavvsaakash

564

Complejidad temporal : O(n) 
Espacio auxiliar : O(1)

Pero el programa anterior no funcionaría si el número es mayor que el rango de enteros. Puede probar el método parseLong() para números de largo alcance. Pero para manejar el caso de números grandes (mayores que el largo alcance), podemos tomar la ayuda de la clase BigInteger en Java. A continuación se muestra el programa Java para demostrar lo mismo. 

Implementación:

// Java regex program to extract the maximum value
// in case of large numbers
 
import java.math.BigInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
class GFG
{
    // Method to extract the maximum value
    static BigInteger extractMaximum(String str)
    {
        // regular expression for atleast one numeric digit
        String regex = "\\d+";
         
        // compiling regex
        Pattern p = Pattern.compile(regex);
         
        // Matcher object
        Matcher m = p.matcher(str);
         
        // initialize MAX = 0
        BigInteger MAX = BigInteger.ZERO;
         
        // loop over matcher
        while(m.find())
        {
            // convert numeric string to BigInteger
            BigInteger num = new BigInteger(m.group());
             
            // compare num with MAX, update MAX if num > MAX
            if(num.compareTo(MAX) > 0)
                MAX = num;
        }
         
        return MAX;
    }
 
    public static void main (String[] args)
    {
        String str = "100klh564231315151313151315abc365bg";
         
        System.out.println(extractMaximum(str));
    }
}

564231315151313151315

Complejidad temporal : O(n) 
Espacio auxiliar : O(1)

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.