1
00:00:00,000 --> 00:00:04,339
Vale, pues a ver

2
00:00:04,339 --> 00:00:06,580
Venga, concentración

3
00:00:06,580 --> 00:00:08,080
Porque de todos

4
00:00:08,080 --> 00:00:11,740
Algunos lo habréis hecho, pero de todos se puede sacar un aprendizaje

5
00:00:11,740 --> 00:00:16,120
A ver, ¿queréis hacer como que me escucháis?

6
00:00:18,460 --> 00:00:18,940
Vale

7
00:00:18,940 --> 00:00:21,239
Bueno, pues entonces, este cambia un poquito

8
00:00:21,239 --> 00:00:22,780
Sigue siendo contar

9
00:00:22,780 --> 00:00:26,320
Luego aquí va a haber una cuenta

10
00:00:26,320 --> 00:00:27,699
Eso sí o sí

11
00:00:27,699 --> 00:00:33,020
Porque este problema, este ejercicio sigue siendo contar algo

12
00:00:33,020 --> 00:00:41,219
Vale, ahora, mi espacio de muestra, mis candidatos a ser contados, ¿cuáles son?

13
00:00:41,979 --> 00:00:46,200
Todos los números comprendidos entre dos solicitados por teclado

14
00:00:46,200 --> 00:00:51,100
Ah, vale, pues ya tengo que leer del teclado, pues venga

15
00:00:51,100 --> 00:01:05,030
Vale, entonces, voy a coger esos dos datos de entrada

16
00:01:05,030 --> 00:01:09,650
el valor inicial

17
00:01:09,650 --> 00:01:15,870
¿vale?

18
00:01:21,700 --> 00:01:23,900
valor inicial de todos ellos

19
00:01:23,900 --> 00:01:25,040
y el valor final

20
00:01:25,040 --> 00:01:36,879
vale, n2

21
00:01:36,879 --> 00:01:39,879
bueno, ya tengo mis dos datos de entrada imprescindibles

22
00:01:39,879 --> 00:01:42,159
el valor inicial y el final

23
00:01:42,159 --> 00:01:43,879
de todo

24
00:01:43,879 --> 00:01:45,879
ese conjunto de elementos

25
00:01:45,879 --> 00:01:47,560
susceptibles de ser contados

26
00:01:47,560 --> 00:01:48,420
de toda mi muestra

27
00:01:48,420 --> 00:01:50,620
vale, entonces

28
00:01:50,620 --> 00:01:53,379
esto va a ser un bucle

29
00:01:53,379 --> 00:01:55,879
lógicamente que va haciendo aparecer

30
00:01:55,879 --> 00:01:57,400
esos elementos

31
00:01:57,400 --> 00:01:58,879
los va haciendo aparecer

32
00:01:58,879 --> 00:02:02,040
sí, sí, sí, pero voy por partes

33
00:02:02,040 --> 00:02:03,340
es como si estuviera haciendo

34
00:02:03,340 --> 00:02:04,379
el hilo de pensamiento

35
00:02:04,379 --> 00:02:07,159
yo voy haciendo primero la arquitectura del programa

36
00:02:07,159 --> 00:02:08,240
y la voy rellenando

37
00:02:08,240 --> 00:02:10,580
de alguna manera lo que intento es

38
00:02:10,580 --> 00:02:12,259
que eduquemos nuestra manera de pensar

39
00:02:12,259 --> 00:02:14,180
que en algunos casos el programa es sencillo

40
00:02:14,180 --> 00:02:15,219
y pues uno lo casca y ya está

41
00:02:15,219 --> 00:02:16,460
y le parece que ni ha pensado

42
00:02:16,460 --> 00:02:18,680
pero bueno, vamos a...

43
00:02:18,680 --> 00:02:20,340
vale, entonces, esto es contar

44
00:02:20,340 --> 00:02:22,500
entonces, esto va a ser una estructura

45
00:02:22,500 --> 00:02:23,180
de este estilo

46
00:02:23,180 --> 00:02:26,039
donde yo tengo que ir haciendo aquí aparecer

47
00:02:26,039 --> 00:02:28,199
los elementos susceptibles de contar

48
00:02:28,199 --> 00:02:30,180
los elementos susceptibles de contar

49
00:02:30,180 --> 00:02:31,319
son todos aquellos

50
00:02:31,319 --> 00:02:33,780
comprendidos entre N1 y N2

51
00:02:33,780 --> 00:02:35,740
luego, con lo que hemos visto

52
00:02:35,740 --> 00:02:36,840
en el ejercicio anterior

53
00:02:36,840 --> 00:02:40,280
pues yo diría, a ver, esta va a ser mi fuente de datos

54
00:02:40,280 --> 00:02:42,699
inicialmente

55
00:02:42,699 --> 00:02:44,360
que sea N1

56
00:02:44,360 --> 00:02:46,300
porque es el primero de todos

57
00:02:46,300 --> 00:02:48,180
en el ejercicio anterior

58
00:02:48,180 --> 00:02:49,479
N era 1

59
00:02:49,479 --> 00:02:51,099
porque yo iba entre 1 y 100

60
00:02:51,099 --> 00:02:52,939
aquí he cambiado

61
00:02:52,939 --> 00:02:55,080
ahora voy entre N1 y N2

62
00:02:55,080 --> 00:02:59,360
Es una extensión de este programa

63
00:02:59,360 --> 00:03:01,300
Donde este es N1

64
00:03:01,300 --> 00:03:03,099
Este es N2

65
00:03:03,099 --> 00:03:04,259
Y este sería el tercer dato

66
00:03:04,259 --> 00:03:08,659
N es mi fuente de datos

67
00:03:08,659 --> 00:03:10,319
Inicialmente es N1

68
00:03:10,319 --> 00:03:12,520
Y se va a ir incrementando

69
00:03:12,520 --> 00:03:13,879
Para ir generando todos

70
00:03:13,879 --> 00:03:18,080
¿Cuándo voy a terminar yo de generar

71
00:03:18,080 --> 00:03:19,039
Mis datos de entrada?

72
00:03:19,819 --> 00:03:22,460
Pues hasta que no haya

73
00:03:22,460 --> 00:03:23,419
Alcanzado N2

74
00:03:23,419 --> 00:03:26,080
Bueno pues me estoy apoyando

75
00:03:26,080 --> 00:03:27,659
la misma estructura del ejercicio anterior.

76
00:03:28,699 --> 00:03:31,840
Tengo que generar mis elementos a contar.

77
00:03:31,960 --> 00:03:33,860
Mis elementos a contar van a ser números.

78
00:03:34,400 --> 00:03:35,240
Luego los guardo aquí.

79
00:03:35,900 --> 00:03:38,439
Y los voy generando partiendo desde el N1

80
00:03:38,439 --> 00:03:41,599
e incrementándolos de uno en uno.

81
00:03:42,659 --> 00:03:43,659
¿Y cuándo?

82
00:03:43,819 --> 00:03:46,060
Pararé cuando N ya haya llegado a ser N2.

83
00:03:46,060 --> 00:03:48,620
Y ahora aquí me faltaría hacer la cuenta.

84
00:03:49,180 --> 00:03:51,800
¿Bajo qué condición incremento la cuenta?

85
00:03:53,300 --> 00:03:54,360
Pues me dicen,

86
00:03:54,360 --> 00:03:56,500
Oye, incrementa la cuenta

87
00:03:56,500 --> 00:03:57,780
Si ese numerito

88
00:03:57,780 --> 00:03:59,340
Que tú vas generando

89
00:03:59,340 --> 00:04:02,000
Si ese numerito es múltiplo de alguien

90
00:04:02,000 --> 00:04:04,560
Ah, vale, si este numerito es múltiplo

91
00:04:04,560 --> 00:04:05,099
De alguien

92
00:04:05,099 --> 00:04:07,740
Y la condición de ser múltiplo, ya sabemos que está

93
00:04:07,740 --> 00:04:09,219
Entonces

94
00:04:09,219 --> 00:04:11,599
Lo cuentas, ah, vale, vale

95
00:04:11,599 --> 00:04:14,300
Pues me falta el alguien, del cual tiene que ser

96
00:04:14,300 --> 00:04:15,599
Múltiplo para que yo sea

97
00:04:15,599 --> 00:04:17,720
Para que lo cuente, ah, vale, pues venga

98
00:04:17,720 --> 00:04:23,089
Lo pedimos aquí, por ejemplo

99
00:04:23,089 --> 00:04:32,470
Uy

100
00:04:32,470 --> 00:04:36,350
Vale, pues ya está

101
00:04:36,350 --> 00:04:38,089
Ya puedo completar la condición

102
00:04:38,089 --> 00:04:40,370
Mientras ese número sea múltiplo de m

103
00:04:40,370 --> 00:04:41,949
Ya está

104
00:04:41,949 --> 00:04:44,209
Y tengo una primera versión

105
00:04:44,209 --> 00:04:45,889
¿Vale?

106
00:04:45,930 --> 00:04:46,629
Tengo una primera

107
00:04:46,629 --> 00:04:53,870
Ah, que no está usado

108
00:04:53,870 --> 00:04:55,449
Vale, bueno, me falta mostrar el resultado

109
00:04:55,449 --> 00:05:01,250
Resultado

110
00:05:01,250 --> 00:05:05,519
Y tengo una primera versión

111
00:05:05,519 --> 00:05:07,180
Para la cual me he apoyado

112
00:05:07,180 --> 00:05:09,360
En problemas que ya he resuelto y ya sé hacer

113
00:05:09,360 --> 00:05:10,879
¿Vale?

114
00:05:10,899 --> 00:05:12,060
Como siempre hacemos

115
00:05:12,060 --> 00:05:14,379
uno pues va, según va haciendo

116
00:05:14,379 --> 00:05:16,259
aplicaciones, según va haciendo programas

117
00:05:16,259 --> 00:05:17,600
va resolviendo situaciones

118
00:05:17,600 --> 00:05:19,860
y ese aprendizaje

119
00:05:19,860 --> 00:05:22,500
ya se le queda instalado para apoyarse en él

120
00:05:22,500 --> 00:05:24,100
para luego resolver otras situaciones

121
00:05:24,100 --> 00:05:25,480
parecidas o similares

122
00:05:25,480 --> 00:05:28,519
pues aquí nos hemos aprovechado en este aprendizaje

123
00:05:28,519 --> 00:05:29,720
en el cual hemos contado

124
00:05:29,720 --> 00:05:32,199
números, ya sabemos

125
00:05:32,199 --> 00:05:33,319
cómo irlos generando

126
00:05:33,319 --> 00:05:35,620
pues desde el valor inicial

127
00:05:35,620 --> 00:05:37,199
hasta el final

128
00:05:37,199 --> 00:05:38,819
incrementando

129
00:05:38,819 --> 00:05:41,240
pues ya nos hemos

130
00:05:41,240 --> 00:05:43,180
apoyado en ese conocimiento, pues aquí

131
00:05:43,180 --> 00:05:44,939
la única diferencia es que el valor inicial

132
00:05:44,939 --> 00:05:46,720
ahora cambiaba, que era n1

133
00:05:46,720 --> 00:05:49,339
y el valor final cambiaba, que era n2

134
00:05:49,339 --> 00:05:51,100
pero la forma de generarlos

135
00:05:51,100 --> 00:05:52,819
era igual, partiendo el valor inicial

136
00:05:52,819 --> 00:05:54,180
incrementando hasta el final

137
00:05:54,180 --> 00:05:56,240
¿mi condición cuál era?

138
00:05:56,839 --> 00:05:58,939
ser múltiplo de, ah vale, ya sé cómo hacer

139
00:05:58,939 --> 00:06:00,300
la condición ser múltiplo de algo

140
00:06:00,300 --> 00:06:03,180
aquí lo único que me ha cambiado es que ese algo

141
00:06:03,180 --> 00:06:04,920
ahora no es 7

142
00:06:04,920 --> 00:06:06,939
sino que es un valor que he tenido que pedir

143
00:06:06,939 --> 00:06:09,040
¿vale? pero la estructura es la misma

144
00:06:09,040 --> 00:06:09,959
yo voy contando

145
00:06:09,959 --> 00:06:12,980
y cuando el bucle ha terminado tengo mi resultado

146
00:06:12,980 --> 00:06:14,819
final, hasta que el bucle ha terminado no tengo

147
00:06:14,819 --> 00:06:16,180
el resultado final ¿vale?

148
00:06:18,939 --> 00:06:19,379
entonces

149
00:06:19,379 --> 00:06:23,100
cuando pensáis en programar

150
00:06:23,100 --> 00:06:24,759
no

151
00:06:24,759 --> 00:06:26,959
tenéis que pensar

152
00:06:26,959 --> 00:06:28,740
en líneas de código

153
00:06:28,740 --> 00:06:30,300
en while, en leaf, en contador

154
00:06:30,300 --> 00:06:31,899
tenéis que pensar siempre

155
00:06:31,899 --> 00:06:34,860
en que vais incorporando patrones lógicos

156
00:06:34,860 --> 00:06:36,759
de alguna manera, vais incorporando patrones

157
00:06:36,759 --> 00:06:38,180
lógicos que luego vais aplicando

158
00:06:38,180 --> 00:06:40,220
si luego escribirlo es lo de menos

159
00:06:40,220 --> 00:06:42,660
pero pensar en términos de patrones que voy incorporando

160
00:06:42,660 --> 00:06:44,720
como contar, como sumar de forma acumulada

161
00:06:44,720 --> 00:06:45,240
como

162
00:06:45,240 --> 00:06:48,420
ir incrementando valores

163
00:06:48,420 --> 00:06:49,339
¿vale?

164
00:06:50,680 --> 00:06:52,360
bueno, pues esta ha sido una primera versión

165
00:06:52,360 --> 00:06:54,139
ahora lógicamente

166
00:06:54,139 --> 00:06:55,980
pues vienen varias cosas, primera

167
00:06:55,980 --> 00:06:58,839
que uno se dé cuenta de que igual puede simplificar

168
00:06:58,839 --> 00:07:00,079
un poquito a lo mejor

169
00:07:00,079 --> 00:07:01,100
¿vale?

170
00:07:02,860 --> 00:07:03,379
sí

171
00:07:03,379 --> 00:07:05,899
o

172
00:07:05,899 --> 00:07:07,980
que uno se ponga a hacer pruebas

173
00:07:07,980 --> 00:07:10,000
Y haciendo las pruebas vea si funciona

174
00:07:10,000 --> 00:07:13,139
Por ejemplo, vamos a ver todos los múltiplos de 2

175
00:07:13,139 --> 00:07:14,920
Entre 2

176
00:07:14,920 --> 00:07:16,620
Y 10

177
00:07:16,620 --> 00:07:18,720
Múltiplos de 2

178
00:07:18,720 --> 00:07:21,439
Me deberían salir 2, 4, 6, 8, 10, 5

179
00:07:21,439 --> 00:07:21,860
¿Verdad?

180
00:07:22,920 --> 00:07:24,120
Esta prueba la ha pasado

181
00:07:24,120 --> 00:07:26,660
¿Significa eso que mi programa

182
00:07:26,660 --> 00:07:27,399
Este bien?

183
00:07:28,199 --> 00:07:29,519
No, esta prueba la ha hecho

184
00:07:29,519 --> 00:07:31,920
Yo tendría que hacer más pruebas realmente

185
00:07:31,920 --> 00:07:34,860
Hombre, en este programa sencillo

186
00:07:34,860 --> 00:07:35,199
Vale

187
00:07:35,199 --> 00:07:37,740
Por ejemplo

188
00:07:37,740 --> 00:07:41,379
Pues yo que sé, entre 6 y 12

189
00:07:41,379 --> 00:07:45,480
¿Cuántos múltiplos de 3 tengo? Pues 3, 6, 9 y 12

190
00:07:45,480 --> 00:07:49,579
Vale, parece que, pero claro, uno tiene que hacer pruebas buscando también

191
00:07:49,579 --> 00:07:52,920
Los casos límite que se llaman, por ejemplo, oye

192
00:07:52,920 --> 00:07:57,100
¿Y si te voy a buscar las cosquillas? Vamos a ver

193
00:07:57,100 --> 00:08:01,660
Todos los múltiplos entre 4 y 1

194
00:08:01,660 --> 00:08:05,540
Todos los múltiplos de 4, aquí me deberían salir

195
00:08:05,540 --> 00:08:07,699
0, porque

196
00:08:07,699 --> 00:08:10,040
4 y 1 es un intervalo

197
00:08:10,040 --> 00:08:11,000
donde el valor inicial

198
00:08:11,000 --> 00:08:14,079
está después

199
00:08:14,079 --> 00:08:16,019
que el final, luego ese intervalo no tiene

200
00:08:16,019 --> 00:08:18,220
contenido, no tiene valores, me debería salir 0

201
00:08:18,220 --> 00:08:20,000
da la casualidad

202
00:08:20,000 --> 00:08:21,980
de que sale 0, claro, porque ¿qué ha ocurrido aquí?

203
00:08:22,100 --> 00:08:23,839
caso interesante de ver lo que ha hecho

204
00:08:23,839 --> 00:08:25,740
¿qué ha ocurrido aquí?

205
00:08:27,100 --> 00:08:27,819
pues que

206
00:08:27,819 --> 00:08:30,300
n1 es mayor que n2

207
00:08:30,300 --> 00:08:32,139
con lo cual jamás

208
00:08:32,139 --> 00:08:33,100
entra en el bucle

209
00:08:33,100 --> 00:08:35,460
luego la cuenta sigue siendo 0

210
00:08:35,460 --> 00:08:37,860
Pues que bien, que suerte

211
00:08:37,860 --> 00:08:39,419
Ha hecho de casualidad

212
00:08:39,419 --> 00:08:40,799
Porque yo no lo he buscado

213
00:08:40,799 --> 00:08:42,440
Ha hecho lo que tenía que hacer

214
00:08:42,440 --> 00:08:46,159
Si el valor inicial es mayor que el final

215
00:08:46,159 --> 00:08:48,279
No quiero que cuente nada

216
00:08:48,279 --> 00:08:50,620
Porque ahí no hay números en ese intervalo

217
00:08:50,620 --> 00:08:52,179
Y es que de hecho no los va a contar

218
00:08:52,179 --> 00:08:53,679
Porque n1

219
00:08:53,679 --> 00:08:54,799
Que es su valor inicial

220
00:08:54,799 --> 00:08:57,620
N1 ya es mayor que n2

221
00:08:57,620 --> 00:08:59,659
Luego jamás va a entrar en este bucle

222
00:08:59,659 --> 00:09:00,220
¿Vale?

223
00:09:01,840 --> 00:09:04,220
Luego, si n1 es

224
00:09:04,220 --> 00:09:07,399
mayor que n2

225
00:09:07,399 --> 00:09:09,340
nunca entraría al bucle

226
00:09:09,340 --> 00:09:16,519
con lo cual me sale contador 0

227
00:09:16,519 --> 00:09:19,220
vale, ese caso de prueba

228
00:09:19,220 --> 00:09:19,840
le he pasado

229
00:09:19,840 --> 00:09:22,879
pero nos podemos poner a

230
00:09:22,879 --> 00:09:24,340
forzar más casos raros

231
00:09:24,340 --> 00:09:26,120
va a la inicial 3

232
00:09:26,120 --> 00:09:28,600
va a la inicial 7, múltiplos de 0

233
00:09:28,600 --> 00:09:33,200
me sale un error de ejecución

234
00:09:33,200 --> 00:09:35,279
estas letras rojas

235
00:09:35,279 --> 00:09:36,820
significan que el programa ha petado

236
00:09:36,820 --> 00:09:39,019
porque le he obligado a hacer algo

237
00:09:39,019 --> 00:09:41,139
que no puede hacer

238
00:09:41,139 --> 00:09:42,759
y se ha roto

239
00:09:42,759 --> 00:09:45,120
entonces tenemos que evitar

240
00:09:45,120 --> 00:09:46,820
que los programas se rompan

241
00:09:46,820 --> 00:09:49,279
porque la imagen que da el que lo usa

242
00:09:49,279 --> 00:09:51,539
no es lo mismo que el programa me diga

243
00:09:51,539 --> 00:09:53,399
perdona, introdujiste un valor

244
00:09:53,399 --> 00:09:54,860
incorrecto, inténtalo otra vez

245
00:09:54,860 --> 00:09:56,440
no es lo mismo que me diga eso educadamente

246
00:09:56,440 --> 00:09:58,840
a que pum, se rompa

247
00:09:58,840 --> 00:10:00,299
y me salgan estas cosas rojas

248
00:10:00,299 --> 00:10:02,500
entonces, ¿por qué se ha roto?

249
00:10:03,240 --> 00:10:05,320
pues tendremos que mirar por qué se ha roto

250
00:10:05,320 --> 00:10:07,519
claro, porque

251
00:10:07,519 --> 00:10:09,480
en este caso

252
00:10:09,480 --> 00:10:11,620
m, que es el valor que yo he metido, era 0

253
00:10:11,620 --> 00:10:13,440
era 0, ¿verdad?

254
00:10:13,519 --> 00:10:14,259
he metido 0

255
00:10:14,259 --> 00:10:16,259
entonces

256
00:10:16,259 --> 00:10:22,019
esta operación hace una división

257
00:10:22,019 --> 00:10:23,639
de la cual se queda

258
00:10:23,639 --> 00:10:25,919
solo con el resto, es cierto, se queda solo con el resto

259
00:10:25,919 --> 00:10:27,460
pero hace una división

260
00:10:27,460 --> 00:10:29,480
con lo cual la división entre 0

261
00:10:29,480 --> 00:10:31,580
la máquina virtual no puede

262
00:10:31,580 --> 00:10:32,639
hacerla y se rompe

263
00:10:32,639 --> 00:10:36,320
Luego nunca deberíamos llegar a hacer una división por cero

264
00:10:36,320 --> 00:10:38,059
Entonces yo debería evitarlo antes

265
00:10:38,059 --> 00:10:40,679
Hombre, puedo

266
00:10:40,679 --> 00:10:44,039
Por ejemplo, primera forma de evitarlo

267
00:10:44,039 --> 00:10:46,139
Confiar en la bondad

268
00:10:46,139 --> 00:10:46,940
De la humanidad

269
00:10:46,940 --> 00:10:48,980
Y decir, si yo le pido

270
00:10:48,980 --> 00:10:51,059
Que me lo meta distinto de cero

271
00:10:51,059 --> 00:10:53,139
Por favor, voy a confiar en que lo va a hacer

272
00:10:53,139 --> 00:10:59,139
Bueno, hay múltiplos de menos tres también

273
00:10:59,139 --> 00:11:04,159
No, porque este es el valor múltiplo,

274
00:11:04,279 --> 00:11:06,539
no el inicial y el final del intervalo.

275
00:11:11,360 --> 00:11:12,460
Pero vamos, que puedes poner

276
00:11:12,460 --> 00:11:14,179
un inicial menos 3 y 4

277
00:11:14,179 --> 00:11:15,980
y no pasa nada, entre menos 3 y 4

278
00:11:15,980 --> 00:11:18,220
todos los comprendidos que sean múltiplos del que sea.

279
00:11:21,759 --> 00:11:23,159
Es que no lo haces entre 0,

280
00:11:23,639 --> 00:11:25,720
porque este no cambia nunca,

281
00:11:25,960 --> 00:11:26,820
este es inamovible.

282
00:11:27,580 --> 00:11:30,559
El que va cambiando es el n,

283
00:11:30,940 --> 00:11:31,539
el que está aquí,

284
00:11:32,000 --> 00:11:32,779
en el dividendo.

285
00:11:32,779 --> 00:11:34,120
este jamás cambia

286
00:11:34,120 --> 00:11:37,340
este es el número del cual tú quieres ver si es múltiplo

287
00:11:37,340 --> 00:11:39,139
si te han metido 7, va a ser siempre 7

288
00:11:39,139 --> 00:11:40,139
jamás cambia

289
00:11:40,139 --> 00:11:42,139
el que cambia es

290
00:11:42,139 --> 00:11:43,919
el dividendo

291
00:11:43,919 --> 00:11:46,120
entonces

292
00:11:46,120 --> 00:11:49,360
tú puedes, pues eso, confiar en la humanidad

293
00:11:49,360 --> 00:11:53,259
vale, pues hombre, podemos confiar

294
00:11:53,259 --> 00:11:55,159
en la humanidad, pero claro

295
00:11:55,159 --> 00:11:56,019
lógicamente

296
00:11:56,019 --> 00:11:59,139
pues, aunque yo le diga distinto

297
00:11:59,139 --> 00:11:59,639
de cero

298
00:11:59,639 --> 00:12:02,159
Pues él se le puede ir la mano

299
00:12:02,159 --> 00:12:03,419
Y seguiría fallando

300
00:12:03,419 --> 00:12:06,059
¿Qué podemos hacer

301
00:12:06,059 --> 00:12:07,279
Para hacerlo ya súper guay?

302
00:12:09,519 --> 00:12:09,960
Obligarlo

303
00:12:09,960 --> 00:12:11,740
Con un bucle de validación

304
00:12:11,740 --> 00:12:13,059
Como ya sabemos bucles

305
00:12:13,059 --> 00:12:16,159
Que este scan next in no se quede aquí

306
00:12:16,159 --> 00:12:18,019
En un ingenuo scan next in

307
00:12:18,019 --> 00:12:20,259
Vamos a meterlo en un bucle

308
00:12:20,259 --> 00:12:22,360
Que esté ahí todo el rato y mientras no me meta

309
00:12:22,360 --> 00:12:24,440
Uno diferente de cero, yo de ahí no salgo

310
00:12:24,440 --> 00:12:26,299
¿Vale? Este fue el primer

311
00:12:26,299 --> 00:12:28,259
Ejemplo que vimos el viernes cuando vimos bucles

312
00:12:28,259 --> 00:12:31,480
un bucle que valida que el dato cumpla una condición

313
00:12:31,480 --> 00:12:33,759
pues hombre, si yo quiero hacer este programa

314
00:12:33,759 --> 00:12:36,019
completamente robusto

315
00:12:36,019 --> 00:12:40,159
y que no tenga errores horribles

316
00:12:40,159 --> 00:12:42,379
de romperse como este

317
00:12:42,379 --> 00:12:44,559
es que no me queda más remedio

318
00:12:44,559 --> 00:12:49,600
o meto este scan next in en un bucle

319
00:12:49,600 --> 00:12:51,440
o la hemos liado

320
00:12:51,440 --> 00:12:54,120
no pasa nada, vamos a meterlo en un bucle

321
00:12:54,120 --> 00:12:56,480
ya lo hicimos ayer, entonces de nuevo

322
00:12:56,480 --> 00:12:59,279
nos estamos apoyando todo el rato

323
00:12:59,279 --> 00:13:00,259
para hacer las cosas

324
00:13:00,259 --> 00:13:02,879
en cosas que ya hemos resuelto

325
00:13:02,879 --> 00:13:05,019
conclusión

326
00:13:05,019 --> 00:13:06,899
uno tiene que hacerlo todo

327
00:13:06,899 --> 00:13:08,940
mirarlo todo y quedárselo aquí

328
00:13:08,940 --> 00:13:09,620
en la cabeza

329
00:13:09,620 --> 00:13:13,120
para programar la habilidad

330
00:13:13,120 --> 00:13:14,279
más importante

331
00:13:14,279 --> 00:13:16,460
primero es la memoria

332
00:13:16,460 --> 00:13:18,580
aprender, aprender, aprender

333
00:13:18,580 --> 00:13:20,639
estudiar de memoria siempre

334
00:13:20,639 --> 00:13:21,120
todo

335
00:13:21,120 --> 00:13:23,419
y segundo la lógica

336
00:13:23,419 --> 00:13:25,679
porque parece que la memoria no sirve para nada

337
00:13:25,679 --> 00:13:28,460
memoria fundamental, uno no puede programar

338
00:13:28,460 --> 00:13:29,879
si no tiene conocimientos aquí

339
00:13:29,879 --> 00:13:32,320
no teóricos, conocimientos de problemas

340
00:13:32,320 --> 00:13:34,279
que ya he resuelto todos aquí para ir tirando

341
00:13:34,279 --> 00:13:34,700
del hilo

342
00:13:34,700 --> 00:13:38,120
y luego ya le aplica la lógica

343
00:13:38,120 --> 00:13:40,039
para componerlos, pero primero

344
00:13:40,039 --> 00:13:41,899
tiene que tenerlo en la cabeza, luego ya

345
00:13:41,899 --> 00:13:43,679
viene la lógica donde tú los compones

346
00:13:43,679 --> 00:13:45,779
bueno pues como ya vimos

347
00:13:45,779 --> 00:13:47,899
el viernes como hacer una

348
00:13:47,899 --> 00:13:49,740
validación, dijimos

349
00:13:49,740 --> 00:13:51,500
oye pues tú te haces aquí un do while

350
00:13:51,500 --> 00:13:55,500
maravilloso, me haces

351
00:13:55,500 --> 00:13:56,559
un do while

352
00:13:56,559 --> 00:13:59,279
Mientras mi numerito M

353
00:13:59,279 --> 00:14:00,639
Sea igual a 0

354
00:14:00,639 --> 00:14:04,940
La declaración la saco fuera, ¿verdad?

355
00:14:11,220 --> 00:14:11,940
¡Hala! Ya está

356
00:14:11,940 --> 00:14:13,899
Ahora este programa

357
00:14:13,899 --> 00:14:16,179
No se va a romper nunca por la

358
00:14:16,179 --> 00:14:18,720
Por la división aritmética

359
00:14:18,720 --> 00:14:20,460
Porque este bucle

360
00:14:20,460 --> 00:14:22,600
Va a estar aquí pidiendo número, pidiendo número

361
00:14:22,600 --> 00:14:23,379
Pidiendo número

362
00:14:23,379 --> 00:14:26,340
Mientras el número sea 0

363
00:14:26,340 --> 00:14:28,559
Todo el rato ahí

364
00:14:28,559 --> 00:14:31,250
De hecho

365
00:14:31,250 --> 00:14:36,850
No puede ser cero

366
00:14:36,850 --> 00:14:40,350
Intenta otra vez

367
00:14:40,350 --> 00:14:44,129
Y ahí va a estar todo el rato

368
00:14:44,129 --> 00:14:45,710
Le número

369
00:14:45,710 --> 00:14:48,090
Perdón

370
00:14:48,090 --> 00:14:49,309
Este no puede ser

371
00:14:49,309 --> 00:14:52,330
No puede ser cero

372
00:14:52,330 --> 00:14:54,470
Será si el numerito metido

373
00:14:54,470 --> 00:14:55,309
Es igual a cero

374
00:14:55,309 --> 00:15:06,500
Ya está

375
00:15:06,500 --> 00:15:08,240
Ya lo tengo validado

376
00:15:08,240 --> 00:15:10,419
Entonces vamos a volver a ejecutar esto

377
00:15:10,419 --> 00:15:14,559
Hay algún

378
00:15:14,559 --> 00:15:18,200
Tengo el

379
00:15:18,200 --> 00:15:20,980
Hay una llave que me

380
00:15:20,980 --> 00:15:24,419
Do while

381
00:15:24,419 --> 00:15:26,700
Ah, vale, la llave del while es la que me falta

382
00:15:26,700 --> 00:15:28,220
Esta, vale

383
00:15:28,220 --> 00:15:30,919
Vale, pues ahora ya sí

384
00:15:30,919 --> 00:15:32,059
Ejecutamos

385
00:15:32,059 --> 00:15:34,460
Valor inicial, cuatro

386
00:15:34,460 --> 00:15:36,320
Valor final, nueve

387
00:15:36,320 --> 00:15:38,860
Cero, no puede ser cero

388
00:15:38,860 --> 00:15:41,120
No puede ser cero, no puede ser cero

389
00:15:41,120 --> 00:15:42,860
No puede ser cero, ahí está el infinito

390
00:15:42,860 --> 00:15:44,279
Cuatro

391
00:15:44,279 --> 00:15:49,460
¡Hala! Ya está

392
00:15:49,460 --> 00:15:52,179
Ahí está todo el rato, no puede ser cero

393
00:15:52,179 --> 00:15:53,379
No puede ser cero, no puede ser cero

394
00:15:53,379 --> 00:15:56,360
¿Vale? Ahí, validando, validando, validando

395
00:15:56,360 --> 00:15:57,639
¿Perdón?

396
00:15:58,980 --> 00:15:59,779
Espero, espero

397
00:15:59,779 --> 00:16:08,220
Bueno, pues haciendo las pruebas

398
00:16:08,220 --> 00:16:09,539
Hemos visto

399
00:16:09,539 --> 00:16:11,480
Que para algún caso de prueba

400
00:16:11,480 --> 00:16:13,379
Esto petaba, que no me gusta que pete

401
00:16:13,379 --> 00:16:15,039
Pues hemos puesto esta validación

402
00:16:15,039 --> 00:16:16,580
Y ya está, muy bien

403
00:16:16,580 --> 00:16:17,759
vale

404
00:16:17,759 --> 00:16:21,279
el otro caso de prueba

405
00:16:21,279 --> 00:16:23,399
que hemos dicho, que nos ha salido de casualidad

406
00:16:23,399 --> 00:16:25,220
vamos a

407
00:16:25,220 --> 00:16:27,159
aprovechar, por ejemplo, el caso de prueba

408
00:16:27,159 --> 00:16:28,279
que hemos dicho de

409
00:16:28,279 --> 00:16:31,159
voy a meter un valor inicial

410
00:16:31,159 --> 00:16:33,240
8 mayor que

411
00:16:33,240 --> 00:16:34,259
el final, 2

412
00:16:34,259 --> 00:16:36,840
entonces me sale el resultado 0

413
00:16:36,840 --> 00:16:38,580
porque no hay múltiplos

414
00:16:38,580 --> 00:16:41,559
entre 8 y 2 porque 2 va antes de 8

415
00:16:41,559 --> 00:16:43,360
pero bueno, vamos a hacerle

416
00:16:43,360 --> 00:16:45,120
un pequeño tuneo al

417
00:16:45,120 --> 00:16:46,360
programa que es, oye

418
00:16:46,360 --> 00:16:49,600
si te han metido el inicial

419
00:16:49,600 --> 00:16:51,019
más grande que el final

420
00:16:51,019 --> 00:16:53,299
vamos a asumir que entonces queremos

421
00:16:53,299 --> 00:16:55,059
intercambiar uno por otro

422
00:16:55,059 --> 00:16:57,740
¿no? podría ser un requisito

423
00:16:57,740 --> 00:16:59,379
que me dice, le digo yo al cliente

424
00:16:59,379 --> 00:17:01,440
oye, si el valor

425
00:17:01,440 --> 00:17:03,460
inicial que ha metido es mayor que el final

426
00:17:03,460 --> 00:17:06,779
asumo

427
00:17:06,779 --> 00:17:09,559
entonces cero, porque ese intervalo no tiene

428
00:17:09,559 --> 00:17:11,440
nada dentro, no, no, asume

429
00:17:11,440 --> 00:17:13,279
que se ha equivocado, es decir

430
00:17:13,279 --> 00:17:15,460
vamos a turnar el programa para que

431
00:17:15,460 --> 00:17:24,880
Tú le metas dos valores y el más pequeño te lo cuentes siempre como el inicial y el mayor como el final, ¿vale?

432
00:17:25,119 --> 00:17:28,380
Y así se queda un programa más robusto, ¿vale?

433
00:17:29,279 --> 00:17:35,640
Luego, ¿vale?

434
00:17:36,380 --> 00:17:38,299
Entonces, el enunciado se quedaría así.

435
00:17:38,299 --> 00:17:59,339
Vamos a contar todos los múltiplos entre dos números leídos por teclado.

436
00:18:03,349 --> 00:18:07,730
Siempre entre el menor y el mayor.

437
00:18:08,930 --> 00:18:09,849
¿Vale?

438
00:18:10,930 --> 00:18:12,349
Entre el menor y el mayor.

439
00:18:12,490 --> 00:18:14,930
Si me dan 8 y 2, pues entre 2 y 8.

440
00:18:14,930 --> 00:18:17,829
Si me dan 4 y 7, entre 4 y 7.

441
00:18:17,930 --> 00:18:20,509
Si me dan 7 y 15, entre 7 y 15.

442
00:18:21,329 --> 00:18:22,849
Independientemente de los números que me den,

443
00:18:23,410 --> 00:18:25,490
yo voy a contar todos los múltiplos comprendidos,

444
00:18:25,549 --> 00:18:26,630
el más pequeño y el mayor.

445
00:18:27,470 --> 00:18:28,750
Entendéis la modificación, ¿no?

446
00:18:28,829 --> 00:18:30,210
Para que el programa sea más robusto.

447
00:18:32,250 --> 00:18:35,750
Luego, el valor inicial, valor final,

448
00:18:35,890 --> 00:18:37,130
en este caso lo vamos a tomar,

449
00:18:37,930 --> 00:18:39,869
que puede ser que los tenga yo que intercambiar.

450
00:18:41,430 --> 00:18:42,369
Bueno, pues entonces,

451
00:18:42,789 --> 00:18:45,930
si yo quiero que mi programa funcione así,

452
00:18:45,930 --> 00:18:48,630
vamos a tener que hacer esto

453
00:18:48,630 --> 00:18:51,109
si resulta que

454
00:18:51,109 --> 00:18:53,430
n1 me lo han dado

455
00:18:53,430 --> 00:18:55,329
mayor

456
00:18:55,329 --> 00:18:56,809
que n2

457
00:18:56,809 --> 00:18:59,490
los tenemos que intercambiar

458
00:18:59,490 --> 00:19:01,910
¿verdad? los tenemos que intercambiar

459
00:19:01,910 --> 00:19:05,839
si n1

460
00:19:05,839 --> 00:19:07,000
es mayor que n2

461
00:19:07,000 --> 00:19:09,900
quiero intercambiarlos, para no tener que tocar

462
00:19:09,900 --> 00:19:10,859
el resto del programa

463
00:19:10,859 --> 00:19:13,500
que lo que haya en n2

464
00:19:13,500 --> 00:19:14,720
pasa a n1

465
00:19:14,720 --> 00:19:17,079
y lo que haya en n1 pasa a n2

466
00:19:17,079 --> 00:19:18,539
¿vale?

467
00:19:19,759 --> 00:19:21,680
¿entendéis que si con ese tuneo

468
00:19:21,680 --> 00:19:23,700
que a mí me dan dos números N1 y N2

469
00:19:23,700 --> 00:19:25,440
y siempre

470
00:19:25,440 --> 00:19:27,500
quiero contar los múltiplos entre el pequeño

471
00:19:27,500 --> 00:19:29,500
y el mayor, pues si N1

472
00:19:29,500 --> 00:19:31,119
es menor que N2 no pasa nada

473
00:19:31,119 --> 00:19:33,380
mi programa pues

474
00:19:33,380 --> 00:19:34,740
tranquilamente funcionará

475
00:19:34,740 --> 00:19:38,480
partiendo de N1

476
00:19:38,480 --> 00:19:40,519
mientras sea menor que N2

477
00:19:40,519 --> 00:19:41,539
tranquilamente

478
00:19:41,539 --> 00:19:44,759
pero si N1 es mayor que N2

479
00:19:44,759 --> 00:19:46,799
los quiero intercambiar yo

480
00:19:46,799 --> 00:19:48,720
de posición, es decir, quiero que

481
00:19:48,720 --> 00:19:50,740
el pequeño vaya siempre

482
00:19:50,740 --> 00:19:51,640
a n1

483
00:19:51,640 --> 00:20:00,579
menor valor

484
00:20:00,579 --> 00:20:03,119
esté

485
00:20:03,119 --> 00:20:03,759
en

486
00:20:03,759 --> 00:20:06,539
n1

487
00:20:06,539 --> 00:20:08,599
y el

488
00:20:08,599 --> 00:20:10,839
mayor valor

489
00:20:10,839 --> 00:20:12,900
en

490
00:20:12,900 --> 00:20:15,039
n2, vale

491
00:20:15,039 --> 00:20:17,200
esto es un

492
00:20:17,200 --> 00:20:19,039
if, porque si se cumple

493
00:20:19,039 --> 00:20:21,019
esta condición, tengo que intercambiarlos

494
00:20:21,019 --> 00:20:23,220
pues esto ya es hacer un código con un if

495
00:20:23,220 --> 00:20:27,039
y la pregunta es, ¿sabríais hacerlo?

496
00:20:30,470 --> 00:20:33,230
Bueno, pues esto hasta aquí lógicamente

497
00:20:33,230 --> 00:20:34,690
todo el mundo ha llegado y es,

498
00:20:35,630 --> 00:20:38,430
si n1 es mayor que n2, tengo que hacer algo.

499
00:20:39,150 --> 00:20:41,390
Tengo que hacer algo, que es intercambiar los valores.

500
00:20:42,829 --> 00:20:44,230
Entonces, lógicamente,

501
00:20:44,849 --> 00:20:47,390
uno que no piensa,

502
00:20:48,150 --> 00:20:50,210
pues le sale a escribir esto que es absolutamente absurdo.

503
00:20:50,589 --> 00:20:51,309
Lógicamente, ¿verdad?

504
00:20:52,589 --> 00:21:12,180
Si uno escribe esto, ha escrito una tontería muy gorda, porque este es N1 que tiene el 7, por ejemplo, y este es N2 que tiene el 3.

505
00:21:13,000 --> 00:21:16,440
Este if sería true porque N1 es mayor que N2.

506
00:21:17,200 --> 00:21:22,480
Entonces, si hacemos esas sentencias, a N1 le damos lo que tiene N2.

507
00:21:22,480 --> 00:21:24,579
muy bien, N1

508
00:21:24,579 --> 00:21:26,299
se queda pisado

509
00:21:26,299 --> 00:21:28,099
y ahora se queda con 3

510
00:21:28,099 --> 00:21:29,940
por lo hemos enseñado lo de N2

511
00:21:29,940 --> 00:21:32,500
y ahora, a N2 le damos

512
00:21:32,500 --> 00:21:34,380
lo que tiene N1, pero es que le queremos dar

513
00:21:34,380 --> 00:21:35,359
lo que tenía de antes

514
00:21:35,359 --> 00:21:37,839
y lo que tenía de antes ha desaparecido

515
00:21:37,839 --> 00:21:39,680
entonces si a N2 le damos N1

516
00:21:39,680 --> 00:21:41,779
a N2 le volvemos a dar su 3

517
00:21:41,779 --> 00:21:44,660
con lo cual, lo que tenía el N1

518
00:21:44,660 --> 00:21:46,700
de antes, lo hemos tirado a la basura

519
00:21:46,700 --> 00:21:48,579
no podemos

520
00:21:48,579 --> 00:21:50,460
recuperarlo para dárselo a N2

521
00:21:50,460 --> 00:21:52,220
otra vez, ¿qué nos falta?

522
00:21:52,480 --> 00:21:59,319
Pues una tercera variable para este no perderlo, para este no perderlo.

523
00:21:59,859 --> 00:22:01,019
Entonces, ¿qué queremos?

524
00:22:01,359 --> 00:22:07,960
Sí, a n1 le queremos dar lo que tiene n2, pero antes querremos haber guardado este 7 antes, para no perderlo.

525
00:22:08,519 --> 00:22:12,559
Oye, vamos a llevar este 7 antes, aquí, antes.

526
00:22:13,759 --> 00:22:17,839
Entonces, nos falta aquí antes llevarlo a una variable para que no se pierda.

527
00:22:17,839 --> 00:22:20,519
el 7 que tenía

528
00:22:20,519 --> 00:22:22,440
vamos a llevarlo a una variable aus

529
00:22:22,440 --> 00:22:23,480
para que no te pierdas

530
00:22:23,480 --> 00:22:26,900
ahora ya sí a n1 le meto n2

531
00:22:26,900 --> 00:22:27,759
ahora ya sí

532
00:22:27,759 --> 00:22:30,880
y el 7 que estaba aquí guardadito

533
00:22:30,880 --> 00:22:33,519
a la espera, ahora ya lo recupero

534
00:22:33,519 --> 00:22:35,880
y se lo paso a n2

535
00:22:35,880 --> 00:22:37,900
ahora ya lo recupero y se lo paso a n2

536
00:22:37,900 --> 00:22:38,400
¿vale?

537
00:22:39,420 --> 00:22:40,660
entonces una variable intermedia

538
00:22:40,660 --> 00:22:45,019
entonces Python tiene una

539
00:22:45,019 --> 00:22:47,420
forma de hacerlo a la vez

540
00:22:47,420 --> 00:22:52,299
Sí, porque como es para vagos

541
00:22:52,299 --> 00:22:56,500
No recuerdo qué operador es el de intercambiar

542
00:22:56,500 --> 00:22:58,759
Es un operador

543
00:22:58,759 --> 00:23:00,519
Que te intercambia el valor de una variable por otra

544
00:23:00,519 --> 00:23:02,160
No recuerdo qué operador es

545
00:23:02,160 --> 00:23:03,960
No

546
00:23:03,960 --> 00:23:07,640
Porque Java es para listos

547
00:23:11,640 --> 00:23:12,200
Entonces

548
00:23:12,200 --> 00:23:14,279
Python ofrece muchos atajos

549
00:23:14,279 --> 00:23:14,940
Muchas cosas

550
00:23:14,940 --> 00:23:18,339
Mucha simplificación

551
00:23:18,339 --> 00:23:20,400
Entonces te evites

552
00:23:20,400 --> 00:23:21,859
La que no piensas

553
00:23:21,859 --> 00:23:22,539
Entonces es muy

554
00:23:22,539 --> 00:23:29,109
Vale, pues entonces

555
00:23:29,109 --> 00:23:31,430
Esto por tanto, me falta esto de aquí

556
00:23:31,430 --> 00:23:35,769
Vamos a guardar

557
00:23:35,769 --> 00:23:37,309
Primero lo que hay en N1

558
00:23:37,309 --> 00:23:39,589
Ahora ya se lo pisoteo

559
00:23:39,589 --> 00:23:41,190
Se lo pisoteo

560
00:23:41,190 --> 00:23:42,970
Y ahora ya

561
00:23:42,970 --> 00:23:45,670
Ese valor

562
00:23:45,670 --> 00:23:48,009
Reservado, que estaba ahí reservadito

563
00:23:48,009 --> 00:23:49,650
Se lo paso en el 2

564
00:23:49,650 --> 00:23:52,230
Pues ahora ya ese caso de prueba

565
00:23:52,230 --> 00:23:54,349
Lo va a pasar

566
00:23:54,349 --> 00:23:58,029
Todos los múltiplos de 2

567
00:23:58,029 --> 00:24:00,009
Comprendidos entre 8 y 2

568
00:24:00,009 --> 00:24:02,390
Perfecto

569
00:24:02,390 --> 00:24:04,109
Aunque mi valor inicial era mayor

570
00:24:04,109 --> 00:24:05,730
No pasa nada, lo ha intercambiado

571
00:24:05,730 --> 00:24:07,210
¿Vale?

572
00:24:20,119 --> 00:24:22,759
Pues todo el programa completo está claro

573
00:24:22,759 --> 00:24:26,200
¿Quién ha dicho no?

574
00:24:26,200 --> 00:24:27,619
Yo he pensado en un poco más pequeño

575
00:24:27,619 --> 00:24:29,059
Para el valor de la nota

576
00:24:29,059 --> 00:24:45,220
A ver, y por último, por último, por último, uno ya podría decir, uy, la verdad es que estoy usando variables de más.

577
00:24:45,700 --> 00:24:46,460
No pasa nada.

578
00:24:46,720 --> 00:24:48,940
Esta versión está estupenda y está muy bien porque es muy clara.

579
00:24:49,759 --> 00:24:51,700
Uno podría decir, estoy usando variables de más.

580
00:24:51,700 --> 00:24:54,059
y es, este valor

581
00:24:54,059 --> 00:24:56,319
n que yo me he inventado

582
00:24:56,319 --> 00:24:56,660
aquí

583
00:24:56,660 --> 00:25:00,240
para empezar valiendo el n1

584
00:25:00,240 --> 00:25:02,200
y irse incrementando

585
00:25:02,200 --> 00:25:04,259
es que puedo usar

586
00:25:04,259 --> 00:25:05,839
ya la propia variable n1

587
00:25:05,839 --> 00:25:07,099
¿verdad?

588
00:25:09,220 --> 00:25:10,200
es decir

589
00:25:10,200 --> 00:25:10,920
mi variable

590
00:25:10,920 --> 00:25:13,259
claro

591
00:25:13,259 --> 00:25:16,460
o sea, yo ahora, esto se ha quedado

592
00:25:16,460 --> 00:25:20,509
vale

593
00:25:20,509 --> 00:25:32,819
Vale, yo tenía mis datos de entrada

594
00:25:32,819 --> 00:25:33,420
Que son

595
00:25:33,420 --> 00:25:35,319
N1

596
00:25:35,319 --> 00:25:37,339
Y N2

597
00:25:37,339 --> 00:25:40,500
Que N1, por ejemplo, puede ser 2

598
00:25:40,500 --> 00:25:42,359
Y N2, 8, los que sean

599
00:25:42,359 --> 00:25:44,420
Y ahora yo me he inventado

600
00:25:44,420 --> 00:25:45,779
Un numerito N

601
00:25:45,779 --> 00:25:48,500
Que empieza valiendo

602
00:25:48,500 --> 00:25:50,019
N1, empieza valiendo 2

603
00:25:50,019 --> 00:25:51,740
Y luego ya se va incrementando

604
00:25:51,740 --> 00:25:54,319
Luego ya se va incrementando con N++

605
00:25:54,319 --> 00:25:56,700
Y este, luego valdrá 3

606
00:25:56,700 --> 00:25:59,119
Luego 4, este ya es el que meto dentro del bucle

607
00:25:59,119 --> 00:26:02,920
y se va incrementando

608
00:26:02,920 --> 00:26:06,180
vale, y la condición es

609
00:26:06,180 --> 00:26:08,259
mientras n sea

610
00:26:08,259 --> 00:26:09,259
menor o igual

611
00:26:09,259 --> 00:26:11,799
que el n2, este de aquí

612
00:26:11,799 --> 00:26:13,200
vale

613
00:26:13,200 --> 00:26:21,099
mientras n sea menor o igual

614
00:26:21,099 --> 00:26:22,099
que n2

615
00:26:22,099 --> 00:26:24,740
que es este

616
00:26:24,740 --> 00:26:26,319
n2

617
00:26:26,319 --> 00:26:27,980
así es como lo tenemos hecho

618
00:26:27,980 --> 00:26:29,920
este n se va incrementando

619
00:26:29,920 --> 00:26:32,160
pero claro, esta variable n1

620
00:26:32,160 --> 00:26:34,339
ahí ya se ha quedado muerta de risa

621
00:26:34,339 --> 00:26:35,920
esta variable n1

622
00:26:35,920 --> 00:26:37,740
solo me está valiendo

623
00:26:37,740 --> 00:26:40,180
para dar un valor inicial a n

624
00:26:40,180 --> 00:26:42,480
porque yo he hecho n igual a n1

625
00:26:42,480 --> 00:26:44,200
solo me ha valido

626
00:26:44,200 --> 00:26:45,559
para dar un valor inicial a n

627
00:26:45,559 --> 00:26:47,880
y luego se queda ahí muerta de risa y ya está

628
00:26:47,880 --> 00:26:49,920
pues claro

629
00:26:49,920 --> 00:26:51,940
vamos a usar esta propia n1

630
00:26:51,940 --> 00:26:53,819
vamos a usarla como n

631
00:26:53,819 --> 00:26:55,720
¿vale? entonces

632
00:26:55,720 --> 00:26:58,420
esta propia variable n1

633
00:26:58,420 --> 00:26:59,559
la utilizo

634
00:26:59,559 --> 00:27:02,420
con lo cual n1 su valor inicial

635
00:27:02,420 --> 00:27:04,519
es n1 lógicamente, es ella misma

636
00:27:04,519 --> 00:27:06,500
su valor inicial es el que me han metido

637
00:27:06,500 --> 00:27:08,319
es ella misma, n1

638
00:27:08,319 --> 00:27:10,980
y ahora la voy incrementando

639
00:27:10,980 --> 00:27:12,539
la voy incrementando

640
00:27:12,539 --> 00:27:13,640
esta propia n1

641
00:27:13,640 --> 00:27:16,400
y ya está, entonces esa otra

642
00:27:16,400 --> 00:27:18,579
variable n, pues no hace

643
00:27:18,579 --> 00:27:20,839
falta que la use, uso la propia n1

644
00:27:20,839 --> 00:27:22,220
que ya tiene su valor inicial

645
00:27:22,220 --> 00:27:24,980
la voy incrementando a n1

646
00:27:24,980 --> 00:27:26,140
la voy incrementando

647
00:27:26,140 --> 00:27:27,480
su propio valor inicial

648
00:27:27,480 --> 00:27:29,700
la voy incrementando a este

649
00:27:29,700 --> 00:27:32,680
y cuando haya llegado a ser N2

650
00:27:32,680 --> 00:27:33,259
¿vale?

651
00:27:34,220 --> 00:27:35,299
la N2

652
00:27:35,299 --> 00:27:37,559
no la puedo reutilizar

653
00:27:37,559 --> 00:27:39,880
porque N2 tiene que conservar su valor

654
00:27:39,880 --> 00:27:40,759
entre iteraciones

655
00:27:40,759 --> 00:27:43,619
porque la evalúo cada vez

656
00:27:43,619 --> 00:27:44,740
en la condición

657
00:27:44,740 --> 00:27:48,000
¿vale? la N2 no la puedo reutilizar

658
00:27:48,000 --> 00:27:49,440
N2 tiene que conservar su valor

659
00:27:49,440 --> 00:27:52,160
porque está en esta condición

660
00:27:52,160 --> 00:27:54,319
pero la N1 la puedo reutilizar

661
00:27:54,319 --> 00:28:11,720
claro, sí

662
00:28:11,720 --> 00:28:12,779
aquí sí

663
00:28:12,779 --> 00:28:16,339
si este valor lo queremos conservar

664
00:28:16,339 --> 00:28:18,119
porque luego queremos mostrar algo

665
00:28:18,119 --> 00:28:19,960
sí, vale

666
00:28:19,960 --> 00:28:22,000
pero si no

667
00:28:22,000 --> 00:28:23,420
necesitamos conservarlo

668
00:28:34,299 --> 00:28:49,569
No lo voy a, como lo voy a estudiar a lo virtual, no lo voy a cambiar para no hacer mucho lío, pero bueno, más o menos situados.

669
00:28:50,769 --> 00:29:04,089
Vale, pues antes de pasar al 6, perdón, ¿qué código? O sea, ¿este?

670
00:29:04,089 --> 00:29:06,930
Ah, perdón.

671
00:29:19,220 --> 00:29:25,279
Pues esperamos que los bucles en todas sus...