Cómo validar el número de licencia de conducir indio usando la expresión regular

Dada la string str , la tarea es verificar si la string dada es un número de licencia de conducir indio válido o no mediante el uso de expresiones regulares .
El número de permiso de conducir indio válido debe cumplir las siguientes condiciones: 

1. Debe tener 16 caracteres (incluyendo espacio o guión (-)).
2. El número de licencia de conducir se puede ingresar en cualquiera de los siguientes formatos:

HR-0619850034761
 OR 
HR06 19850034761

1. Los dos primeros caracteres deben ser letras mayúsculas que representen el código de estado.
2. Los siguientes dos caracteres deben ser dígitos que representen el código RTO.
3. Los siguientes cuatro caracteres deben ser dígitos que representen el año de emisión de la licencia.
4. Los siete caracteres siguientes deben ser dígitos del 0 al 9.

Nota: En este artículo, comprobaremos el año de emisión de la licencia entre 1900 y 2099. Se puede personalizar para cambiar el año de emisión de la licencia.

Ejemplos:

Entrada: str = «HR-0619850034761»; 
Salida: verdadero 
Explicación: 
La string dada satisface todas las condiciones mencionadas anteriormente. Por lo tanto, no es un número de permiso de conducir indio válido.

Entrada: str = “MH27 30120034761”; 
Salida: falso 
Explicación: 
La string dada tiene la licencia emitida el año 3012, ese no es un año válido porque en este artículo validamos el año 1900-2099. Por lo tanto, no es un número de permiso de conducir indio válido.

Entrada: str = «GJ-2420180»; 
Salida: falso 
Explicación: 
La string dada tiene 10 caracteres. Por lo tanto, no es un número de permiso de conducir indio válido. 
 

Enfoque: La idea es usar la expresión regular para resolver este problema. Se pueden seguir los siguientes pasos para calcular la respuesta: 

• Consigue la cuerda.
• Cree una expresión regular para verificar el número de licencia de conducir indio válido como se menciona a continuación:

expresión regular = «^(([AZ]{2}[0-9]{2})( )|([AZ]{2}-[0-9]{2}))((19|20)[0 -9][0-9])[0-9]{7}$”; 

• Dónde: 
  • ^ representa el comienzo de la string.
  • ( representa el comienzo del grupo 1.
  • ( representa el comienzo del grupo 2.
  • [AZ]{2} representa que los primeros dos caracteres deben ser alfabetos en mayúsculas.
  • [0-9]{2} representa que los siguientes dos caracteres deben ser dígitos.
  • ) representa el final del grupo 2.
  • ( ) representa el carácter de espacio en blanco.
  • | representa el o.
  • ( representa el comienzo del grupo 3.
  • [AZ]{2} representa que los primeros dos caracteres deben ser alfabetos en mayúsculas.
  • – representa el guión.
  • [0-9]{2} representa que los siguientes dos caracteres deben ser dígitos.
  • ) representa el final del grupo 3.
  • ) representa el final del grupo 1.
  • ((19|20)[0-9][0-9]) representa el año 1900-2099.
  • [0-9]{7} representa que los siguientes siete caracteres deben ser dígitos del 0 al 9.
  • $ representa el final de la string.
• Haga coincidir la string dada con la expresión regular. En Java, esto se puede hacer usando Pattern.matcher() .
• Devuelve verdadero si la string coincide con la expresión regular dada; de lo contrario, devuelve falso.

A continuación se muestra la implementación del enfoque anterior:

// Java program to validate
// Indian driving license number
// using regular expression
 
import java.util.regex.*;
class GFG {
 
    // Function to validate
    // Indian driving license number
    // using regular expression
    public static boolean isValidLicenseNo(String str)
    {
        // Regex to check valid
        // Indian driving license number
        String regex = "^(([A-Z]{2}[0-9]{2})"
                       + "( )|([A-Z]{2}-[0-9]"
                       + "{2}))((19|20)[0-9]"
                       + "[0-9])[0-9]{7}$";
 
        // Compile the ReGex
        Pattern p = Pattern.compile(regex);
 
        // If the string is empty
        // return false
        if (str == null) {
            return false;
        }
 
        // Find match between given string
        // and regular expression
        // uSing Pattern.matcher()
 
        Matcher m = p.matcher(str);
 
        // Return if the string
        // matched the ReGex
        return m.matches();
    }
 
    // Driver code
    public static void main(String args[])
    {
 
        // Test Case 1:
        String str1 = "HR-0619850034761";
        System.out.println(isValidLicenseNo(str1));
 
        // Test Case 2:
        String str2 = "UP14 20160034761";
        System.out.println(isValidLicenseNo(str2));
 
        // Test Case 3:
        String str3 = "12HR-37200602347";
        System.out.println(isValidLicenseNo(str3));
 
        // Test Case 4:
        String str4 = "MH27 30123476102";
        System.out.println(isValidLicenseNo(str4));
 
        // Test Case 5:
        String str5 = "GJ-2420180";
        System.out.println(isValidLicenseNo(str5));
    }
}

# Python program to validate
# Indian driving license number
# using regular expression
 
import re
 
# Function to validate Indian
# driving license number.
def isValidLicenseNo(str):
 
    # Regex to check valid
    # Indian driving license number
    regex = ("^(([A-Z]{2}[0-9]{2})" +
             "( )|([A-Z]{2}-[0-9]" +
             "{2}))((19|20)[0-9]" +
             "[0-9])[0-9]{7}$")
     
    # Compile the ReGex
    p = re.compile(regex)
 
    # If the string is empty
    # return false
    if (str == None):
        return False
 
    # Return if the string
    # matched the ReGex
    if(re.search(p, str)):
        return True
    else:
        return False
 
# Driver code
 
# Test Case 1:
str1 = "HR-0619850034761"
print(isValidLicenseNo(str1))
 
# Test Case 2:
str2 = "UP14 20160034761"
print(isValidLicenseNo(str2))
 
# Test Case 3:
str3 = "12HR-37200602347"
print(isValidLicenseNo(str3))
 
# Test Case 4:
str4 = "MH27 30123476102"
print(isValidLicenseNo(str4))
 
# Test Case 5:
str5 = "GJ-2420180"
print(isValidLicenseNo(str5))
 
# This code is contributed by avanitrachhadiya2155

// C++ program to validate the
// Indian driving license number
// using Regular Expression
#include <iostream>
#include <regex>
using namespace std;
 
// Function to validate the
// Indian driving license number
bool isValidLicenseNo(string str)
{
 
    // Regex to check valid
    // Indian driving license number
    const regex pattern("^(([A-Z]{2}[0-9]{2})( "
                        ")|([A-Z]{2}-[0-9]{2}))"
                        "((19|20)[0-"
                        "9][0-9])[0-9]{7}$");
 
    // If the Indian driving
    // license number is empty return false
    if (str.empty())
    {
        return false;
    }
 
    // Return true if the Indian
    // driving license number
    // matched the ReGex
    if (regex_match(str, pattern))
    {
        return true;
    }
    else {
        return false;
    }
}
 
// Driver Code
int main()
{
    // Test Case 1:
    string str1 = "HR-0619850034761";
    cout << isValidLicenseNo(str1) << endl;
 
    // Test Case 2:
    string str2 = "UP14 20160034761";
    cout << isValidLicenseNo(str2) << endl;
 
    // Test Case 3:
    string str3 = "12HR-37200602347";
    cout << isValidLicenseNo(str3) << endl;
 
    // Test Case 4:
    string str4 = "MH27 30123476102";
    cout << isValidLicenseNo(str4) << endl;
 
    // Test Case 5:
    string str5 = "GJ-2420180";
    cout << isValidLicenseNo(str5) << endl;
 
    return 0;
}
 
// This code is contributed by yuvraj_chandra

true
true
false
false
false