Browse Source

updated readme, cp missing images

Jose Ortiz 9 years ago
parent
commit
5984991551
4 changed files with 179 additions and 183 deletions
  1. 179
    183
      README.md
  2. BIN
      images/latex-image-1.pdf
  3. BIN
      images/latex-image-2.pdf
  4. BIN
      images/latex-image-3.pdf

+ 179
- 183
README.md View File

22
 
22
 
23
 1. Haber repasado los siguientes conceptos:
23
 1. Haber repasado los siguientes conceptos:
24
 
24
 
25
-    * operadores lógicos.
26
-
27
-    * `if`, `else`, `else if`.
25
+operadores lógicos.
26
+`if`, `else`, `else if`.
28
 
27
 
29
 2. Haber repasado el uso de objetos de la clase `string` y su método `length()`.
28
 2. Haber repasado el uso de objetos de la clase `string` y su método `length()`.
30
 
29
 
31
 3. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
30
 3. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
32
 
31
 
33
-4. haber tomado el quiz Pre-Lab que se encuentra en Moodle.
32
+4. Haber tomado el quiz Pre-Lab que se encuentra en Moodle.
34
 
33
 
35
 
34
 
36
 ---
35
 ---
55
 
54
 
56
 |      | Categoría                        | Puntos                                   | Notas                                                |
55
 |      | Categoría                        | Puntos                                   | Notas                                                |
57
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
56
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
58
-| 1.   | Número de caracteres             | $$4\left(len\right)$$                                 | $$len$$ es el largo de la contraseña                        |
57
+| 1.   | Número de caracteres             | $4\left(len\right)$                                 | $len$ es el largo de la contraseña                        |
59
 | 2.   | Letras mayúsculas                | ![sumaMayus.png](images/sumaMayus.png)
58
 | 2.   | Letras mayúsculas                | ![sumaMayus.png](images/sumaMayus.png)
60
-     | $$n$$ es el número de letras mayúsculas                |
59
+     | $n$ es el número de letras mayúsculas                |
61
 | 3.   | Letras minúsculas                | ![sumaMin.png](images/sumaMin.png)
60
 | 3.   | Letras minúsculas                | ![sumaMin.png](images/sumaMin.png)
62
-    | $$n$$ es el número de letras minúsculas                |
61
+    | $n$ es el número de letras minúsculas                |
63
 | 4.   | Dígitos                          |  ![sumaDigitos.png](images/sumaDigitos.png)
62
 | 4.   | Dígitos                          |  ![sumaDigitos.png](images/sumaDigitos.png)
64
-   | $$n$$ es el número de dígitos                          |
65
-| 5.   | Símbolos                         | $$6n$$     | $$n$$ es el número de símbolos                         |
66
-| 6.   | Dígitos o símbolos en el medio   | $$2n$$                                    | $$n$$ es el número de dígitos y símbolos en el medio   |
67
-| 7.   | Requisitos                       | ![criterios.png](images/criterios.png)                              | $$n$$ es el número de criterios que se cumplen        |
63
+   | $n$ es el número de dígitos                          |
64
+| 5.   | Símbolos                         | $6n$     | $n$ es el número de símbolos                         |
65
+| 6.   | Dígitos o símbolos en el medio   | $2n$                                    | $n$ es el número de dígitos y símbolos en el medio   |
66
+| 7.   | Requisitos                       | ![criterios.png](images/criterios.png)                              | $n$ es el número de criterios que se cumplen        |
68
 
67
 
69
 **Tabla 1.** Criterios positivos para  la fortaleza de la contraseña. 
68
 **Tabla 1.** Criterios positivos para  la fortaleza de la contraseña. 
70
 
69
 
72
 
71
 
73
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **sumas**.
72
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **sumas**.
74
 
73
 
75
-1. **Número de caracteres**: este es el criterio más simple. La puntuación es $$4$$ veces el largo de la contraseña. Por ejemplo, `"ab453"` tiene un conteo de $$5$$ y puntuación de $$4 \cdot 5= 20$$.
74
+1. **Número de caracteres**: este es el criterio más simple. La puntuación es $4$ veces el largo de la contraseña. Por ejemplo, `"ab453"` tiene un conteo de $5$ y puntuación de $4 \cdot 5= 20$.
76
 
75
 
77
-2. **Letras mayúsculas** La puntuación es $$2 \left(len - n \right)$$ si la contraseña consiste de una mezcla de letras mayúsculas **Y** al menos otro tipo de caracter (minúscula, dígitos, símbolos). De lo contrario, la puntuación es $$0$$. Por ejemplo,
76
+2. **Letras mayúsculas** La puntuación es $2 \left(len - n \right)$ si la contraseña consiste de una mezcla de letras mayúsculas **Y** al menos otro tipo de caracter (minúscula, dígitos, símbolos). De lo contrario, la puntuación es $0$. Por ejemplo,
78
 
77
 
79
-    a. la puntuación para `"ab453"` sería $$0$$ ya que no tiene letras mayúsculas (el conteo también es $$0$$)
78
+    a. la puntuación para `"ab453"` sería $0$ ya que no tiene letras mayúsculas (el conteo también es $0$)
80
 
79
 
81
-    b. la puntuación para `"ALGO"` sería $$0$$ porque **solo** contiene letras mayúsculas (el conteo es $$4$$).
80
+    b. la puntuación para `"ALGO"` sería $0$ porque **solo** contiene letras mayúsculas (el conteo es $4$).
82
 
81
 
83
-    c. la puntuación para `"SANC8in"` sería $$2  \left(7-4\right) = 6$$ porque la contraseña es de largo $$7$$, contiene $$4$$ letras mayúsculas, y contiene caracteres de otro tipo (el conteo es $$4$$).
82
+    c. la puntuación para `"SANC8in"` sería $2  \left(7-4\right) = 6$ porque la contraseña es de largo $7$, contiene $4$ letras mayúsculas, y contiene caracteres de otro tipo (el conteo es $4$).
84
 
83
 
85
-3. **Letras minúsculas** La puntuación es $$2 \left(len - n\right)$$ si la contraseña es una mezcla de letras minúsculas **Y** al menos otro tipo de caracter (mayúscula, dígitos, símbolos). De lo contrario, la puntuación es $$0$$. Por ejemplo,
84
+3. **Letras minúsculas** La puntuación es $2 \left(len - n\right)$ si la contraseña es una mezcla de letras minúsculas **Y** al menos otro tipo de caracter (mayúscula, dígitos, símbolos). De lo contrario, la puntuación es $0$. Por ejemplo,
86
 
85
 
87
-    a. la puntuación para `"ab453"` sería $$2 \left(5-2\right) = 6$$ porque la contraseña es de largo $$5$$, contiene $$2$$ letras minúsculas, y contiene caracteres de otro tipo. El conteo es $$2$$.
86
+    a. la puntuación para `"ab453"` sería $2 \left(5-2\right) = 6$ porque la contraseña es de largo $5$, contiene $2$ letras minúsculas, y contiene caracteres de otro tipo. El conteo es $2$.
88
 
87
 
89
-    b. la puntuación para `"ALGO"` sería $$0$$ porque no contiene letras minúsculas. El conteo es $$0$$.
88
+    b. la puntuación para `"ALGO"` sería $0$ porque no contiene letras minúsculas. El conteo es $0$.
90
 
89
 
91
-    c. la puntuación para `"sancochin"`  sería $$0$$ porque contiene **solo** letras minúsculas. El conteo es $$9$$.
90
+    c. la puntuación para `"sancochin"`  sería $0$ porque contiene **solo** letras minúsculas. El conteo es $9$.
92
 
91
 
93
-4. **Dígitos** La puntuación es $$4n$$ si la contraseña consiste de una mezcla de dígitos **Y** al menos otro tipo de caracter (minúscula, mayúscula, símbolos). De otro modo la puntuación es $$0$$. Por ejemplo,
92
+4. **Dígitos** La puntuación es $4n$ si la contraseña consiste de una mezcla de dígitos **Y** al menos otro tipo de caracter (minúscula, mayúscula, símbolos). De otro modo la puntuación es $0$. Por ejemplo,
94
 
93
 
95
-  a. la puntuación para `"ab453"` sería $$4 \cdot3 = 12$$ porque la contraseña contiene $$3$$ dígitos y contiene caracteres de otro tipo.
94
+  a. la puntuación para `"ab453"` sería $4 \cdot3 = 12$ porque la contraseña contiene $3$ dígitos y contiene caracteres de otro tipo.
96
 
95
 
97
-  b. la puntuación para `"ALGO"` sería $$0$$ porque no tiene dígitos.
96
+  b. la puntuación para `"ALGO"` sería $0$ porque no tiene dígitos.
98
 
97
 
99
-  c. la puntuación para `801145555` sería $$0$$ porque contiene **solo** dígitos.
98
+  c. la puntuación para `801145555` sería $0$ porque contiene **solo** dígitos.
100
 
99
 
101
-5. **Símbolos** La puntuación es $$6n$$ si la contraseña contiene $$n$$ símbolos. De otro modo la puntuación es $$0$$. Por ejemplo,
100
+5. **Símbolos** La puntuación es $6n$ si la contraseña contiene $n$ símbolos. De otro modo la puntuación es $0$. Por ejemplo,
102
 
101
 
103
-  a. la puntuación para `"ab453"` sería $$0$$ porque no contiene símbolos.
102
+  a. la puntuación para `"ab453"` sería $0$ porque no contiene símbolos.
104
 
103
 
105
-  b. la puntuación para `"ALGO!!"` sería $$6 \cdot 2$$ porque contiene $$2$$ símbolos y contiene otros tipos de caracteres.
104
+  b. la puntuación para `"ALGO!!"` sería $6 \cdot 2$ porque contiene $2$ símbolos y contiene otros tipos de caracteres.
106
 
105
 
107
-  c. la puntuación para `”---><&&”`  sería $$6 \cdot 7 = 42$$ porque contiene $$7$$ símbolos. Nota que en el caso de símbolos, se otorga puntuación incluso cuando no hay otro tipo de caracteres.
106
+  c. la puntuación para `”---><&&”`  sería $6 \cdot 7 = 42$ porque contiene $7$ símbolos. Nota que en el caso de símbolos, se otorga puntuación incluso cuando no hay otro tipo de caracteres.
108
 
107
 
109
-6. **Dígitos o símbolos en el medio** La puntuación es $$2n$$ si la contraseña contiene símbolos o dígitos que no están en la primera o última posición. Por ejemplo,
108
+6. **Dígitos o símbolos en el medio** La puntuación es $2n$ si la contraseña contiene símbolos o dígitos que no están en la primera o última posición. Por ejemplo,
110
 
109
 
111
-  a. la puntuación para `"ab453"` sería $$2 \cdot2 = 4$$ porque contiene dos dígitos que no están en la primera o última posición, estos son `4` y `5`. 
110
+  a. la puntuación para `"ab453"` sería $2 \cdot2 = 4$ porque contiene dos dígitos que no están en la primera o última posición, estos son `4` y `5`. 
112
 
111
 
113
-  b. la puntuación para `"ALGO!"` sería $$0$$ porque no contiene dígitos ni símbolos en el medio, el único símbolo está al final.
112
+  b. la puntuación para `"ALGO!"` sería $0$ porque no contiene dígitos ni símbolos en el medio, el único símbolo está al final.
114
 
113
 
115
-  c. la puntuación para `S&c8i7o!`  sería $$2 \cdot 3 = 6$$ porque contiene $$3$$ símbolos o dígitos en el medio, estos son `&`, 8`, y `7`.
114
+  c. la puntuación para `S&c8i7o!`  sería $2 \cdot 3 = 6$ porque contiene $3$ símbolos o dígitos en el medio, estos son `&`, 8`, y `7`.
116
 
115
 
117
-7. **Requisitos**: Se otorga  $$2n$$ solo si el criterio del largo **Y** 3 o 4 de los otros criterios se cumplen, donde $$n$$ es el número de *criterios* que se cumplen. Los criterios son:
116
+7. **Requisitos**: Se otorga  $2n$ solo si el criterio del largo **Y** 3 o 4 de los otros criterios se cumplen, donde $n$ es el número de *criterios* que se cumplen. Los criterios son:
118
 
117
 
119
     a. La contraseña debe tener 8 o más caracteres de largo.
118
     a. La contraseña debe tener 8 o más caracteres de largo.
120
 
119
 
121
-    b. Contener:  
122
-        1. Letras mayúsculas
123
-        2. Letras minúsculas
124
-        3. Números
125
-        4. Símbolos
120
+    b. Contener:        - Letras mayúsculas
121
+        - Letras minúsculas
122
+        - Números
123
+        - Símbolos
126
 
124
 
127
     Cada uno de los listados en la parte b. cuenta como un criterio individual. Por ejemplo,
125
     Cada uno de los listados en la parte b. cuenta como un criterio individual. Por ejemplo,
128
 
126
 
129
-      a. la puntuación para `"ab453"` sería $$0$$ porque el criterio del largo no se cumple.
127
+      a. la puntuación para `"ab453"` sería $0$ porque el criterio del largo no se cumple.
130
 
128
 
131
-      b. la puntuación para `"abABCDEF"` sería $$0$$ debido a que, a pesar de que se cumple el criterio del largo, solo 2 de los 4 otros criterios se cumplen (mayúsculas y minúsculas).
129
+      b. la puntuación para `"abABCDEF"` sería $0$ debido a que, a pesar de que se cumple el criterio del largo, solo 2 de los 4 otros criterios se cumplen (mayúsculas y minúsculas).
132
 
130
 
133
-      c. la puntuación para `"abAB99!!"` sería $$2 \cdot 5 = 10$$ debido a que cumple la condición del largo y también los otros 4 criterios.
131
+      c. la puntuación para `"abAB99!!"` sería $2 \cdot 5 = 10$ debido a que cumple la condición del largo y también los otros 4 criterios.
134
 
132
 
135
 
133
 
136
 #### Restando puntos
134
 #### Restando puntos
139
 
137
 
140
 |      | Categoría                         | Puntos                                   | Notas                                                                   |
138
 |      | Categoría                         | Puntos                                   | Notas                                                                   |
141
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
139
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
142
-| 1.   | Solo letras                       |![resLetras.png](images/resLetras.png)    | $$len$$ es el largo de la contraseña                                           |
143
-| 2.   | Solo dígitos                      | ![resDigitos.png](images/resDigitos.png)    | $$len$$ es el largo de la contraseña                                           |
144
-| 3.   | Letras mayúsculas consecutivas    | $$-2n$$                                   | $$n$$ es el número de letras mayúsculas que siguen a otra letra mayúscula |
145
-| 4.   | Letras minúsculas consecutivas    | $$-2n$$                                   | $$n$$ es el número de letras minúsculas que siguen a otra letra minúscula                                                                     |
146
-| 5.   | Dígitos consecutivos              | $$-2n$$                                   | $$n$$ es el número de dígitos que siguen a otro dígito                     |
140
+| 1.   | Solo letras                       |![resLetras.png](images/resLetras.png)    | $len$ es el largo de la contraseña                                           |
141
+| 2.   | Solo dígitos                      | ![resDigitos.png](images/resDigitos.png)    | $len$ es el largo de la contraseña                                           |
142
+| 3.   | Letras mayúsculas consecutivas    | $-2n$                                   | $n$ es el número de letras mayúsculas que siguen a otra letra mayúscula |
143
+| 4.   | Letras minúsculas consecutivas    | $-2n$                                   | $n$ es el número de letras minúsculas que siguen a otra letra minúscula                                                                     |
144
+| 5.   | Dígitos consecutivos              | $-2n$                                   | $n$ es el número de dígitos que siguen a otro dígito                     |
147
 
145
 
148
 **Tabla 2.** Criterios negativos para la fortaleza de la contraseña. 
146
 **Tabla 2.** Criterios negativos para la fortaleza de la contraseña. 
149
 
147
 
151
 
149
 
152
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **restas**.
150
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **restas**.
153
 
151
 
154
-1. **Letras solamente**: La puntuación es $$-len$$ para una contraseña que consista solo de letras, de otro modo obtiene $$0$$. Por ejemplo, 
152
+1. **Letras solamente**: La puntuación es $-len$ para una contraseña que consista solo de letras, de otro modo obtiene $0$. Por ejemplo, 
155
 
153
 
156
-    a. la puntuación para `"ab453"` sería $$0$$ ya que contiene letras y números
154
+    a. la puntuación para `"ab453"` sería $0$ ya que contiene letras y números
157
 
155
 
158
-    b. la puntuación para `"Barrunto"` sería $$-8$$ ya que consiste solo de letras y su largo es $$8$$.
156
+    b. la puntuación para `"Barrunto"` sería $-8$ ya que consiste solo de letras y su largo es $8$.
159
 
157
 
160
-2. **Dígitos solamente**: La puntuación es $$-len$$ para una contraseña que consista solo de dígitos, de otro modo obtiene $$0$$. Por ejemplo, 
158
+2. **Dígitos solamente**: La puntuación es $-len$ para una contraseña que consista solo de dígitos, de otro modo obtiene $0$. Por ejemplo, 
161
 
159
 
162
-    a. la puntuación para `"ab453"` sería $$0$$ ya que contiene solo letras y números
160
+    a. la puntuación para `"ab453"` sería $0$ ya que contiene solo letras y números
163
 
161
 
164
-    b. la puntuación para `”987987987”` sería $$-9$$ ya que consiste solo de dígitos y su largo es $$9$$.
162
+    b. la puntuación para `”987987987”` sería $-9$ ya que consiste solo de dígitos y su largo es $9$.
165
 
163
 
166
-3. **Letras mayúsculas consecutivas**: La puntuación es $$-2n$$ donde $$n$$ es el número de letras mayúsculas que siguen a otra letra mayúscula. Por ejemplo,
164
+3. **Letras mayúsculas consecutivas**: La puntuación es $-2n$ donde $n$ es el número de letras mayúsculas que siguen a otra letra mayúscula. Por ejemplo,
167
 
165
 
168
-    a. la puntuación para `"DB453"` sería $$-2 \cdot 1 = -2$$ ya que solo contiene una letra mayúscula (`B`) que sigue a otra letra mayúscula.
166
+    a. la puntuación para `"DB453"` sería $-2 \cdot 1 = -2$ ya que solo contiene una letra mayúscula (`B`) que sigue a otra letra mayúscula.
169
 
167
 
170
-    b. la puntuación para `"TNS1PBMA"` sería $$-2 \cdot 5 = -10$$ ya que contiene 5 letras mayúsculas (`N`, `S`, `B`, `M`, `A`) que siguen a otra letra mayúscula.
168
+    b. la puntuación para `"TNS1PBMA"` sería $-2 \cdot 5 = -10$ ya que contiene 5 letras mayúsculas (`N`, `S`, `B`, `M`, `A`) que siguen a otra letra mayúscula.
171
 
169
 
172
 4. **Letras minúsculas consecutivas**: Igual que el criterio #3 pero para letras minúsculas.
170
 4. **Letras minúsculas consecutivas**: Igual que el criterio #3 pero para letras minúsculas.
173
 
171
 
197
 
195
 
198
 1.  Carga a Qt el proyecto `PassworStrength`  haciendo doble "click" en el archivo `PasswordStrength.pro` en el directorio `Documents/eip/Conditionals-PasswordStrength` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/conditionals-passwordstrength` para descargar la carpeta `Conditionals-PasswordStrength` a tu computadora.
196
 1.  Carga a Qt el proyecto `PassworStrength`  haciendo doble "click" en el archivo `PasswordStrength.pro` en el directorio `Documents/eip/Conditionals-PasswordStrength` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/conditionals-passwordstrength` para descargar la carpeta `Conditionals-PasswordStrength` a tu computadora.
199
 
197
 
198
+
200
 2. Configura el proyecto.  El proyecto consiste de varios archivos. **Solo escribirás código en el archivo `readpassword.cpp`. No debes cambiar nada en los demás archivos.** Sin embargo, debes familiarizarte con las funciones que ya están definidas en ellos, ya que usarás algunas de ellas para crear tu código.
199
 2. Configura el proyecto.  El proyecto consiste de varios archivos. **Solo escribirás código en el archivo `readpassword.cpp`. No debes cambiar nada en los demás archivos.** Sin embargo, debes familiarizarte con las funciones que ya están definidas en ellos, ya que usarás algunas de ellas para crear tu código.
201
 
200
 
202
-      * `psfunctions.cpp` : contiene las implementaciones de algunas de las funciones que tu programa va a invocar para calcular la puntuación de la fortaleza total de la contraseña. **No tienes que cambiar nada del código en este archivo ni en el archivo `psfunctions.h`**. Simplemente invocarás desde la función `readPass` en el archivo `readpassword.cpp` las funciones contenidas en ellos, según sea necesario. Hay funciones que no necesitarás invocar. Nota que el nombre de las funciones te dice lo que la función hace.
203
 
201
 
202
+      * `psfunctions.cpp` : contiene las implementaciones de algunas de las funciones que tu programa va a invocar para calcular la puntuación de la fortaleza total de la contraseña. **No tienes que cambiar nada del código en este archivo ni en el archivo `psfunctions.h`**. Simplemente invocarás desde la función `readPass` en el archivo `readpassword.cpp` las funciones contenidas en ellos, según sea necesario. Hay funciones que no necesitarás invocar. Nota que el nombre de las funciones te dice lo que la función hace.
204
       * `psfunctions.h` : contiene los prototipos de las funciones definidas en `psfunctions.cpp`.
203
       * `psfunctions.h` : contiene los prototipos de las funciones definidas en `psfunctions.cpp`.
205
      
204
      
205
+   
206
 
206
 
207
 ###Ejercicio 2: Conocer las funciones para actualizar la interface gráfica de usuarios.
207
 ###Ejercicio 2: Conocer las funciones para actualizar la interface gráfica de usuarios.
208
 
208
 
219
 Hay funciones pre-definidas que actualizan la interface gráfica. Para que la aplicación funcione como esperada, cada vez que tu código compute la puntuación que se adjudica para un criterio debes invocar la función que actualiza ese criterio en el interface gráfico. Las funciones para actualizar los criterios tienen la siguiente sintaxis:  
219
 Hay funciones pre-definidas que actualizan la interface gráfica. Para que la aplicación funcione como esperada, cada vez que tu código compute la puntuación que se adjudica para un criterio debes invocar la función que actualiza ese criterio en el interface gráfico. Las funciones para actualizar los criterios tienen la siguiente sintaxis:  
220
 
220
 
221
 
221
 
222
-```cpp
222
+  ```
223
   void setCRITERIO(int count, int score) ;
223
   void setCRITERIO(int count, int score) ;
224
-```
224
+  ```
225
 
225
 
226
-donde CRITERIO debe reemplazarse por el criterio evaluado. Observa que la función requiere dos argumentos: el **conteo** que es la cantidad de caracteres que cumple con el criterio y la **puntuación** que es el cálculo que tu implementarás siguiendo las tablas de arriba.  Por ejemplo,
226
+  donde CRITERIO debe reemplazarse por el criterio evaluado. Observa que la función requiere dos argumentos: el **conteo** que es la cantidad de caracteres que cumple con el criterio y la **puntuación** que es el cálculo que tu implementarás siguiendo las tablas de arriba.  Por ejemplo,
227
 
227
 
228
-```cpp
228
+```
229
 count = pass.length() ;
229
 count = pass.length() ;
230
 score = 4 * count ;
230
 score = 4 * count ;
231
 setNumberOfCharacters(count, score);
231
 setNumberOfCharacters(count, score);
232
 totalScore += score ;
232
 totalScore += score ;
233
 
233
 
234
 ```
234
 ```
235
-
236
 En  el código de arriba `count` contiene  el número de caracteres en la contraseña, `score` contiene el cómputo de la puntuación del criterio de número de caracteres y `setNumberOfCharacters(count, score);` invoca la función para que se actualice la información correspondiente al criterio “Number of characters” en la interface gráfica.
235
 En  el código de arriba `count` contiene  el número de caracteres en la contraseña, `score` contiene el cómputo de la puntuación del criterio de número de caracteres y `setNumberOfCharacters(count, score);` invoca la función para que se actualice la información correspondiente al criterio “Number of characters” en la interface gráfica.
237
 
236
 
238
 
237
 
239
-Las funciones para actualizar la interface gráfica son:
238
+  Las funciones para actualizar la interface gráfica son:
239
+  ```
240
+    // Para actualizar el largo de  la contraseña.
241
+    void setNumberOfCharacters(int count, int score) ;  
240
 
242
 
241
-```cpp
242
-// Para actualizar el largo de  la contraseña.
243
-void setNumberOfCharacters(int count, int score) ;  
243
+    // Para las sumas
244
 
244
 
245
-// Para las sumas
245
+    // Para actualizar los caracteres en mayúscula.
246
+    void setUpperCharacters(int count, int score) ;
246
 
247
 
247
-// Para actualizar los caracteres en mayúscula.
248
-void setUpperCharacters(int count, int score) ;
248
+    // Para actualizar los caracteres en minúscula.
249
+    void setLowerCharacters(int count, int score) ;
249
 
250
 
250
-// Para actualizar los caracteres en minúscula.
251
-void setLowerCharacters(int count, int score) ;
251
+    // Para actualizar los caracteres que son dígitos.
252
+    void setDigits(int count, int score) ;
252
 
253
 
253
-// Para actualizar los caracteres que son dígitos.
254
-void setDigits(int count, int score) ;
254
+    // Para actualizar los caracteres que son símbolos.
255
+    void setSymbols(int count, int score) ;
255
 
256
 
256
-// Para actualizar los caracteres que son símbolos.
257
-void setSymbols(int count, int score) ;
257
+    // Para actualizar digitos o simbolos en el medio
258
+    void setMiddleDigitsOrSymbols(int count, int score) ;
258
 
259
 
259
-// Para actualizar digitos o simbolos en el medio
260
-void setMiddleDigitsOrSymbols(int count, int score) ;
260
+    // Para actualizar el criterio de  los requisitos
261
+    void setRequirements(int count, int score) ;
261
 
262
 
262
-// Para actualizar el criterio de  los requisitos
263
-void setRequirements(int count, int score) ;
263
+    // Para las restas
264
 
264
 
265
-// Para las restas
265
+    // Para actualizar el criterio de letras solamente.
266
+    void setLettersOnly(int count, int score) ;
266
 
267
 
267
-// Para actualizar el criterio de letras solamente.
268
-void setLettersOnly(int count, int score) ;
268
+    // Para actualizar el criterio de dígitos solamente.
269
+    void setDigitsOnly(int count, int score) ;
269
 
270
 
270
-// Para actualizar el criterio de dígitos solamente.
271
-void setDigitsOnly(int count, int score) ;
271
+    // Para actualizar el criterio de mayúsculas consecutivas.
272
+    void setConsecutiveUpper(int count, int score) ;
272
 
273
 
273
-// Para actualizar el criterio de mayúsculas consecutivas.
274
-void setConsecutiveUpper(int count, int score) ;
274
+    // Para actualizar el criterio de minúsculas consecutivas.
275
+    void setConsecutiveLower(int count, int score) ;
275
 
276
 
276
-// Para actualizar el criterio de minúsculas consecutivas.
277
-void setConsecutiveLower(int count, int score) ;
278
-
279
-// Para actualizar el criterio de dígitos consecutivos.
280
-void setConsecutiveDigits(int count, int score) ; 
281
-```
277
+    // Para actualizar el criterio de dígitos consecutivos.
278
+    void setConsecutiveDigits(int count, int score) ; 
279
+  ```
282
 
280
 
283
 ###Ejercicio 3: Calcular la puntuación de los criterios y la puntuación total de la contraseña
281
 ###Ejercicio 3: Calcular la puntuación de los criterios y la puntuación total de la contraseña
284
 
282
 
310
 
308
 
311
 ---
309
 ---
312
 
310
 
313
-En el Ejemplo 2, el conteo de los **requisitos** es 5 porque `"S1nf@nia!"` cumple con el criterio de largo y también contiene mayúsculas, minúsculas, números y símbolos. Por lo tanto, la puntuación del número de requisitos es $$2 \cdot 5 =10$$.
311
+En el Ejemplo 2, el conteo de los **requisitos** es 5 porque `"S1nf@nia!"` cumple con el criterio de largo y también contiene mayúsculas, minúsculas, números y símbolos. Por lo tanto, la puntuación del número de requisitos es $2 \cdot 5 =10$.
314
 
312
 
315
 En el código del proyecto vas a encontrar ejemplos de cómo calcular los primeros dos criterios positivos: el número de caracteres en la contraseña y el número de letras mayúsculas. Puedes compilar y ejecutar el ejemplo para que veas la interfase funcionando con esos dos criterios. Parte de tu tarea es añadir el código para computar las puntuaciones de los demás criterios. Recuerda que debes ir acumulando el resultado de la puntuación total y hacer invocaciones para actualizar la interface gráfica.
313
 En el código del proyecto vas a encontrar ejemplos de cómo calcular los primeros dos criterios positivos: el número de caracteres en la contraseña y el número de letras mayúsculas. Puedes compilar y ejecutar el ejemplo para que veas la interfase funcionando con esos dos criterios. Parte de tu tarea es añadir el código para computar las puntuaciones de los demás criterios. Recuerda que debes ir acumulando el resultado de la puntuación total y hacer invocaciones para actualizar la interface gráfica.
316
 
314
 
318
 
316
 
319
 ###Ejercicio 4: Determinar y desplegar la fortaleza de la contraseña
317
 ###Ejercicio 4: Determinar y desplegar la fortaleza de la contraseña
320
 
318
 
321
-En la parte superior de la interface gráfica se ingresa la contraseña.  El usuario ingresará la contraseña en la parte superior de la interface gráfica. Debajo aparece un *informe* que contiene los distintos criterios, el conteo para cada criterio, y la puntuación individual para los criterios. Este informe se va actualizando según el usuario va ingresando los caracteres de la contraseña.  La puntuación total será la suma de todas los puntos (sumas y restas) de los criterios individuales.
319
+    En la parte superior de la interface gráfica se ingresa la contraseña.  El usuario ingresará la contraseña en la parte superior de la interface gráfica. Debajo aparece un *informe* que contiene los distintos criterios, el conteo para cada criterio, y la puntuación individual para los criterios. Este informe se va actualizando según el usuario va ingresando los caracteres de la contraseña.  La puntuación total será la suma de todas los puntos (sumas y restas) de los criterios individuales.
322
 
320
 
323
-Basado en la puntuación total, el programa debe clasificar la fortaleza de la contraseña como sigue:
321
+    Basado en la puntuación total, el programa debe clasificar la fortaleza de la contraseña como sigue:
324
 
322
 
325
 | Puntación total |  Fortaleza  |
323
 | Puntación total |  Fortaleza  |
326
 |-----------------|-------------|
324
 |-----------------|-------------|
366
 ![main2.png](images/main2.png)
364
 ![main2.png](images/main2.png)
367
 ![main3.png](images/main3.png)
365
 ![main3.png](images/main3.png)
368
 
366
 
369
-Commonly, when solving a problem, there are one or more steps that depend on whether certain conditions are met. Computer programs are built to solve problems, so they should have a structure that allows them to make decisions. In C++ the decision instructions (or conditionals) are structured using  `if`, `else`, `else if` or `switch`. In today's laboratory experience you will practice the use of some of these structures by completing the design of an application that determines the strength of a password.
367
+Commonly, when solving a problem, there are one or more steps that depend on whether certain conditions are met. Computer programs are built to solve problems, so they should have a structure that allows them to make decisions. In C++ the decision instructions (or conditionals) are structured using  `if`, `else`, `else if` or `switch`. Relational expressions and logical operators are common when handling decision structures. In today's laboratory experience you will practice the use of some of these structures by completing the design of an application that determines the strength of a password.
370
 
368
 
371
 ##Objectives:
369
 ##Objectives:
372
 
370
 
387
 
385
 
388
 3. Studied the concepts and instructions for this laboratory session.
386
 3. Studied the concepts and instructions for this laboratory session.
389
 
387
 
390
-4. Taken the Pre-Lab quiz 6].
388
+4. Taken the Pre-Lab quiz in Moodle.
391
 
389
 
392
 ---
390
 ---
393
 
391
 
412
 
410
 
413
 |      | Category                        | Points                                   | Notes                                                |
411
 |      | Category                        | Points                                   | Notes                                                |
414
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
412
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
415
-| 1.   | Number of characters             | $$4\left(len\right)$$                                 | $$len$$ is the length of the password                        |
413
+| 1.   | Number of characters             | $4\left(len\right)$                                 | $len$ is the length of the password                        |
416
 | 2.   | Uppercase letters                | ![addUpper.png](images/addUpper.png)
414
 | 2.   | Uppercase letters                | ![addUpper.png](images/addUpper.png)
417
-     | $$n$$ is the number of uppercase letters                |
415
+     | $n$ is the number of uppercase letters                |
418
 | 3.   | Lowercase letters                | ![addLower.png](images/addLower.png)
416
 | 3.   | Lowercase letters                | ![addLower.png](images/addLower.png)
419
-    | $$n$$ is the number of lowercase letters                |
417
+    | $n$ is the number of lowercase letters                |
420
 | 4.   | Digits                          |  ![addDigits.png](images/addDigits.png)
418
 | 4.   | Digits                          |  ![addDigits.png](images/addDigits.png)
421
-   | $$n$$ is the number of digits                          |
422
-| 5.   | Symbols                        | $$6n$$     | $$n$$ is the number of symbols                       |
423
-| 6.   | Digits or symbols in the middle   | $$2n$$                                    | $$n$$ is the number of digits or symbols in the middle   |
424
-| 7.   | Requisites                       | ![criteria.png](images/criteria.png)                              | $$n$$ is the number of criteria that are met        |
419
+   | $n$ is the number of digits                          |
420
+| 5.   | Symbols                        | $6n$     | $n$ is the number of symbols                       |
421
+| 6.   | Digits or symbols in the middle   | $2n$                                    | $n$ is the number of digits or symbols in the middle   |
422
+| 7.   | Requisites                       | ![criteria.png](images/criteria.png)                              | $n$ is the number of criteria that are met        |
425
 
423
 
426
 **Table 1.** Positive criteria for password strength. 
424
 **Table 1.** Positive criteria for password strength. 
427
 
425
 
429
 
427
 
430
 What follows are some additional details and examples for the criteria of **adding points**.
428
 What follows are some additional details and examples for the criteria of **adding points**.
431
 
429
 
432
-1. **Number of characters**: this is the simplestcriteria. The score will be $$4$$ times the length of the password. For example, `"ab453"` has a count of $$5$$ and a score of $$4 \cdot 5 = 20$$.
430
+1. **Number of characters**: this is the simplestcriteria. The score will be $4$ times the length of the password. For example, `"ab453"` has a count of $5$ and a score of $4 \cdot 5 = 20$.
433
 
431
 
434
-2. **Uppercase letters**: the score is $$2 \left(len - n \right)$$ if the password consists of a mix of uppercase letters **AND** at least another type of character (lowercase, digits, symbols). If not, the score is $$0$$. For example,
432
+2. **Uppercase letters**: the score is $2 \left(len - n \right)$ if the password consists of a mix of uppercase letters **AND** at least another type of character (lowercase, digits, symbols). If not, the score is $0$. For example,
435
 
433
 
436
-  a. the score for `"ab453"` would be $$0$$ since it doesn't have uppercase letters (the count is also $$0$$).
434
+  a. the score for `"ab453"` would be $0$ since it doesn't have uppercase letters (the count is also $0$).
437
 
435
 
438
-  b. the score for `"ALGO"` would be $$0$$ since it **only** has uppercase letters (the count is $$4$$).
436
+  b. the score for `"ALGO"` would be $0$ since it **only** has uppercase letters (the count is $4$).
439
 
437
 
440
-  c. the score for `"SANC8in"` would be $$2  \left(7-4\right) = 6$$ since the password has a length of $$7$$, has $$4$$ uppercase letters, and contains characters of another type (the count is $$4$$).
438
+  c. the score for `"SANC8in"` would be $2  \left(7-4\right) = 6$ since the password has a length of $7$, has $4$ uppercase letters, and contains characters of another type (the count is $4$).
441
 
439
 
442
-3. **Lowercase letters**: the score is $$2 \left(len - n\right)$$ if the password is a mix of lowercase letters **AND** at least another type of character (uppercase, digits, symbols). If not, the score is $$0$$. For example,
440
+3. **Lowercase letters**: the score is $2 \left(len - n\right)$ if the password is a mix of lowercase letters **AND** at least another type of character (uppercase, digits, symbols). If not, the score is $0$. For example,
443
 
441
 
444
-  a. the score for `"ab453"` would be $$2 \left(5-2\right) = 6$$ because the password has a length of $$5$$, contains $$2$$ lowercase letters, and contains characters of another type. The count is $$2$$.
442
+  a. the score for `"ab453"` would be $2 \left(5-2\right) = 6$ because the password has a length of $5$, contains $2$ lowercase letters, and contains characters of another type. The count is $2$.
445
 
443
 
446
-  b. the score for `"ALGO"` would be $$0$$ because it doesn't have lowercase letters. The count is $$0$$.
444
+  b. the score for `"ALGO"` would be $0$ because it doesn't have lowercase letters. The count is $0$.
447
 
445
 
448
-  c. the score for `"sancochin"`  would be $$0$$ because it contains **only** lowercase letters. The count is $$9$$.
446
+  c. the score for `"sancochin"`  would be $0$ because it contains **only** lowercase letters. The count is $9$.
449
 
447
 
450
-4. **Digits**: the score is $$4n$$ if the password consists of a mix of digits **AND** at least another type of character (lowercase, uppercase, symbols). If not, the score is $$0$$. For example,
448
+4. **Digits**: the score is $4n$ if the password consists of a mix of digits **AND** at least another type of character (lowercase, uppercase, symbols). If not, the score is $0$. For example,
451
 
449
 
452
-  a. the score for `"ab453"` would be  $$4 \cdot 3 = 12$$ because the password contains $$3$$ digits and contains characters of another type.
450
+  a. the score for `"ab453"` would be  $4 \cdot 3 = 12$ because the password contains $3$ digits and contains characters of another type.
453
 
451
 
454
-  b. the score for `"ALGO"` would be $$0$$ because it doesn't have digits.
452
+  b. the score for `"ALGO"` would be $0$ because it doesn't have digits.
455
 
453
 
456
-  c. the score for `801145555` would be $$0$$ because it contains **only** digits.
454
+  c. the score for `801145555` would be $0$ because it contains **only** digits.
457
 
455
 
458
-5. **Symbols** The score is $$6n$$ if the password contains $$n$$ symbols. Otherwise, the score is $$0$$. For example,
456
+5. **Symbols** The score is $6n$ if the password contains $n$ symbols. Otherwise, the score is $0$. For example,
459
 
457
 
460
-  a. the score for `"ab453"` would be $$0$$ because it does not contain symbols.
458
+  a. the score for `"ab453"` would be $0$ because it does not contain symbols.
461
 
459
 
462
-  b. the score for `"ALGO!!"` would be $$6 \cdot 2$$ because it contains $$2$$ symbols and contains other types of characters.
460
+  b. the score for `"ALGO!!"` would be $6 \cdot 2$ because it contains $2$ symbols and contains other types of characters.
463
 
461
 
464
-  c. the score for `”---><&&”` would be $$6 \cdot 7 = 42$$ because it contains $$7$$ symbols. Note that in the case of symbols, points are given even when there aren't other types of characters.
462
+  c. the score for `”---><&&”` would be $6 \cdot 7 = 42$ because it contains $7$ symbols. Note that in the case of symbols, points are given even when there aren't other types of characters.
465
 
463
 
466
-6. **Digits or symbols in the middle** The score is $$2n$$ if the password contains symbols or digits that are not in the first or last position. For example,
464
+6. **Digits or symbols in the middle** The score is $2n$ if the password contains symbols or digits that are not in the first or last position. For example,
467
 
465
 
468
-  a. the score for `"ab453"` would be $$2 \cdot2 = 4$$ because it contains 2 digits that are not in the first or last position, these are `4` and `5`.
466
+  a. the score for `"ab453"` would be $2 \cdot2 = 4$ because it contains 2 digits that are not in the first or last position, these are `4` and `5`.
469
 
467
 
470
-  b. the score for `"ALGO!"` would be $$0$$ because it does not contain digits or symbols in the middle, the only symbol is in the last position.
468
+  b. the score for `"ALGO!"` would be $0$ because it does not contain digits or symbols in the middle, the only symbol is in the last position.
471
 
469
 
472
-  c. the score for `S&c8i7o!` would be $$2 \cdot 3 = 6$$ because it contains $$3$$ symbols or digits in the middle, these are `&`, 8`, and `7`.
470
+  c. the score for `S&c8i7o!` would be $2 \cdot 3 = 6$ because it contains $3$ symbols or digits in the middle, these are `&`, 8`, and `7`.
473
 
471
 
474
-7. **Requisites**: The score is $$2n$$ only if the length criteria **AND** 3 or 4 of the other criteria are met, where $$n$$ is the number of *criteria* that are met. The criteria are:
472
+7. **Requisites**: The score is $2n$ only if the length criteria **AND** 3 or 4 of the other criteria are met, where $n$ is the number of *criteria* that are met. The criteria are:
475
 
473
 
476
   a. The password must contain 8 or more characters of length.
474
   a. The password must contain 8 or more characters of length.
477
 
475
 
481
     - Numbers
479
     - Numbers
482
     - Symbols
480
     - Symbols
483
 
481
 
484
-  Each of the items listed in part b. count as one individual criteria. For example,
482
+Each of the items listed in part b. count as one individual criteria. For example,
485
 
483
 
486
-    1. the score for `"ab453"` would be $$0$$ because the criteria for length is not met.
484
+  a. the score for `"ab453"` would be $0$ because the criteria for length is not met.
487
 
485
 
488
-    2. the score for `"abABCDEF"` would be $$0$$ because, despite the fact that the length criteria is met, only 2 of the 4 other criteria are met (uppercase and lowercase letters).
489
-
490
-    3. the score for `"abAB99!!"` would be $$2 \cdot 5 = 10$$ because the length criteria and the other 4 criteria are met.
486
+  b. the score for `"abABCDEF"` would be $0$ because, despite the fact that the length criteria is met, only 2 of the 4 other criteria are met (uppercase and lowercase letters).
491
 
487
 
488
+  c. the score for `"abAB99!!"` would be $2 \cdot 5 = 10$ because the length criteria and the other 4 criteria are met.
492
 
489
 
493
 
490
 
494
 #### Subtracting points
491
 #### Subtracting points
497
 
494
 
498
 |      | Category                         | Points                                   | Notes                                                                  |
495
 |      | Category                         | Points                                   | Notes                                                                  |
499
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
496
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
500
-| 1.   | Only letters                       |![subsLetters.png](images/subsLetters.png)    | $$len$$ is the length of the password                                          |
501
-| 2.   | Only digits                      | ![subsDigits.png](images/subsDigits.png)    | $$len$$ is the length of the password                                           |
502
-| 3.   | Consecutive uppercase letters    | $$-2n$$                                   | $$n$$ is the number of uppercase letters that follow another uppercase letter |
503
-| 4.   | Consecutive lowercase letters   | $$-2n$$                                   | $$n$$ is the number of lowercase letters that follow another lowercase letter                                                                     |
504
-| 5.   | Consecutive digits             | $$-2n$$                                   | $$n$$ is the number of digits that follow another digit                     |
497
+| 1.   | Only letters                       |![subsLetters.png](images/subsLetters.png)    | $len$ is the length of the password                                          |
498
+| 2.   | Only digits                      | ![subsDigits.png](images/subsDigits.png)    | $len$ is the length of the password                                           |
499
+| 3.   | Consecutive uppercase letters    | $-2n$                                   | $n$ is the number of uppercase letters that follow another uppercase letter |
500
+| 4.   | Consecutive lowercase letters   | $-2n$                                   | $n$ is the number of lowercase letters that follow another lowercase letter                                                                     |
501
+| 5.   | Consecutive digits             | $-2n$                                   | $n$ is the number of digits that follow another digit                     |
505
 
502
 
506
 
503
 
507
 **Table 2.** Negative criteria for password strength. 
504
 **Table 2.** Negative criteria for password strength. 
510
 
507
 
511
 The following are additional details and examples of the criteria for **subtracting points**.
508
 The following are additional details and examples of the criteria for **subtracting points**.
512
 
509
 
513
-1. **Only letters**: The score is $$-len$$ for a password that consists of letters only, otherwise it is $$0$$. For example,
510
+1. **Only letters**: The score is $-len$ for a password that consists of letters only, otherwise it is $0$. For example,
514
 
511
 
515
-  a. the score for `"ab453"` would be $$0$$ since it contains letters and numbers.
512
+  a. the score for `"ab453"` would be $0$ since it contains letters and numbers.
516
 
513
 
517
-  b. the score for `"Barrunto"` would be $$-8$$ since it only contains letters and its length is $$8$$.
514
+  b. the score for `"Barrunto"` would be $-8$ since it only contains letters and its length is $8$.
518
 
515
 
519
-2. **Only digits**: The score is $$-len$$ for a password that consists of digits only, otherwise it is $$0$$. For example,
516
+2. **Only digits**: The score is $-len$ for a password that consists of digits only, otherwise it is $0$. For example,
520
 
517
 
521
-  a. the score for `"ab453"` would be $$0$$ since it contains only letters and numbers.
518
+  a. the score for `"ab453"` would be $0$ since it contains only letters and numbers.
522
 
519
 
523
-  b. the score for `”987987987”` would be $$-9$$ since it contains only digits and its length is $$9$$.
520
+  b. the score for `”987987987”` would be $-9$ since it contains only digits and its length is $9$.
524
 
521
 
525
-3. **Consecutive uppercase letters**: The score is $$-2n$$ where $$n$$ is the number of uppercase letters that follow another uppercase letter. For example,
522
+3. **Consecutive uppercase letters**: The score is $-2n$ where $n$ is the number of uppercase letters that follow another uppercase letter. For example,
526
 
523
 
527
-  a. the score for `"DB453"` would be $$-2 \cdot 1 = -2$$ since it only contains one uppercase letter (`B`) that follows another uppercase letter.
524
+  a. the score for `"DB453"` would be $-2 \cdot 1 = -2$ since it only contains one uppercase letter (`B`) that follows another uppercase letter.
528
 
525
 
529
-  b. the score for `"TNS1PBMA"` would be $$-2 \cdot 5 = -10$$ since it contains 5 uppercase letters (`N`, `S`, `B`, `M`, `A`) that follow another uppercase letter.
526
+  b. the score for `"TNS1PBMA"` would be $-2 \cdot 5 = -10$ since it contains 5 uppercase letters (`N`, `S`, `B`, `M`, `A`) that follow another uppercase letter.
530
 
527
 
531
 4. **Consecutive lowercase letters**: The same as for criteria #3 but for lowercase letters.
528
 4. **Consecutive lowercase letters**: The same as for criteria #3 but for lowercase letters.
532
 
529
 
581
 There are predefined functions that update the graphical interface. For the application to work properly, each time that your code computes the score that is given for each criteria you should invoke the function to update that particular criteria in the graphical interface. The functions to update the criteria have the following syntax:
578
 There are predefined functions that update the graphical interface. For the application to work properly, each time that your code computes the score that is given for each criteria you should invoke the function to update that particular criteria in the graphical interface. The functions to update the criteria have the following syntax:
582
 
579
 
583
 
580
 
584
-```cpp
585
-void setCRITERIA(int count, int score) ;
586
-```
581
+  ```
582
+  void setCRITERIA(int count, int score) ;
583
+  ```
587
 
584
 
588
   where CRITERIA should be replaced by the criteria that is being evaluated. Observe that the function requires two arguments: the **count** that is the amount of characters that meet the criteria and the **score** that is the calculation that you will implement following the tables presented above. For example,
585
   where CRITERIA should be replaced by the criteria that is being evaluated. Observe that the function requires two arguments: the **count** that is the amount of characters that meet the criteria and the **score** that is the calculation that you will implement following the tables presented above. For example,
589
 
586
 
590
-```cpp
591
-count = pass.length() ;
592
-score = 4 * count ;
593
-setNumberOfCharacters(count, score);
594
-totalScore += score ;
587
+  ```
588
+  count = pass.length() ;
589
+  score = 4 * count ;
590
+  setNumberOfCharacters(count, score);
591
+  totalScore += score ;
595
 
592
 
596
-```
593
+  ```
597
 
594
 
598
   In the above code `count` contains the number of characters in the password, `score` contains the computation for the score of the criteria for the number of characters, and `setNumberOfCharacters(count, score);` invokes the function to update the corresponding information for the criteria "Number of characters" in the graphical interface.
595
   In the above code `count` contains the number of characters in the password, `score` contains the computation for the score of the criteria for the number of characters, and `setNumberOfCharacters(count, score);` invokes the function to update the corresponding information for the criteria "Number of characters" in the graphical interface.
599
 
596
 
600
   The functions to update the graphical interface are:
597
   The functions to update the graphical interface are:
601
-  
602
-```cpp
603
-// To update the password's length.
604
-void setNumberOfCharacters(int count, int score) ;  
598
+    ```
599
+    // To update the password's length.
600
+    void setNumberOfCharacters(int count, int score) ;  
605
 
601
 
606
-// For adding points
602
+    // For adding points
607
 
603
 
608
-// To update the uppercase characters.
609
-void setUpperCharacters(int count, int score) ;
604
+    // To update the uppercase characters.
605
+    void setUpperCharacters(int count, int score) ;
610
 
606
 
611
-// To update the lowercase characters.
612
-void setLowerCharacters(int count, int score) ;
607
+    // To update the lowercase characters.
608
+    void setLowerCharacters(int count, int score) ;
613
 
609
 
614
-// To update the characters that are digits.
615
-void setDigits(int count, int score) ;
610
+    // To update the characters that are digits.
611
+    void setDigits(int count, int score) ;
616
 
612
 
617
-// To update the characters that are symbols.
618
-void setSymbols(int count, int score) ;
613
+    // To update the characters that are symbols.
614
+    void setSymbols(int count, int score) ;
619
 
615
 
620
-// To update the digits or symbols in the middle
621
-void setMiddleDigitsOrSymbols(int count, int score) ;
616
+    // To update the digits or symbols in the middle
617
+    void setMiddleDigitsOrSymbols(int count, int score) ;
622
 
618
 
623
-// To update the criterium of the requisites
624
-void setRequirements(int count, int score) ;
619
+    // To update the criterium of the requisites
620
+    void setRequirements(int count, int score) ;
625
 
621
 
626
-// For subtracting points
622
+    // For subtracting points
627
 
623
 
628
-// To update the criterium of only letters.
629
-void setLettersOnly(int count, int score) ;
624
+    // To update the criterium of only letters.
625
+    void setLettersOnly(int count, int score) ;
630
 
626
 
631
-// To update the criterium of only digits.
632
-void setDigitsOnly(int count, int score) ;
627
+    // To update the criterium of only digits.
628
+    void setDigitsOnly(int count, int score) ;
633
 
629
 
634
-// To update the criterium of consecutive uppercase letters.
635
-void setConsecutiveUpper(int count, int score) ;
630
+    // To update the criterium of consecutive uppercase letters.
631
+    void setConsecutiveUpper(int count, int score) ;
636
 
632
 
637
-// To update the criterium of consecutive lowercase letters.
638
-void setConsecutiveLower(int count, int score) ;
633
+    // To update the criterium of consecutive lowercase letters.
634
+    void setConsecutiveLower(int count, int score) ;
639
 
635
 
640
-// To update the criterium of consecutive digits.
641
-void setConsecutiveDigits(int count, int score) ; 
642
-```
636
+    // To update the criterium of consecutive digits.
637
+    void setConsecutiveDigits(int count, int score) ; 
638
+    ```
643
 
639
 
644
 
640
 
645
 
641
 
673
 
669
 
674
 ---
670
 ---
675
 
671
 
676
-In Example 2, the number of **requisites** is 5 because `"S1nf@nia!"` meets the criteria for length and also contains uppercase letters, lowercase letters, numbers and symbols. Therefore, the score for the number of requisites is $$2 \cdot 5 =10$$.
672
+In Example 2, the number of **requisites** is 5 because `"S1nf@nia!"` meets the criteria for length and also contains uppercase letters, lowercase letters, numbers and symbols. Therefore, the score for the number of requisites is $2 \cdot 5 =10$.
677
 
673
 
678
 In the project's code you will find examples of how to calculate the first two positive criteria: the number of characters in the password and the numbers of uppercase letters. You can compile and execute the example so you can see the working interface with these two criteria. Part of your task is to add the code to compute the score for the remaining criteria. Remember that you should accumulate the total score and invoke the functions to update the graphical interface.
674
 In the project's code you will find examples of how to calculate the first two positive criteria: the number of characters in the password and the numbers of uppercase letters. You can compile and execute the example so you can see the working interface with these two criteria. Part of your task is to add the code to compute the score for the remaining criteria. Remember that you should accumulate the total score and invoke the functions to update the graphical interface.
679
 
675
 

BIN
images/latex-image-1.pdf View File


BIN
images/latex-image-2.pdf View File


BIN
images/latex-image-3.pdf View File