1
00:00:00,940 --> 00:00:08,039
Muy bien, vale, pues ya está grabando. Pues nada, vamos a empezar un poquito con la clase.

2
00:00:08,720 --> 00:00:17,500
En principio voy a compartiros mi escritorio, me veréis en una esquinita y veréis también mi pantalla o a lo mejor dejáis de verme a mí, no estoy muy seguro.

3
00:00:17,879 --> 00:00:21,100
A ver, comparto aquí, vale, ahí estamos.

4
00:00:21,100 --> 00:00:25,219
Entonces, ahora me veis ahí en una esquina seguramente

5
00:00:25,219 --> 00:00:31,059
Yo voy a abrirme por aquí el chat para asegurarme y los participantes

6
00:00:31,059 --> 00:00:34,280
Para asegurarme que os veo y que... lo que pasa es que me ocupa pantalla

7
00:00:34,280 --> 00:00:39,479
Entonces no... no... vale, no me gusta tenerlo mucho

8
00:00:39,479 --> 00:00:47,259
Bien, y quiero empezar un poquito viendo esto, los organigramas

9
00:00:47,259 --> 00:00:49,799
¿Vale? Hemos empezado viendo los organigramas

10
00:00:49,799 --> 00:00:59,799
Bueno, un organigrama, para poderlo analizar y poderlo analizar de una forma conveniente, lo mejor es hacer una...

11
00:01:00,799 --> 00:01:13,290
Vale, perfecto. Pues nada, en principio, los organigramas, los tengo aquí, ¿vale? Estos son los organigramas, el B y el A.

12
00:01:13,290 --> 00:01:19,150
se han de analizar primero cuando nos enfrentamos a un organigrama

13
00:01:19,150 --> 00:01:22,609
que no sabemos qué es lo que nos está haciendo

14
00:01:22,609 --> 00:01:26,590
tenemos que intentar ver qué cosas entran y qué cosas salen

15
00:01:26,590 --> 00:01:30,230
yo para analizar los organigramas os recomiendo que sobre todo al principio

16
00:01:30,230 --> 00:01:34,150
yo estas cosas pues como las he hecho muchas veces las hago ya casi mentalmente

17
00:01:34,150 --> 00:01:36,010
las hago sobre la marcha un poco

18
00:01:36,010 --> 00:01:39,849
pero lo que os recomiendo es que utilicéis una plantilla

19
00:01:39,849 --> 00:01:42,329
una plantilla como esta que os enseño aquí a la derecha

20
00:01:43,129 --> 00:01:45,109
Voy a cerrarme aquí estas cositas.

21
00:01:45,230 --> 00:01:46,209
Voy a cerrar el chat, ¿vale?

22
00:01:46,209 --> 00:01:49,310
Luego, si me levantáis la mano, no os voy a ver.

23
00:01:49,450 --> 00:01:51,230
Entonces, luego, cuando termine de hablar,

24
00:01:51,370 --> 00:01:53,030
yo miro a ver quién quiere decir algo.

25
00:01:53,129 --> 00:01:54,510
Pero vosotros, si tenéis alguna pregunta,

26
00:01:54,829 --> 00:01:55,750
poned la mano arriba, ¿vale?

27
00:01:56,670 --> 00:01:56,909
Bien.

28
00:01:57,430 --> 00:02:01,090
Entonces, hay unas plantillas que yo me gusta utilizar, ¿vale?

29
00:02:01,109 --> 00:02:04,430
Esta es una plantillita que me he hecho en un segundín, ¿vale?

30
00:02:04,430 --> 00:02:06,049
Pero podéis hacerlas como más os guste.

31
00:02:06,510 --> 00:02:08,949
Entonces, en las plantillas tenemos las entradas,

32
00:02:08,949 --> 00:02:10,949
las salidas y las variables, ¿de acuerdo?

33
00:02:11,689 --> 00:02:16,169
Entonces, vamos a analizar, por ejemplo, este algoritmo y vamos a ver un poco cómo vemos que hace.

34
00:02:17,129 --> 00:02:23,870
Lo primero es ver las entradas y las salidas, que son las lecturas y las escrituras,

35
00:02:24,310 --> 00:02:27,669
y también dónde empieza y dónde acaba el algoritmo, porque tengo que ver el flujo.

36
00:02:27,669 --> 00:02:31,990
Este es un algoritmo muy sencillo que tiene prácticamente lineal, excepto un pequeño bucle en esta parte.

37
00:02:32,990 --> 00:02:39,189
Entonces, empezamos arrancando con un terminal de inicio y terminamos siempre con un terminal de fin.

38
00:02:39,189 --> 00:02:46,669
suelen ser redondos o redondeados como este. Primero las entradas, ¿vale? Aquí vamos a leer k,

39
00:02:47,210 --> 00:02:53,490
entonces me apunto aquí leer k o pongo k simplemente y luego cuando identifique qué significa ya lo

40
00:02:53,490 --> 00:03:03,849
pondré ahí, ¿vale? Y las salidas en este caso son k y suma, ¿vale? Esas son las salidas que son las

41
00:03:03,849 --> 00:03:08,370
cosas que voy a escribir. Y después ¿qué variables utilizo? Bueno, pues tengo una variable que es k,

42
00:03:08,370 --> 00:03:11,389
que es donde voy a almacenar lo que meco, ¿vale?

43
00:03:12,150 --> 00:03:15,250
Tengo una variable n y una variable suma, que las voy a poner aquí.

44
00:03:15,770 --> 00:03:17,030
n y suma.

45
00:03:17,949 --> 00:03:18,349
Perfecto.

46
00:03:18,550 --> 00:03:20,770
Esto lo podéis hacer con una plantilla o con un papel.

47
00:03:21,110 --> 00:03:22,370
O sea, esto lo hacéis en un momento, ¿vale?

48
00:03:22,370 --> 00:03:24,110
No hace falta que tengáis todo bien estructurado.

49
00:03:24,229 --> 00:03:25,770
Yo lo que pasa es que quiero que lo veáis bien.

50
00:03:26,550 --> 00:03:29,849
Entonces, empezamos leyendo k, ¿perfecto?

51
00:03:30,270 --> 00:03:33,030
Con lo cual k es un número que introduce el usuario.

52
00:03:33,610 --> 00:03:34,629
Vamos a poner un ejemplo.

53
00:03:34,750 --> 00:03:36,490
Vamos a hacer una ejecución simulada,

54
00:03:36,490 --> 00:03:40,689
una ejecución donde nosotros vamos a ir paso a paso viendo qué cosas

55
00:03:40,689 --> 00:03:44,810
va haciendo cada parte del algoritmo. Entonces yo le voy a poner un ejemplo

56
00:03:44,810 --> 00:03:48,250
voy a poner aquí un 4, ¿vale? Yo introduzco 4

57
00:03:48,250 --> 00:03:52,569
entonces aquí en K yo le voy a poner valor

58
00:03:52,569 --> 00:03:56,909
de momento yo sé que esto es un valor introducido por el

59
00:03:56,909 --> 00:04:00,810
usuario. Esto puede ser un sensor de otro bot o puede ser

60
00:04:01,389 --> 00:04:04,449
una toma de datos de algún sitio

61
00:04:04,449 --> 00:04:07,409
o puedo estar leyendo algún archivo, no lo sé.

62
00:04:07,610 --> 00:04:12,229
El caso es que la entrada al algoritmo se hace a través de esa variable k.

63
00:04:12,870 --> 00:04:17,110
Y en la k, en el valor de la variable, voy a almacenar ese valor.

64
00:04:17,810 --> 00:04:22,329
¿Vale? En el contenido de esta caja llamada k voy a meter un 4,

65
00:04:22,529 --> 00:04:23,709
que es el número que yo he metido.

66
00:04:23,889 --> 00:04:29,029
Recordar que en este ejemplo, voy a poner aquí ejemplo 4, ¿vale?

67
00:04:29,589 --> 00:04:34,029
Quiere decirse que yo he metido un 4 en ese valor k.

68
00:04:34,350 --> 00:04:36,470
Perfecto, me ha pedido un número, yo he metido k.

69
00:04:37,509 --> 00:04:39,670
Ahora, siguiente paso, un proceso.

70
00:04:40,430 --> 00:04:40,709
¿Qué hace?

71
00:04:41,529 --> 00:04:44,290
Asigna el valor 0 a n y el valor 0 a suma.

72
00:04:44,509 --> 00:04:46,870
Pues asigna 0 a n y 0 a suma.

73
00:04:47,050 --> 00:04:49,189
Esos son los valores que tienen ahora mismo mis tres variables.

74
00:04:49,910 --> 00:04:52,689
k tiene 4, n tiene 0 y suma tiene.

75
00:04:54,069 --> 00:04:54,509
Seguimos.

76
00:04:55,009 --> 00:04:59,310
Entramos en este bucle, que es un bucle repetir hasta.

77
00:05:00,269 --> 00:05:02,029
Repetir hasta que n sea igual a k.

78
00:05:02,709 --> 00:05:07,610
Entonces, entramos en este bucle y lo siguiente que hacemos es un proceso, ¿qué es lo que hacemos?

79
00:05:07,610 --> 00:05:19,370
Pues bien, la variable n va a tomar el valor de su propio valor más 1, con lo cual en el valor de n, en esta primera vuelta del bucle, n se va a actualizar su valor y se va a poner a 1.

80
00:05:20,509 --> 00:05:26,970
Y la variable suma va a coger su contenido, lo que vale la variable suma, y le va a sumar lo que valga n.

81
00:05:26,970 --> 00:05:36,490
Pues voy a coger suma que es 0 y le voy a sumar 1, con lo cual 0 más 1, 1, y lo voy a almacenar dentro de suma, ¿entendéis esto?

82
00:05:37,069 --> 00:05:51,209
Es decir, el valor de la variable suma es su propio valor anterior más lo que valga n en este momento, 0 más 1, 1, y lo almaceno dentro de suma.

83
00:05:51,209 --> 00:05:53,470
Eso es lo que quiere decir esta orden de aquí.

84
00:05:54,129 --> 00:05:55,410
Y ahora hago la comprobación.

85
00:05:55,689 --> 00:05:56,629
¿Es n igual a k?

86
00:05:57,230 --> 00:05:59,529
n vale 1 en este momento y k vale 4.

87
00:05:59,649 --> 00:06:00,290
No son iguales.

88
00:06:00,870 --> 00:06:02,230
Como no son iguales, repito el bucle.

89
00:06:03,110 --> 00:06:03,750
¿Qué hago?

90
00:06:03,949 --> 00:06:06,410
A la variable n le sumo 1.

91
00:06:06,670 --> 00:06:06,910
¿Veis?

92
00:06:07,129 --> 00:06:11,170
Entonces, este valor n, si os fijáis, va creciendo de 1 en 1.

93
00:06:11,329 --> 00:06:14,290
A cada vuelta del bucle va creciendo de 1 en 1.

94
00:06:14,790 --> 00:06:18,449
Y suma, lo que va a hacer es almacenar ahora su propio valor,

95
00:06:18,449 --> 00:06:23,689
que es 1, que es lo que vale ahora, más lo que vale n en este momento, que es 2, 2 y 1, 3.

96
00:06:24,050 --> 00:06:32,470
Fijaros, lo voy a poner aquí debajo, que en este caso el valor de suma era 0 más 1, ¿vale?

97
00:06:32,730 --> 00:06:36,410
Esto es 0 más 1, que era el valor anterior, más el valor de n, 0 más 1.

98
00:06:36,990 --> 00:06:44,550
Ahora, el valor de suma es el valor anterior, que era 0 más 1, más 2, ¿vale? 0 más 1 más 2, ¿de acuerdo?

99
00:06:45,290 --> 00:06:49,949
Bien, y ahora volvemos a hacer la comprobación, estamos en este punto del programa y volvemos a hacer la comprobación.

100
00:06:50,170 --> 00:06:53,449
¿Es n igual a k? ¿2 es igual a 4? No.

101
00:06:53,910 --> 00:06:55,810
Por lo tanto, volvemos a entrar al núcleo.

102
00:06:56,069 --> 00:06:59,930
Se vuelve a actualizar n, n es igual a n más 1, por lo tanto, 2 más 1, 3.

103
00:07:00,730 --> 00:07:05,889
Suma es igual a su propio valor más lo que valga n, 3 más 3, 6.

104
00:07:05,889 --> 00:07:11,970
Que ahora, si os fijáis, lo que he hecho es 0 más 1 más 2 más 3, le añado el 3.

105
00:07:12,730 --> 00:07:14,529
Y continuamos, ¿vale?

106
00:07:15,110 --> 00:07:16,569
¿3 es igual a 4? No.

107
00:07:17,089 --> 00:07:17,889
Volvemos al bucle.

108
00:07:18,389 --> 00:07:19,790
Estamos saliendo por la salida del no.

109
00:07:20,589 --> 00:07:23,990
Y entonces cojo y digo, 3, le añado 1, 4.

110
00:07:24,490 --> 00:07:28,769
Y a suma le sumo el valor, estoy haciendo este proceso, n igual a n más 1,

111
00:07:28,829 --> 00:07:32,550
y ahora suma, le pongo suma más n, 6 más 4, 10.

112
00:07:33,790 --> 00:07:36,910
Entonces aquí he hecho 0 más 1 más 2 más 3 más 4.

113
00:07:37,610 --> 00:07:39,670
Y ahora compruebo, ¿es n igual a k?

114
00:07:39,790 --> 00:07:40,930
¿4 es igual a 4? Sí.

115
00:07:41,310 --> 00:07:43,449
Por lo tanto, me voy por la salida del sí,

116
00:07:43,449 --> 00:07:51,029
Y en las salidas pongo K, que no ha cambiado en toda la ejecución del programa, vale 4 y sigue valiendo 4 y siempre ha valido 4.

117
00:07:51,470 --> 00:07:55,129
Y la suma, que lo que me devuelve en este caso es 10.

118
00:07:55,509 --> 00:08:07,079
Pero que yo ya he visto que es la suma de todos los números desde 1 hasta... ¿Vale?

119
00:08:07,860 --> 00:08:13,740
Entonces fijaros que yo introduzco un valor, que eso es un valor que pedimos al usuario.

120
00:08:13,740 --> 00:08:21,040
y luego lo que hago es un bucle en el cual voy sumándole 1 acá a n, perdón, en cada vuelta

121
00:08:21,040 --> 00:08:27,420
y voy acumulando dentro de la suma, por lo tanto n es un contador, es el contador de vuelta,

122
00:08:27,420 --> 00:08:32,659
la vuelta 0, la vuelta 1, la vuelta 2, la vuelta 3, la vuelta 4 y suma es un acumulador

123
00:08:32,659 --> 00:08:40,919
que va acumulando ese valor de n. En la primera vuelta acumula 1, en la segunda vuelta acumula 1 más 2,

124
00:08:40,919 --> 00:08:45,059
o sea, va sumando a su propio valor, por eso se llama un acumulador, ¿vale?

125
00:08:45,679 --> 00:08:51,159
Y ya está, entonces ya hemos visto cuál es el algoritmo y cuál es lo que está haciendo,

126
00:08:51,399 --> 00:08:56,639
cuál es su propósito, su propósito es sumarme todos los números desde 0 o desde 1

127
00:08:56,639 --> 00:09:00,980
hasta el número que le meta el usuario, ya está, es una serie, ¿vale?

128
00:09:01,019 --> 00:09:05,299
Si habéis estudiado matemática en las series, las series son sumas de sucesivos elementos.

129
00:09:05,940 --> 00:09:09,299
Bueno, pues ya está, esto sería el análisis de este primer algoritmo

130
00:09:09,299 --> 00:09:11,159
Y es muy fácil con una plantilla de este tipo.

131
00:09:12,000 --> 00:09:16,299
Bueno, voy a abrirlo de la... a ver, por aquí, participantes...

132
00:09:17,620 --> 00:09:20,019
Vale, ¿alguien tiene alguna pregunta sobre esto de momento?

133
00:09:20,639 --> 00:09:21,639
En el chat.

134
00:09:22,740 --> 00:09:25,620
Vale, no veo que nadie haya levantado la mano, no veo que nadie haga preguntas.

135
00:09:25,980 --> 00:09:27,740
Si no, paso al segundo ejemplo.

136
00:09:28,240 --> 00:09:28,440
¿De acuerdo?

137
00:09:29,559 --> 00:09:30,000
Perfecto.

138
00:09:30,320 --> 00:09:31,460
Pues seguimos.

139
00:09:31,980 --> 00:09:35,620
Lo mismo que antes, si tenéis alguna duda en cualquier momento, por favor, levantad la mano.

140
00:09:35,820 --> 00:09:37,500
Segundo ejemplo de algoritmo.

141
00:09:37,500 --> 00:09:39,539
voy a vaciar mi plantilla

142
00:09:39,539 --> 00:09:42,659
¿vale? vaciamos mi plantilla

143
00:09:42,659 --> 00:09:44,539
de datos y volvemos

144
00:09:44,539 --> 00:09:46,600
ahora, bueno en las conclusiones evidentemente

145
00:09:46,600 --> 00:09:48,240
yo aquí abajo tengo una de estas conclusiones

146
00:09:48,240 --> 00:09:50,299
donde escribiría un poco pues ya el resumen

147
00:09:50,299 --> 00:09:52,580
lo que entra, lo que sale, cuál es el propósito

148
00:09:52,580 --> 00:09:54,559
del programa y un poco el funcionamiento

149
00:09:54,559 --> 00:09:56,440
si os fijáis cuando yo quiero

150
00:09:56,440 --> 00:09:58,460
describir el funcionamiento de este algoritmo no me

151
00:09:58,460 --> 00:10:00,700
pongo a describir lo que hace cada caja, eso ya lo veo

152
00:10:00,700 --> 00:10:02,100
¿vale? yo no digo

153
00:10:02,100 --> 00:10:04,659
primero leemos K, luego hacemos n igual a 0

154
00:10:04,659 --> 00:10:06,460
luego suma igual a 0, luego n igual a

155
00:10:06,460 --> 00:10:15,799
Eso ya lo veo. Lo que quiero que me digáis es que este proceso lo que va a hacer es repetir en bucle la suma de estos elementos

156
00:10:15,799 --> 00:10:22,220
y el incremento de la n hasta cuando se haga igual al valor introducido por el usuario.

157
00:10:23,179 --> 00:10:32,500
Entonces primero se lee, luego se inicializan las variables con el valor 0 y después se va incrementando el valor de n

158
00:10:32,500 --> 00:10:38,220
y acumulando ese valor dentro de suma hasta que n es igual a k.

159
00:10:38,899 --> 00:10:44,139
Y cuando n se hace igual a k, salimos y escribimos el número de vueltas que hemos dado,

160
00:10:44,139 --> 00:10:50,700
el número límite o el límite de nuestro bucle y la suma total de esos valores.

161
00:10:51,500 --> 00:10:55,039
Entonces, bueno, pues esto, luego vamos a ver un programita que es súper guay,

162
00:10:55,220 --> 00:10:58,080
que nos permite ver esto de una forma muy visual, ¿vale?

163
00:10:58,080 --> 00:10:59,320
También nos va a ayudar a entenderlo.

164
00:10:59,960 --> 00:11:01,000
Bueno, vamos al segundo.

165
00:11:01,000 --> 00:11:07,399
Entonces, segundo ejemplo, bien, ¿qué entradas tenemos aquí?

166
00:11:07,620 --> 00:11:11,659
Pues tenemos n, solamente metemos n y ya veremos lo que es.

167
00:11:11,840 --> 00:11:15,320
Antes era el límite o el número hasta donde queríamos ir sumando.

168
00:11:16,279 --> 00:11:17,799
¿Vale? ¿Qué variables tenemos en este caso?

169
00:11:17,799 --> 00:11:24,820
Pues tenemos la variable n, nuevamente, y tenemos la variable p y no hay más.

170
00:11:25,440 --> 00:11:27,759
¿Vale? Tenemos la variable p y ya no hay más.

171
00:11:27,960 --> 00:11:30,700
Perfecto. Vamos a ver qué es lo que estamos haciendo.

172
00:11:31,000 --> 00:11:35,500
Pues lo primero que hacemos es leemos n, con lo cual a n le damos el valor del usuario.

173
00:11:35,620 --> 00:11:37,240
Este es un valor introducido por el usuario.

174
00:11:38,340 --> 00:11:46,360
Valor, ya lo he dicho antes, valor, valor introducido por el usuario, ¿vale?

175
00:11:46,840 --> 00:11:48,299
Valor introducido por el usuario.

176
00:11:48,480 --> 00:11:51,440
Y yo le voy a poner un ejemplo, por ejemplo, tres, ¿vale?

177
00:11:51,500 --> 00:11:52,440
Un número cualquiera.

178
00:11:53,480 --> 00:11:58,620
¿Vale? O bueno, voy a poner, para ir cogiendo los valores, voy a ponerle un valor cero, ¿de acuerdo?

179
00:11:58,620 --> 00:12:05,799
empezamos a ejecutar, leemos n y le introducimos el valor 0, el usuario pone el valor 0.

180
00:12:06,019 --> 00:12:07,500
¿Es n igual a 0? Sí.

181
00:12:08,120 --> 00:12:11,200
Bueno, pues entonces escribimos que el factorial de 0 es igual a 1.

182
00:12:11,539 --> 00:12:22,940
Por lo tanto, la salida, si n es igual a 0, la salida es factorial de 0 es 1.

183
00:12:22,940 --> 00:12:25,759
Y ya esto nos da una pista de cuál es el propósito de este programa.

184
00:12:26,399 --> 00:12:27,559
El factorial de 0 es 1.

185
00:12:28,379 --> 00:12:30,240
Lo mismo estamos calculando el factorial de un número.

186
00:12:31,139 --> 00:12:33,860
Hemos estudiado en matemáticas lo que vale el factorial, ¿vale?

187
00:12:34,039 --> 00:12:38,860
Recordamos, os lo escribo aquí, que 5 factorial, que se escribe así con una unidación,

188
00:12:39,519 --> 00:12:45,639
es igual a 5 por 4 por 3 por 2 y por 1, ¿vale?

189
00:12:46,159 --> 00:12:54,139
Es decir, vamos a ir multiplicando desde el número que me dan hasta el 1.

190
00:12:54,379 --> 00:12:57,179
Y esta multiplicación es lo que llamamos 5 factorial.

191
00:12:58,259 --> 00:13:00,840
Pues entonces, ¿qué vamos a hacer nosotros?

192
00:13:01,139 --> 00:13:04,480
Vamos a ver si este programa lo que me calcula son números factoriales.

193
00:13:04,679 --> 00:13:08,500
Pues bueno, si es 0, el factorial de 0 es 1, con lo cual la salida es correcta.

194
00:13:09,220 --> 00:13:12,460
¿Qué pasa si el usuario, cuando empezamos y ya se termina el programa?

195
00:13:12,720 --> 00:13:17,220
Vamos a hacer otra ejecución donde n le voy a poner el valor menos 3, un número negativo.

196
00:13:18,120 --> 00:13:23,179
Bueno, pues si le pongo el valor menos 3, entonces n es igual a 0, no, salgo hacia abajo.

197
00:13:23,179 --> 00:13:30,700
n es mayor que 0, no, aquí esto es un error de la gráfica, esto es una flecha que tendría que tener esta dirección

198
00:13:30,700 --> 00:13:37,240
no esta, no es una vuelta, sino que es una ida, entonces este es uno de los dos errores que tenía este programa

199
00:13:37,240 --> 00:13:43,580
ahora veremos el otro, esta salida es hacia abajo, la flecha tendría que estar indicándome la dirección hacia abajo

200
00:13:43,580 --> 00:13:53,120
escribimos el número negativo y escribimos prueba con positivos, por lo tanto en mis salidas pongo si n es menor que 0

201
00:13:53,120 --> 00:13:57,129
la salida es

202
00:13:57,129 --> 00:13:59,789
número negativo

203
00:13:59,789 --> 00:14:02,250
prueba con positivo.

204
00:14:04,889 --> 00:14:05,769
¿Vale? Ya lo tengo.

205
00:14:06,289 --> 00:14:09,090
Y ahora vamos a ver qué pasa si el número es positivo.

206
00:14:09,289 --> 00:14:10,429
Vamos a probar con el 3.

207
00:14:11,149 --> 00:14:12,809
Entonces, ¿qué pasa si n es igual a 3?

208
00:14:12,870 --> 00:14:14,029
Bueno, primero, ¿n es igual a 0?

209
00:14:14,129 --> 00:14:16,009
Seguimos ejecutando desde el principio siempre.

210
00:14:16,590 --> 00:14:17,429
Leemos n, 3.

211
00:14:18,029 --> 00:14:18,789
¿n es igual a 0?

212
00:14:19,070 --> 00:14:20,269
No, para abajo.

213
00:14:20,690 --> 00:14:21,830
¿n es mayor que 0?

214
00:14:21,990 --> 00:14:23,009
Sí, para abajo.

215
00:14:23,970 --> 00:14:26,190
Inicializamos p y le ponemos el valor 1.

216
00:14:26,450 --> 00:14:29,789
Esto es un valor inicial que yo le meto a p a saco.

217
00:14:30,289 --> 00:14:30,850
p igual a 1.

218
00:14:31,129 --> 00:14:32,690
Inicializo esa variable con su valor.

219
00:14:33,190 --> 00:14:35,590
Y ahora empiezo al bucle, que es un bucle repetirá esta.

220
00:14:35,830 --> 00:14:36,389
Igual que el anterior.

221
00:14:37,470 --> 00:14:38,669
p es igual a p por n.

222
00:14:38,909 --> 00:14:40,789
Bueno, ¿cuánto vale en la primera vuelta?

223
00:14:41,009 --> 00:14:41,730
¿Cuánto vale p?

224
00:14:41,830 --> 00:14:42,070
1.

225
00:14:42,210 --> 00:14:42,789
¿Cuánto vale n?

226
00:14:42,870 --> 00:14:43,070
3.

227
00:14:43,149 --> 00:14:44,049
3 por 1, 3.

228
00:14:44,230 --> 00:14:45,990
Por lo tanto aquí voy a poner un 3.

229
00:14:47,450 --> 00:14:49,009
n es igual a n menos 1.

230
00:14:49,009 --> 00:14:51,970
Con lo cual en la primera vuelta esto será un 2.

231
00:14:53,090 --> 00:14:55,230
Y una vez que hemos terminado de hacer el proceso,

232
00:14:55,230 --> 00:14:57,649
preguntamos, ¿qué es n igual a 1?

233
00:14:58,470 --> 00:15:01,350
Si n es igual a 1, me saldría.

234
00:15:01,929 --> 00:15:04,190
Pero como no lo es, repito el bucle.

235
00:15:04,830 --> 00:15:06,669
Vuelvo a hacer p es igual a p por n.

236
00:15:07,350 --> 00:15:10,129
3 por 2, vale, fijaros que aquí he hecho

237
00:15:10,129 --> 00:15:14,809
1 por 3

238
00:15:14,809 --> 00:15:17,809
para alcanzar el valor de p.

239
00:15:18,169 --> 00:15:21,149
¿Lo veis? 1 por 3, p por n.

240
00:15:21,529 --> 00:15:24,929
En esta segunda vuelta he dicho que voy a hacer p es igual a p por n,

241
00:15:24,929 --> 00:15:35,629
que es 3 por 2, ¿vale? Que es 6. Por lo cual aquí habré hecho 1 por 3 por 2, ¿vale? Y después hago n igual a n menos 1.

242
00:15:37,769 --> 00:15:52,870
Y pregunto, ¿es n igual a 1? Sí. Salgo hacia abajo y escribo, si n es mayor que 0, entonces me pone factorial igual

243
00:15:52,870 --> 00:15:56,809
y me devuelve el valor de p, que en este caso sería 6, ¿vale?

244
00:15:56,870 --> 00:15:58,990
En el caso del ejemplo sería 6.

245
00:15:59,690 --> 00:16:05,330
Entonces, si os fijáis, lo que he hecho aquí es 3 por 2 por 1,

246
00:16:05,429 --> 00:16:07,129
que es calcular el factorial, ¿vale?

247
00:16:08,029 --> 00:16:11,970
Si hubiéramos metido aquí un 4, pues vamos a hacerlo rápido,

248
00:16:13,490 --> 00:16:16,490
todo esto lo voy a borrar, esto lo voy a borrar,

249
00:16:16,629 --> 00:16:18,690
si hubiera metido el valor de 4, pues me hubiera dado,

250
00:16:18,690 --> 00:16:26,090
primero p vale 1, bueno pasamos las dos primeras, no es 0, no es mayor que 0, ¿vale?

251
00:16:26,169 --> 00:16:30,110
y aquí p igual a 1, entonces tenemos estos valores iniciales

252
00:16:30,110 --> 00:16:36,029
en el bucle hacemos 4 por 1 es 4 y a este restamos 1, 3

253
00:16:36,029 --> 00:16:39,929
4 por 3 es 12 y a este le restamos 1, 2

254
00:16:39,929 --> 00:16:44,450
12 por 2 es 24 y a este le restamos 1, 1

255
00:16:44,450 --> 00:16:49,049
Y como ya es igual a 1, salgo del bucle, con lo cual 4 factorial será 24.

256
00:16:49,289 --> 00:16:54,789
Si hacemos 4 por 3 por 2 por 1, 4 por 3, 12, por 2, 24, por 1, 24.

257
00:16:55,129 --> 00:16:57,350
¿Vale? Me quedaría perfectamente el factorial.

258
00:16:57,789 --> 00:17:01,529
Por lo tanto, ¿cuál es el propósito de este algoritmo?

259
00:17:02,289 --> 00:17:04,029
Sacarme el factorial de un número.

260
00:17:04,170 --> 00:17:06,789
Pero claro, el factorial de 0 no cumple la regla.

261
00:17:07,430 --> 00:17:12,150
Por lo tanto, por lo tanto, el factorial de 0 tengo que darle un caso especial.

262
00:17:12,150 --> 00:17:14,789
que es factorial de 0 igual a 1

263
00:17:14,789 --> 00:17:16,529
por eso tengo que hacer esta primera comprobación

264
00:17:16,529 --> 00:17:18,170
y además

265
00:17:18,170 --> 00:17:20,569
no existen factoriales de números negativos

266
00:17:20,569 --> 00:17:22,710
¿vale? porque en el momento en el que sea

267
00:17:22,710 --> 00:17:24,349
negativo, como tengo que ir restando 1

268
00:17:24,349 --> 00:17:26,269
dejar el menos 1 menos 2 menos 3 menos 4

269
00:17:26,269 --> 00:17:28,769
me iría al infinito, con lo cual no puede ser

270
00:17:28,769 --> 00:17:29,829
un factorial de un número negativo

271
00:17:29,829 --> 00:17:32,710
por lo tanto, como el número tiene que ser positivo

272
00:17:32,710 --> 00:17:34,769
y distinto de 0, esta primera condición

273
00:17:34,769 --> 00:17:36,910
y esta segunda condición lo que hacen es protegerme

274
00:17:36,910 --> 00:17:39,089
toda la ejecución

275
00:17:39,089 --> 00:17:40,869
de los valores que no son válidos

276
00:17:40,869 --> 00:17:43,609
y después una vez que sabemos que el valor es válido

277
00:17:43,609 --> 00:17:45,730
entramos en el bucle y ejecutamos

278
00:17:45,730 --> 00:17:47,549
esa multiplicación recursiva

279
00:17:47,549 --> 00:17:49,430
hasta que tengo el factorial y cuando

280
00:17:49,430 --> 00:17:51,430
tengo el factorial lo saco

281
00:17:51,430 --> 00:17:53,029
sin ningún problema, ¿vale?

282
00:17:53,529 --> 00:17:55,369
más o menos, ¿eh? entonces

283
00:17:55,369 --> 00:17:57,569
quiero que me digáis si tenéis

284
00:17:57,569 --> 00:17:59,369
alguna duda, de momento vuelvo a

285
00:17:59,369 --> 00:18:00,910
sacar aquí las pantallitas de

286
00:18:00,910 --> 00:18:03,349
cuando lo veáis, las estoy sacando

287
00:18:03,349 --> 00:18:05,450
¿vale? decirme si me seguís

288
00:18:05,450 --> 00:18:07,390
escuchando, si estáis ahí, si os habéis dormido ya

289
00:18:07,390 --> 00:18:09,529
o si, ¿vale? a través del chat

290
00:18:09,529 --> 00:18:17,630
Que alguien conteste, por favor. Que alguien dé señales de vida. A ver... Hola.

291
00:18:19,940 --> 00:18:20,720
Sí se oye, sí.

292
00:18:21,279 --> 00:18:24,220
Ah, vale. Ah, sí me gusta, sí me gusta. Vale.

293
00:18:24,920 --> 00:18:28,740
Veo que Antonio Casado por aquí está aplaudiendo. Eso está bien.

294
00:18:29,720 --> 00:18:34,339
Bueno, ¿podrías decir otra vez lo de factorial cero? Sí, claro.

295
00:18:35,259 --> 00:18:42,539
La norma, la regla, la regla para el factorial es cogerme desde el número, lo voy a poner aquí abajo, ¿vale?

296
00:18:43,299 --> 00:18:46,039
Si tengo factorial de un número, 7, ¿vale?

297
00:18:46,119 --> 00:18:55,519
Lo que hago es ir haciendo la multiplicación hacia atrás hasta el 0, o hasta el 1, perdón.

298
00:18:55,880 --> 00:19:03,140
Entonces, 7 por 6, por 5, por 4, por 3, por 2, por 2 y por 1.

299
00:19:03,140 --> 00:19:08,039
Ahí va, aquí, por 2 y por 1, ¿vale?

300
00:19:08,539 --> 00:19:10,119
Entonces, esa es la norma.

301
00:19:10,299 --> 00:19:11,579
Pero, ¿qué pasa con el 0 factorial?

302
00:19:11,759 --> 00:19:13,299
Que el 0 factorial es un caso especial.

303
00:19:13,299 --> 00:19:20,299
El cero factorial no lo podemos calcular según la norma.

304
00:19:21,519 --> 00:19:24,019
Simplemente los matemáticos han llegado a un convenio.

305
00:19:24,279 --> 00:19:26,779
Un convenio que es cero factorial es igual a uno, siempre.

306
00:19:26,940 --> 00:19:28,079
¿Por qué? Porque nos da la gana.

307
00:19:28,619 --> 00:19:30,299
Porque nosotros lo valemos y lo decidimos.

308
00:19:31,059 --> 00:19:33,539
Como somos los que decidimos las cosas que se hacen en matemáticas,

309
00:19:34,099 --> 00:19:36,420
pues vamos a tomar la decisión de que cero factorial es igual a uno.

310
00:19:36,900 --> 00:19:38,720
Y se acabó. Es una norma.

311
00:19:39,200 --> 00:19:45,059
Entonces, yo no puedo hacer 0 por números menores que 0,

312
00:19:45,140 --> 00:19:49,599
restando de 1 en 1 hasta llegar a 0, porque si os fijáis, nunca llegaría.

313
00:19:50,440 --> 00:19:52,200
Entonces, 0 factorial por convenio es 1.

314
00:19:52,880 --> 00:19:57,480
7 factorial es multiplicar 7 por 6, restándole 1 al 7 hasta que llegue al 1.

315
00:19:58,200 --> 00:20:00,779
Y si es un número negativo, no existe factorial.

316
00:20:01,579 --> 00:20:05,220
Entonces, aquí lo que hago es protegerme al principio de esos valores que no son válidos.

317
00:20:05,359 --> 00:20:07,220
Primero, compruebo si n es igual a 0.

318
00:20:07,920 --> 00:20:12,720
Si n es igual a 0, me salgo y digo, vale, el factorial de 0 es igual a 1,

319
00:20:12,799 --> 00:20:16,720
porque es un caso especial, no puedo aplicarle el bucle, no puedo aplicarle la norma.

320
00:20:17,619 --> 00:20:22,599
Entonces, el caso especial del 0 lo trato aquí, n igual a 0, un caso especial,

321
00:20:23,059 --> 00:20:25,220
y lo saco, factorial de 0 es igual a 1.

322
00:20:25,779 --> 00:20:29,759
Si no es 0, todavía tengo una opción de que esto no sea válido,

323
00:20:29,759 --> 00:20:32,779
y es cuando los números son negativos, por eso hago esta comprobación.

324
00:20:32,779 --> 00:20:47,680
Si n es mayor que 0, ¿vale? Hago el bucle, pero si no es mayor que 0, como ya he comprobado que no era 0 y no es mayor que 0, la única opción que quedaría para esta salida del no es que sea menor estrictamente que 0.

325
00:20:48,299 --> 00:20:58,839
Es un número por debajo de 0. Por lo tanto, escribo número negativo y escribo prueba con positivos, metiendo números positivos, porque con ese no me vale. Y se acabó.

326
00:20:59,380 --> 00:21:04,680
Entonces, lo que hago es protegerme aquí de los valores que no son válidos para el algoritmo.

327
00:21:05,220 --> 00:21:08,779
Y aquí está realmente el cuerpo del algoritmo, que es el cálculo del factorial,

328
00:21:09,359 --> 00:21:14,480
que es el bucle que me va multiplicando el número por uno menos, por uno menos, por uno menos, hasta llegar al uno.

329
00:21:14,960 --> 00:21:18,180
Y cuando llega al uno se sale y me escribe el valor resultante y se acabó.

330
00:21:18,859 --> 00:21:19,019
¿Vale?

331
00:21:20,619 --> 00:21:23,119
¿Contesta eso la pregunta, Liz?

332
00:21:24,799 --> 00:21:25,240
¿Vale?

333
00:21:26,059 --> 00:21:26,500
¿Mario?

334
00:21:26,500 --> 00:21:29,900
que va a ser el que preguntabas

335
00:21:29,900 --> 00:21:32,240
¿contesta eso tu pregunta?

336
00:21:33,019 --> 00:21:34,000
vale, perfecto

337
00:21:34,000 --> 00:21:34,940
entonces

338
00:21:34,940 --> 00:21:37,980
¿qué ocurre? yo os decía

339
00:21:37,980 --> 00:21:39,900
vale, esto está guay

340
00:21:39,900 --> 00:21:41,859
pero también hay que ver

341
00:21:41,859 --> 00:21:44,059
una vez que nos podemos

342
00:21:44,059 --> 00:21:45,839
hacer esto, si esto falla en algún sitio

343
00:21:45,839 --> 00:21:47,440
yo nada más verlo

344
00:21:47,440 --> 00:21:49,440
ya os digo, yo he hecho muchos algoritmos

345
00:21:49,440 --> 00:21:51,740
me doy cuenta de que

346
00:21:51,740 --> 00:21:52,700
este algoritmo tiene un error

347
00:21:52,700 --> 00:21:55,720
tiene un error en la ejecución, por la forma

348
00:21:55,720 --> 00:22:00,759
en la que hace las cosas. Fijaros, vamos a poner un ejemplo, ¿de acuerdo? Y voy a hacer

349
00:22:00,759 --> 00:22:09,059
el ejemplo en el caso de que el usuario introduzca el valor 1. Todo el mundo sabe, ¿verdad?,

350
00:22:09,059 --> 00:22:15,920
que factorial de 1 es 1. Y se acabó. Factorial de 1 es 1. Factorial de 0 es 1 por convenio,

351
00:22:15,980 --> 00:22:22,339
pero factorial de 1 es 1. Es 1 por sí mismo y se acabó. Entonces, si yo le pongo el valor

352
00:22:22,339 --> 00:22:30,400
1, ¿qué va a ocurrir? Fijaros, el filtro para los valores válidos me lo paso, porque

353
00:22:30,400 --> 00:22:35,660
n no es 0, por lo tanto salgo hacia abajo, y n es positivo, por lo tanto salgo hacia

354
00:22:35,660 --> 00:22:43,279
abajo. Ya estoy dentro del bucle. Inicializo p a 1. Y ahora fijaros el error. p es p por

355
00:22:43,279 --> 00:22:50,019
n. 1 por 1, 1. Hasta aquí todo bien. n igual a n menos 1. Cuidadito, que ahora lo pongo

356
00:22:50,019 --> 00:22:51,900
a 0. Y ahora hago la comprobación. ¿Es n

357
00:22:51,900 --> 00:22:54,039
igual a 1? No. No es

358
00:22:54,039 --> 00:22:55,960
n igual a 1. Por lo tanto, me meto

359
00:22:55,960 --> 00:22:56,279
en el bucle.

360
00:22:57,460 --> 00:23:00,059
p es igual a p por n. 1 por 0. 0.

361
00:23:01,660 --> 00:23:03,299
Y n es igual a n menos 1.

362
00:23:03,680 --> 00:23:05,779
Ahora ya estamos en n igual a menos 1. Fijaros

363
00:23:05,779 --> 00:23:08,200
que me he pasado y ahora ya estoy haciendo un disparate.

364
00:23:08,900 --> 00:23:10,039
¿Vale? ¿Es n igual a

365
00:23:10,039 --> 00:23:11,799
1? Para nada. Y vuelvo a entrar

366
00:23:11,799 --> 00:23:13,779
en el bucle. Y ahora hago

367
00:23:13,779 --> 00:23:14,839
0 por menos 1. 0.

368
00:23:16,539 --> 00:23:17,720
n igual a n menos 1.

369
00:23:17,720 --> 00:23:18,299
N igual a n menos 2.

370
00:23:18,299 --> 00:23:23,240
y pregunto, ¿es n igual a 1? No, y vuelvo a entrar en el bucle

371
00:23:23,240 --> 00:23:29,980
y veo que p es 0 por 0 por menos 2, 0, y menos 2 se convierte en menos 3

372
00:23:29,980 --> 00:23:33,279
y así puedo seguir, menos 3 es menos 4, menos 5 es menos 6

373
00:23:33,279 --> 00:23:38,920
y no va a acabar nunca este proceso, se ha saltado el límite del bucle

374
00:23:38,920 --> 00:23:43,980
y por la forma en la que está escrito no terminaría en la vida

375
00:23:43,980 --> 00:23:54,740
Entonces, para el caso de n igual a 1, este programa tiene un fallo, tiene un error y habría que corregirlo, habría que hacer las cosas de otra forma para permitir que eso no pasara.

376
00:23:55,259 --> 00:24:07,900
O ponemos un caso especial para n igual a 1 aquí arriba, con lo cual también, si aquí le pongo, por ejemplo, simplemente, si n es igual a 0 o n es igual a 1, escribo factorial igual a 1.

377
00:24:07,900 --> 00:24:09,559
y me he quedado tan ancho

378
00:24:09,559 --> 00:24:12,140
porque tanto el factorial de 0 como el factorial de 1 vale 1

379
00:24:12,140 --> 00:24:14,319
y después ya he protegido

380
00:24:14,319 --> 00:24:16,019
contra el valor que me hacía que esto cascara

381
00:24:16,019 --> 00:24:17,960
¿N es negativo? No

382
00:24:17,960 --> 00:24:19,440
por lo tanto cuando entro aquí

383
00:24:19,440 --> 00:24:22,640
ni es 0, ni es 1, ni es negativo

384
00:24:22,640 --> 00:24:24,539
con lo cual ya estoy seguro de que esto va a funcionar

385
00:24:24,539 --> 00:24:26,160
y ya estaría protegiendo

386
00:24:26,160 --> 00:24:27,920
correctamente este programa

387
00:24:27,920 --> 00:24:29,119
y el algoritmo funcione

388
00:24:29,119 --> 00:24:32,079
¿entendéis cuál es el error?

389
00:24:32,839 --> 00:24:34,039
¿vale? ¿entendéis un poco

390
00:24:34,039 --> 00:24:36,019
cuál es el problema de este algoritmo?

391
00:24:36,019 --> 00:24:38,619
contestarme por el chat

392
00:24:38,619 --> 00:24:40,700
aún si, o si queréis activaros

393
00:24:40,700 --> 00:24:42,720
el micro y me decís

394
00:24:42,720 --> 00:24:44,240
que sí, y ya está

395
00:24:44,240 --> 00:24:45,140
¿vale?

396
00:24:46,259 --> 00:24:48,660
es un error muy tonto, pero es un error que muchas

397
00:24:48,660 --> 00:24:50,579
veces lo cometemos cuando

398
00:24:50,579 --> 00:24:52,240
cuando estamos

399
00:24:52,240 --> 00:24:54,500
calculando variables, fijaros que en este caso

400
00:24:54,500 --> 00:24:56,720
también tenemos, por ponerle el nombre que voy a

401
00:24:56,720 --> 00:24:58,619
darles ahora, tenemos una

402
00:24:58,619 --> 00:25:00,519
variable que es la variable de entrada que

403
00:25:00,519 --> 00:25:02,700
nos sirve de contador, voy a poner un ejemplo

404
00:25:02,700 --> 00:25:04,619
que se vea bien, el del 4 por ejemplo

405
00:25:04,619 --> 00:25:18,420
4, p se inicializaría a 1, 4 por 1 es 4, resto 1, 3, 4 por 3, 12, resto 1, 2, 12 por 2, 24, resto 1, 1, y aquí ya me saldría.

406
00:25:19,039 --> 00:25:27,960
Vale, entonces, fijaros que esta es la forma de ejecutar un algoritmo rápido, pero tenemos que ver muy claro cuáles son las variables y cuál es el valor que en cada momento tiene esta variable.

407
00:25:28,599 --> 00:25:31,279
Eso me ayuda muchísimo para entender cómo funciona un algoritmo.

408
00:25:31,279 --> 00:25:44,660
¿Vale? Bien, entonces, ahí tenemos un ejemplo, el valor de n igual a 4, ¿vale? Y cómo ha ido evolucionando. En este caso el factorial sería 24 y la salida sería esta.

409
00:25:44,660 --> 00:25:53,299
Y aquí en las conclusiones yo escribiría, ¿vale? Las conclusiones. Pues mis conclusiones serían que el propósito de este programa es calcular el factorial de un número,

410
00:25:53,299 --> 00:26:00,559
que para ello primero elimina los valores que no son válidos para la norma general

411
00:26:00,559 --> 00:26:05,420
que serían el valor de n igual a 0 que su función es 1 y el valor que sea un número negativo que no se puede hacer

412
00:26:05,420 --> 00:26:10,900
y una vez que hemos hecho esa comprobación pasamos a escribir el algoritmo de multiplicación

413
00:26:10,900 --> 00:26:15,579
con un bucle repetir hasta que n sea igual a 1, ¿de acuerdo?

414
00:26:15,859 --> 00:26:22,019
Y en las conclusiones yo pondría y además el programa tiene un fallo y es que para el valor de n igual a 1 no funciona

415
00:26:22,019 --> 00:26:25,859
y además el organigrama tiene un fallo y es que esta flecha está al revés.

416
00:26:26,740 --> 00:26:29,519
Y con eso estamos de acuerdo, ¿vale?

417
00:26:30,259 --> 00:26:33,700
Bueno, más o menos espero que os haya quedado claro que una plantilla de estas

418
00:26:33,700 --> 00:26:38,259
o escribiendo en un folio simplemente poniendo cuáles son las entradas,

419
00:26:38,400 --> 00:26:40,819
cuáles son las salidas y cuáles son los valores de las variables,

420
00:26:40,819 --> 00:26:45,680
se entiende muy bien cómo funcionan los algoritmos y es una forma muy útil para identificar esto.

421
00:26:46,200 --> 00:26:50,220
¿De acuerdo? Ya os digo, no me describáis cuando queréis describir un algoritmo que hace cada caja.

422
00:26:50,220 --> 00:27:10,630
Bien, bueno, pues voy a cerrar esto y voy a enseñaros entonces un pequeño resumen que os he preparado, un pequeño resumen de cómo nosotros vamos a analizar los ejemplos de los diagramas de acu, ¿de acuerdo?

423
00:27:10,630 --> 00:27:23,829
Esto luego os lo pasaré, todo este material os lo dejaré colgado en el blog, ¿de acuerdo? Bien, pues lo primero, vamos a ver el análisis de los algoritmos, ¿vale? Y cómo resolverlos y vamos a tener que cubrir una serie de fases.

424
00:27:24,750 --> 00:27:26,130
Primero, ¿cuál es el problema?

425
00:27:27,190 --> 00:27:31,210
Bueno, pues el problema es que tenemos que localizar las variables.

426
00:27:32,029 --> 00:27:34,910
Nosotros tenemos que localizar las variables y al localizar las variables,

427
00:27:35,190 --> 00:27:40,009
para eso es importante localizar los elementos que van a ir cambiando de valor

428
00:27:40,009 --> 00:27:43,150
o aquellos que yo introduzco a través del teclado.

429
00:27:43,390 --> 00:27:44,789
Entonces, eso es importante.

430
00:27:45,569 --> 00:27:50,950
Hay contadores, hay acumuladores, hay variables que me cogen un límite,

431
00:27:50,950 --> 00:27:58,009
que me cojan el límite de un bucle, entonces tenemos que ver qué variables son las importantes

432
00:27:58,009 --> 00:28:02,769
y sobre todo apuntármelas en un papel e ir actualizando sus valores para ver qué afectan.

433
00:28:03,849 --> 00:28:07,789
Tenemos, evidentemente, es crucial detectar cuáles son las entradas de los datos y cuáles son las salidas.

434
00:28:07,890 --> 00:28:13,970
La salida del algoritmo es lo que me va a dar el propósito, lo que devuelve el algoritmo al final es lo que quiera o que haga,

435
00:28:14,289 --> 00:28:15,890
entonces eso me va a dar el propósito.

436
00:28:15,890 --> 00:28:28,490
¿Vale? Y entonces, una vez que hemos visto qué variables tengo, cuáles son las entradas y cuál es la salida, es donde ya vamos a saber qué problema trata de resolver el algoritmo, ¿vale?

437
00:28:28,769 --> 00:28:32,410
Entonces, normalmente nos fijamos en eso, en entradas y salidas para intentar entender.

438
00:28:33,309 --> 00:28:40,710
Luego también hay que analizar qué hacen los procesos internos, ¿vale? Las asignaciones, las actualizaciones de los valores para las variables.

439
00:28:40,710 --> 00:28:44,529
y también tenemos que ver qué cosas se van haciendo en los bucles

440
00:28:44,529 --> 00:28:47,930
o en las bifurcaciones, en las decisiones que se toman, ¿de acuerdo?

441
00:28:48,410 --> 00:28:53,130
Y por último, llegamos a la conclusión, conclusión de lo que hemos analizado.

442
00:28:53,549 --> 00:28:56,309
Normalmente a estas alturas ya sabemos perfectamente qué es lo que hace el algoritmo,

443
00:28:56,750 --> 00:29:00,730
entonces no tenemos problema para poder resolver este tipo de preguntas.

444
00:29:02,130 --> 00:29:06,029
Bueno, vamos a poner el primer ejemplo, ¿vale? Ya lo habéis visto, ¿no?

445
00:29:06,029 --> 00:29:08,930
En este caso, pues el primer algoritmo teníamos tres variables,

446
00:29:08,930 --> 00:29:14,710
que era la k, que era el límite, era lo que yo leía, pero además me sirve, como veis aquí,

447
00:29:15,710 --> 00:29:22,970
a ver un segundito, si como veis aquí, ¿vale? Veis que n es igual a k, entonces el valor n igual a k,

448
00:29:23,069 --> 00:29:27,369
lo que está haciendo es, a ver un segundito, si estoy compartiendo la pantalla correcta,

449
00:29:27,410 --> 00:29:33,589
¿verdad? Estáis viendo la presentación, ¿no? A ver, un segundo, a ver en el chat,

450
00:29:33,589 --> 00:29:37,210
Contestadme por el chat si estáis viendo la presentación bien

451
00:29:37,210 --> 00:29:39,710
Vale, perfecto

452
00:29:39,710 --> 00:29:42,190
Entonces, en este de aquí es el límite

453
00:29:42,190 --> 00:29:45,069
Porque es el que me va a marcar la salida del bucle

454
00:29:45,069 --> 00:29:47,789
La salida del bucle lo tengo en n igual a k

455
00:29:47,789 --> 00:29:49,210
Por lo tanto, k es el límite

456
00:29:49,210 --> 00:29:50,970
Es una variable que tiene un límite

457
00:29:50,970 --> 00:29:52,869
Luego tengo un contador que es n

458
00:29:52,869 --> 00:29:54,750
Que si os fijáis va creciendo de uno en uno

459
00:29:54,750 --> 00:29:56,670
En cada vuelta crece en uno

460
00:29:56,670 --> 00:29:57,690
Con lo cual es un contador

461
00:29:57,690 --> 00:29:59,849
Y luego tengo un acumulador

462
00:29:59,849 --> 00:30:01,950
Que es donde voy metiendo el valor acumulado

463
00:30:01,950 --> 00:30:03,289
De la suma de todos esos

464
00:30:03,289 --> 00:30:04,650
los números que van sucediendo.

465
00:30:05,470 --> 00:30:07,430
Con lo cual ya identifico mis variables.

466
00:30:08,450 --> 00:30:16,009
Después, tenemos que K me marca ese límite, ¿vale?

467
00:30:16,089 --> 00:30:20,269
La salida del bucle, las entradas y las salidas, es K la entrada,

468
00:30:20,910 --> 00:30:24,450
y la salida es la suma, que es el acumulador, lo que tenga el valor del acumulador.

469
00:30:25,009 --> 00:30:28,690
Y el propósito es resolver la suma de los K primeros números consecutivos, ¿vale?

470
00:30:28,690 --> 00:30:29,549
Los naturales.

471
00:30:30,410 --> 00:30:30,650
Bien.

472
00:30:30,650 --> 00:30:55,410
Bien, segundo ejemplo, ya lo hemos analizado, volvemos a él, ¿vale? Las variables n y p, después tenemos que k va a ser, bueno, en este caso n nos sirve tanto de contador como de límite, ¿por qué? Porque va a ser el que va a ir contando en qué vuelta me encuentro, ¿vale? Y también es el que va a hacer el límite de la salida, en este caso es la misma variable, ¿vale?

473
00:30:55,410 --> 00:31:03,349
El hecho de utilizar la misma variable con los dos propósitos hace que aquí no pueda decir el factorial de el número n es p,

474
00:31:03,569 --> 00:31:07,069
porque n siempre va a valer 1, si os fijáis, esta es la condición de salida.

475
00:31:07,069 --> 00:31:14,309
Con lo cual, como me he ido restando de mi variable inicial números, no sé cuál era el número inicial.

476
00:31:14,990 --> 00:31:17,569
A estas alturas del algoritmo he perdido esa información.

477
00:31:17,569 --> 00:31:27,750
o guardo en una variable diferente el valor inicial o aquí al final no podré decir el factorial del número, el que sea, es p, ¿vale?

478
00:31:28,170 --> 00:31:31,890
Entonces, bueno, pues eso son cosillas que son luego mejoras que podemos hacer nosotros en los aburridos.

479
00:31:32,210 --> 00:31:42,490
Y la suma es la salida que es el acumulador, que en este caso no acumula sumando, sino que acumula multiplicando y ahí acumulando en su valor la multiplicación, ¿vale?

480
00:31:43,049 --> 00:31:47,549
Y hemos visto que el propósito es devolver el factorial del número k introducido por el usuario.

481
00:31:47,569 --> 00:31:52,069
Y ya está. ¿De acuerdo? Entonces veis que es todo bastante intuitivo.

482
00:31:52,730 --> 00:31:58,670
Hemos visto que tenía dos problemas, el problema de la flecha y hemos visto que tenía el problema de que si le pongo n igual a 1,

483
00:31:59,190 --> 00:32:06,509
como en la condición previa a la comprobación ya me dice, me pregunta si n es igual, o sea, me resta 1 a la n,

484
00:32:07,150 --> 00:32:13,910
cuando le pongo n igual a 1, aquí peta. ¿Vale? No saldrá nunca de este bucle y se queda de forma infinita g.

485
00:32:13,910 --> 00:32:35,190
¿De acuerdo? Bueno, preguntas hasta aquí. A ver, abrimos un poquito el turno de preguntas, ¿vale? No sé si tenéis alguna cuestión que decirme. ¿Alguien ha levantado la mano? Antonio está aplaudiendo, Sergio está aplaudiendo, pero bueno, ya podéis dejar de aplaudir.

486
00:32:35,190 --> 00:32:46,049
¿Alguien tiene alguna duda? Vale, perfecto. Pues nada, seguimos viaje.

487
00:32:47,089 --> 00:32:55,390
¿Qué tengo para enseñaros? Pues tengo para enseñaros un programita que se llama PSINT, que es un programa gratuito que podéis descargaros de internet.

488
00:32:56,750 --> 00:33:01,049
Tengo un vídeo en mi canal de YouTube donde os explico cómo descargarlo y cómo instalarlo.

489
00:33:01,049 --> 00:33:03,549
instalarlo, de acuerdo, ahora os diré

490
00:33:03,549 --> 00:33:05,069
dónde están los vídeos de mi canal y

491
00:33:05,069 --> 00:33:06,670
dónde están todas estas cosillas que

492
00:33:06,670 --> 00:33:08,910
podéis utilizar, si queréis, entonces

493
00:33:08,910 --> 00:33:12,569
PSINT es un programa que nos sirve para

494
00:33:12,569 --> 00:33:16,130
esto, entonces, bueno, aquí ya termina la

495
00:33:16,130 --> 00:33:18,609
presentación, vale, esto lo pasaré para

496
00:33:18,609 --> 00:33:20,430
que lo tengáis, con lo cual ahí tenéis un

497
00:33:20,430 --> 00:33:23,869
poquito toda la, toda la, perfecto, vuelvo a mi

498
00:33:23,869 --> 00:33:29,369
a mi pantallita, a ver, un segundo, que he

499
00:33:29,369 --> 00:33:35,990
perdido, vuelvo a compartir mi escritorio, perdonad, que ha saltado sin querer, vale.

500
00:33:36,670 --> 00:33:41,710
Y entonces ahora lo que voy a hacer es enseñaros este, el programa PSI, ¿de acuerdo?

501
00:33:42,470 --> 00:33:48,150
Fijaros, voy a volver a coger los algoritmos que teníamos, voy a coger el facilito,

502
00:33:48,890 --> 00:33:52,970
y este programa me sirve para poner algoritmos en formato pseudocódigo.

503
00:33:52,970 --> 00:33:57,549
Entonces, un algoritmo empieza con un inicial algoritmo y un final, fin algoritmo,

504
00:33:57,549 --> 00:34:01,789
que es el inicio y el fin, ¿vale? Estas son las estructuras redondas.

505
00:34:02,670 --> 00:34:06,630
Y luego aquí a la derecha, en los comandos, ¿vale?

506
00:34:09,429 --> 00:34:10,789
Voy a quitar esto de la estorba.

507
00:34:11,530 --> 00:34:15,090
Entonces aquí veis que tenemos una serie de cosas que se pueden hacer.

508
00:34:15,190 --> 00:34:17,809
Un escribir, que son salidas, un leer, que son entradas,

509
00:34:18,170 --> 00:34:20,570
un asignar, que me va a asignar valores a variables,

510
00:34:21,050 --> 00:34:22,550
estos son la variable igual a algo,

511
00:34:22,550 --> 00:34:28,789
y luego aquí bifurcaciones y bucles del tipo repetir hasta o repetir mientras, ¿vale?

512
00:34:28,869 --> 00:34:34,130
O un bucle con un contador que va adquiriendo valores desde un valor hasta el que sea.

513
00:34:34,369 --> 00:34:43,230
Bueno, entonces, fijaros, el algoritmo que yo voy a poner aquí, pues, va a ser algoritmo A, ¿vale?

514
00:34:43,269 --> 00:34:44,969
Este es el algoritmo A que estamos haciendo.

515
00:34:45,050 --> 00:34:46,489
Lo primero que hago es leer K.

516
00:34:47,190 --> 00:34:51,190
Le doy a leer y la variable que quiero leer es la variable K.

517
00:34:51,190 --> 00:34:54,489
Fijaros que estoy copiando prácticamente lo que pone en ese algoritmo.

518
00:34:55,269 --> 00:35:12,369
Ahora le voy a asignar a la variable n el valor 0 y a la variable suma le voy a asignar el valor 0.

519
00:35:13,369 --> 00:35:16,570
Entonces, en un momento voy a ir siguiendo lo que hace el programa.

520
00:35:16,570 --> 00:35:21,789
Lo que hago es leer k, luego le pongo a n el valor 0 y asumo el valor 0.

521
00:35:22,329 --> 00:35:26,010
Y ahora voy a hacer este proceso repetitivo que está dentro de un bucle repetir hasta.

522
00:35:26,190 --> 00:35:30,630
Con lo cual, si os fijáis, tengo aquí la estructura del repetir hasta, ¿vale?

523
00:35:31,230 --> 00:35:33,449
Repetir hasta que suceda algo.

524
00:35:34,050 --> 00:35:35,630
¿Qué secuencia de acciones tengo que hacer?

525
00:35:35,769 --> 00:35:44,820
Bueno, pues tengo que asignarle a la variable n la expresión n más 1

526
00:35:44,820 --> 00:35:58,269
y a la variable suma le voy a poner la suma más n.

527
00:35:59,329 --> 00:36:01,789
Bien, ¿y hasta cuándo voy a repetir esto?

528
00:36:03,010 --> 00:36:07,280
Hasta que n sea igual, ¿vale?

529
00:36:08,280 --> 00:36:11,139
Bien, y cuando salga de este bucle, ¿qué voy a hacer?

530
00:36:11,139 --> 00:36:23,590
Voy a escribir por pantalla k y voy a escribir por pantalla suma, ¿vale?

531
00:36:24,929 --> 00:36:39,059
Ahí va, me he saltado, perdonadme, este fin de algoritmo me lo he zampado, no es aquí, este fin de algoritmo es aquí, ¿vale? Eso es, es que un pequeño error táctico.

532
00:36:41,869 --> 00:36:50,030
Vale, ahora estaría bien, entonces fijaros, ¿qué es lo que estoy haciendo? He puesto el nombre del algoritmo, inicio, sería este inicio del algoritmo,

533
00:36:50,030 --> 00:36:56,730
luego leemos k, ponemos a n el valor 0, sumamos, perdona, al valor de la suma le damos el valor 0

534
00:36:56,730 --> 00:37:00,469
y luego vamos a repetir hasta que n sea igual a k, que es este bucle,

535
00:37:01,889 --> 00:37:05,250
n coge el valor n más 1 y suma, coge el valor suma más n.

536
00:37:06,550 --> 00:37:09,989
Escribimos k cuando terminemos y escribimos suma y terminamos el algoritmo.

537
00:37:10,250 --> 00:37:11,590
¿Qué es lo guapo de este programa?

538
00:37:11,769 --> 00:37:17,150
Que aparte de poderlo escribir aquí de una forma un poquito como si fuera lenguaje natural,

539
00:37:17,469 --> 00:37:19,150
yo puedo ver el diagrama de flujo.

540
00:37:20,030 --> 00:37:28,090
Que si os fijáis, tiene una pinta bastante parecida al diagrama de flujo que teníamos original.

541
00:37:28,250 --> 00:37:35,050
Leemos k, asignamos el valor 0 a n, asignamos el valor 0 a suma, n es n más 1, suma, suma más n,

542
00:37:35,050 --> 00:37:38,650
y aquí preguntamos n es igual a k, y cuando es falso, volvemos para arriba.

543
00:37:39,650 --> 00:37:45,429
Y si es verdadero, escribo suma y escribo k, que si os fijáis son las entradas y salidas,

544
00:37:45,570 --> 00:37:48,110
con la flechita hacia afuera la de escribir y esta es la de leer.

545
00:37:48,929 --> 00:37:57,769
Veis que el diagrama de flujo es prácticamente clavado, pero además lo puedo ejecutar, que esto es la maravilla de este programa, ¿veis?

546
00:37:57,909 --> 00:38:03,590
Yo lo ejecuto, me sale una ventanita y me dice, es aquí en el play este redondo, ejecución iniciada.

547
00:38:04,070 --> 00:38:09,289
¿Qué estamos haciendo? Leer K, entonces aquí le voy a poner un número, 4, ¿vale?

548
00:38:09,289 --> 00:38:16,889
Y entonces me pone, acaba de terminar de ejecutar el bucle y escribe K, que es 4, y escribe la suma, que es 10.

549
00:38:16,889 --> 00:38:19,710
4 y 3, 7 y 2, 9 y 1, 10.

550
00:38:19,869 --> 00:38:21,590
Perfecto, me ha sumado todos los números

551
00:38:21,590 --> 00:38:24,050
entre 1 y 4.

552
00:38:24,590 --> 00:38:24,769
¿Vale?

553
00:38:25,769 --> 00:38:27,469
Y me sale el resultado 3, 10.

554
00:38:27,789 --> 00:38:28,829
¿Veis que es muy críptico?

555
00:38:29,289 --> 00:38:31,309
Esto mola más si yo le pongo

556
00:38:31,309 --> 00:38:33,309
algo de información para que la ejecución

557
00:38:33,309 --> 00:38:34,909
sea más guapa.

558
00:38:34,909 --> 00:38:36,110
Yo le pongo aquí

559
00:38:36,110 --> 00:38:37,429
escribir

560
00:38:37,429 --> 00:38:40,610
introduce, entre comillas,

561
00:38:40,750 --> 00:38:42,690
siempre los textos, introduce

562
00:38:42,690 --> 00:38:46,670
ahí va, introduce

563
00:38:46,670 --> 00:38:48,389
un número

564
00:38:48,389 --> 00:38:56,849
para que sepa que es lo que tiene que meter el usuario, ¿vale? Leemos K, repetimos el bucle y ahora cuando escribo, ¿vale?

565
00:38:56,929 --> 00:39:14,989
Lo que voy a hacer es escribir la suma de los números desde 1 hasta, le pongo este texto y detrás el valor de la variable K, ¿vale?

566
00:39:14,989 --> 00:39:23,429
Y aquí le pongo otro texto, que es, fijaros que estoy concatenando textos, es dos puntos, espacio, coma, sub.

567
00:39:23,909 --> 00:39:26,889
¿Qué he hecho aquí? Voy a quitarme este escribir.

568
00:39:29,639 --> 00:39:35,840
¿Qué he hecho aquí? Muy fácil, lo que he hecho ha sido escribir una cosa detrás de otra, con lo cual me va a escribir este texto,

569
00:39:36,400 --> 00:39:40,940
la suma de los números desde uno hasta, después me va a poner el valor de la variable k,

570
00:39:40,940 --> 00:39:43,739
después otro texto, que es

571
00:39:43,739 --> 00:39:45,519
un espacio, es dos puntos

572
00:39:45,519 --> 00:39:47,679
y después el valor de la variable suma

573
00:39:47,679 --> 00:39:50,139
¿vale? entonces esto, puesto de esta

574
00:39:50,139 --> 00:39:52,059
forma, esto lo tenéis explicado

575
00:39:52,059 --> 00:39:53,719
también en los vídeos y lo que veis

576
00:39:53,719 --> 00:39:55,840
con un poquito más de detalle, ¿vale? introduce

577
00:39:55,840 --> 00:39:57,780
el número, ahora ya sé que me está pidiendo

578
00:39:57,780 --> 00:39:59,760
pues 4, y ahora me dice

579
00:39:59,760 --> 00:40:01,780
la suma de los números desde 1 hasta

580
00:40:01,780 --> 00:40:03,719
4 es 10, ahora tiene sentido

581
00:40:03,719 --> 00:40:05,719
¿veis? ahora me está dando un programa

582
00:40:05,719 --> 00:40:07,739
en condiciones, le he añadido

583
00:40:07,739 --> 00:40:09,719
simplemente pues un poquito de interacción en la

584
00:40:09,719 --> 00:40:11,400
Entraría en la salida para saber qué está haciendo.

585
00:40:11,760 --> 00:40:14,719
Eso no te lo han puesto en este algoritmo, en este organigrama,

586
00:40:15,079 --> 00:40:17,519
porque entonces te estarían diciendo cuál es el propósito.

587
00:40:17,639 --> 00:40:20,400
Entonces no podrían, no, no se estarían dando la solución del ejercicio.

588
00:40:20,860 --> 00:40:21,599
Por eso no lo han hecho.

589
00:40:22,179 --> 00:40:22,539
¿De acuerdo?

590
00:40:23,639 --> 00:40:24,000
Bien.

591
00:40:24,940 --> 00:40:27,000
Entonces, este es el algoritmo, este.

592
00:40:27,619 --> 00:40:29,440
También, bueno, yo ya me los he hecho, ¿vale?

593
00:40:29,480 --> 00:40:34,480
Entonces, este algoritmo, si os fijáis, tendría, bueno, perdonad,

594
00:40:34,480 --> 00:40:39,340
antes de hacer el siguiente algoritmo, una cosa que también es muy chula es esto.

595
00:40:39,719 --> 00:40:46,420
Veréis. Yo puedo ejecutarlo paso a paso. Aquí en los pasitos estos, lo puedo ejecutar paso a paso.

596
00:40:46,619 --> 00:40:51,039
Entonces, fijaros. Me sale la ventana de la salida y me va poniendo una flechita donde estamos.

597
00:40:51,219 --> 00:40:55,960
Y además le digo explicar con detalle y me va a ir diciendo qué hace en cada paso.

598
00:40:56,559 --> 00:40:58,599
Entonces, este algoritmo, lo voy a poner así para verlo todo.

599
00:40:59,639 --> 00:41:05,719
Fijaros. Está leer en los detalles. Vale. Entonces, está leyendo el...

600
00:41:05,719 --> 00:41:27,500
Pero voy a detener y voy a empezar a ejecutar. Comenzar. Vale, el algoritmo comienza con el proceso algoritmo A, vale, pues esto nada, sin problema. Siguiente. Escribimos por pantalla, introduzco el número, vale, se pone. En la pantalla veis que ha salido aquí, en la pantalla que es esta, vale, esta, hoy va, esta ventanita. Vale, esta ventanita.

601
00:41:28,239 --> 00:41:29,940
Entonces, ahora, seguimos.

602
00:41:30,860 --> 00:41:32,179
Se espera que el usuario ingrese un valor.

603
00:41:32,519 --> 00:41:34,639
Vamos a ingresar un valor, el 2.

604
00:41:35,480 --> 00:41:36,300
Sí, el 3.

605
00:41:36,820 --> 00:41:37,860
Vamos a hacerlo corto.

606
00:41:38,679 --> 00:41:38,920
¿De acuerdo?

607
00:41:39,139 --> 00:41:39,480
Entra.

608
00:41:40,300 --> 00:41:44,480
El valor ingresado se almacena en K, que es lo que estamos haciendo aquí, en esta flecha.

609
00:41:44,699 --> 00:41:45,760
Pasamos a la siguiente orden.

610
00:41:46,659 --> 00:41:48,900
Se evalúa la expresión a asignar, 0.

611
00:41:49,159 --> 00:41:52,760
El resultado es 0, es decir, lo que está a la derecha, que es lo que tengo que asignar, es 0,

612
00:41:52,760 --> 00:41:55,199
porque es lo que le he puesto a juego, y el resultado se guarda en L.

613
00:41:55,699 --> 00:41:56,960
0 se guarda en L.

614
00:41:57,500 --> 00:42:04,599
Se evalúa la expresión a asignar, que es 0, el resultado es 0, y eso se aguarda en suma, ¿vale?

615
00:42:04,840 --> 00:42:05,980
Y ahora repetimos.

616
00:42:07,400 --> 00:42:13,699
Se evalúa la expresión a asignar, que es n más 1, el resultado es 1, porque 0 más 1 es 1.

617
00:42:14,639 --> 00:42:17,260
Y el resultado se guarda en n, n ahora vale 1.

618
00:42:18,820 --> 00:42:25,619
Se evalúa la expresión suma más n, el resultado es 1, y el resultado se almacena en suma.

619
00:42:25,619 --> 00:42:29,199
y ahora se evalúa la condición, ¿es n igual a k?

620
00:42:30,519 --> 00:42:34,940
Falso, se continúa iterando, se continúa con la siguiente iteración, con la siguiente repetición.

621
00:42:36,039 --> 00:42:40,760
¿Vale? n más 1, el resultado es 2, el resultado se guarda en n,

622
00:42:41,519 --> 00:42:44,940
se hace suma más n, que es 3, se guarda en suma,

623
00:42:45,579 --> 00:42:47,519
se evalúa la condición, ¿n es igual a k?

624
00:42:48,119 --> 00:42:53,119
Falso, se continúa iterando, el resultado ahora es 3 y se guarda en n,

625
00:42:53,119 --> 00:42:59,079
La suma es 6 y se guarda en suma, se evalúa, ¿es n igual a k? Ahora sí, porque le hemos dado el valor 3.

626
00:42:59,940 --> 00:43:04,219
En la condición es verdadero, se sale de la estructura repetir y ahora se evalúa la expresión.

627
00:43:04,500 --> 00:43:17,280
La suma de los números desde 1 hasta, se escribe, se evalúa la expresión k, se escribe el resultado, se evalúa la expresión es, se escribe el resultado y se evalúa la expresión suma y es 6.

628
00:43:17,280 --> 00:43:25,500
Se evalúa, quiere decir que el programa hace ese proceso, ¿vale? Hace el proceso de entender qué es lo que tiene que hacer ahí, el resultado es simplemente el texto y lo escribo.

629
00:43:25,960 --> 00:43:32,219
Y ya estaría, y termina el programa. Pinta el algoritmo, me da la marca de ejecución finalizada y se acabó.

630
00:43:32,739 --> 00:43:40,079
Veis que he ejecutado el algoritmo pasito a pasito. También le puedo poner, en vez de con detalle, le puedo hacer esto, que avance.

631
00:43:40,079 --> 00:43:55,900
A ver, un segundito, le voy a dar aquí a comenzar. Vale. Y entonces ahora lo que va a hacer es, con esta velocidad, le voy a poner una velocidad un poquito más lenta, ¿vale? Para que veáis que él va a ir haciendo aquí la ejecución.

632
00:43:55,900 --> 00:44:14,900
Le pongo 8 para que sea más largo y fijaros lo que ocurre, va evaluando, va evaluando, repite, entra dentro del bucle, va haciendo, estos son los procesos, no te va poniendo ninguna salida porque son procesos internos que hace el programa, pero veis que ya está dentro del bucle, veis que está dentro del bucle, veis que está dentro del bucle.

633
00:44:14,900 --> 00:44:27,969
¿Hasta cuándo? Hasta que el número sea 8. Y cuando sea 8, voy a ver un poquito más rápido, ¿vale? Y cuando sea 8, saldrá del bucle y me pondrá simplemente el resultado.

634
00:44:29,309 --> 00:44:45,769
¿Vale? Debe estar a punto. Ahí está. 8, la suma de los números es 36. ¿De acuerdo? Veis que está súper chulo este programa porque me permite poner un algoritmo en formato de pseudocódigo y ejecutarlo y ver cuál es el resultado.

635
00:44:46,269 --> 00:45:00,329
Bien, vamos a hacer otro ejemplo, voy a quitarle esto del paso a paso ya, ¿vale? Entonces, vamos a ver el ejemplo del otro algoritmo que teníamos, que era este, ¿de acuerdo?

636
00:45:00,329 --> 00:45:06,090
el algoritmo un poquito más complicado. Como no quería estar aquí perdiendo la vida,

637
00:45:06,650 --> 00:45:16,130
vale, un segundito, vale, si yo no voy a cerrar este, no quiero guardar cambios, vale, yo

638
00:45:16,130 --> 00:45:20,869
ya me lo he preparado aquí, algoritmo B, vale, si no he equivocado es esto. Entonces,

639
00:45:20,969 --> 00:45:27,269
fijaros, yo ya le he puesto también un poco algunas cositas, vale, bueno, este es el programa,

640
00:45:27,269 --> 00:45:38,389
perdón, ese es el programa pelado, tal cual está, entonces, algoritmo B es leer n, si n es igual a 0, entonces escribimos factores de 0 igual a 1,

641
00:45:38,809 --> 00:45:48,929
y si no, bajamos hacia abajo, entramos en la siguiente condición, si n es mayor que 0, entonces entraríamos, y si no, escribimos número negativo y prueba con positivo.

642
00:45:48,929 --> 00:45:54,230
Y el bucle principal asignaría a p el valor 1, que sería esta caja.

643
00:45:55,030 --> 00:46:04,210
Repetimos, p es p por n y n es igual a n menos 1 y esto va a repetirse hasta que n sea igual a 1.

644
00:46:05,090 --> 00:46:09,510
Cuando n sea igual a 1 salimos y escribimos factorial igual a p y se acabó.

645
00:46:10,150 --> 00:46:12,409
Entonces voy a ejecutarlo para ver qué pasa.

646
00:46:12,409 --> 00:46:24,190
Voy a ponerle aquí un 4. Me dice 4 factorial 24, ¿vale? 4 por 3, 12, por 2, 24, por 1, 24. Perfecto. Funciona. Reiniciamos.

647
00:46:25,130 --> 00:46:33,969
Ahora le voy a poner un 0 factorial de 0 igual a 1. Claro, era el caso que me sacaba por esta rama, ¿verdad? Y me ponía factorial de 0 igual a 1. Perfecto.

648
00:46:34,969 --> 00:46:36,789
Después, le voy a poner un menos 4.

649
00:46:37,929 --> 00:46:40,170
Número negativo, prueba con positivos, perfecto.

650
00:46:40,530 --> 00:46:43,869
Está saliendo por esta rama de la condición con la cual está funcionando.

651
00:46:44,550 --> 00:46:45,630
Pero, ¿qué pasa si le pongo un 1?

652
00:46:48,619 --> 00:46:49,639
Se me ha quedado colgado.

653
00:46:50,440 --> 00:46:52,840
Veis que no devuelve nada, no hace nada, se queda flipado.

654
00:46:53,280 --> 00:46:53,599
¿Por qué?

655
00:46:54,039 --> 00:46:58,900
Porque es el caso que hemos detectado que era erróneo y que me metía en este bucle de forma infinita.

656
00:46:59,800 --> 00:47:00,000
¿Vale?

657
00:47:01,059 --> 00:47:03,099
Entonces, ¿cómo hacemos que eso no pase?

658
00:47:03,599 --> 00:47:04,619
Como os he dicho antes.

659
00:47:04,619 --> 00:47:32,809
Entonces, si yo pongo aquí, si n es igual a 0, o, que tengo aquí los operadores que puedo utilizar, o, ¿vale? Es que quería utilizar la forma correcta, o, n igual a 1, entonces voy a poner factorial igual a 1.

660
00:47:32,809 --> 00:47:35,030
ahora no pongo 0 porque no sé si es 0 o 1

661
00:47:35,030 --> 00:47:37,090
ya tengo ahí un pequeño problema

662
00:47:37,090 --> 00:47:39,469
¿veis? ahora, vamos a ver qué pasa ahora

663
00:47:39,469 --> 00:47:40,869
ejecución iniciada

664
00:47:40,869 --> 00:47:43,090
pongo 4, funciona, perfecto

665
00:47:43,090 --> 00:47:44,750
reiniciamos

666
00:47:44,750 --> 00:47:49,429
pongo un menos 5

667
00:47:49,429 --> 00:47:51,309
o menos 4, vale, negativo

668
00:47:51,309 --> 00:47:52,989
¿qué pasa si ahora pongo un 1?

669
00:47:54,210 --> 00:47:55,550
¡ay amigo! ahora funciona

670
00:47:55,550 --> 00:47:57,170
ya hemos protegido del caso

671
00:47:57,170 --> 00:47:58,949
de que n sea igual a 1

672
00:47:58,949 --> 00:48:00,849
y está funcionando el programa y lo hemos

673
00:48:00,849 --> 00:48:02,369
resuelto el problema

674
00:48:02,369 --> 00:48:04,050
yo además de esto

675
00:48:04,050 --> 00:48:08,909
le cogería y le añadiría una segunda variable, ¿vale?

676
00:48:08,969 --> 00:48:11,369
que es valor inicial, le voy a llamar v

677
00:48:11,369 --> 00:48:15,989
y entonces lo que voy a hacer es asignarle al valor inicial v

678
00:48:15,989 --> 00:48:17,730
para no perderlo, ¿de acuerdo?

679
00:48:17,909 --> 00:48:21,489
v, a v le voy a asignar n

680
00:48:21,489 --> 00:48:24,409
simplemente voy a coger el valor que introduce el usuario

681
00:48:24,409 --> 00:48:28,570
y lo voy a almacenar, ¿vale? dentro de la variable v

682
00:48:28,570 --> 00:48:31,250
entonces aquí cuando escriba el resultado voy a poner

683
00:48:31,250 --> 00:48:33,269
factorial de

684
00:48:33,269 --> 00:48:37,050
el valor v, que es el inicial

685
00:48:37,050 --> 00:48:39,030
que este no lo voy a cambiar en toda la ejecución

686
00:48:39,030 --> 00:48:40,769
es

687
00:48:40,769 --> 00:48:42,849
vale

688
00:48:42,849 --> 00:48:45,110
o si queréis lo ponemos en formato

689
00:48:45,110 --> 00:48:46,409
matemático, que queda más chulo

690
00:48:46,409 --> 00:48:49,030
v, que es el valor de

691
00:48:49,030 --> 00:48:49,449
la

692
00:48:49,449 --> 00:48:51,730
de la variable

693
00:48:51,730 --> 00:48:53,929
admiración

694
00:48:53,929 --> 00:48:56,989
igual, comillas

695
00:48:56,989 --> 00:48:58,150
coma

696
00:48:58,150 --> 00:49:02,489
en este caso sería, perdón

697
00:49:02,489 --> 00:49:29,929
1, en este caso sería igual a 1, entonces ponemos el número que está en el valor inicial con una admiración detrás que es el factorial es igual a 1, después aquí en este resultado, ahora ya sí que le puedo poner que lo mismo que antes, v, comillas, admiración, es igual a comillas, coma, y ahora le pongo aquí p, fijaros como me queda ahora,

698
00:49:29,929 --> 00:49:42,639
Y aquí, antes de leer este n, le voy a poner un escribir, porque si no, me quedo muy putre, introduce un número.

699
00:49:43,360 --> 00:49:47,800
Vale, entonces, ¿qué hemos hecho? Lo voy a poner aquí todo ya visto, ¿vale?

700
00:49:48,199 --> 00:49:51,820
¿Qué hemos hecho? Fijaros, introduzco un número y vamos a leer la variable.

701
00:49:51,980 --> 00:49:56,940
Y yo voy a almacenar ese valor para que no se me pierda en una variable adicional que es v.

702
00:49:56,940 --> 00:50:01,380
y después si n es 0 o n es 1

703
00:50:01,380 --> 00:50:02,320
entonces voy a poner

704
00:50:02,320 --> 00:50:05,500
el valor introducido inicialmente

705
00:50:05,500 --> 00:50:08,119
con una admiración detrás es igual a 1

706
00:50:08,119 --> 00:50:10,559
si no, que es esta salida

707
00:50:10,559 --> 00:50:12,699
si no, veo si es negativo

708
00:50:12,699 --> 00:50:14,860
y si no, repito el bucle, calculo el factorial

709
00:50:14,860 --> 00:50:16,739
y veo, entonces fijaros que ahora

710
00:50:16,739 --> 00:50:18,000
va a quedar mucho más mundo

711
00:50:18,000 --> 00:50:19,699
ah vale, no sé si es que

712
00:50:19,699 --> 00:50:22,780
como que no se encontró

713
00:50:22,780 --> 00:50:24,820
ah vale, pero aquí me falta

714
00:50:24,820 --> 00:50:28,300
me falta buena comida

715
00:50:28,300 --> 00:50:30,860
vale, entonces

716
00:50:30,860 --> 00:50:33,019
fijaros, introduzo el número

717
00:50:33,019 --> 00:50:34,460
le pongo un número

718
00:50:34,460 --> 00:50:36,699
6 y me dice 6 factorial

719
00:50:36,699 --> 00:50:39,019
igual a 720, perfecto, quedado ahí

720
00:50:39,019 --> 00:50:40,719
reiniciamos

721
00:50:40,719 --> 00:50:42,380
introduzo el número 1

722
00:50:42,380 --> 00:50:44,860
1 factorial es 1, perfecto

723
00:50:44,860 --> 00:50:46,019
reiniciamos

724
00:50:46,019 --> 00:50:48,579
0 factorial es 1

725
00:50:48,579 --> 00:50:50,820
ahora está super chulo, ahora ya queda

726
00:50:50,820 --> 00:50:52,900
mucho mejor la visualización del

727
00:50:52,900 --> 00:50:54,639
programa a través del espargonismo con

728
00:50:54,639 --> 00:50:56,539
de entradas y salidas más claras.

729
00:50:56,800 --> 00:50:58,480
Y si le pongo menos 3, pues me dice,

730
00:50:58,559 --> 00:50:59,880
número negativo, prueba compositiva.

731
00:51:00,739 --> 00:51:00,920
¿Vale?

732
00:51:01,380 --> 00:51:03,519
Otra mejora que yo le haría a este programa también,

733
00:51:03,659 --> 00:51:05,659
sería que este número negativo,

734
00:51:06,260 --> 00:51:08,420
este no, en vez de irme al final,

735
00:51:08,980 --> 00:51:11,380
yo le pondría que me viniera de nuevo al EDM.

736
00:51:11,920 --> 00:51:15,400
Es decir, que me volviera a insistir en la petición del número.

737
00:51:15,400 --> 00:51:17,780
Me diría, número negativo, prueba compositivos,

738
00:51:18,039 --> 00:51:20,260
y quedaría esperando el nuevo valor que yo le introduzca.

739
00:51:20,980 --> 00:51:21,199
¿Vale?

740
00:51:21,219 --> 00:51:22,539
Porque me dice prueba compositivos,

741
00:51:22,639 --> 00:51:23,860
pero me lleva al final del algoritmo,

742
00:51:23,860 --> 00:51:25,960
con lo cual es un poco absurdo, tengo que volverla a ejecutar

743
00:51:25,960 --> 00:51:27,639
¿vale? entonces

744
00:51:27,639 --> 00:51:29,639
esta orden de prueba con positivos

745
00:51:29,639 --> 00:51:31,639
es mejor llevarla a volver a pedir

746
00:51:31,639 --> 00:51:33,400
el, ¿vale? perdón

747
00:51:33,400 --> 00:51:35,420
la variable, por lo tanto

748
00:51:35,420 --> 00:51:36,840
esa

749
00:51:36,840 --> 00:51:39,340
esta

750
00:51:39,340 --> 00:51:41,320
comprobación yo la haría

751
00:51:41,320 --> 00:51:43,480
protegiendo el

752
00:51:43,480 --> 00:51:45,679
leer, esto es como yo lo haría

753
00:51:45,679 --> 00:51:47,860
¿de acuerdo? entonces, ¿qué voy a hacer?

754
00:51:48,559 --> 00:51:49,579
le voy a poner un

755
00:51:49,579 --> 00:51:51,699
repetir hasta

756
00:51:51,699 --> 00:51:53,480
¿de acuerdo?

757
00:51:53,860 --> 00:52:06,059
Y le voy a decir que me repita hasta que, bueno, voy a repetir esto, escribir, control, x, como aquí dentro, ¿vale?

758
00:52:06,059 --> 00:52:23,099
Voy a escribir, introducir el número y leer el número, ¿hasta cuándo? Hasta que n sea mayor, bueno, hasta que n sea mayor o igual que 0, ¿vale?

759
00:52:23,860 --> 00:52:38,719
Bien, si, como quiero ponerle el texto este, lo de número negativo, proba con positivos, este de aquí, si n es, ¿vale?

760
00:52:39,579 --> 00:52:43,619
Si, tengo que ponerle un sí, ¿vale?

761
00:52:45,199 --> 00:52:59,820
Si n es mayor que 0 estrictamente, no, es menor que 0, perdón, esto no es menor o igual, esto es menor,

762
00:52:59,820 --> 00:53:01,960
no voy a decir nada, ¿vale?

763
00:53:02,019 --> 00:53:03,699
hasta que n sea a no mayor o igual

764
00:53:03,699 --> 00:53:06,739
¿vale? entonces aquí le voy a poner

765
00:53:06,739 --> 00:53:08,320
esto, estoy reescribiendo simplemente

766
00:53:08,320 --> 00:53:09,719
la protección, ahora lo entendéis

767
00:53:09,719 --> 00:53:12,599
¿vale? estoy cambiando un poco de orden las cosas

768
00:53:12,599 --> 00:53:14,179
y si no, no va

769
00:53:14,179 --> 00:53:15,760
vale, entonces

770
00:53:15,760 --> 00:53:18,239
aquí asigno ahora

771
00:53:18,239 --> 00:53:19,579
el valor a proteger

772
00:53:19,579 --> 00:53:21,900
y esto ya simplemente

773
00:53:21,900 --> 00:53:23,679
si no, todo esto es

774
00:53:23,679 --> 00:53:31,440
es x

775
00:53:31,440 --> 00:53:33,920
este sí

776
00:53:33,920 --> 00:53:34,699
ahora ya no es

777
00:53:34,699 --> 00:53:37,780
Entonces, fijaros

778
00:53:37,780 --> 00:53:39,639
¿Qué es lo que estoy haciendo?

779
00:53:40,099 --> 00:53:41,239
¿Cómo me queda a mí mi programa?

780
00:53:41,460 --> 00:53:44,599
Me queda, voy a repetir, introduzco el número y leer la variable

781
00:53:44,599 --> 00:53:45,780
¿Vale?

782
00:53:46,320 --> 00:53:48,239
Voy a ver si es menor que 0

783
00:53:48,239 --> 00:53:51,500
Si es menor que 0, escribo número negativo, prueba con positivos

784
00:53:51,500 --> 00:53:55,760
Y esto del bucle lo voy a repetir hasta que n sea mayor o igual que 0

785
00:53:55,760 --> 00:53:56,659
¿Vale?

786
00:53:56,659 --> 00:54:00,239
Por lo cual voy a estar escribiendo el número negativo, prueba con positivos

787
00:54:00,239 --> 00:54:02,440
Hasta que n sea 0 o más que 0

788
00:54:03,300 --> 00:54:08,559
Después, v lo actualizo con la variable inicial, esto ya es lo mismo que antes.

789
00:54:09,059 --> 00:54:14,000
Si n es igual a 0 o n es igual a 1, pongo que el factorial es 1 y si no, pues le calculo su factorial.

790
00:54:14,539 --> 00:54:18,460
Esto tiene mucho más sentido porque he protegido las entradas y he pedido las peticiones,

791
00:54:18,619 --> 00:54:21,159
luego he comprobado el sí y luego me he metido en el sí.

792
00:54:21,719 --> 00:54:23,000
Fijaros cómo funciona ahora.

793
00:54:23,719 --> 00:54:30,880
A ver aquí, a ver si esto es válido.

794
00:54:31,420 --> 00:54:32,059
Creo que sí.

795
00:54:32,059 --> 00:54:54,860
Vale, introduce el número, el número va a ser menos 4, número negativo, prueba con positivos, introduce un número, perfecto, menos 3, menos 8, como soy tonto, pues ahora digo, ah, vale, venga, un número positivo es un 4, el factorial de 4 es 24, ¿de acuerdo?

796
00:54:54,860 --> 00:55:00,179
¿Vale? Reiniciamos. Introduce un número. Si le pongo el 0, me da factorial de 0 es 1.

797
00:55:00,380 --> 00:55:06,380
Si le pongo un 1, me da factorial de 1 es 1. Y si le pongo un número negativo, pues me dice que prevé con el número.

798
00:55:06,559 --> 00:55:09,599
Ahora está funcionando de una forma mejor. ¿Veis que tiene muchas mejoras? ¿Vale?

799
00:55:10,119 --> 00:55:14,400
Entonces, bueno, pues también así veis cómo se pueden mejorar, ¿vale? los programas.

800
00:55:14,699 --> 00:55:19,639
Esto de PSINT es una maravilla porque nos permite escribir los algoritmos de una forma sencilla.

801
00:55:19,639 --> 00:55:24,239
Me permite ver cómo me quedan. Fijaros en el diagrama de flujo ahora, cómo cambia.

802
00:55:24,860 --> 00:55:36,239
¿Vale? Entonces ahora el diagrama de flujo me queda como os he dicho. Voy a hacer un bucle en el cual hasta que n sea positivo voy a estar pidiendo el número,

803
00:55:36,380 --> 00:55:42,539
introduzco el número n y si es negativo pongo por pantalla simplemente el texto. ¿Veis cómo está hecho?

804
00:55:43,039 --> 00:55:50,400
Y luego lo que hago es simplemente, si n es 0 o 1, pongo que el factorial es 1 y si no, lo calculo con el algoritmo manual y se ha dado.

805
00:55:50,400 --> 00:55:52,719
de acuerdo, vale

806
00:55:52,719 --> 00:55:55,099
llevo mucho tiempo hablando, voy a ver si

807
00:55:55,099 --> 00:55:56,820
alguien se ha perdido, chat

808
00:55:56,820 --> 00:55:57,639
abierto

809
00:55:57,639 --> 00:56:00,519
has puesto algo de mal

810
00:56:00,519 --> 00:56:02,820
vale, sí

811
00:56:02,820 --> 00:56:05,059
a veces cometo pequeños

812
00:56:05,059 --> 00:56:06,900
errores, pero bueno, ya veis que al final el programa

813
00:56:06,900 --> 00:56:07,619
también te va dando

814
00:56:07,619 --> 00:56:10,199
esos errores, vale

815
00:56:10,199 --> 00:56:13,000
a ver, alguien tiene alguna

816
00:56:13,000 --> 00:56:14,760
pregunta, alguien tiene alguna duda

817
00:56:14,760 --> 00:56:16,880
sobre lo que hemos visto, vale

818
00:56:16,880 --> 00:56:19,059
ya estamos, ya lo hemos terminado

819
00:56:19,059 --> 00:56:23,019
ya esto es el final de la clase. Entonces, preguntas, venga,

820
00:56:23,139 --> 00:56:26,639
preguntas que tengáis sobre los algoritmos, sobre la forma de analizarlos,

821
00:56:26,860 --> 00:56:31,139
sobre cómo utilizar PSI. Os quiero enseñar, antes de

822
00:56:31,139 --> 00:56:35,019
acabar, una cosa, ¿vale? Si nos vamos a

823
00:56:35,019 --> 00:56:35,380
YouTube,

824
00:56:37,219 --> 00:56:42,360
voy a entrar, es que no, no veo Juanel.

825
00:56:43,400 --> 00:56:45,460
Vale, con las pantallas estas, vale, ahora.

826
00:56:45,460 --> 00:57:17,099
Entonces, si vamos a YouTube, ¿vale? Y buscáis Juanra, ¿vale? Y buscáis Juanra, ¿vale? No, Juanra García, ahí estoy, ¿vale?

827
00:57:17,099 --> 00:57:23,739
entráis en mi canal y veis que aquí tengo varios vídeos, tengo varias listas de reproducción.

828
00:57:23,940 --> 00:57:29,679
Entonces, bueno, en las listas de reproducción hay una concretamente que es la de programación, ¿de acuerdo?

829
00:57:30,320 --> 00:57:36,780
Y entonces esta lista de reproducción tiene pues algunos conceptos básicos sobre los diagramas de flujo,

830
00:57:36,780 --> 00:57:42,019
pero tiene, fijaros, esto que es la instalación del primer algoritmo con PSINT, este vídeo es el que os dice

831
00:57:42,019 --> 00:57:48,639
cómo descargaros e instalaros el PSINT y luego aquí os explico un poquito cómo funcionar con

832
00:57:48,639 --> 00:57:54,980
PSINT con los comandos básicos y los comandos avanzados y también cómo utilizar PSINT para

833
00:57:54,980 --> 00:58:01,940
poder programar algoritmos de control de robots. Pues los robots al final las entradas las cogen

834
00:58:01,940 --> 00:58:07,800
a través de sensores, las salidas son actuaciones sobre los dispositivos de salida, sobre los

835
00:58:07,800 --> 00:58:09,960
actuadores, con lo cual yo voy a activar

836
00:58:09,960 --> 00:58:11,719
o desactivar esos actuadores

837
00:58:11,719 --> 00:58:13,739
y el proceso

838
00:58:13,739 --> 00:58:15,960
intermedio es lo que yo hago con los

839
00:58:15,960 --> 00:58:18,059
valores que he leído de los sensores

840
00:58:18,059 --> 00:58:19,219
y que ando haciendo con variables

841
00:58:19,219 --> 00:58:21,800
para poder decidir si actúo

842
00:58:21,800 --> 00:58:23,780
o no actúo sobre los elementos

843
00:58:23,780 --> 00:58:25,780
de esa línea. Bueno, entonces eso

844
00:58:25,780 --> 00:58:27,239
un poquito aquí lo tenéis, ¿vale?

845
00:58:27,599 --> 00:58:29,639
Si queréis, pues bueno, son unos cuantos vídeos, esto

846
00:58:29,639 --> 00:58:31,980
lo estoy grabando para la gente de

847
00:58:31,980 --> 00:58:33,659
CPRPT, de proyectos

848
00:58:33,659 --> 00:58:35,239
tecnológicos, de robótica de cuarto,

849
00:58:35,860 --> 00:58:37,760
pero bueno, pues aquí también tenéis algo de información

850
00:58:37,760 --> 00:58:39,599
creo que os puede ser útil para vosotros, ¿de acuerdo?

851
00:58:40,559 --> 00:58:44,219
Y nada más, en principio esto es todo lo que tenía que contaros.

852
00:58:44,219 --> 00:58:47,179
Os voy a recordar que tenéis el blog, ¿vale?

853
00:58:48,719 --> 00:58:51,679
Tenéis el blog de clase.

854
00:58:52,420 --> 00:58:53,619
A ver, un segundito, perdón.

855
00:59:02,050 --> 00:59:07,340
¿Vale? En el blog, a ver si sale.

856
00:59:07,659 --> 00:59:10,019
Vale, en el blog vais a segundo bachillerato,

857
00:59:10,219 --> 00:59:13,960
es educa2madrid.org, Juan.Garcia146.

858
00:59:14,679 --> 00:59:39,440
Aquí tenéis, ¿vale? Toda la información de todo lo que os voy mandando. Aquí tenéis los vídeos sobre los diagramas de flujo y los organigramas, que son esos vídeos que os han dado a enseñar, ¿vale? Que estaría bien que los vierais. Y el trabajo de Scratch. Aquí tenéis todo lo que os voy poniendo. Bueno, pues os pondré esta clase y os pondré también, pues, los próximos trabajos que os voy a enseñar. ¿Vale?

859
00:59:40,159 --> 00:59:41,780
Bueno, chicos, pues nada más.

860
00:59:42,559 --> 00:59:44,960
Abro por aquí el chat por si me tenéis que decir algo.

861
00:59:45,800 --> 00:59:47,320
¿Vale? ¿Va a haber alguna clase más esta semana?

862
00:59:47,420 --> 00:59:51,199
No. En principio voy a hacer una clase como mucho a la semana.

863
00:59:51,739 --> 00:59:52,960
¿De acuerdo? Según lo vaya viendo.

864
00:59:53,639 --> 00:59:56,059
Y voy a intentar consolidar un poco todo en una clase.

865
00:59:56,440 --> 00:59:58,300
¿De acuerdo? Y luego ya os iré avisando.

866
00:59:58,420 --> 01:00:00,480
Como tengo el correo de todos vosotros, ¿vale?

867
01:00:01,260 --> 01:00:03,559
Os mando un correo y os mando la convocatoria.

868
01:00:03,559 --> 01:00:05,940
Lo que voy a hacer es que a partir de ahora

869
01:00:05,940 --> 01:00:08,199
siempre va a ser la clase en horario

870
01:00:08,199 --> 01:00:12,000
de clase vuestro, con lo cual así no me coincide

871
01:00:12,000 --> 01:00:14,840
con ningún otro profesor. Buscaré una de las dos horas

872
01:00:14,840 --> 01:00:17,860
o la del lunes o la del jueves, probablemente

873
01:00:17,860 --> 01:00:20,400
será la del lunes y en la hora del lunes

874
01:00:20,400 --> 01:00:23,920
haremos la clase, ¿vale? Tengo que ver si tengo

875
01:00:23,920 --> 01:00:26,880
material para dar la clase y si no, pues un poco con ejercicios

876
01:00:26,880 --> 01:00:29,239
y como lo íbamos haciendo, vamos a ver. ¿De acuerdo?

877
01:00:29,739 --> 01:00:32,380
¿Alguna pregunta más? ¿Tenéis alguien algo que decir?

878
01:00:32,380 --> 01:00:34,920
alguna mano arriba

879
01:00:34,920 --> 01:00:36,599
veo que nadie ha levantado la mano

880
01:00:36,599 --> 01:00:38,440
todavía, alguna cosita más

881
01:00:38,440 --> 01:00:40,860
cuidaros

882
01:00:40,860 --> 01:00:42,820
e intentar aprovechar

883
01:00:42,820 --> 01:00:44,380
al máximo el tiempo, que al final

884
01:00:44,380 --> 01:00:46,980
esto vuela y todavía no sabemos

885
01:00:46,980 --> 01:00:48,820
ni qué va a pasar con la evau, así que

886
01:00:48,820 --> 01:00:50,980
en principio se hará un poco más tarde

887
01:00:50,980 --> 01:00:52,579
pero eso va a ser, con lo cual no perdáis

888
01:00:52,579 --> 01:00:54,780
el ritmo, ¿vale?

889
01:00:55,559 --> 01:00:56,440
Pues venga, nada

890
01:00:56,440 --> 01:00:58,900
cuidaros y nos vemos en la próxima clase

891
01:00:58,900 --> 01:01:00,219
Venga, hasta luego

892
01:01:00,219 --> 01:01:00,980
Chao