1
00:00:00,370 --> 00:00:03,990
Ya automáticamente pienso, ah, datos de entrada, vale, hay datos de entrada,

2
00:00:04,129 --> 00:00:07,849
tengo que leer del teclado, vale, muy bien, hay datos de entrada, pues,

3
00:00:08,509 --> 00:00:20,949
planto esto, tengo que leer dos valores y ahora sumar todos los valores

4
00:00:20,949 --> 00:00:23,969
comprendidos entre esos dos que cumplan no sé qué.

5
00:00:24,670 --> 00:00:27,210
Entonces, ah, vale, tengo que sumar un montón de cosas,

6
00:00:27,210 --> 00:00:30,210
tengo que sumar un montón de cosas, pues entonces automáticamente

7
00:00:30,750 --> 00:00:34,210
ya hago el chip, vaya, tengo que hacer una suma acumulativa, ¿vale?

8
00:00:34,210 --> 00:00:39,590
¿Vale? Como ya identificamos ayer, ese patrón algorítmico ya lo identificamos.

9
00:00:39,689 --> 00:00:44,969
Anda, una suma acumulativa, ¿vale? Pues es una variable acumuladora que la inicializo a cero

10
00:00:44,969 --> 00:00:50,670
y luego asociada a un bucle, siempre asociada a un bucle, exactamente igual que el contador,

11
00:00:50,969 --> 00:00:56,770
el contador siempre asociado a un bucle, pues asociado a un bucle en esa variable acumuladora

12
00:00:56,770 --> 00:01:01,030
se va sumando en cada iteración un sumandito nuevo, ¿vale?

13
00:01:01,030 --> 00:01:26,269
Pues como identificamos que vamos a tener que hacer una suma acumulativa, pues nuestro programa va a tener que ser algo como esto, es una suma de enteros, pues una variable acumuladora o suma que empieza valiendo cero asociada a un bucle, asociada a un bucle y ahora dentro de ese bucle pues tendremos que hacer algo como esto, ¿vale?

14
00:01:26,269 --> 00:01:52,439
Y este será mi resultado, vale, pues a ver, ¿qué tengo yo que ir sumando? Pues números que parten de un valor inicial A que me dan y cada vez es uno mayor, cada vez es uno mayor, cada vez es uno mayor, hasta llegar a uno final que me dan B, pues justo lo que hicimos.

15
00:01:53,379 --> 00:02:03,239
Pues estos sumandos serán números que inicialmente sea el numerito primero A que me han dado,

16
00:02:04,500 --> 00:02:09,000
ese numerito A primero que me han dado, todavía no he hecho la lectura, porque ese es el primer sumando,

17
00:02:09,000 --> 00:02:16,860
y ahora, una vez que he incorporado cada sumando, el siguiente sumando, ¿cómo lo obtengo?

18
00:02:18,680 --> 00:02:20,759
Pues incrementándolo de uno en uno.

19
00:02:20,759 --> 00:02:23,539
vale, el primer sumando será

20
00:02:23,539 --> 00:02:25,900
cada iteración

21
00:02:25,900 --> 00:02:27,900
me incrementa sumando de uno en uno

22
00:02:27,900 --> 00:02:29,819
me lo va incrementando y lo voy acumulando

23
00:02:29,819 --> 00:02:31,639
a suma, vale

24
00:02:31,639 --> 00:02:32,819
ya me voy aproximando

25
00:02:32,819 --> 00:02:35,680
pero, releyendo

26
00:02:35,680 --> 00:02:37,599
esto y dejándolo bien entendido

27
00:02:37,599 --> 00:02:39,699
cuidado, a esa

28
00:02:39,699 --> 00:02:41,520
suma, solo

29
00:02:41,520 --> 00:02:43,599
incorpora los que

30
00:02:43,599 --> 00:02:45,599
sean múltiplos de 5, cuidado

31
00:02:45,599 --> 00:02:47,080
no los sumes todos

32
00:02:47,080 --> 00:02:49,740
no todos los sumandos

33
00:02:49,740 --> 00:03:03,740
se van a ir incorporando a la suma, solo los que sean múltiplos de 5, ah vale, pues no pasa nada, entonces cuidado, esto estará condicionado a que sumando sea múltiplo de 5,

34
00:03:03,900 --> 00:03:12,340
que ya sabemos como calcular si un número es múltiplo de otro, si el resto de dividirlo entre otro es 0, vale, pues ya se va aproximando,

35
00:03:12,340 --> 00:03:28,939
A esta suma acumulativa voy sumando un número, otro número, otro número, que voy obteniendo, incrementándolos de uno en uno, de uno en uno, pero ¿lo sumo todos? No, cuidado, solo sumo estos, vale, muy bien.

36
00:03:28,939 --> 00:03:34,759
me siguen faltando cosas

37
00:03:34,759 --> 00:03:37,479
por supuesto inicializar A

38
00:03:37,479 --> 00:03:40,960
ese es un dato que tendré que leer por teclado

39
00:03:40,960 --> 00:03:46,539
pero vamos a acabar con el bucle

40
00:03:46,539 --> 00:03:50,240
condición de finalización del bucle

41
00:03:50,240 --> 00:03:52,659
sumo todos partiendo desde el A

42
00:03:52,659 --> 00:03:54,599
hasta el fin de los tiempos

43
00:03:54,599 --> 00:03:57,599
sigo incrementando sumando hasta el fin de los tiempos

44
00:03:57,599 --> 00:03:59,439
de forma que se vayan sumando

45
00:03:59,439 --> 00:04:01,159
todos los múltiplos de 5

46
00:04:01,159 --> 00:04:03,439
partiendo desde la A hasta el final de los tiempos

47
00:04:03,439 --> 00:04:05,020
no, no tiene sentido

48
00:04:05,020 --> 00:04:06,419
que sea hasta el final de los tiempos

49
00:04:06,419 --> 00:04:08,080
ningún bucle debería ser infinito

50
00:04:08,080 --> 00:04:09,680
¿qué dice aquí?

51
00:04:10,659 --> 00:04:13,680
ah, vale, sólo los comprendidos entre A y B

52
00:04:13,680 --> 00:04:14,939
cuando hayas llegado a B

53
00:04:14,939 --> 00:04:15,879
no sumes más

54
00:04:15,879 --> 00:04:19,680
vale, pues entonces, ¿qué condición de finalización podemos poner?

55
00:04:21,680 --> 00:04:23,399
lo mismo clavado que hacíamos ayer

56
00:04:23,399 --> 00:04:23,879
lo mismo

57
00:04:23,879 --> 00:04:26,319
¿qué condición de finalización pondríamos?

58
00:04:34,870 --> 00:04:40,430
Yo sumo primero el a, luego el a más 1, el a más 2, el a más 3, el a más 4, ¿no?

59
00:04:40,470 --> 00:04:44,209
El a más 5 lo vuelvo a sumar, el a más 6, el a más 7, el a más 8, ¿no?

60
00:04:45,329 --> 00:04:48,129
El a más 10 lo vuelvo a sumar, ¿vale?

61
00:04:48,370 --> 00:04:52,550
Pero esto ya sí suman todos los múltiplos de 5 partiendo desde el a, ¿no?

62
00:04:52,550 --> 00:04:53,910
En algún momento paro de sumar.

63
00:04:55,290 --> 00:04:58,569
Entonces, esa parada la tengo que reflejar con esta condición.

64
00:05:00,810 --> 00:05:02,949
Entonces, ¿qué condición podría Isabel?

65
00:05:02,949 --> 00:05:08,089
Recordad que la condición de ahí tiene que ser la negada de la que me hace parar.

66
00:05:08,529 --> 00:05:10,110
¿Cuándo querremos parar de sumar?

67
00:05:11,350 --> 00:05:12,449
¿Cuándo querremos parar?

68
00:05:13,509 --> 00:05:16,470
Decidme esa condición en función de las variables que tengo aquí.

69
00:05:16,569 --> 00:05:18,290
Suma, sumando, que son las únicas que tengo.

70
00:05:18,810 --> 00:05:20,550
¿Cuándo querremos parar de sumar?

71
00:05:21,089 --> 00:05:25,350
En un enunciado que me dice sumar todos los comprendidos entre A y B, patatín.

72
00:05:26,149 --> 00:05:27,730
¿Cuándo querremos parar de sumar?

73
00:05:29,589 --> 00:05:32,389
Vale, pero decídmelo directamente en sentencia Java.

74
00:05:32,389 --> 00:05:35,550
¿Cuándo qué variable

75
00:05:35,550 --> 00:05:36,529
sea igual a qué variable?

76
00:05:37,009 --> 00:05:37,269
¿O cómo?

77
00:05:37,269 --> 00:05:38,250
Cuando A sea igual a B.

78
00:05:40,129 --> 00:05:41,209
Cuando A sea igual a B.

79
00:05:41,209 --> 00:05:43,050
Pero aquí en ningún momento

80
00:05:43,050 --> 00:05:44,430
se toca A y B, con lo cual...

81
00:05:44,430 --> 00:05:45,670
Cuando sumando sea igual a B.

82
00:05:46,610 --> 00:05:48,730
Vale, cuando sumando sea igual a B.

83
00:05:49,509 --> 00:05:49,930
¿Vale?

84
00:05:51,509 --> 00:05:53,350
El B entonces no lo vas a sumar.

85
00:05:53,889 --> 00:05:55,329
Vamos a suponer que lo queremos incluir.

86
00:05:56,910 --> 00:05:57,129
¿Vale?

87
00:05:57,170 --> 00:05:59,050
Entonces, ¿cómo modificamos esa sentencia?

88
00:05:59,209 --> 00:06:01,569
Es lo mismo que nos pasó en el ejercicio de ayer.

89
00:06:01,569 --> 00:06:03,910
mientras sea diferente de n

90
00:06:03,910 --> 00:06:05,810
si tú quieres parar

91
00:06:05,810 --> 00:06:07,870
cuando sumando sea igual a b

92
00:06:07,870 --> 00:06:09,589
entonces la que tienes que poner ahí

93
00:06:09,589 --> 00:06:10,610
sería la negada

94
00:06:10,610 --> 00:06:13,829
mientras sumando sea diferente de b

95
00:06:13,829 --> 00:06:15,470
la negada

96
00:06:15,470 --> 00:06:17,889
y si ponemos mientras sumando sea

97
00:06:17,889 --> 00:06:18,930
diferente de b

98
00:06:18,930 --> 00:06:22,290
si pones aquí

99
00:06:22,290 --> 00:06:25,769
mientras sumando sea

100
00:06:25,769 --> 00:06:27,149
diferente de b

101
00:06:27,149 --> 00:06:29,389
dato que tendremos que haber leído por ahí

102
00:06:29,389 --> 00:06:31,750
claro, aquí nos falta esa parte

103
00:06:31,750 --> 00:06:32,990
pero esa parte es la más fácil

104
00:06:32,990 --> 00:06:34,550
leer A y B

105
00:06:34,550 --> 00:06:36,910
si lo pones así

106
00:06:36,910 --> 00:06:39,930
el B no se llegaría a sumar

107
00:06:39,930 --> 00:06:41,470
es lo que nos pasaba ayer

108
00:06:41,470 --> 00:06:43,370
si poníamos mientras sumándose

109
00:06:43,370 --> 00:06:44,310
diferente de N

110
00:06:44,310 --> 00:06:47,050
entonces ¿cómo modificamos la sentencia?

111
00:06:47,589 --> 00:06:48,850
para que fuera más general

112
00:06:48,850 --> 00:06:53,230
claro, literalmente

113
00:06:53,230 --> 00:06:53,930
¿qué pusimos?

114
00:06:54,569 --> 00:06:56,370
¿qué tendríamos que poner? dictármelo tal cual

115
00:06:56,370 --> 00:06:58,410
vale

116
00:06:59,329 --> 00:07:01,430
Eso, algo mejor, ¿no?

117
00:07:02,689 --> 00:07:05,550
Mientras sumando sea menor o igual que B.

118
00:07:09,250 --> 00:07:12,649
Mientras sumando sea menor o igual que B, entro.

119
00:07:12,970 --> 00:07:15,790
Entonces, el primero que ya no me suma es el B más 1.

120
00:07:16,550 --> 00:07:17,970
Ese es el primero que ya no me suma.

121
00:07:21,680 --> 00:07:23,839
Bueno, pues esa condición, vale, ya la tenemos.

122
00:07:32,379 --> 00:07:34,439
Vale, pues este bucle está.

123
00:07:35,420 --> 00:07:37,139
Mientras sumando sea menor o igual que B,

124
00:07:37,139 --> 00:08:12,779
Voy incorporándolos a la suma acumulativa, pero solo los incorporo si son múltiplos de 5, ¿qué nos falta? Leer los datos de entrada A y B, mis datos de entrada A y B no los he leído, ¿vale? Pues vamos a leerlos, ¿vale?

125
00:08:12,779 --> 00:08:48,639
Leemos A y leemos B. Esto ya estaría, pero me han dicho, ojo, cuidado, si el usuario introduce una más grande que B, entonces intercámbialo, porque si no los intercambiamos y el usuario introduce una que es mayor que B, el resultado final del programa, la suma final, ¿cuánto me saldría?

126
00:08:57,500 --> 00:09:11,820
¿Vale? Este es mi programa. Imaginaos que el usuario introduce una A igual a 7 y un B igual a 1, que es la situación en la que queremos hacer el intercambio.

127
00:09:11,820 --> 00:09:18,480
Si no hiciéramos el intercambio, este programa, ¿qué valor me daría para suma?

128
00:09:18,480 --> 00:09:22,480
Una vez que ya he terminado, que termina con esta línea que aquí no ha cabido,

129
00:09:22,700 --> 00:09:37,039
¿qué valor me mostraría para suma en el caso de que yo introduzca una más grande que B?

130
00:09:37,039 --> 00:09:44,379
Venga, valor final del programa

131
00:09:44,379 --> 00:09:46,500
O sea, resultado final, suma

132
00:09:46,500 --> 00:09:48,600
Si yo le introdujera un A mayor que B

133
00:09:48,600 --> 00:09:51,860
¿Qué valor da?

134
00:09:51,980 --> 00:09:54,360
¿O si da error de ejecución?

135
00:09:54,600 --> 00:09:55,179
¿Qué pasaría?

136
00:10:03,980 --> 00:10:05,679
¿Error? ¿En qué momento daría error?

137
00:10:08,450 --> 00:10:09,509
No, ¿en qué línea?

138
00:10:09,610 --> 00:10:10,509
¿Cuándo daría un error?

139
00:10:15,149 --> 00:10:16,710
¿Pero por qué? ¿Debido a qué?

140
00:10:17,009 --> 00:10:18,750
Porque no puede sumar

141
00:10:18,750 --> 00:10:23,240
¿Por qué no puede ser?

142
00:10:23,240 --> 00:10:24,960
Si sumando es mayor que B

143
00:10:24,960 --> 00:10:25,940
No tiene que hacer nada

144
00:10:25,940 --> 00:10:27,919
vale, pero eso no es un error

145
00:10:27,919 --> 00:10:30,120
simplemente este while

146
00:10:30,120 --> 00:10:31,419
¿cuántas veces ejecutaría?

147
00:10:32,200 --> 00:10:35,220
claro, pero eso no es un error

148
00:10:35,220 --> 00:10:36,940
el programa no daría error

149
00:10:36,940 --> 00:10:39,840
un while ya hemos dicho muchas veces

150
00:10:39,840 --> 00:10:42,019
si la primera vez que llegamos

151
00:10:42,019 --> 00:10:44,200
por allí, en la primera iteración

152
00:10:44,200 --> 00:10:45,759
la condición es falsa

153
00:10:45,759 --> 00:10:47,600
el while no se ejecuta nunca

154
00:10:47,600 --> 00:10:49,980
y ya está, y eso no produce error

155
00:10:49,980 --> 00:10:51,940
en la ejecución, simplemente en este programa

156
00:10:51,940 --> 00:10:54,120
el while nunca llega a ejecutarse

157
00:10:54,120 --> 00:10:56,159
con lo cual si el while

158
00:10:56,159 --> 00:10:58,139
nunca llega a ejecutarse, el resultado final

159
00:10:58,139 --> 00:10:59,019
del programa será

160
00:10:59,019 --> 00:11:00,879
cero, ¿verdad?

161
00:11:01,980 --> 00:11:04,179
¿Vale? Entonces, si A es mayor

162
00:11:04,179 --> 00:11:04,559
que B,

163
00:11:06,240 --> 00:11:08,080
esto es falso

164
00:11:08,080 --> 00:11:10,379
de partida, es falso,

165
00:11:10,779 --> 00:11:12,100
nunca entramos en el

166
00:11:12,100 --> 00:11:14,419
while, la suma no se incrementa

167
00:11:14,419 --> 00:11:15,919
en nada, y da cero.

168
00:11:16,940 --> 00:11:18,379
Otra cosa es que con el usuario

169
00:11:18,379 --> 00:11:19,860
que nos ha pedido el programa, le digamos,

170
00:11:20,019 --> 00:11:22,139
¿es eso lo que quieres? Si A es

171
00:11:22,139 --> 00:11:23,960
mayor que B, ¿quieres que te dé cero?

172
00:11:24,519 --> 00:11:25,720
Entonces, él nos dice, no, no,

173
00:11:26,159 --> 00:11:44,620
Lo que te he dicho en el enunciado, si A es mayor que B, entonces intercámbiame A por B, porque sí que quiero sumar todos los comprendidos entre A y B, pero a lo mejor yo te los estoy dando en orden cambiado, yo lo que quiero es que me hagas la suma igualmente, aunque yo te dé A y B en orden correcto, en orden cambiado.

174
00:11:44,620 --> 00:11:46,840
entonces una vez que él nos dice eso

175
00:11:46,840 --> 00:11:48,700
ya es cuando nosotros decimos

176
00:11:48,700 --> 00:11:51,080
vale, pues entonces voy a tener que incorporar a mi programa

177
00:11:51,080 --> 00:11:52,700
una sentencia

178
00:11:52,700 --> 00:11:55,080
que intercambie los valores de A y B

179
00:11:55,080 --> 00:11:56,779
solo si

180
00:11:56,779 --> 00:11:58,059
A es mayor que B

181
00:11:58,059 --> 00:12:00,720
vale, pues una vez que hemos identificado

182
00:12:00,720 --> 00:12:02,200
que eso es lo que tenemos que hacer

183
00:12:02,200 --> 00:12:03,980
pues ya sabemos programar esto

184
00:12:03,980 --> 00:12:07,320
solo en el caso de que A sea mayor que B

185
00:12:07,320 --> 00:12:09,039
tengo que hacer algo, solo en ese caso

186
00:12:09,039 --> 00:12:11,360
¿eso qué es? pues unir, lógicamente

187
00:12:11,360 --> 00:12:38,340
pero nosotros con lo que sabemos, sabemos programar cualquier cosa que nos pidan, cualquiera, vale, pues entonces aquí, ojo, que si, y solo en ese caso, si a es mayor que b, ojo, porque en ese caso, tengo que intercambiar, aquí, si a es mayor que b, ojo, porque solo en ese caso, solo en ese caso,

188
00:12:38,340 --> 00:12:41,120
tengo que intercambiar los valores

189
00:12:41,120 --> 00:12:41,919
de las variables

190
00:12:41,919 --> 00:12:47,370
y eso ya hemos resuelto como hacerlo

191
00:12:47,370 --> 00:12:51,570
voy a guardar

192
00:12:51,570 --> 00:12:53,409
en una variable que me invento

193
00:12:53,409 --> 00:12:55,070
solo como variable temporal

194
00:12:55,070 --> 00:12:56,990
voy a guardar lo que tiene A

195
00:12:56,990 --> 00:12:59,350
para no perderlo, lo guardo ahí

196
00:12:59,350 --> 00:13:00,830
ahora

197
00:13:00,830 --> 00:13:04,070
a mi variable A

198
00:13:04,070 --> 00:13:05,490
que ya tengo guardado

199
00:13:05,490 --> 00:13:07,710
lo que tiene, con lo cual me da igual pisarla

200
00:13:07,710 --> 00:13:09,610
sobre escribirla con lo que sea

201
00:13:09,610 --> 00:13:11,909
le voy a asignar lo que tiene B

202
00:13:11,909 --> 00:13:16,080
vale, y a B

203
00:13:16,080 --> 00:13:17,960
¿qué le asigno? lo que tenía

204
00:13:17,960 --> 00:13:20,240
A, ¿y qué era lo que tenía

205
00:13:20,240 --> 00:13:21,840
A? esto

206
00:13:21,840 --> 00:13:26,779
vale, eso es lo que acabamos

207
00:13:26,779 --> 00:13:28,700
de explicar hace

208
00:13:28,700 --> 00:13:29,779
un ratín

209
00:13:29,779 --> 00:13:32,679
vale, me invento

210
00:13:32,679 --> 00:13:34,000
yo una variable auxiliar

211
00:13:34,000 --> 00:13:36,559
aquí

212
00:13:36,559 --> 00:13:38,440
tengo yo mis A y mis B

213
00:13:38,440 --> 00:13:42,320
a mi variable

214
00:13:42,320 --> 00:13:44,419
auxiliar le asigno

215
00:13:44,419 --> 00:13:46,419
lo que tenía

216
00:13:46,419 --> 00:13:48,399
A, imaginaos que A tiene 7

217
00:13:48,399 --> 00:13:50,480
y B 1, le asigno

218
00:13:50,480 --> 00:13:52,460
lo que tiene A, el 7, vale, pues el 7

219
00:13:52,460 --> 00:13:53,820
se queda ahí guardadito temporal

220
00:13:53,820 --> 00:13:56,080
ahora mi variable A

221
00:13:56,080 --> 00:13:58,440
ya la puedo pisar y asignar

222
00:13:58,440 --> 00:14:00,340
lo que tenía B, se queda con el 1

223
00:14:00,340 --> 00:14:02,500
y ahora ya

224
00:14:02,500 --> 00:14:03,580
mi variable B

225
00:14:03,580 --> 00:14:06,299
le asigno lo que tenía A

226
00:14:06,299 --> 00:14:07,919
de antes, que lo he conservado aquí

227
00:14:07,919 --> 00:14:09,919
para no perderlo

228
00:14:09,919 --> 00:14:11,559
en la sobrescritura anterior

229
00:14:11,559 --> 00:14:14,200
pues le asigno el 7, el 1 desaparece

230
00:14:14,200 --> 00:14:16,179
entonces estas 3

231
00:14:16,179 --> 00:14:22,899
sentencias de código consiguen como resultado final el intercambio y efectivamente aquí me ha

232
00:14:22,899 --> 00:14:29,240
aparecido una variable que he necesitado usar como valor temporal es grave pues no es grave porque

233
00:14:29,240 --> 00:14:35,340
qué le pasa a esta variable pues lo que explicamos ayer donde la he declarado yo esta variable la

234
00:14:35,340 --> 00:14:41,980
he declarado dentro de este bloque un bloque es un código entre llaves la he declarado aquí luego

235
00:14:41,980 --> 00:14:44,080
cuando este código termina de ejecutarse

236
00:14:44,080 --> 00:14:46,139
que es aquí fuera

237
00:14:46,139 --> 00:14:47,940
cuando ese bloque ha terminado

238
00:14:47,940 --> 00:14:50,240
todas las variables declaradas

239
00:14:50,240 --> 00:14:52,120
aquí dentro desaparecen

240
00:14:52,120 --> 00:14:53,860
pues aux fuera

241
00:14:53,860 --> 00:14:56,580
ya deja de molestar

242
00:14:56,580 --> 00:14:57,820
tuvo

243
00:14:57,820 --> 00:14:59,919
su función aquí dentro

244
00:14:59,919 --> 00:15:02,340
pero una vez que ya cumplió

245
00:15:02,340 --> 00:15:03,799
su función no la quiero para nada

246
00:15:03,799 --> 00:15:05,759
pues la declaro aquí dentro

247
00:15:05,759 --> 00:15:08,639
y cuando este bloque termina de ejecutarse

248
00:15:08,639 --> 00:15:10,240
esta variable aux

249
00:15:10,240 --> 00:15:10,960
ha desaparecido

250
00:15:10,960 --> 00:15:13,799
A y B por supuesto no han desaparecido

251
00:15:13,799 --> 00:15:15,860
porque A y B están declaradas aquí arriba

252
00:15:15,860 --> 00:15:18,159
solo desaparecen

253
00:15:18,159 --> 00:15:19,700
las que estén declaradas dentro

254
00:15:19,700 --> 00:15:20,360
de este bloque

255
00:15:20,360 --> 00:15:25,379
yo podía haber declarado aux fuera

256
00:15:25,379 --> 00:15:25,860
también

257
00:15:25,860 --> 00:15:29,519
pero entonces aux va a estar existiendo

258
00:15:29,519 --> 00:15:31,860
ahí esa cajita toda la vida del programa

259
00:15:31,860 --> 00:15:33,919
si yo aux

260
00:15:33,919 --> 00:15:35,320
la hubiera declarado aquí fuera

261
00:15:35,320 --> 00:15:37,379
int aux

262
00:15:37,379 --> 00:15:39,899
y aquí me hubiera limitado a usarla

263
00:15:39,899 --> 00:15:41,740
pues sí, el efecto del programa

264
00:15:41,740 --> 00:15:42,279
es el mismo

265
00:15:42,279 --> 00:15:44,480
es idéntico el efecto del programa

266
00:15:44,480 --> 00:15:46,100
pero

267
00:15:46,100 --> 00:15:48,659
a cambio

268
00:15:48,659 --> 00:15:50,940
mi variable aux

269
00:15:50,940 --> 00:15:53,960
con este 7

270
00:15:53,960 --> 00:15:56,059
se queda ya para siempre

271
00:15:56,059 --> 00:15:57,720
todo el programa ahí en memoria

272
00:15:57,720 --> 00:15:58,299
esa variable

273
00:15:58,299 --> 00:16:01,340
y que necesidad de tener una variable ahí en memoria

274
00:16:01,340 --> 00:16:03,220
ocupando 4 bytes de memoria

275
00:16:03,220 --> 00:16:04,659
que necesidad

276
00:16:04,659 --> 00:16:07,519
si solamente la voy a usar

277
00:16:07,519 --> 00:16:08,860
en este bloque, solo aquí

278
00:16:08,860 --> 00:16:11,860
pues si solo la voy a usar en este bloque

279
00:16:11,860 --> 00:16:14,259
la declaro local a este bloque

280
00:16:14,259 --> 00:16:15,019
vale

281
00:16:15,019 --> 00:16:19,639
la declaro local a este bloque

282
00:16:19,639 --> 00:16:21,000
y mucho mejor

283
00:16:21,000 --> 00:16:23,440
me garantizo que desaparece

284
00:16:23,440 --> 00:16:25,740
se acabó este espacio

285
00:16:25,740 --> 00:16:28,200
y se acabó todo cuando el bloque termina

286
00:16:28,200 --> 00:16:31,799
y esto ya no es solo

287
00:16:31,799 --> 00:16:33,019
por un tema de ahorrar memoria

288
00:16:33,019 --> 00:16:35,379
porque 4 bytes de RAM que ocupa un int

289
00:16:35,379 --> 00:16:37,200
4 bytes de RAM no van a ningún lado

290
00:16:37,200 --> 00:16:39,360
esto sobre todo

291
00:16:39,360 --> 00:16:40,580
es por

292
00:16:40,580 --> 00:16:43,480
evitar posibles

293
00:16:43,480 --> 00:16:45,740
errores derivados de que haya

294
00:16:45,740 --> 00:16:47,659
demasiadas variables en un momento dado

295
00:16:47,659 --> 00:16:50,159
si yo estoy en un punto del programa

296
00:16:50,159 --> 00:16:51,940
en el que tengo mil variables

297
00:16:51,940 --> 00:16:53,919
declaradas, de las cuales solo estoy

298
00:16:53,919 --> 00:16:55,820
usando tres, pues hay

299
00:16:55,820 --> 00:16:58,179
un montón de variables de las que yo no soy consciente

300
00:16:58,179 --> 00:16:59,919
que están ahí declaradas porque las

301
00:16:59,919 --> 00:17:02,179
usé en un momento dado, con sus nombres

302
00:17:02,179 --> 00:17:03,820
y a lo mejor

303
00:17:03,820 --> 00:17:05,480
las uso sin querer

304
00:17:05,480 --> 00:17:07,660
creyendo que estoy haciendo otra cosa

305
00:17:07,660 --> 00:17:09,960
y porque me confundo

306
00:17:09,960 --> 00:17:10,900
escribiendo el nombre

307
00:17:10,900 --> 00:17:13,720
entonces abono el terreno para errores

308
00:17:13,720 --> 00:17:15,339
porque tengo un montón de variables

309
00:17:15,339 --> 00:17:17,279
con sus nombres, ahí y a lo mejor

310
00:17:17,279 --> 00:17:19,039
me confundo, pongo el nombre de otra

311
00:17:19,039 --> 00:17:21,079
y estoy usando esa otra

312
00:17:21,079 --> 00:17:23,319
entonces lo ideal es que en cada

313
00:17:23,319 --> 00:17:25,400
punto del código solo existan

314
00:17:25,400 --> 00:17:26,660
las variables que estoy usando

315
00:17:26,660 --> 00:17:29,500
¿qué necesidad de que la variable

316
00:17:29,500 --> 00:17:30,960
aux exista todo el programa?

317
00:17:31,160 --> 00:17:33,339
¿para molestar hay una variable aux y que yo

318
00:17:33,339 --> 00:17:35,680
escriba aux sin querer y la lié?

319
00:17:36,819 --> 00:17:37,500
¿creyendo que

320
00:17:37,500 --> 00:17:39,140
hago una cosa y no estoy haciendo otra?

321
00:17:39,140 --> 00:17:41,759
pues a declararla localmente

322
00:17:41,759 --> 00:17:44,099
luego todas las variables

323
00:17:44,099 --> 00:17:46,240
se declaran lo más local que se pueda

324
00:17:46,240 --> 00:17:48,420
en el bloque más interno en el que se van a usar

325
00:17:48,420 --> 00:17:49,579
en el bloque más interno

326
00:17:49,579 --> 00:17:52,599
y esto es importante

327
00:17:52,599 --> 00:17:54,180
entender lo de las variables locales

328
00:17:54,180 --> 00:17:56,019
y su ámbito, lo que vimos ayer

329
00:17:56,019 --> 00:18:00,230
bueno pues entonces

330
00:18:00,230 --> 00:18:02,289
gran parte del programa

331
00:18:02,289 --> 00:18:02,910
está hecho

332
00:18:02,910 --> 00:18:05,970
ya está hecho lo de

333
00:18:05,970 --> 00:18:07,210
leer los valores de entrada

334
00:18:07,210 --> 00:18:08,930
intercambiarlos

335
00:18:08,930 --> 00:18:11,309
si A es mayor que B

336
00:18:11,309 --> 00:18:13,329
y ahora ya

337
00:18:13,329 --> 00:18:15,289
hacer la suma

338
00:18:15,289 --> 00:18:15,569
¿vale?

339
00:18:17,130 --> 00:18:19,369
entonces, antes de

340
00:18:19,369 --> 00:18:21,670
bueno, nada

341
00:18:21,670 --> 00:18:22,329
sí

342
00:18:22,329 --> 00:18:27,559
venga, vamos a

343
00:18:27,559 --> 00:18:29,559
a incorporar esto que hemos dicho

344
00:18:29,559 --> 00:18:30,640
ignoremoslo

345
00:18:30,640 --> 00:18:33,299
pero vamos ahora ya a incorporarlo

346
00:18:33,299 --> 00:18:35,559
una pequeñita validación de datos

347
00:18:35,559 --> 00:18:39,240
vamos a incorporar, oye tú

348
00:18:39,240 --> 00:18:41,940
no le dejes al usuario

349
00:18:41,940 --> 00:18:44,420
introducir valores negativos

350
00:18:44,420 --> 00:18:46,099
para A o B, no le dejes

351
00:18:46,099 --> 00:18:50,000
entonces, ¿qué significa no dejarle?

352
00:18:50,099 --> 00:18:51,400
tú no puedes salir del ordenador

353
00:18:51,400 --> 00:18:54,380
y agarrarle la mano para que no le dé

354
00:18:54,380 --> 00:18:55,839
al menos, lógicamente

355
00:18:55,839 --> 00:18:58,500
entonces, no dejarle

356
00:18:58,500 --> 00:18:59,220
significa

357
00:18:59,220 --> 00:19:01,640
meterle ahí en un bucle

358
00:19:01,640 --> 00:19:03,900
del que no salga

359
00:19:03,900 --> 00:19:06,480
hasta que no introduzca un valor positivo

360
00:19:06,480 --> 00:19:12,549
es decir, eso es validar un dato

361
00:19:12,549 --> 00:19:14,490
este

362
00:19:14,490 --> 00:19:16,390
next in de aquí

363
00:19:16,390 --> 00:19:17,089
que yo he hecho

364
00:19:17,089 --> 00:19:20,349
él ahí puede meter

365
00:19:20,349 --> 00:19:22,309
cualquier número entero que le den la gana

366
00:19:22,309 --> 00:19:24,329
menos 12, 13, cualquiera

367
00:19:24,329 --> 00:19:26,210
puede meter, y yo no tengo forma

368
00:19:26,210 --> 00:19:28,130
de evitarlo, no voy a salir del ordenador

369
00:19:28,130 --> 00:19:29,470
a agarrarle la mano

370
00:19:29,470 --> 00:19:32,029
lo único que puedo hacer

371
00:19:32,029 --> 00:19:34,289
es meter esto en un bucle

372
00:19:34,289 --> 00:19:36,329
de tal forma que

373
00:19:36,329 --> 00:19:38,509
mientras este número sea negativo

374
00:19:38,509 --> 00:19:40,750
lo vuelva a pedir, y si es negativo

375
00:19:40,750 --> 00:19:42,569
lo vuelva a pedir, y si es negativo

376
00:19:42,569 --> 00:19:44,329
lo vuelva a pedir, es lo único que puede hacer

377
00:19:44,329 --> 00:19:46,289
es mi única manera de obligarle

378
00:19:46,289 --> 00:19:48,529
no dejarle salir de un bucle

379
00:19:48,529 --> 00:19:49,930
de recogida de datos

380
00:19:49,930 --> 00:19:51,910
hasta que el dato que me da

381
00:19:51,910 --> 00:19:54,630
no cumpla exactamente lo que

382
00:19:54,630 --> 00:19:56,230
yo necesito que cumpla

383
00:19:56,230 --> 00:19:58,390
entonces

384
00:19:58,390 --> 00:20:00,650
pues ya está, vamos a meter

385
00:20:00,650 --> 00:20:01,609
esto en un bucle

386
00:20:01,609 --> 00:20:03,470
y ahora

387
00:20:03,470 --> 00:20:07,029
aquí que bucle pondríais, un while o un do while

388
00:20:08,509 --> 00:20:13,029
¿Qué bucle pega ahí de las dos estructuras que tenemos?

389
00:20:14,789 --> 00:20:15,950
While o do while.

390
00:20:19,309 --> 00:20:21,309
¿Recordáis la diferencia entre while y do?

391
00:20:22,980 --> 00:20:29,200
Pues según esa diferencia, teniendo en cuenta que yo ya he concluido que tengo que meter esto en un bucle,

392
00:20:29,380 --> 00:20:31,799
para que esté todo el rato leyendo mientras sea negativo.

393
00:20:32,440 --> 00:20:35,599
¿Lo meteríais en un bucle while o lo meteríais en un bucle do while?

394
00:20:39,579 --> 00:20:40,880
Venga, que alguien diga algo.

395
00:20:40,880 --> 00:20:50,700
cuando procedía

396
00:20:50,700 --> 00:20:52,339
cuando se adaptaba más

397
00:20:52,339 --> 00:20:53,619
poner un bucle do-while

398
00:20:53,619 --> 00:20:59,589
¿Perdón?

399
00:21:00,069 --> 00:21:04,819
¿Tenía que revisar algo primero?

400
00:21:06,339 --> 00:21:07,299
Más o menos

401
00:21:07,299 --> 00:21:08,059
o sea, cuando

402
00:21:08,059 --> 00:21:11,460
la primera ejecución del código

403
00:21:11,460 --> 00:21:13,319
tenía que hacerse sí o sí

404
00:21:13,319 --> 00:21:15,819
cuando lo que había dentro del bucle

405
00:21:15,819 --> 00:21:17,440
una primera vez

406
00:21:17,440 --> 00:21:19,480
queríamos que se hiciera sí o sí

407
00:21:19,480 --> 00:21:21,400
y ya las siguientes condicionadas

408
00:21:21,400 --> 00:21:23,480
¿Vale?

409
00:21:23,559 --> 00:21:24,680
Entonces, en este caso

410
00:21:25,579 --> 00:21:28,220
¿Necesitamos que se haga una primera vez sí o sí?

411
00:21:30,619 --> 00:21:32,500
Sí, porque es un bucle de lectura de datos.

412
00:21:32,660 --> 00:21:34,279
Entonces, la primera hay que hacerla.

413
00:21:34,880 --> 00:21:36,019
La primera hay que hacerla.

414
00:21:36,420 --> 00:21:40,059
Y las siguientes se harán o no dependiendo de la condición que sea.

415
00:21:40,140 --> 00:21:41,559
En este caso, si ya es negativo.

416
00:21:42,420 --> 00:21:48,700
Con lo cual, aquí, lógicamente, pega mucho mejor un do while.

417
00:21:48,700 --> 00:21:52,519
pega mejor un do while

418
00:21:52,519 --> 00:21:54,799
donde la condición será

419
00:21:54,799 --> 00:21:55,259
¿cuál?

420
00:21:56,380 --> 00:21:57,500
¿qué condición pongo ahí?

421
00:22:05,519 --> 00:22:06,920
bueno, ahora estoy solamente leyendo el a

422
00:22:06,920 --> 00:22:08,000
luego el b lo hago por libre

423
00:22:08,000 --> 00:22:16,029
¿a mayor que 0?

424
00:22:19,250 --> 00:22:21,150
piensa que esta es la condición

425
00:22:21,150 --> 00:22:23,849
que mientras se cumpla

426
00:22:23,849 --> 00:22:25,069
vuelvo otra vez arriba

427
00:22:25,069 --> 00:22:26,289
y vuelvo otra vez arriba

428
00:22:26,289 --> 00:22:28,589
cuando deja de cumplirse es cuando salgo

429
00:22:28,589 --> 00:22:36,700
¿qué condición tendría que poner ahí?

430
00:22:38,859 --> 00:22:41,059
Mientras esa condición se cumpla,

431
00:22:41,240 --> 00:22:42,539
tengo que volver a pedirlo.

432
00:22:42,640 --> 00:22:43,579
Tengo que volver a pedirlo.

433
00:22:43,619 --> 00:22:44,640
Pues, ¿qué condición pondría?

434
00:22:55,980 --> 00:22:58,079
Mientras a A le pase algo,

435
00:22:58,599 --> 00:22:59,440
tengo que volver a pedir.

436
00:22:59,519 --> 00:22:59,759
¿El qué?

437
00:23:04,430 --> 00:23:05,029
Claro.

438
00:23:05,950 --> 00:23:08,829
Me han dicho que yo no permita negativos.

439
00:23:09,670 --> 00:23:10,990
Lo que acabo de decir es,

440
00:23:11,289 --> 00:23:13,289
mientras el usuario meta negativos,

441
00:23:13,410 --> 00:23:15,309
se vuelve a pedir, y se vuelve a pedir, y se vuelve a pedir.

442
00:23:16,190 --> 00:23:16,410
¿Vale?

443
00:23:16,769 --> 00:23:19,309
Es mi única forma de asegurarme

444
00:23:19,309 --> 00:23:21,869
que lo que introduce sea positivo

445
00:23:21,869 --> 00:23:23,910
entonces

446
00:23:23,910 --> 00:23:25,589
mientras a sea

447
00:23:25,589 --> 00:23:27,869
menor que cero, ahí le tengo

448
00:23:27,869 --> 00:23:28,589
¿vale?

449
00:23:32,279 --> 00:23:33,660
me falta aquí la llave

450
00:23:33,660 --> 00:23:38,319
vale, mientras a sea

451
00:23:38,319 --> 00:23:40,019
negativo, otra vez arriba

452
00:23:40,019 --> 00:23:42,319
y otra vez arriba, entonces la primera

453
00:23:42,319 --> 00:23:44,079
vez es incondicional, me pide el primero

454
00:23:44,079 --> 00:23:46,019
y ya las siguientes

455
00:23:46,019 --> 00:23:48,059
las pide o no

456
00:23:48,059 --> 00:23:50,420
en función de si ese es negativo o no

457
00:23:50,420 --> 00:24:34,740
Luego este es un bucle que está validando el primer dato y ahí se queda atascado, pues lo mismo con el B, exactamente lo mismo con el B, porque el B tampoco puede ser negativo, pues esto igual y ya está, mientras B sea negativo vuelve a pedir B y vuelve a pedir B y vuelve a pedir B y así todo el rato.

458
00:24:34,740 --> 00:24:39,099
entonces no salimos de este bucle

459
00:24:39,099 --> 00:24:44,619
hasta que el dato introducido sea mayor o igual que cero

460
00:24:44,619 --> 00:24:53,430
vale

461
00:24:53,430 --> 00:24:58,869
ahora ya parece que está todo

462
00:24:58,869 --> 00:24:59,789
leemos los datos

463
00:24:59,789 --> 00:25:03,470
pero le tenemos al usuario metido en un bucle

464
00:25:03,470 --> 00:25:04,329
metido en un bucle

465
00:25:04,329 --> 00:25:07,289
mientras lo que introduzca no sea como queremos

466
00:25:07,289 --> 00:25:09,490
mientras no cumpla nuestro patrón

467
00:25:09,490 --> 00:25:13,930
cuando ya hemos salido de los dos bucles

468
00:25:13,930 --> 00:25:15,970
a y b son mayores o iguales que 0

469
00:25:15,970 --> 00:25:18,190
si a es mayor

470
00:25:18,190 --> 00:25:19,589
que 20, cambiamos, vale

471
00:25:19,589 --> 00:25:21,990
y ahora ya sí, pues hacemos

472
00:25:21,990 --> 00:25:23,369
la suma

473
00:25:23,369 --> 00:25:28,809
vale

474
00:25:28,809 --> 00:25:31,329
entonces

475
00:25:31,329 --> 00:25:34,109
esto ya en principio, pues nos tendría que

476
00:25:34,109 --> 00:25:35,309
funcionar

477
00:25:35,309 --> 00:25:37,509
introduzca la

478
00:25:37,509 --> 00:25:40,049
que le pongo el menos 3, pues ahí se está

479
00:25:40,049 --> 00:25:42,029
ahí se está, hasta que yo no

480
00:25:42,029 --> 00:25:43,269
introduzca un número positivo

481
00:25:43,269 --> 00:25:45,630
pues el 8

482
00:25:45,630 --> 00:25:46,529
muy bien

483
00:25:46,529 --> 00:25:51,069
Ah, vale, es que he hecho copia y pega

484
00:25:51,069 --> 00:25:52,150
En el de abajo

485
00:25:52,150 --> 00:25:54,250
Y no he puesto introduzca B

486
00:25:54,250 --> 00:25:56,950
Vale, entonces

487
00:25:56,950 --> 00:25:59,410
Parece que me está pidiendo A otra vez

488
00:25:59,410 --> 00:25:59,849
Pero no

489
00:25:59,849 --> 00:26:02,950
Vale, pues lo paro, introduzca B

490
00:26:02,950 --> 00:26:06,180
Pues venga

491
00:26:06,180 --> 00:26:12,789
Ahora ya sí

492
00:26:12,789 --> 00:26:14,549
Lógicamente el menos 4 no

493
00:26:14,549 --> 00:26:16,569
Pues venga, le doy el 9

494
00:26:16,569 --> 00:26:18,609
Ahora ya me ha dejado el B

495
00:26:18,609 --> 00:26:21,329
Si al B le diera menos 1, pues tampoco

496
00:26:21,329 --> 00:26:22,690
Dame el b

497
00:26:22,690 --> 00:26:24,390
El 1

498
00:26:24,390 --> 00:26:27,609
Se los he dado cambiados, con lo cual él va a intercambiarlos

499
00:26:27,609 --> 00:26:29,369
A por b y me va a sumar

500
00:26:29,369 --> 00:26:31,250
Todos los múltiplos de 5 entre 1 y 9

501
00:26:31,250 --> 00:26:33,750
Que solo hay 1, 5, con lo cual me tendrá que sacar 5

502
00:26:33,750 --> 00:26:35,289
Vamos a ver

503
00:26:35,289 --> 00:26:36,490
Efectivamente

504
00:26:36,490 --> 00:26:38,970
La suma de todos los múltiplos de 5

505
00:26:38,970 --> 00:26:41,569
Comprendidos entre 1 y 9

506
00:26:41,569 --> 00:26:43,009
Es 5

507
00:26:43,009 --> 00:26:46,440
Porque solo hay 1

508
00:26:46,440 --> 00:26:49,900
Vale, pues ya está

509
00:26:49,900 --> 00:26:52,359
Vamos a parar aquí un momentín

510
00:26:52,359 --> 00:26:53,960
Vale