JAVA - Validación de contraseñas
Publicado por Antonio (5 intervenciones) el 27/12/2022 19:26:44
Buenas, necesito ayuda en el ejercicio 2, puesto que los array me están costando! Copio el enunciado, muchas gracias
El módulo de autenticación de un sistema informático tiene las siguientes reglas sobre sus contraseñas:
- las contraseñas deben tener entre diez y veinte caracteres, ambos incluidos;
- toda contraseña debe contener, como mínimo, todo lo siguiente: una letra mayúscula, minúscula. un dígito, un carácter especial;
- los únicos caracteres especiales permitidos son los del conjunto: \!|#$%&()=?*+-_{}[]:;,.<>@ (no incluye el espacio en blanco);
- los únicos caracteres permitidos son, por tanto: letras (mayúsculas y minúsculas), dígitos y los caracteres especiales anteriores. Si la contraseña contiene algún otro carácter, no será considerada como válida.
- Cualquier contraseña que no cumpla esas reglas no será considerado un password válido.
Escribe un programa en Java que analice cada una de las contraseñas contenidas en un array y genere un nuevo array (en este caso de boolean) donde se indique, para cada contraseña, si es válida o no. Para ello tendrás que
1. Declarar un array de referencias a objetos String de entrada. Este array contendrá las contraseñas que nos servirán para probar el programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Esta parte se te proporciona ya escrita en el proyecto base con las contraseñas de prueba con los caracteres apropiadamente escapados para que no se produzcan errores al teclearlos;
2. Declarar un array de boolean para los resultados. Servirá para almacenar en cada posición i si la contraseña que hay en la posición i del array anterior es una contraseña válida o no.
3. Reservar en memoria el tamaño apropiado para el array de boolean. No debes indicar un literal, sino que debes calcular el tamaño del array de entrada para que si este cambiara de tamaño no hubiera que modificar nada más. Puedes hacer ese new a la vez que realizas la declaración en el paso anterior.
4. Declarar cadenas (variables String) para modelar las distintas condiciones en forma de expresión regular que tendrás que utilizar para verificar si se cumplen o no los requisitos de una contraseña válida.
5. Recorrer cada uno de los elementos del array de contraseñas.
5.1 . Analizar cada elemento teniendo en cuenta las reglas de validación de contraseñas. Para los casos en los que se supere la prueba (contraseña válida), se colocará un valor true en la posición correspondiente del array de resultados (array de boolean). Si no es así, se almacenará un valor false.
6. Mostrar por pantalla el contenido los resultados, recorriendo de nuevo cada elemento del array de contraseñas e indicando para cada una si es o no válida. Para que las comprobaciones sean fáciles de seguir, cada resultado debe colocarse en una línea diferente y numerada, comenzando por 1.
Es obligatorio llevar a cabo las verificaciones de las reglas de validación (salvo la de los tamaños) mediante el uso de expresiones regulares en Java.
Del cual yo tengo esta plantilla, muchas gracias.
El módulo de autenticación de un sistema informático tiene las siguientes reglas sobre sus contraseñas:
- las contraseñas deben tener entre diez y veinte caracteres, ambos incluidos;
- toda contraseña debe contener, como mínimo, todo lo siguiente: una letra mayúscula, minúscula. un dígito, un carácter especial;
- los únicos caracteres especiales permitidos son los del conjunto: \!|#$%&()=?*+-_{}[]:;,.<>@ (no incluye el espacio en blanco);
- los únicos caracteres permitidos son, por tanto: letras (mayúsculas y minúsculas), dígitos y los caracteres especiales anteriores. Si la contraseña contiene algún otro carácter, no será considerada como válida.
- Cualquier contraseña que no cumpla esas reglas no será considerado un password válido.
Escribe un programa en Java que analice cada una de las contraseñas contenidas en un array y genere un nuevo array (en este caso de boolean) donde se indique, para cada contraseña, si es válida o no. Para ello tendrás que
1. Declarar un array de referencias a objetos String de entrada. Este array contendrá las contraseñas que nos servirán para probar el programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Esta parte se te proporciona ya escrita en el proyecto base con las contraseñas de prueba con los caracteres apropiadamente escapados para que no se produzcan errores al teclearlos;
2. Declarar un array de boolean para los resultados. Servirá para almacenar en cada posición i si la contraseña que hay en la posición i del array anterior es una contraseña válida o no.
3. Reservar en memoria el tamaño apropiado para el array de boolean. No debes indicar un literal, sino que debes calcular el tamaño del array de entrada para que si este cambiara de tamaño no hubiera que modificar nada más. Puedes hacer ese new a la vez que realizas la declaración en el paso anterior.
4. Declarar cadenas (variables String) para modelar las distintas condiciones en forma de expresión regular que tendrás que utilizar para verificar si se cumplen o no los requisitos de una contraseña válida.
5. Recorrer cada uno de los elementos del array de contraseñas.
5.1 . Analizar cada elemento teniendo en cuenta las reglas de validación de contraseñas. Para los casos en los que se supere la prueba (contraseña válida), se colocará un valor true en la posición correspondiente del array de resultados (array de boolean). Si no es así, se almacenará un valor false.
6. Mostrar por pantalla el contenido los resultados, recorriendo de nuevo cada elemento del array de contraseñas e indicando para cada una si es o no válida. Para que las comprobaciones sean fáciles de seguir, cada resultado debe colocarse en una línea diferente y numerada, comenzando por 1.
Es obligatorio llevar a cabo las verificaciones de las reglas de validación (salvo la de los tamaños) mediante el uso de expresiones regulares en Java.
Del cual yo tengo esta plantilla, muchas gracias.
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public class Ejercicio02 {public static void main(String[] args) {
//---------------------------------------------- // Declaración de variables //---------------------------------------------- // Constantes // Variables de entrada // 1. Declaramos el array relleno de contraseñas (algunas inválidas y otras válidas)String[] listaPasswords = {
// Passwords no válidos"Hh0011Aa\"99", // Contiene un carácter no válido (")
"/HhOoLlAa22/", // Contiene un carácter no válido (/)
"1234567890", // Faltan una mayúscula, una minúscula y un carácter especial
"++LuisAntonio==2223++", // Demasiado largo
"<Aa1!>", // Demasiado corto
"3st0_3s_un@_pru3b@", // Falta una letra mayúscula
"Est0_3s_0tr@_Pru3b@_+", // Demasiado largo
"{[(P@$$w*rd)]}", // Falta un número
"SuperPaSSw0rd", // Falta un carácter especial
"BARRATAI:4", // Falta una letra minúscula
"C0LuOuP04", // Demasiado corto
"{[(P@SSW0RD)]}", // Falta un número
"[1234567890Aa^]", // Contiene un carácter no válido (^)
// Passwords válidos"[1234567890Aa,]", "LuisAntonio=23","RoyoRoyo42$", "1234567Aa-", "Est0_Es_1_Pru3b@",
"Ju@n3nriqu301!", "BarTaLleGi.4", "<C0LuOuP0#4>", "{[(P@$$w0rd)]}", "\\UnoDosTres45\\"
}; // Variables de salida // 2 y 3. Declaramos el array de resultados para rellenarlo según los resultados de los análisis y reservamos memoria para él // Variables auxiliares // 4. Declaramos cadenas que modelen, en forma de expresión regular, las distintas condiciones que deben darse //---------------------------------------------- // Entrada de datos //---------------------------------------------- // No hay entrada de datos como tal pues el programa se alimentará de la información proporcionada por el array listaPasswordsSystem.out.println("VALIDACIÓN DE CONTRASEÑAS");
System.out.println("-------------------------");
System.out.println("Las contraseñas deben tener entre 10 y 20 caracteres.");
System.out.println("Deben contener al menos: ");
System.out.println("una mayúcula, una minúscula, un dígito y un carácter especial.");
System.out.printf ("Los únicos caracteres especiales permitidos son los del conjunto: %s\n", "\\!|#$%&()=?*+-_{}[]{}:;,.<>@");
System.out.println("Cualquier otro carácter dará lugar a una contraseña inválida");
//---------------------------------------------- // Procesamiento //---------------------------------------------- // 5. Recorremos cada uno de los elementos de la lista de contraseñas // 5.1. Para cada password, si se superan todas las condiciones, se incluirá un valor true en el array de resultados. // Si no es así, se incluirá un valor false //---------------------------------------------- // Salida de resultados //----------------------------------------------System.out.println ();
System.out.println ("RESULTADO");
System.out.println ("---------");
// 6. Mostramos por pantalla los resultados }}Valora esta pregunta
0