Comprobar si una string contiene mayúsculas, minúsculas, caracteres especiales y valores numéricos

Dada la string str de longitud N , la tarea es verificar si la string dada contiene letras en mayúsculas, letras en minúsculas, caracteres especiales y valores numéricos o no. Si la string los contiene todos, imprima «Sí» . De lo contrario, escriba “No” . 

Ejemplos: 

Entrada: str = “#GeeksForGeeks123@” 
Salida: Sí 
Explicación: 
La string dada contiene caracteres en mayúsculas (‘G’, ‘F’), caracteres en minúsculas (‘e’, ‘k’, ‘s’, ‘o’, ‘ r’), caracteres especiales (‘#’, ‘@’) y valores numéricos (‘1’, ‘2’, ‘3’). Por lo tanto, la salida es Sí. 
 

Entrada: str = “GeeksForGeeks” 
Salida: No 
Explicación: 
La string dada contiene solo caracteres en mayúsculas y minúsculas. Por lo tanto, la salida es No.

Enfoque ingenuo: el enfoque más simple es iterar sobre la string y verificar si la string dada contiene caracteres en mayúsculas, minúsculas, numéricos y especiales. A continuación se muestran los pasos: 

1. Recorra la string carácter por carácter de principio a fin.
2. Verifique el valor ASCII de cada carácter para las siguientes condiciones: 
   • Si el valor ASCII se encuentra en el rango de [65, 90] , entonces es una letra mayúscula.
   • Si el valor ASCII se encuentra en el rango de [97, 122] , entonces es una letra minúscula.
   • Si el valor ASCII se encuentra en el rango de [48, 57] , entonces es un número.
   • Si el valor ASCII se encuentra en los rangos [32, 47] , [58, 64] , [91, 96] o [123, 126] , entonces es un carácter especial
3. Imprima Sí si la string contiene todo lo anterior. De lo contrario , imprima No.

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

Enfoque de expresión regular: la idea es el concepto de una expresión regular para resolver este problema. A continuación se muestran los pasos: 

• Cree una expresión regular para verificar si la string dada contiene mayúsculas, minúsculas, caracteres especiales y valores numéricos como se menciona a continuación:

expresión regular = «^(?=.*[az])(?=.*[AZ])(?=.*\\d)» + «(?=.*[-+_!@#$%^& *., ?]).+$” 
donde, 
 

• ^ representa el comienzo de la string.
• (?=.*[az]) representan al menos un carácter en minúscula.
• (?=.*[AZ]) representa al menos un carácter en mayúscula.
• (?=.*\\d) representa al menos un valor numérico.
• (?=.*[-+_!@#$%^&*., ?]) representa al menos un carácter especial.
• . representa cualquier carácter excepto el salto de línea.
• + representa una o más veces.

• Haga coincidir la string dada con la expresión regular usando Pattern.matcher() .
• Imprima Sí si la string coincide con la expresión regular dada. De lo contrario , imprima No.

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

// C++ program to check if the string
// contains uppercase, lowercase
// special character & numeric value
#include <iostream>
#include <regex>
using namespace std;
void isAllPresent(string str)
{
   
  // Regex to check if a string
  // contains uppercase, lowercase
  // special character & numeric value
  const regex pattern("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[-+_!@#$%^&*.,?]).+$");
 
  // If the string is empty
  // then print No
  if (str.empty())
  {
    cout<<"No"<<endl;
    return ;
  }
 
  // Print Yes If the string matches
  // with the Regex
  if(regex_match(str, pattern))
  {
    cout << "Yes" << endl;
  }
  else
  {
    cout << "No" << endl;
  }
  return;
}
 
// Driver Code
int main()
{
  string str = "#GeeksForGeeks123@";
  isAllPresent(str);
  return 0;
}
 
// This code is contributed by yuvraj_chandra

// Java program for the above approach
 
import java.util.regex.*;
 
class GFG {
 
    // Function that checks if a string
    // contains uppercase, lowercase
    // special character & numeric value
    public static void
    isAllPresent(String str)
    {
        // ReGex to check if a string
        // contains uppercase, lowercase
        // special character & numeric value
        String regex = "^(?=.*[a-z])(?=."
                       + "*[A-Z])(?=.*\\d)"
                       + "(?=.*[-+_!@#$%^&*., ?]).+$";
 
        // Compile the ReGex
        Pattern p = Pattern.compile(regex);
 
        // If the string is empty
        // then print No
        if (str == null) {
            System.out.println("No");
            return;
        }
 
        // Find match between given string
        // & regular expression
        Matcher m = p.matcher(str);
 
        // Print Yes if string
        // matches ReGex
        if (m.matches())
            System.out.println("Yes");
        else
            System.out.println("No");
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // Given string
        String str = "#GeeksForGeeks123@";
 
        // Function Call
        isAllPresent(str);
    }
}

# Python3 program for the
# above approach
import re
 
# Function that checks if a string
# contains uppercase, lowercase
# special character & numeric value
def isAllPresent(str):
 
    # ReGex to check if a string
    # contains uppercase, lowercase
    # special character & numeric value
    regex = ("^(?=.*[a-z])(?=." +
             "*[A-Z])(?=.*\\d)" +
             "(?=.*[-+_!@#$%^&*., ?]).+$")
     
    # Compile the ReGex
    p = re.compile(regex)
 
    # If the string is empty
    # return false
    if (str == None):
        print("No")
        return
 
    # Print Yes if string
    # matches ReGex
    if(re.search(p, str)):
        print("Yes")
    else:
        print("No")
 
# Driver code
 
# Given string
str = "#GeeksForGeeks123@"
 
#Function Call
isAllPresent(str)
 
# This code is contributed by avanitrachhadiya2155

// C# program for the above approach
using System;
using System.Text.RegularExpressions;
 
class GFG {
 
    // Function that checks if a string
    // contains uppercase, lowercase
    // special character & numeric value
    static void
    isAllPresent(string str)
    {
        // ReGex to check if a string
        // contains uppercase, lowercase
        // special character & numeric value
        string regex = "^(?=.*[a-z])(?=."
                    + "*[A-Z])(?=.*\\d)"
                    + "(?=.*[-+_!@#$%^&*., ?]).+$";
 
        // Compile the ReGex
        Regex p = new Regex(regex);
 
        // If the string is empty
        // then print No
        if (str == null) {
            Console.Write("No");
            return;
        }
 
        // Find match between given string
        // & regular expression
        Match m = p.Match(str);
 
        // Print Yes if string
        // matches ReGex
        if (m.Success)
            Console.Write("Yes");
        else
            Console.Write("No");
    }
 
    // Driver Code
    public static void Main()
    {
        // Given string
        string str = "#GeeksForGeeks123@";
 
        // Function Call
        isAllPresent(str);
    }
}
 
// This code is contributed by Samim Hossain Mondal

<script>
      // JavaScript program to check if the string
      // contains uppercase, lowercase
      // special character & numeric value
 
      function isAllPresent(str) {
        // Regex to check if a string
        // contains uppercase, lowercase
        // special character & numeric value
        var pattern = new RegExp(
          "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[-+_!@#$%^&*.,?]).+$"
        );
 
        // If the string is empty
        // then print No
        if (!str || str.length === 0) {
          document.write("No" + "<br>");
          return;
        }
 
        // Print Yes If the string matches
        // with the Regex
        if (pattern.test(str)) {
          document.write("Yes" + "<br>");
        } else {
          document.write("No" + "<br>");
        }
        return;
      }
 
      // Driver Code
      var str = "#GeeksForGeeks123@";
      isAllPresent(str);
    </script>

Yes

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