EIP
/
selections-passwordstrength
Watch 2
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Arreglando README

Rafael Arce Nazario 9 years ago
parent
abf7931a48
commit
cb95c9cd0a
1 changed files with 145 additions and 149 deletions
Unified View Show Diff Stats
  1. 145
    149
      README.md

+ 145
- 149
README.md View File

1 
 [English](#markdown-header-decision-structures-password-strength) | [Español](#markdown-header-estructuras-de-decision-fortaleza-de-contrasenas)
 1 
 [English](#markdown-header-decision-structures-password-strength) | [Español](#markdown-header-estructuras-de-decision-fortaleza-de-contrasenas)
2
2
3 
-#Estructuras de decisión - Fortaleza de contraseñas
3 
+# Estructuras de decisión - Fortaleza de contraseñas
4
4
5 
 ![main1.png](images/main1.png)
 5 
 ![main1.png](images/main1.png)
6 
 ![main2.png](images/main2.png)
 6 
 ![main2.png](images/main2.png)
8
8
9
9
10
10
11 
-En casi todas las instancias en que queremos resolver un problema hay una o más opciones que dependen  de si se cumplen o no ciertas condiciones. Los programas de computadoras se construyen para resolver problemas y, por lo tanto, deben tener una estructura que permita tomar decisiones. En C++ las  instrucciones de decisión (o condicionales) se estructuran utilizando `if`, `else`, `else if` o `switch`. Muchas veces el uso de estas estructuras también envuelve el uso de expresiones de relación y operadores lógicos. En la experiencia de laboratorio de hoy practicarás el uso de algunas  estructuras de decisión completando el diseño de una aplicación que determina la fortaleza de  una contraseña de acceso ("password").
11 
+En casi todas las instancias en que queremos resolver un problema hay una o más opciones que dependen  de si se cumplen o no ciertas condiciones. Los programas de computadoras se construyen para resolver problemas y, por lo tanto, deben tener una estructura que permita tomar decisiones. En C++ las  instrucciones de decisión (o condicionales) se estructuran utilizando `if`, `else`, `else if` o `switch`. Muchas veces el uso de estas estructuras también envuelve el uso de expresiones de relación y operadores lógicos. En la experiencia de laboratorio de hoy practicarás el uso de algunas  estructuras de decisión completando el diseño de una aplicación que determina la fortaleza de  una contraseña de acceso ("password").
12
12
13 
-##Objetivos:
13 
+## Objetivos:
14
14
15 
 1.  Utilizar expresiones relacionales y seleccionar operadores lógicos adecuados para la toma de decisiones.
 15 
 1.  Utilizar expresiones relacionales y seleccionar operadores lógicos adecuados para la toma de decisiones.
16 
 2. Aplicar estructuras de decisión.
 16 
 2. Aplicar estructuras de decisión.
17
17
18
18
19 
-##Pre-Lab:
19 
+## Pre-Lab:
20
20
21 
 Antes de llegar al laboratorio debes:
 21 
 Antes de llegar al laboratorio debes:
22
22
23 
 1. Haber repasado los siguientes conceptos:
 23 
 1. Haber repasado los siguientes conceptos:
24
24
25 
-operadores lógicos.
26 
-`if`, `else`, `else if`.
25 
+    a. operadores lógicos
26 
+
27 
+    b. `if`, `else`, `else if`.
27
28
28 
 2. Haber repasado el uso de objetos de la clase `string` y su método `length()`.
 29 
 2. Haber repasado el uso de objetos de la clase `string` y su método `length()`.
29
30
36
37
37 
 ---
 38 
 ---
38
39
39 
-##Fortaleza de contraseñas de acceso
40 
+## Fortaleza de contraseñas de acceso
40
41
41 
 Utilizar contraseñas de acceso resistentes es esencial para mantener los datos seguros en los sistemas de información. Una contraseña se considera resistente o fuerte ("strong") si resulta costo-inefectivo para el "pirata informático" ("hacker") emplear tiempo tratando de adivinarla usando contraseñas ingenuas o fuerza bruta. Por ejemplo, una contraseña que consiste de una palabra simple del diccionario, sin números, símbolos o letras mayúsculas, es tan fácil de descifrar que hasta "un cavernícola puede hacerlo".
 42 
 Utilizar contraseñas de acceso resistentes es esencial para mantener los datos seguros en los sistemas de información. Una contraseña se considera resistente o fuerte ("strong") si resulta costo-inefectivo para el "pirata informático" ("hacker") emplear tiempo tratando de adivinarla usando contraseñas ingenuas o fuerza bruta. Por ejemplo, una contraseña que consiste de una palabra simple del diccionario, sin números, símbolos o letras mayúsculas, es tan fácil de descifrar que hasta "un cavernícola puede hacerlo".
42
43
54
55
55 
 |      | Categoría                        | Puntos                                   | Notas                                                |
 56 
 |      | Categoría                        | Puntos                                   | Notas                                                |
56 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
 57 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
57 
-| 1.   | Número de caracteres             | $4\left(len\right)$                                 | $len$ es el largo de la contraseña                        |
58 
-| 2.   | Letras mayúsculas                | ![sumaMayus.png](images/sumaMayus.png)
59 
-     | $n$ es el número de letras mayúsculas                |
60 
-| 3.   | Letras minúsculas                | ![sumaMin.png](images/sumaMin.png)
61 
-    | $n$ es el número de letras minúsculas                |
62 
-| 4.   | Dígitos                          |  ![sumaDigitos.png](images/sumaDigitos.png)
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        |
58 
+| 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)| $n$ es el número de letras mayúsculas                |
60 
+| 3.   | Letras minúsculas                | ![sumaMin.png](images/sumaMin.png) | $$n$$ es el número de letras minúsculas                |
61 
+| 4.   | Dígitos                          |  ![sumaDigitos.png](images/sumaDigitos.png) | $$n$$ es el número de dígitos                          |
62 
+| 5.   | Símbolos                         | $$6n$$     | $$n$$ es el número de símbolos                         |
63 
+| 6.   | Dígitos o símbolos en el medio   | $$2n$$                                   | $n$ es el número de dígitos y símbolos en el medio   |
64 
+| 7.   | Requisitos                       | ![criterios.png](images/criterios.png)                              | $$n$$ es el número de criterios que se cumplen        |
67
65
68 
-**Tabla 1.** Criterios positivos para  la fortaleza de la contraseña.
66 
+**Tabla 1.** Criterios positivos para  la fortaleza de la contraseña.
69
67
70 
 ---
 68 
 ---
71
69
72 
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **sumas**.
 70 
 Lo que sigue son algunos detalles adicionales y ejemplos de los criterios para **sumas**.
73
71
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$.
72 
+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$$.
75
73
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,
74 
+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,
77
75
78 
-    a. la puntuación para `"ab453"` sería $0$ ya que no tiene letras mayúsculas (el conteo también es $0$)
76 
+    a. la puntuación para `"ab453"` sería $$0$$ ya que no tiene letras mayúsculas (el conteo también es $$0$$)
79
77
80 
-    b. la puntuación para `"ALGO"` sería $0$ porque **solo** contiene letras mayúsculas (el conteo es $4$).
78 
+    b. la puntuación para `"ALGO"` sería $$0$$ porque **solo** contiene letras mayúsculas (el conteo es $$4$$).
81
79
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$).
80 
+    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$$).
83
81
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,
82 
+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,
85
83
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$.
84 
+    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$$.
87
85
88 
-    b. la puntuación para `"ALGO"` sería $0$ porque no contiene letras minúsculas. El conteo es $0$.
86 
+    b. la puntuación para `"ALGO"` sería $$0$$ porque no contiene letras minúsculas. El conteo es $$0$$.
89
87
90 
-    c. la puntuación para `"sancochin"`  sería $0$ porque contiene **solo** letras minúsculas. El conteo es $9$.
88 
+    c. la puntuación para `"sancochin"`  sería $$0$$ porque contiene **solo** letras minúsculas. El conteo es $$9$$.
91
89
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,
90 
+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,
93
91
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.
92 
+  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.
95
93
96 
-  b. la puntuación para `"ALGO"` sería $0$ porque no tiene dígitos.
94 
+  b. la puntuación para `"ALGO"` sería $$0$$ porque no tiene dígitos.
97
95
98 
-  c. la puntuación para `801145555` sería $0$ porque contiene **solo** dígitos.
96 
+  c. la puntuación para `801145555` sería $$0$$ porque contiene **solo** dígitos.
99
97
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,
98 
+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,
101
99
102 
-  a. la puntuación para `"ab453"` sería $0$ porque no contiene símbolos.
100 
+  a. la puntuación para `"ab453"` sería $$0$$ porque no contiene símbolos.
103
101
104 
-  b. la puntuación para `"ALGO!!"` sería $6 \cdot 2$ porque contiene $2$ símbolos y contiene otros tipos de caracteres.
102 
+  b. la puntuación para `"ALGO!!"` sería $$6 \cdot 2$$ porque contiene $$2$$ símbolos y contiene otros tipos de caracteres.
105
103
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.
104 
+  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.
107
105
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,
106 
+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,
109
107
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`.
108 
+  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`.
111
109
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.
110 
+  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.
113
111
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`.
112 
+  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`.
115
113
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:
114 
+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:
117
115
118 
     a. La contraseña debe tener 8 o más caracteres de largo.
 116 
     a. La contraseña debe tener 8 o más caracteres de largo.
119
117
120 
-    b. Contener:        - Letras mayúsculas
121 
-        - Letras minúsculas
122 
-        - Números
123 
-        - Símbolos
118 
+    b. Contener:
119 
+
120 
+        1. Letras mayúsculas
121 
+        2. Letras minúsculas
122 
+        3. Números
123 
+        4. Símbolos
124
124
125 
     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,
126
126
127 
-      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.
128
128
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).
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).
130
130
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.
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.
132
132
133
133
134 
 #### Restando puntos
 134 
 #### Restando puntos
137
137
138 
 |      | Categoría                         | Puntos                                   | Notas                                                                   |
 138 
 |      | Categoría                         | Puntos                                   | Notas                                                                   |
139 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
 139 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
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                     |
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                     |
145
145
146 
-**Tabla 2.** Criterios negativos para la fortaleza de la contraseña.
146 
+**Tabla 2.** Criterios negativos para la fortaleza de la contraseña.
147
147
148 
 ---
 148 
 ---
149
149
150 
 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**.
151
151
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,
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,
153
153
154 
-    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
155
155
156 
-    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$$.
157
157
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,
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,
159
159
160 
-    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
161
161
162 
-    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$$.
163
163
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,
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,
165
165
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.
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.
167
167
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.
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.
169
169
170 
 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.
171
171
189
189
190 
 ---
 190 
 ---
191
191
192 
-##Sesión de laboratorio:
192 
+## Sesión de laboratorio:
193
193
194 
-En esta experiencia de laboratorio practicarás el uso de expresiones matemáticas y estructuras condicionales para computar la puntuación de resistencia o fortaleza de una contraseña combinando las puntuaciones de los criterios individuales.
194 
+En esta experiencia de laboratorio practicarás el uso de expresiones matemáticas y estructuras condicionales para computar la puntuación de resistencia o fortaleza de una contraseña combinando las puntuaciones de los criterios individuales.
195
195
196 
 Tu tarea es completar el diseño de una aplicación para medir la fortaleza de las contraseñas de acceso ("password strength"). Al final obtendrás un programa que será una versión simplificada de la aplicación en http://www.passwordmeter.com/. Como no existe un sistema oficial para medir las contraseñas, se utilizarán las fórmulas creadas por el "passwordmeter" para evaluar la fortaleza general de una contraseña dada. La aplicación permitirá al usuario entrar una contraseña y calculará su fortaleza utilizando una serie de reglas.
 196 
 Tu tarea es completar el diseño de una aplicación para medir la fortaleza de las contraseñas de acceso ("password strength"). Al final obtendrás un programa que será una versión simplificada de la aplicación en http://www.passwordmeter.com/. Como no existe un sistema oficial para medir las contraseñas, se utilizarán las fórmulas creadas por el "passwordmeter" para evaluar la fortaleza general de una contraseña dada. La aplicación permitirá al usuario entrar una contraseña y calculará su fortaleza utilizando una serie de reglas.
197
197
198 
 La fortaleza de la contraseña se cuantificará otorgando puntos por utilizar "buenas" técnicas de selección de contraseñas (como combinar símbolos y letras) y restando puntos por utilizar "malos" hábitos (como utilizar solo letras minúsculas o caracteres consecutivos de un mismo tipo). Tu programa analizará la contraseña dada por el usuario y usará los criterios en las tablas presentadas arriba para computar una puntuación para la fortaleza de la contraseña.
 198 
 La fortaleza de la contraseña se cuantificará otorgando puntos por utilizar "buenas" técnicas de selección de contraseñas (como combinar símbolos y letras) y restando puntos por utilizar "malos" hábitos (como utilizar solo letras minúsculas o caracteres consecutivos de un mismo tipo). Tu programa analizará la contraseña dada por el usuario y usará los criterios en las tablas presentadas arriba para computar una puntuación para la fortaleza de la contraseña.
199
199
200 
-Una vez completada la aplicación, esta mostrará una ventana en donde, según se vayan entrando los caracteres de la contraseña, se desglosará la puntuación parcial obtenida. Esta interface gráfica para el usuario le ofrecerá  una manera de mejorar su contraseña y corregir los  malos hábitos típicos al formular contraseñas débiles.
200 
+Una vez completada la aplicación, esta mostrará una ventana en donde, según se vayan entrando los caracteres de la contraseña, se desglosará la puntuación parcial obtenida. Esta interface gráfica para el usuario le ofrecerá  una manera de mejorar su contraseña y corregir los  malos hábitos típicos al formular contraseñas débiles.
201
201
202
202
203
203
204 
-###Ejercicio 1: Familiarizarte con las funciones pre-definidas
204 
+### Ejercicio 1: Familiarizarte con las funciones pre-definidas
205
205
206 
 El primer paso en esta experiencia de laboratorio es familiarizarte con las funciones pre-definidas en el código. Invocarás estas funciones en el código que crearás para computar la puntuación de varios de los criterios para fortaleza de contraseñas.
 206 
 El primer paso en esta experiencia de laboratorio es familiarizarte con las funciones pre-definidas en el código. Invocarás estas funciones en el código que crearás para computar la puntuación de varios de los criterios para fortaleza de contraseñas.
207
207
209
209
210 
 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.
 210 
 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.
211
211
212 
-
213 
 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.
 212 
 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.
214
213
215 
-
216 
       * `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.
 214 
       * `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.
215 
+
217 
       * `psfunctions.h` : contiene los prototipos de las funciones definidas en `psfunctions.cpp`.
 216 
       * `psfunctions.h` : contiene los prototipos de las funciones definidas en `psfunctions.cpp`.
218 
-
219 
-
220
217
221 
-###Ejercicio 2: Conocer las funciones para actualizar la interface gráfica de usuarios.
218 
+
219 
+
220 
+### Ejercicio 2: Conocer las funciones para actualizar la interface gráfica de usuarios.
222
221
223 
 En el ejercicio de laboratorio crearás el código para calcular la puntuación asociada a cada uno de los criterios de las tablas de sumas y deducciones mostradas arriba. Estas puntuaciones deben ser actualizadas en la interface gráfica de usuarios que se muestra en la Figura 1.
 222 
 En el ejercicio de laboratorio crearás el código para calcular la puntuación asociada a cada uno de los criterios de las tablas de sumas y deducciones mostradas arriba. Estas puntuaciones deben ser actualizadas en la interface gráfica de usuarios que se muestra en la Figura 1.
224
223
289 
     void setConsecutiveLower(int count, int score) ;
 288 
     void setConsecutiveLower(int count, int score) ;
290
289
291 
     // Para actualizar el criterio de dígitos consecutivos.
 290 
     // Para actualizar el criterio de dígitos consecutivos.
292 
-    void setConsecutiveDigits(int count, int score) ;
291 
+    void setConsecutiveDigits(int count, int score) ;
293 
   ```
 292 
   ```
294
293
295 
-###Ejercicio 3: Calcular la puntuación de los criterios y la puntuación total de la contraseña
294 
+### Ejercicio 3: Calcular la puntuación de los criterios y la puntuación total de la contraseña
296
295
297
296
298 
-El código que te proveemos contiene las funciones que computan el conteo para  la mayoría de los criterios y cuyos nombres reflejan lo que hace y devuelve la función. Por ejemplo, `countUppercase`, devuelve el número de caracteres que son letras mayúsculas. [Aquí](http://ccom.uprrp.edu/~rarce/ccom3033f14/documentation/passwordStrengthCL/psfunctions_8cpp.html) hay una lista y descripción de las funciones.
297 
+El código que te proveemos contiene las funciones que computan el conteo para  la mayoría de los criterios y cuyos nombres reflejan lo que hace y devuelve la función. Por ejemplo, `countUppercase`, devuelve el número de caracteres que son letras mayúsculas. [Aquí](http://ccom.uprrp.edu/~rarce/ccom3033f14/documentation/passwordStrengthCL/psfunctions_8cpp.html) hay una lista y descripción de las funciones.
299
298
300 
 Tu tarea es utilizar expresiones matemáticas y estructuras condicionales para las puntuaciones de los criterios individuales y combinarlas para computar la puntuación total de fortaleza de una contraseña.
 299 
 Tu tarea es utilizar expresiones matemáticas y estructuras condicionales para las puntuaciones de los criterios individuales y combinarlas para computar la puntuación total de fortaleza de una contraseña.
301
300
322
321
323 
 ---
 322 
 ---
324
323
325 
-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$.
324 
+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$$.
326
325
327 
 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.
 326 
 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.
328
327
329
328
330
329
331 
-###Ejercicio 4: Determinar y desplegar la fortaleza de la contraseña
330 
+### Ejercicio 4: Determinar y desplegar la fortaleza de la contraseña
332
331
333 
-    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.
332 
+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.
334
333
335 
-    Basado en la puntuación total, el programa debe clasificar la fortaleza de la contraseña como sigue:
334 
+Basado en la puntuación total, el programa debe clasificar la fortaleza de la contraseña como sigue:
336
335
337 
 | Puntación total |  Fortaleza  |
 336 
 | Puntación total |  Fortaleza  |
338 
 |-----------------|-------------|
 337 
 |-----------------|-------------|
342 
 | [60,80)         | Fuerte      |
 341 
 | [60,80)         | Fuerte      |
343 
 | [80,100]        | Bien fuerte |
 342 
 | [80,100]        | Bien fuerte |
344
343
345 
-El código provisto ya invoca la función `strengthDisplay` con la fortaleza calculada y la puntuación final para actualizar la clasificación y la barra que indica la fortaleza en la interface gráfica.
344 
+El código provisto ya invoca la función `strengthDisplay` con la fortaleza calculada y la puntuación final para actualizar la clasificación y la barra que indica la fortaleza en la interface gráfica.
346
345
347 
 ---
 346 
 ---
348
347
349 
 ---
 348 
 ---
350
349
351 
-##Entregas
350 
+## Entregas
352
351
353 
 Utiliza "Entrega" en Moodle para entregar el archivo `readpassword.cpp` que contiene el código con el cómputo de las puntuaciones de los criterios individuales, la puntuación final, las invocaciones para actualizar la interface gráfica, la clasificación de la fortaleza y se despliegue. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
 352 
 Utiliza "Entrega" en Moodle para entregar el archivo `readpassword.cpp` que contiene el código con el cómputo de las puntuaciones de los criterios individuales, la puntuación final, las invocaciones para actualizar la interface gráfica, la clasificación de la fortaleza y se despliegue. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
354
353
358
357
359 
 ---
 358 
 ---
360
359
361 
-##Referencias
360 
+## Referencias
362
361
363
362
364 
 [1] Passwordmeter, http://www.passwordmeter.com/
 363 
 [1] Passwordmeter, http://www.passwordmeter.com/
372
371
373 
 [English](#markdown-header-decision-structures-password-strength) | [Español](#markdown-header-estructuras-de-decision-fortaleza-de-contrasenas)
 372 
 [English](#markdown-header-decision-structures-password-strength) | [Español](#markdown-header-estructuras-de-decision-fortaleza-de-contrasenas)
374
373
375 
-#Decision Structures - Password Strength
374 
+# Decision Structures - Password Strength
376
375
377 
 ![main1.png](images/main1.png)
 376 
 ![main1.png](images/main1.png)
378 
 ![main2.png](images/main2.png)
 377 
 ![main2.png](images/main2.png)
380
379
381 
 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.
 380 
 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.
382
381
383 
-##Objectives:
382 
+## Objectives:
384
383
385 
 1. Use relational expressions and select adequate logical operators to make decisions.
 384 
 1. Use relational expressions and select adequate logical operators to make decisions.
386 
 2. Apply decision structures.
 385 
 2. Apply decision structures.
391 
 Before you get to the laboratory you should have:
 390 
 Before you get to the laboratory you should have:
392
391
393 
 1. Reviewed the following concepts:
 392 
 1. Reviewed the following concepts:
394 
-
395 
-    a. Logical operators
393 
+
394 
+    a. Logical operators.
395 
+
396 
     b. `if`, `else`, `else if`.
 396 
     b. `if`, `else`, `else if`.
397
397
398 
 2. Reviewed the use of objects of the `string` class and its `length()` method.
 398 
 2. Reviewed the use of objects of the `string` class and its `length()` method.
405
405
406 
 ---
 406 
 ---
407
407
408 
-##Password strength
408 
+## Password strength
409
409
410 
 Using strong passwords is essential to securing information. A password is considered strong if it is not cost-effective for a hacker to try and guess it using different methods or brute force. For example, a password that consists of a simple dictionary word, without digits, symbols or uppercase letters, is so easy to decipher that even a caveman could do it.
 410 
 Using strong passwords is essential to securing information. A password is considered strong if it is not cost-effective for a hacker to try and guess it using different methods or brute force. For example, a password that consists of a simple dictionary word, without digits, symbols or uppercase letters, is so easy to decipher that even a caveman could do it.
411
411
414 
 The following tables review the added and subtracted values for various criteria in passwords:
 414 
 The following tables review the added and subtracted values for various criteria in passwords:
415
415
416
416
417 
-###Assigning points to a password
417 
+### Assigning points to a password
418
418
419 
-####Adding Points:
419 
+#### Adding Points:
420
420
421 
 ---
 421 
 ---
422
422
424
424
425 
 |      | Category                        | Points                                   | Notes                                                |
 425 
 |      | Category                        | Points                                   | Notes                                                |
426 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
 426 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------: |
427 
-| 1.   | Number of characters             | $4\left(len\right)$                                 | $len$ is the length of the password                        |
428 
-| 2.   | Uppercase letters                | ![addUpper.png](images/addUpper.png)
429 
-     | $n$ is the number of uppercase letters                |
430 
-| 3.   | Lowercase letters                | ![addLower.png](images/addLower.png)
431 
-    | $n$ is the number of lowercase letters                |
432 
-| 4.   | Digits                          |  ![addDigits.png](images/addDigits.png)
433 
-   | $n$ is the number of digits                          |
434 
-| 5.   | Symbols                        | $6n$     | $n$ is the number of symbols                       |
435 
-| 6.   | Digits or symbols in the middle   | $2n$                                    | $n$ is the number of digits or symbols in the middle   |
436 
-| 7.   | Requisites                       | ![criteria.png](images/criteria.png)                              | $n$ is the number of criteria that are met        |
427 
+| 1.   | Number of characters             | $$4\left(len\right)$$                                 | $$len$$ is the length of the password                        |
428 
+| 2.   | Uppercase letters                | ![addUpper.png](images/addUpper.png) | $$n$$ is the number of uppercase letters                |
429 
+| 3.   | Lowercase letters                | ![addLower.png](images/addLower.png)  | $$n$$ is the number of lowercase letters                |
430 
+| 4.   | Digits                          |  ![addDigits.png](images/addDigits.png) | $$n$$ is the number of digits                          |
431 
+| 5.   | Symbols                        | $$6n$$     | $$n$$ is the number of symbols                       |
432 
+| 6.   | Digits or symbols in the middle   | $$2n$$                                    | $$n$$ is the number of digits or symbols in the middle   |
433 
+| 7.   | Requisites                       | ![criteria.png](images/criteria.png)                              | $$n$$ is the number of criteria that are met        |
437
434
438 
-**Table 1.** Positive criteria for password strength.
435 
+**Table 1.** Positive criteria for password strength.
439
436
440 
 ---
 437 
 ---
441
438
442 
 What follows are some additional details and examples for the criteria of **adding points**.
 439 
 What follows are some additional details and examples for the criteria of **adding points**.
443
440
444 
-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$.
441 
+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$$.
445
442
446 
-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,
443 
+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,
447
444
448 
-  a. the score for `"ab453"` would be $0$ since it doesn't have uppercase letters (the count is also $0$).
445 
+  a. the score for `"ab453"` would be $$0$$ since it doesn't have uppercase letters (the count is also $$0$$).
449
446
450 
-  b. the score for `"ALGO"` would be $0$ since it **only** has uppercase letters (the count is $4$).
447 
+  b. the score for `"ALGO"` would be $$0$$ since it **only** has uppercase letters (the count is $$4$$).
451
448
452 
-  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$).
449 
+  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$$).
453
450
454 
-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,
451 
+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,
455
452
456 
-  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$.
453 
+  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$$.
457
454
458 
-  b. the score for `"ALGO"` would be $0$ because it doesn't have lowercase letters. The count is $0$.
455 
+  b. the score for `"ALGO"` would be $$0$$ because it doesn't have lowercase letters. The count is $$0$$.
459
456
460 
-  c. the score for `"sancochin"`  would be $0$ because it contains **only** lowercase letters. The count is $9$.
457 
+  c. the score for `"sancochin"`  would be $$0$$ because it contains **only** lowercase letters. The count is $$9$$.
461
458
462 
-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,
459 
+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,
463
460
464 
-  a. the score for `"ab453"` would be  $4 \cdot 3 = 12$ because the password contains $3$ digits and contains characters of another type.
461 
+  a. the score for `"ab453"` would be  $$4 \cdot 3 = 12$$ because the password contains $$3$$ digits and contains characters of another type.
465
462
466 
-  b. the score for `"ALGO"` would be $0$ because it doesn't have digits.
463 
+  b. the score for `"ALGO"` would be $$0$$ because it doesn't have digits.
467
464
468 
-  c. the score for `801145555` would be $0$ because it contains **only** digits.
465 
+  c. the score for `801145555` would be $$0$$ because it contains **only** digits.
469
466
470 
-5. **Symbols** The score is $6n$ if the password contains $n$ symbols. Otherwise, the score is $0$. For example,
467 
+5. **Symbols** The score is $$6n$$ if the password contains $$n$$ symbols. Otherwise, the score is $$0$$. For example,
471
468
472 
-  a. the score for `"ab453"` would be $0$ because it does not contain symbols.
469 
+  a. the score for `"ab453"` would be $$0$$ because it does not contain symbols.
473
470
474 
-  b. the score for `"ALGO!!"` would be $6 \cdot 2$ because it contains $2$ symbols and contains other types of characters.
471 
+  b. the score for `"ALGO!!"` would be $$6 \cdot 2$$ because it contains $$2$$ symbols and contains other types of characters.
475
472
476 
-  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.
473 
+  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.
477
474
478 
-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,
475 
+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,
479
476
480 
-  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`.
477 
+  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`.
481
478
482 
-  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.
479 
+  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.
483
480
484 
-  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`.
481 
+  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`.
485
482
486 
-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:
483 
+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:
487
484
488 
   a. The password must contain 8 or more characters of length.
 485 
   a. The password must contain 8 or more characters of length.
489
486
495
492
496 
 Each of the items listed in part b. count as one individual criteria. For example,
 493 
 Each of the items listed in part b. count as one individual criteria. For example,
497
494
498 
-  a. the score for `"ab453"` would be $0$ because the criteria for length is not met.
495 
+  a. the score for `"ab453"` would be $$0$$ because the criteria for length is not met.
499
496
500 
-  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).
497 
+  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).
501
498
502 
-  c. the score for `"abAB99!!"` would be $2 \cdot 5 = 10$ because the length criteria and the other 4 criteria are met.
499 
+  c. the score for `"abAB99!!"` would be $$2 \cdot 5 = 10$$ because the length criteria and the other 4 criteria are met.
503
500
504
501
505 
 #### Subtracting points
 502 
 #### Subtracting points
508
505
509 
 |      | Category                         | Points                                   | Notes                                                                  |
 506 
 |      | Category                         | Points                                   | Notes                                                                  |
510 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
 507 
 | :--- | :-------------------------------- | :-------------------------------------: | ----------------------------------------------------:                   |
511 
-| 1.   | Only letters                       |![subsLetters.png](images/subsLetters.png)    | $len$ is the length of the password                                          |
512 
-| 2.   | Only digits                      | ![subsDigits.png](images/subsDigits.png)    | $len$ is the length of the password                                           |
513 
-| 3.   | Consecutive uppercase letters    | $-2n$                                   | $n$ is the number of uppercase letters that follow another uppercase letter |
514 
-| 4.   | Consecutive lowercase letters   | $-2n$                                   | $n$ is the number of lowercase letters that follow another lowercase letter                                                                     |
515 
-| 5.   | Consecutive digits             | $-2n$                                   | $n$ is the number of digits that follow another digit                     |
508 
+| 1.   | Only letters                       |![subsLetters.png](images/subsLetters.png)    | $$len$$ is the length of the password                                          |
509 
+| 2.   | Only digits                      | ![subsDigits.png](images/subsDigits.png)    | $$len$$ is the length of the password                                           |
510 
+| 3.   | Consecutive uppercase letters    | $$-2n$$                                   | $$n$$ is the number of uppercase letters that follow another uppercase letter |
511 
+| 4.   | Consecutive lowercase letters   | $$-2n$$                                   | $$n$$ is the number of lowercase letters that follow another lowercase letter                                                                     |
512 
+| 5.   | Consecutive digits             | $$-2n$$                                   | $$n$$ is the number of digits that follow another digit                     |
516
513
517
514
518 
-**Table 2.** Negative criteria for password strength.
515 
+**Table 2.** Negative criteria for password strength.
519
516
520 
 ---
 517 
 ---
521
518
522 
 The following are additional details and examples of the criteria for **subtracting points**.
 519 
 The following are additional details and examples of the criteria for **subtracting points**.
523
520
524 
-1. **Only letters**: The score is $-len$ for a password that consists of letters only, otherwise it is $0$. For example,
521 
+1. **Only letters**: The score is $$-len$$ for a password that consists of letters only, otherwise it is $$0$$. For example,
525
522
526 
-  a. the score for `"ab453"` would be $0$ since it contains letters and numbers.
523 
+  a. the score for `"ab453"` would be $$0$$ since it contains letters and numbers.
527
524
528 
-  b. the score for `"Barrunto"` would be $-8$ since it only contains letters and its length is $8$.
525 
+  b. the score for `"Barrunto"` would be $$-8$$ since it only contains letters and its length is $$8$$.
529
526
530 
-2. **Only digits**: The score is $-len$ for a password that consists of digits only, otherwise it is $0$. For example,
527 
+2. **Only digits**: The score is $$-len$$ for a password that consists of digits only, otherwise it is $$0$$. For example,
531
528
532 
-  a. the score for `"ab453"` would be $0$ since it contains only letters and numbers.
529 
+  a. the score for `"ab453"` would be $$0$$ since it contains only letters and numbers.
533
530
534 
-  b. the score for `”987987987”` would be $-9$ since it contains only digits and its length is $9$.
531 
+  b. the score for `”987987987”` would be $$-9$$ since it contains only digits and its length is $$9$$.
535
532
536 
-3. **Consecutive uppercase letters**: The score is $-2n$ where $n$ is the number of uppercase letters that follow another uppercase letter. For example,
533 
+3. **Consecutive uppercase letters**: The score is $$-2n$$ where $$n$$ is the number of uppercase letters that follow another uppercase letter. For example,
537
534
538 
-  a. the score for `"DB453"` would be $-2 \cdot 1 = -2$ since it only contains one uppercase letter (`B`) that follows another uppercase letter.
535 
+  a. the score for `"DB453"` would be $$-2 \cdot 1 = -2$$ since it only contains one uppercase letter (`B`) that follows another uppercase letter.
539
536
540 
-  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.
537 
+  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.
541
538
542 
 4. **Consecutive lowercase letters**: The same as for criteria #3 but for lowercase letters.
 539 
 4. **Consecutive lowercase letters**: The same as for criteria #3 but for lowercase letters.
543
540
562
559
563 
 ---
 560 
 ---
564
561
565 
-##Laboratory session:
562 
+## Laboratory session:
566
563
567 
 In this laboratory session you will practice the use of mathematical expressions and conditional structures to compute the score for the strength of a password combining the points for the individual criteria.
 564 
 In this laboratory session you will practice the use of mathematical expressions and conditional structures to compute the score for the strength of a password combining the points for the individual criteria.
568
565
570
567
571 
 The strength of the password will be quantified by adding points for using good password selection techniques (like combining symbols and letters) and subtracting points for using bad habits (like using only uppercase letters or consecutive symbols of the same type). Your program will analyze the password given by the user and use the criteria in the tables presented above to compute a score for the password's strength.
 568 
 The strength of the password will be quantified by adding points for using good password selection techniques (like combining symbols and letters) and subtracting points for using bad habits (like using only uppercase letters or consecutive symbols of the same type). Your program will analyze the password given by the user and use the criteria in the tables presented above to compute a score for the password's strength.
572
569
573 
-Once the application is complete, it will show a window where, as the password characters are entered, the partial score will be displayed. This graphical interface will offer the user a way to improve his password and correct typical weak password habits.
570 
+Once the application is complete, it will show a window where, as the password characters are entered, the partial score will be displayed. This graphical interface will offer the user a way to improve his password and correct typical weak password habits.
574
571
575
572
576
573
577
574
578 
-###Exercise 1: Familiarize yourself with the pre-defined functions
575 
+### Exercise 1: Familiarize yourself with the pre-defined functions
579
576
580 
 The first step in this laboratory experience is to familiarize yourself with the functions that are pre-defined in the code.  You will call these functions as part of your own code to compute the score of the various password strength criteria.
 577 
 The first step in this laboratory experience is to familiarize yourself with the functions that are pre-defined in the code.  You will call these functions as part of your own code to compute the score of the various password strength criteria.
581
578
583
580
584 
 1. Load the project `PassworStrength` onto Qt by double clicking the file `PasswordStrength.pro` in the directory `Documents/eip/Conditionals-PasswordStrength` of your computer. You can also go to `http://bitbucket.org/eip-uprrp/conditionals-passwordstrength` to download the folder `Conditionals-PasswordStrength` to your computer.
 581 
 1. Load the project `PassworStrength` onto Qt by double clicking the file `PasswordStrength.pro` in the directory `Documents/eip/Conditionals-PasswordStrength` of your computer. You can also go to `http://bitbucket.org/eip-uprrp/conditionals-passwordstrength` to download the folder `Conditionals-PasswordStrength` to your computer.
585
582
586 
-
587 
 2. Configure the project. The project consists of several files. **You will only write code in the file  `readpassword.cpp`. You should not make any changes in the other files.** Despite this, you should familiarize yourself with the functions that are already defined in them, since you will be using some of them to create your code.
 583 
 2. Configure the project. The project consists of several files. **You will only write code in the file  `readpassword.cpp`. You should not make any changes in the other files.** Despite this, you should familiarize yourself with the functions that are already defined in them, since you will be using some of them to create your code.
588
584
589 
   * `psfunctions.cpp` : contains the implementations of some of the functions that will invoke in your program to calculate the score for the password's strength. **You do not have to change anything in this file or in the file `psfunctions.h`**. Simply invoke the functions as necessary from the `readPass` function in the `readpassword.cpp` file. Note that the function names tell you what the functions do.
 585 
   * `psfunctions.cpp` : contains the implementations of some of the functions that will invoke in your program to calculate the score for the password's strength. **You do not have to change anything in this file or in the file `psfunctions.h`**. Simply invoke the functions as necessary from the `readPass` function in the `readpassword.cpp` file. Note that the function names tell you what the functions do.
591 
   * `psfunctions.h` : contains the prototypes for the functions defined in `psfunctions.cpp`.
 587 
   * `psfunctions.h` : contains the prototypes for the functions defined in `psfunctions.cpp`.
592
588
593
589
594 
-###Exercise 2: Understand the functions to update the user's graphical interface.
590 
+### Exercise 2: Understand the functions to update the user's graphical interface.
595
591
596 
 In the laboratory exercise you will write code to calculate the score associated to each one of the criteria in the tables for adding and subtracting points shown above. These scores should be updated in the user's graphical interface that is shown in Figure 1.
 592 
 In the laboratory exercise you will write code to calculate the score associated to each one of the criteria in the tables for adding and subtracting points shown above. These scores should be updated in the user's graphical interface that is shown in Figure 1.
597
593
662 
     void setConsecutiveLower(int count, int score) ;
 658 
     void setConsecutiveLower(int count, int score) ;
663
659
664 
     // To update the criterium of consecutive digits.
 660 
     // To update the criterium of consecutive digits.
665 
-    void setConsecutiveDigits(int count, int score) ;
661 
+    void setConsecutiveDigits(int count, int score) ;
666 
     ```
 662 
     ```
667
663
668
664
669
665
670 
-###Exercise 3: Compute the score for the criteria and the total score for the password
666 
+### Exercise 3: Compute the score for the criteria and the total score for the password
671
667
672 
 The code that we're providing you contains the functions that compute the count for the majority of the criteria and whose names reflect what they do and what the function returns. For example, `countUppercase`, return the number of characters that are uppercase letters.
 668 
 The code that we're providing you contains the functions that compute the count for the majority of the criteria and whose names reflect what they do and what the function returns. For example, `countUppercase`, return the number of characters that are uppercase letters.
673
669
702 
 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.
 698 
 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.
703
699
704
700
705 
-###Exercise 4: Determine and display the password's strength
701 
+### Exercise 4: Determine and display the password's strength
706
702
707 
 The password is entered in the top section of the graphical interface. The user will input the password in the top section of the graphical interface. Below appears the *report* that contains the different criteria, the count for each criteria, and the individual score for the criteria. This report will be updated as the user inputs the password's characters. The total score will be the sum of all of the points (addition and subtraction) of the individual criteria.
 703 
 The password is entered in the top section of the graphical interface. The user will input the password in the top section of the graphical interface. Below appears the *report* that contains the different criteria, the count for each criteria, and the individual score for the criteria. This report will be updated as the user inputs the password's characters. The total score will be the sum of all of the points (addition and subtraction) of the individual criteria.
708
704
723
719
724 
 ---
 720 
 ---
725
721
726 
-##Deliverables
722 
+## Deliverables
727
723
728 
 Use "Deliverables" in Moodle to upload the `readpassword.cpp` file that contains the code with the computation for the score of the individual criteria, the final score, the function calls to update the graphical interface, the password's classification and the display functions. Remember to use good programming techniques, include the name of the programmers involved, and to document your program.
 724 
 Use "Deliverables" in Moodle to upload the `readpassword.cpp` file that contains the code with the computation for the score of the individual criteria, the final score, the function calls to update the graphical interface, the password's classification and the display functions. Remember to use good programming techniques, include the name of the programmers involved, and to document your program.
729
725
733
729
734 
 ---
 730 
 ---
735
731
736 
-##References
732 
+## References
737
733
738 
 [1] Passwordmeter, http://www.passwordmeter.com/
 734 
 [1] Passwordmeter, http://www.passwordmeter.com/