1
00:00:00,750 --> 00:00:20,190
Vale, a ver, pues esto de la sentencia de decisión en realidad ya nos permite aproximarnos un poquito más a este término, ¿vale? Ya nos permite aproximarnos un poco más a este término, ¿vale?

2
00:00:20,190 --> 00:00:21,510
un algoritmo es

3
00:00:21,510 --> 00:00:23,870
un concepto que

4
00:00:23,870 --> 00:00:26,109
está más allá de la programación

5
00:00:26,109 --> 00:00:27,809
¿vale? más allá de la programación, un algoritmo

6
00:00:27,809 --> 00:00:28,989
exclusivamente es

7
00:00:28,989 --> 00:00:32,329
la secuencia de acciones

8
00:00:32,329 --> 00:00:34,350
que conducen a la resolución

9
00:00:34,350 --> 00:00:36,109
de un problema, ¿verdad? eso es un algoritmo

10
00:00:36,109 --> 00:00:37,109
¿tenemos clase de algoritmo?

11
00:00:37,810 --> 00:00:39,670
no, eso es

12
00:00:39,670 --> 00:00:41,329
eso es pensar

13
00:00:41,329 --> 00:00:43,369
¿vale?

14
00:00:43,469 --> 00:00:46,070
no, hombre, no, es que

15
00:00:46,070 --> 00:00:46,409
claro

16
00:00:46,409 --> 00:00:50,009
sí, vale

17
00:00:50,009 --> 00:00:52,049
entonces una secuencia de pasos para resolver un problema

18
00:00:52,049 --> 00:00:53,549
entonces pues bueno

19
00:00:53,549 --> 00:00:56,329
quiero viajar a París

20
00:00:56,329 --> 00:00:58,170
busco

21
00:00:58,170 --> 00:01:00,130
un billete, lo pago

22
00:01:00,130 --> 00:01:01,689
me voy al aeropuerto

23
00:01:01,689 --> 00:01:04,390
monto en el avión, aterrizo

24
00:01:04,390 --> 00:01:06,230
si Dios quiere, bajo del avión

25
00:01:06,230 --> 00:01:06,950
y llego a París

26
00:01:06,950 --> 00:01:09,930
pues eso es un algoritmo

27
00:01:09,930 --> 00:01:12,189
una secuencia de pasos para resolver

28
00:01:12,189 --> 00:01:14,250
mi problema de que quiero llegar a París

29
00:01:14,250 --> 00:01:17,939
vale, en programación

30
00:01:17,939 --> 00:01:19,920
también lo que buscamos es resolver

31
00:01:19,920 --> 00:01:20,500
problemas

32
00:01:20,500 --> 00:01:24,060
tengo 15 usuarios

33
00:01:24,060 --> 00:01:25,959
y quiero ver de esos 15

34
00:01:25,959 --> 00:01:28,019
cuál es el que más ha pagado

35
00:01:28,019 --> 00:01:30,420
15 clientes

36
00:01:30,420 --> 00:01:31,719
vale, pues mi problema

37
00:01:31,719 --> 00:01:32,819
aplicación que he dado

38
00:01:32,819 --> 00:01:35,780
los clientes de una base de datos

39
00:01:35,780 --> 00:01:37,540
mire cuál es el que más ha pagado

40
00:01:37,540 --> 00:01:39,939
problema, a resolver

41
00:01:39,939 --> 00:01:42,400
¿cómo? con un algoritmo que programamos

42
00:01:42,400 --> 00:01:44,219
¿vale? un algoritmo en términos generales

43
00:01:44,219 --> 00:01:46,019
es eso, una secuencia

44
00:01:46,019 --> 00:01:47,840
de acciones para resolver un problema

45
00:01:47,840 --> 00:01:49,939
que queremos resolver, que necesitamos

46
00:01:49,939 --> 00:01:52,000
resolver. Y eso es lo que hacemos cuando

47
00:01:52,000 --> 00:01:54,000
programamos. Programamos exclusivamente

48
00:01:54,000 --> 00:01:56,040
para eso. ¿Para qué un problema

49
00:01:56,040 --> 00:01:57,920
que queremos resolver, en lugar

50
00:01:57,920 --> 00:02:00,040
de hacerlo nosotros, que no lo podemos

51
00:02:00,040 --> 00:02:01,700
hacer porque somos demasiado lentos

52
00:02:01,700 --> 00:02:02,459
calculando,

53
00:02:03,900 --> 00:02:05,879
o no tenemos una capacidad de almacenamiento

54
00:02:05,879 --> 00:02:08,060
de datos demasiado grande, no podemos memorizar

55
00:02:08,060 --> 00:02:09,840
mil millones de clientes a la vez,

56
00:02:10,340 --> 00:02:11,800
pues algo que nosotros podríamos

57
00:02:11,800 --> 00:02:13,439
hacer, pero nos falta

58
00:02:13,439 --> 00:02:15,580
memoria y nos falta

59
00:02:15,580 --> 00:02:17,680
velocidad, pues se lo damos

60
00:02:17,680 --> 00:02:19,639
a alguien que no sabe hacer absolutamente

61
00:02:19,639 --> 00:02:21,479
nada, pero a cambio

62
00:02:21,479 --> 00:02:23,500
tiene memoria y

63
00:02:23,500 --> 00:02:25,560
tiene velocidad. Es lo único que nos

64
00:02:25,560 --> 00:02:27,520
aporta un ordenador. Memoria y

65
00:02:27,520 --> 00:02:28,620
velocidad nos aportan nada más.

66
00:02:29,460 --> 00:02:31,500
Entonces, bueno, pues entonces

67
00:02:31,500 --> 00:02:33,439
yo le digo lo que tiene que hacer,

68
00:02:34,099 --> 00:02:35,560
se lo digo paso por paso,

69
00:02:35,819 --> 00:02:37,539
pa, pa, pa, pa, y él lo

70
00:02:37,539 --> 00:02:39,620
hace. ¿Vale? Y no va a hacer nada

71
00:02:39,620 --> 00:02:40,759
que no le hayamos dicho nosotros.

72
00:02:41,819 --> 00:02:43,500
Bueno, pues ese paso por

73
00:02:43,500 --> 00:02:45,139
paso que tenemos que hacer

74
00:02:45,139 --> 00:02:46,259
es el algoritmo.

75
00:02:48,159 --> 00:02:49,400
Bueno, pues entonces

76
00:02:49,400 --> 00:03:08,719
Ya ese término, cuando ya hablamos de programación, pues ya se ha refinado un poquito más y algoritmo implica ser una secuencia de pasos para que el algoritmo sea válido y yo me planté programarlo, cuidado no os olvidéis que tiene que ser finito, ¿vale?

77
00:03:08,719 --> 00:03:37,580
Y secuenciado, tiene que ser una sentencia tras otra, es decir, una sentencia tras otra o una orden tras otra, como lo queráis llamar, y tiene que acabar, ¿vale?

78
00:03:37,580 --> 00:03:40,479
Entonces, si yo consigo

79
00:03:40,479 --> 00:03:42,879
Especificar

80
00:03:42,879 --> 00:03:43,699
Cómo hacer algo

81
00:03:43,699 --> 00:03:46,159
Con una sentencia, una instrucción

82
00:03:46,159 --> 00:03:47,659
Tras otra, gira a la derecha

83
00:03:47,659 --> 00:03:49,900
No sé qué, no sé cuánto, patatín, patatín, patatín

84
00:03:49,900 --> 00:03:51,900
Y además, tiene un fin

85
00:03:51,900 --> 00:03:52,819
Tiene un fin

86
00:03:52,819 --> 00:03:55,219
Entonces habré hecho un algoritmo válido

87
00:03:55,219 --> 00:03:57,139
Pues cuando yo he llegado a un algoritmo válido

88
00:03:57,139 --> 00:03:59,900
Que lo puedo expresar en mis propias palabras

89
00:03:59,900 --> 00:04:01,960
Con diagramas de flujo

90
00:04:01,960 --> 00:04:03,659
Como sea, cuando yo he llegado a un algoritmo válido

91
00:04:03,659 --> 00:04:05,900
Ahora ya, lo programo

92
00:04:06,520 --> 00:04:07,020
¿Vale?

93
00:04:07,020 --> 00:04:08,759
en el lenguaje de programación que elija

94
00:04:08,759 --> 00:04:11,520
y ese ya lo hace, ese va a seguir

95
00:04:11,520 --> 00:04:13,300
pum pum como un tonto lo que le vamos diciendo

96
00:04:13,300 --> 00:04:15,560
pues es tonto, o sea lo único que sabe hacer

97
00:04:15,560 --> 00:04:17,879
es operaciones aritméticas y lógicas

98
00:04:17,879 --> 00:04:19,279
no sabe hacer nada más que eso

99
00:04:19,279 --> 00:04:21,360
operaciones aritméticas y lógicas, lo que pasa es que las hace

100
00:04:21,360 --> 00:04:23,500
muy deprisa y además

101
00:04:23,500 --> 00:04:25,779
puede almacenar a la vez

102
00:04:25,779 --> 00:04:27,519
millones de números que nosotros no podemos

103
00:04:27,519 --> 00:04:29,459
numerizar, bueno pero tenemos que

104
00:04:29,459 --> 00:04:30,319
decir que hacer

105
00:04:30,319 --> 00:04:32,920
y se lo decimos con un algoritmo

106
00:04:32,920 --> 00:04:35,660
bueno pues entonces

107
00:04:35,660 --> 00:04:56,339
Entonces, para construir ese algoritmo, nosotros primero recogemos datos, datos de entrada. Eso es evidente, eso estaría como al margen del algoritmo. El algoritmo trabaja con datos de entrada que hemos recogido. Y ahora, a partir de ahí, empezamos a combinar estas sentencias o estas acciones, como lo queráis llamar, empezamos a combinarlas.

108
00:04:56,339 --> 00:04:59,519
vale, pues cuál es una de estas sentencias

109
00:04:59,519 --> 00:05:01,379
o acciones que podemos empezar ya

110
00:05:01,379 --> 00:05:03,379
a combinar para conseguir un algoritmo

111
00:05:03,379 --> 00:05:05,279
pues una de esas sentencias

112
00:05:05,279 --> 00:05:07,319
o acciones es la sentencia

113
00:05:07,319 --> 00:05:08,399
de decisión, vale

114
00:05:08,399 --> 00:05:17,639
o selectiva según el manual que

115
00:05:17,639 --> 00:05:19,180
estudiéis o como sea

116
00:05:19,180 --> 00:05:24,649
vale, es

117
00:05:24,649 --> 00:05:27,569
obvio que para

118
00:05:27,569 --> 00:05:29,509
poder hacer algo, para poder

119
00:05:29,509 --> 00:05:31,589
solucionar un problema, yo

120
00:05:31,589 --> 00:05:32,769
tengo que tener una manera

121
00:05:32,769 --> 00:05:35,709
de expresar, si ocurre

122
00:05:35,709 --> 00:05:37,069
esto, haz esta cosa

123
00:05:37,069 --> 00:05:39,129
y si no, haz esta otra

124
00:05:39,129 --> 00:05:41,829
porque eso ocurre en cualquier situación

125
00:05:41,829 --> 00:05:43,029
entonces

126
00:05:43,029 --> 00:05:45,149
problema que yo quiero resolver

127
00:05:45,149 --> 00:05:46,430
quiero

128
00:05:46,430 --> 00:05:48,490
cruzar la calle

129
00:05:48,490 --> 00:05:50,930
ahora me planteo hacer el algoritmo

130
00:05:50,930 --> 00:05:53,129
mires el semáforo

131
00:05:53,129 --> 00:05:54,990
si está en rojo

132
00:05:54,990 --> 00:05:57,870
esperas, si está en verde

133
00:05:57,870 --> 00:05:58,790
sigues

134
00:05:58,790 --> 00:06:01,430
entonces siempre, cualquier algoritmo

135
00:06:01,430 --> 00:06:03,470
que uno quiera plantear, siempre va a haber

136
00:06:03,470 --> 00:06:05,730
puntos en los cuales tenga que pensar

137
00:06:05,730 --> 00:06:06,970
evaluar una condición

138
00:06:06,970 --> 00:06:09,490
y en función de esa condición hacer una cosa

139
00:06:09,490 --> 00:06:11,269
u otra, siempre, yo me quiero ir a París

140
00:06:11,269 --> 00:06:12,389
vale

141
00:06:12,389 --> 00:06:14,949
pero tengo este dinero

142
00:06:14,949 --> 00:06:17,670
eh, miro

143
00:06:17,670 --> 00:06:19,250
eh, billete de avión

144
00:06:19,250 --> 00:06:21,569
¿el precio es menor

145
00:06:21,569 --> 00:06:23,589
que mi dinero? sí, cojo

146
00:06:23,589 --> 00:06:25,370
el avión, ¿el precio es mayor

147
00:06:25,370 --> 00:06:27,589
que mi dinero? no, voy a mirar

148
00:06:27,589 --> 00:06:29,670
la web de autobuses, vale, siempre

149
00:06:29,670 --> 00:06:31,769
cualquier algoritmo que uno se vaya a plantear

150
00:06:31,769 --> 00:06:37,410
para resolver un problema, va a necesitar tener la posibilidad de expresar esta sentencia.

151
00:06:37,629 --> 00:06:42,350
¿Qué esta sentencia es? ¿Esto se cumple? Si hago esto, no se cumple, hago esto otro.

152
00:06:43,250 --> 00:06:49,269
Y esto no es un tema de lenguaje de programación, es una idea, una idea que tenemos que poder expresar.

153
00:06:50,529 --> 00:06:55,629
¿Vale? ¿Cómo expresamos esa idea al margen de cualquier lenguaje de programación?

154
00:06:56,329 --> 00:06:58,769
Bueno, para eso están los diagramas de flujo, son una herramienta.

155
00:07:16,100 --> 00:07:19,699
Los diagramas de flujo son una herramienta gráfica muy chorra y muy sencillita

156
00:07:19,699 --> 00:07:25,060
para visualizar un algoritmo que yo ya tengo hecho, ¿vale?

157
00:07:25,220 --> 00:07:50,779
Los diagramas de flujo son una herramienta para visualizar algoritmos de forma gráfica.

158
00:07:50,959 --> 00:07:55,360
Entonces, cuando estamos en la fase de pensar yo mi algoritmo,

159
00:07:55,439 --> 00:07:57,379
que todavía no estoy programando porque no me hace falta,

160
00:07:57,920 --> 00:08:00,040
cuando estamos en la fase de pensar yo mi algoritmo,

161
00:08:00,120 --> 00:08:02,660
a veces podemos hacer un pequeño diagrama de flujo para verlo.

162
00:08:02,660 --> 00:08:05,439
y de hecho, pues cuando uno está haciendo un software

163
00:08:05,439 --> 00:08:07,379
y está todavía en la fase de diseño

164
00:08:07,379 --> 00:08:08,860
de ver cómo lo hace, para qué, para qué, para qué

165
00:08:08,860 --> 00:08:11,100
pues cuando le quiere pasar

166
00:08:11,100 --> 00:08:13,160
lo que ha hecho a otro para que el otro

167
00:08:13,160 --> 00:08:15,399
continúa, pues le pasa un diagrama de flujo

168
00:08:15,399 --> 00:08:17,279
con lo que ha pensado, no le pasa un código

169
00:08:17,279 --> 00:08:19,620
escrito, le pasa un diagrama de flujo

170
00:08:19,620 --> 00:08:21,199
el otro con el diagrama de flujo dice

171
00:08:21,199 --> 00:08:23,319
ah, vale, este algoritmo lo has hecho así, voy a incorporarle

172
00:08:23,319 --> 00:08:25,399
esto a otro, entonces es una herramienta

173
00:08:26,040 --> 00:08:27,819
para la fase de elaboración

174
00:08:27,819 --> 00:08:29,819
del algoritmo, vale, lo que pasa es como

175
00:08:29,819 --> 00:08:31,639
la usamos tanto, se usa

176
00:08:31,639 --> 00:08:32,940
tanto y está tan extendida

177
00:08:32,940 --> 00:08:35,100
pues tiene ciertas

178
00:08:35,100 --> 00:08:37,559
ciertas reglas, para que todos

179
00:08:37,559 --> 00:08:39,399
usamos las mismas reglas, pero vamos

180
00:08:39,399 --> 00:08:40,100
las reglas

181
00:08:40,100 --> 00:08:43,600
básicas para esta herramienta gráfica

182
00:08:44,460 --> 00:08:45,500
pues son que el diagrama

183
00:08:45,500 --> 00:08:47,279
de flujo tiene un inicio, ¿vale?

184
00:08:47,399 --> 00:08:49,480
eso está claro, tiene un inicio

185
00:08:49,480 --> 00:08:51,639
se puede marcar así o con

186
00:08:51,639 --> 00:08:53,759
un puntito así sin más, tiene el inicio

187
00:08:53,759 --> 00:08:55,820
y ahora a partir de ahí ya empieza

188
00:08:55,820 --> 00:08:57,759
el caminito del algoritmo, y el caminito

189
00:08:57,759 --> 00:08:59,379
es una línea, que va por aquí y por aquí

190
00:08:59,379 --> 00:09:01,840
es una línea, cualquier programa es una línea

191
00:09:01,840 --> 00:09:02,559
que se va ejecutando

192
00:09:02,559 --> 00:09:05,340
sentencia, sentencia, sentencia

193
00:09:05,340 --> 00:09:07,799
vale, y esta línea

194
00:09:07,799 --> 00:09:09,980
se va cruzando ya con acciones

195
00:09:09,980 --> 00:09:11,159
se va cruzando con acciones

196
00:09:11,159 --> 00:09:14,139
las acciones de asignar valor a variables

197
00:09:14,139 --> 00:09:15,820
o de mostrar valor que son las

198
00:09:15,820 --> 00:09:16,659
de entrada y salida

199
00:09:16,659 --> 00:09:19,740
pues se suelen representar con los romboides

200
00:09:19,740 --> 00:09:20,159
estos

201
00:09:20,159 --> 00:09:23,580
¿vale? por ejemplo

202
00:09:23,580 --> 00:09:25,620
pues yo quiero decir leer

203
00:09:25,620 --> 00:09:26,639
mi variable n

204
00:09:26,639 --> 00:09:28,779
por ejemplo

205
00:09:28,779 --> 00:09:30,580
un algoritmo que

206
00:09:30,580 --> 00:09:32,720
recibe dos números

207
00:09:32,720 --> 00:09:34,679
y muestra la suma

208
00:09:34,679 --> 00:09:36,139
pues lo primero que tenemos que hacer

209
00:09:36,139 --> 00:09:38,379
leer del teclado

210
00:09:38,379 --> 00:09:40,740
una variable, pues como eso es una sentencia

211
00:09:40,740 --> 00:09:42,659
de entrada y salida, pues romboide

212
00:09:42,659 --> 00:09:44,620
vale, que es lo siguiente que hago

213
00:09:44,620 --> 00:09:46,779
leer la variable m, pues otra sentencia

214
00:09:46,779 --> 00:09:47,720
de entrada y salida

215
00:09:47,720 --> 00:09:52,840
leer m, vale, aquí

216
00:09:52,840 --> 00:09:55,259
esto es una expresión de lo que

217
00:09:55,259 --> 00:09:56,840
se va a hacer, esto no es lenguaje de planación

218
00:09:56,840 --> 00:09:58,700
aquí no, eso de declarar

219
00:09:58,700 --> 00:09:59,620
no sé qué, no

220
00:09:59,620 --> 00:10:03,080
es una visualización de lo que hay que hacer

221
00:10:03,080 --> 00:10:05,059
vale, mi algoritmo sigue

222
00:10:05,059 --> 00:10:07,159
por aquí, ahora que tengo que hacer

223
00:10:07,159 --> 00:10:08,679
ahora ya una sentencia

224
00:10:08,679 --> 00:10:10,840
una expresión, una operación

225
00:10:10,840 --> 00:10:12,940
para asignar, pues esas

226
00:10:12,940 --> 00:10:14,860
sentencias generales que son operaciones

227
00:10:14,860 --> 00:10:17,440
pues con un cuadradito normal y corriente

228
00:10:17,440 --> 00:10:19,139
pues aquí diríamos

229
00:10:19,139 --> 00:10:21,019
pues por ejemplo, el resultado

230
00:10:21,019 --> 00:10:22,179
que lo llamo r

231
00:10:22,179 --> 00:10:24,299
igual a n más m

232
00:10:24,299 --> 00:10:26,759
vale, sentencias generales

233
00:10:26,759 --> 00:10:29,659
que evalúan expresiones y lo asignan a valores

234
00:10:29,659 --> 00:10:31,320
vale, una vez que he hecho esto

235
00:10:31,320 --> 00:10:33,460
¿qué tengo que hacer? una sentencia de salida

236
00:10:33,460 --> 00:10:34,860
porque ahora lo muestro por pantalla

237
00:10:34,860 --> 00:10:37,860
pues un romboide porque es sentencia de salida

238
00:10:37,860 --> 00:10:39,039
y pongo mostrar

239
00:10:39,039 --> 00:10:41,440
R

240
00:10:41,440 --> 00:10:44,000
vale, he acabado el algoritmo

241
00:10:44,000 --> 00:10:45,259
para resolver el problema

242
00:10:45,259 --> 00:10:47,460
de recibir dos valores y mostrar

243
00:10:47,460 --> 00:10:49,799
la suma, pues sí, ya lo he acabado

244
00:10:49,799 --> 00:10:50,740
pues nada, fin

245
00:10:50,740 --> 00:10:52,980
ala

246
00:10:52,980 --> 00:10:56,470
vale, pues este es un algoritmo válido

247
00:10:56,470 --> 00:10:59,029
Porque es una secuencia de cosas una tras otra

248
00:10:59,029 --> 00:11:01,690
Y eso tiene que ser así siempre

249
00:11:01,690 --> 00:11:02,769
Una secuencia de cosas

250
00:11:02,769 --> 00:11:04,070
Pa, pa, pa, pa

251
00:11:04,070 --> 00:11:04,889
Una tras otra

252
00:11:04,889 --> 00:11:07,269
Aquí no pasan cosas en paralelo, nunca

253
00:11:07,269 --> 00:11:10,129
Una tras otra, pa, pa, pa, pa

254
00:11:10,129 --> 00:11:10,809
¿Vale?

255
00:11:11,149 --> 00:11:12,929
Y además acaba, en un fin

256
00:11:12,929 --> 00:11:14,669
Si no acaba no es un algoritmo válido

257
00:11:14,669 --> 00:11:16,970
Bueno, pues yo ya visualizo esto

258
00:11:16,970 --> 00:11:18,809
Y viendo esto digo

259
00:11:18,809 --> 00:11:21,070
Ah, vale, pues sí, esto hace lo que yo quiero hacer

260
00:11:21,070 --> 00:11:22,970
Y entonces ahora ya

261
00:11:22,970 --> 00:11:25,690
Pues lo puedo pasar a un lenguaje para vaciar

262
00:11:25,690 --> 00:11:29,090
una vez que tengo un diagrama de flujo

263
00:11:29,090 --> 00:11:30,409
pasar al lenguaje de pronunciación

264
00:11:30,409 --> 00:11:31,950
ya es inmediato

265
00:11:31,950 --> 00:11:36,929
bueno, ¿significa esto que vosotros cada vez

266
00:11:36,929 --> 00:11:39,210
que hagáis un programa tenéis que hacer un diagrama de flujo antes?

267
00:11:39,710 --> 00:11:41,990
pues no, lo cuento como que es una herramienta

268
00:11:41,990 --> 00:11:44,110
para visualizar de forma gráfica

269
00:11:44,110 --> 00:11:44,710
algoritmos

270
00:11:44,710 --> 00:11:48,049
y lo he puesto ahora porque para visualizar

271
00:11:48,049 --> 00:11:50,269
gráficamente lo que es una sentencia de decisión

272
00:11:50,269 --> 00:11:51,610
pues nos es muy útil

273
00:11:51,610 --> 00:11:53,850
¿vale? pero nosotros

274
00:11:53,850 --> 00:11:56,289
hacemos programas cortos

275
00:11:56,289 --> 00:11:58,210
entonces pues sí, uno tiene que hacerse un diseño

276
00:11:58,210 --> 00:11:59,129
con su lápiz y papel

277
00:11:59,129 --> 00:12:01,990
cuando ya el programa tiene cierta complejidad

278
00:12:01,990 --> 00:12:04,509
y cuando ya tiene claro lo que quiere hacer

279
00:12:04,509 --> 00:12:05,590
ya se ha hecho sus

280
00:12:05,590 --> 00:12:08,429
tachones y sus cosas en el papel

281
00:12:08,429 --> 00:12:09,090
pues entonces ya

282
00:12:09,090 --> 00:12:10,730
se pone a programa

283
00:12:10,730 --> 00:12:13,950
que cuando estáis haciendo ese primer diseño

284
00:12:13,950 --> 00:12:15,549
de esto como lo hago y ahora le sumo

285
00:12:15,549 --> 00:12:17,230
pues entonces tengo que hacer esto, no sé qué

286
00:12:17,230 --> 00:12:20,789
¿os viene bien usar un diagrama de flujo en vuestro papel y lápiz?

287
00:12:20,929 --> 00:12:22,090
genial, pues lo usáis

288
00:12:22,090 --> 00:12:23,029
¿vale?

289
00:12:23,850 --> 00:12:33,289
Pero lo importante es que antes de hacer un programa, antes hay una, de codificar un código, antes hay una fase que es, ¿qué tengo que hacer? ¿Cómo lo voy a hacer?

290
00:12:33,289 --> 00:12:39,570
Y ahí se hace uno sus graficitos y sus rollos hasta que tiene ya claro cómo lo va a hacer.

291
00:12:39,990 --> 00:12:41,870
Y eso ya ni es Java, ni es Python, ni es nada.

292
00:12:42,250 --> 00:12:45,710
Cuando tiene claro cómo lo va a hacer, pues ahora, hombre, se pone a codificar.

293
00:12:45,710 --> 00:12:47,950
bueno

294
00:12:47,950 --> 00:12:50,049
vale, pues entonces

295
00:12:50,049 --> 00:12:51,190
vamos a incorporar

296
00:12:51,190 --> 00:12:54,149
la sentencia de decisión en nuestros algoritmos

297
00:12:54,149 --> 00:12:55,090
en los algoritmos

298
00:12:55,090 --> 00:12:57,830
bueno, pues por ejemplo, en este algoritmo podría ser

299
00:12:57,830 --> 00:13:00,409
leer n y m

300
00:13:00,409 --> 00:13:02,250
y mostrar

301
00:13:02,250 --> 00:13:04,309
la suma solo en el

302
00:13:04,309 --> 00:13:05,629
caso de que sea positiva

303
00:13:05,629 --> 00:13:08,389
si es negativa, pues mostrar

304
00:13:08,389 --> 00:13:09,909
es negativo

305
00:13:09,909 --> 00:13:11,330
entonces no es válido, por ejemplo

306
00:13:11,330 --> 00:13:14,190
es un programa que necesita sumar

307
00:13:14,190 --> 00:13:16,490
dos variables, pero la suma solo tiene sentido

308
00:13:16,490 --> 00:13:18,389
para esa aplicación si fuera

309
00:13:18,389 --> 00:13:20,330
positiva, por ejemplo, si es negativa

310
00:13:20,330 --> 00:13:22,230
no, bueno, pues ya lo hemos cambiado

311
00:13:22,230 --> 00:13:24,529
leer dos variables, mostrar suma si es positiva

312
00:13:24,529 --> 00:13:25,970
y si no, pues decir

313
00:13:25,970 --> 00:13:28,330
pues no, pues lo siento

314
00:13:28,330 --> 00:13:29,370
el resultado no es válido

315
00:13:29,370 --> 00:13:31,929
bueno, pues este algoritmo

316
00:13:31,929 --> 00:13:34,049
se nos modificaría de esta manera

317
00:13:34,049 --> 00:13:37,500
tendría su inicio

318
00:13:37,500 --> 00:13:40,179
eso, obligatorio como siempre

319
00:13:40,179 --> 00:13:41,860
tenemos que leer dos variables

320
00:13:41,860 --> 00:13:44,000
pues nada, dos sentencias de entrada y salida

321
00:13:44,000 --> 00:13:46,600
leer n

322
00:13:46,600 --> 00:13:52,000
y leer m

323
00:13:52,000 --> 00:13:52,860
vale

324
00:13:52,860 --> 00:13:56,379
ahora obtenemos la suma

325
00:13:56,379 --> 00:13:58,059
vamos pasito por pasito para

326
00:13:58,059 --> 00:14:00,500
r igual a n

327
00:14:00,500 --> 00:14:01,320
más m

328
00:14:01,320 --> 00:14:04,019
y ahora

329
00:14:04,019 --> 00:14:06,179
no saltamos aquí directamente

330
00:14:06,179 --> 00:14:07,720
porque esto

331
00:14:07,720 --> 00:14:09,360
no lo hacemos si o si

332
00:14:09,360 --> 00:14:12,519
claro, aquí tenemos dos opciones

333
00:14:12,519 --> 00:14:13,519
o mostrar r

334
00:14:13,519 --> 00:14:15,539
o mostrar

335
00:14:15,539 --> 00:14:19,980
el resultado inválido, entonces aquí a donde me voy

336
00:14:19,980 --> 00:14:22,860
tengo dos opciones, tengo la opción de

337
00:14:22,860 --> 00:14:28,120
mostrar R o tengo la opción de

338
00:14:28,120 --> 00:14:30,519
no válido, mostrar no válido

339
00:14:30,519 --> 00:14:35,159
tengo que expresar en el algoritmo que tengo esas dos opciones

340
00:14:35,159 --> 00:14:40,240
claro, un algoritmo tiene que saber si nosotros lo hemos definido perfectamente

341
00:14:40,240 --> 00:14:42,320
hay que definir de qué depende

342
00:14:42,320 --> 00:14:45,679
que depende, él no lo va a decidir aleatoriamente

343
00:14:45,679 --> 00:14:47,159
nunca un programa

344
00:14:47,159 --> 00:14:51,279
un programa nunca puede decidir

345
00:14:51,279 --> 00:14:53,980
aleatoriamente que hace, siempre hay que decírselo

346
00:14:53,980 --> 00:14:56,960
todo perfectamente pautado, vale, pues depende

347
00:14:56,960 --> 00:14:59,879
de una condición, ¿cómo expresamos eso aquí?

348
00:15:00,500 --> 00:15:02,659
pues las condiciones se ponen en un rombito

349
00:15:02,659 --> 00:15:06,600
así, y aquí pondríamos R mayor que 0

350
00:15:06,600 --> 00:15:08,120
que esa es mi condición

351
00:15:08,120 --> 00:15:11,019
y las condiciones tienen dos opciones

352
00:15:11,019 --> 00:15:12,299
true o false

353
00:15:12,299 --> 00:15:15,120
dos ramas, la rama del sí

354
00:15:15,120 --> 00:15:18,480
y la rama del no

355
00:15:18,480 --> 00:15:20,440
tienen dos opciones

356
00:15:20,440 --> 00:15:21,799
la rama del sí y la rama del no

357
00:15:21,799 --> 00:15:24,500
¿vale? que la condición

358
00:15:24,500 --> 00:15:25,179
se cumple

359
00:15:25,179 --> 00:15:28,639
el algoritmo tira por la rama del sí

360
00:15:28,639 --> 00:15:30,600
que la condición no se

361
00:15:30,600 --> 00:15:32,480
cumple, el algoritmo tira por la rama del no

362
00:15:32,480 --> 00:15:34,379
y ya se ha acabado

363
00:15:34,379 --> 00:15:35,360
esta sentencia

364
00:15:35,360 --> 00:15:38,019
esto en el diagrama se expresa

365
00:15:38,019 --> 00:15:39,179
que cerramos por aquí

366
00:15:39,179 --> 00:15:41,840
y el programa sigue

367
00:15:41,840 --> 00:15:43,779
el algoritmo sigue si es que tuviera que hacer

368
00:15:43,779 --> 00:15:44,379
más cosas

369
00:15:44,379 --> 00:15:47,700
vamos a suponer que lo que tiene que hacer es ahora decir

370
00:15:47,700 --> 00:15:48,759
adiós, por ejemplo

371
00:15:48,759 --> 00:15:51,539
pues nada, esto vendría aquí, mostrar

372
00:15:51,539 --> 00:15:53,000
adiós, sentencia de salida

373
00:15:53,000 --> 00:15:59,740
y fin, ¿vale?

374
00:16:02,240 --> 00:16:03,399
bueno, pues esto

375
00:16:03,399 --> 00:16:05,759
que en el diagrama de flujo es así

376
00:16:05,759 --> 00:16:06,379
esto

377
00:16:06,379 --> 00:16:10,440
esta es la sentencia de decisión

378
00:16:10,440 --> 00:16:12,139
que se programa con una

379
00:16:12,139 --> 00:16:14,139
única sentencia en el lenguaje Java

380
00:16:14,139 --> 00:16:17,679
sentencia de decisión

381
00:16:17,679 --> 00:16:20,080
o sentencia selectiva

382
00:16:20,080 --> 00:16:21,659
¿Vale?

383
00:16:22,440 --> 00:16:23,320
Toda esta

384
00:16:23,320 --> 00:16:25,539
O sea, la sentencia de decisión

385
00:16:25,539 --> 00:16:27,440
es una sentencia ya compleja

386
00:16:27,440 --> 00:16:28,559
No es como la de asignación

387
00:16:28,559 --> 00:16:30,100
que es una sola línea

388
00:16:30,100 --> 00:16:32,039
A igual a 3 más B

389
00:16:32,039 --> 00:16:35,360
No, la sentencia de decisión es una única sentencia

390
00:16:35,360 --> 00:16:37,580
pero es gorda, tiene cosas dentro

391
00:16:37,580 --> 00:16:38,960
pero es una única sentencia

392
00:16:38,960 --> 00:16:40,779
No asociéis sentencia a línea

393
00:16:40,779 --> 00:16:43,200
No, una sentencia

394
00:16:43,200 --> 00:16:44,399
no es una línea

395
00:16:44,399 --> 00:16:46,279
Eso será una línea de código

396
00:16:46,279 --> 00:16:48,940
una línea de código es una línea de código

397
00:16:48,940 --> 00:16:50,899
está claro, es una línea de mi fichero de texto

398
00:16:50,899 --> 00:16:52,559
pero una sentencia

399
00:16:52,559 --> 00:16:54,639
es otra cosa, una sentencia es un

400
00:16:54,639 --> 00:16:56,440
cuerpo que hace algo

401
00:16:56,440 --> 00:16:58,419
de forma autónoma

402
00:16:58,419 --> 00:17:00,960
una sentencia de asignación lo es

403
00:17:00,960 --> 00:17:03,019
esta es una sentencia

404
00:17:03,019 --> 00:17:04,400
n igual a 3 más b

405
00:17:04,400 --> 00:17:05,900
eso es una sentencia

406
00:17:05,900 --> 00:17:09,240
pero esta, que ahora la escribiremos como es otra

407
00:17:09,240 --> 00:17:11,180
es otra única sentencia

408
00:17:11,180 --> 00:17:12,839
es otra, es una sentencia compleja

409
00:17:12,839 --> 00:17:15,119
porque incorpora una decisión

410
00:17:15,119 --> 00:17:36,140
Lo que hago en la rama del sí y lo que hago en la rama del no, pero es una única sentencia. ¿Que tiene varias líneas de código? Pues sí, tiene varias líneas de código. ¿Vale? Entonces, línea de código es una cosa, es la línea de texto y sentencia es otra. Es un conjunto de líneas de código que hacen algo en concreto. ¿Vale?

411
00:17:36,140 --> 00:17:39,119
hasta ahora que sentencias hemos visto

412
00:17:39,119 --> 00:17:40,940
repito, pues las de

413
00:17:40,940 --> 00:17:42,220
declaración de variables

414
00:17:42,220 --> 00:17:43,960
y las de asignación

415
00:17:43,960 --> 00:17:48,309
asignación leyendo por teclado

416
00:17:48,309 --> 00:17:49,809
o directamente, me da igual

417
00:17:49,809 --> 00:17:51,269
pero son las únicas que hemos visto

418
00:17:51,269 --> 00:17:53,089
y la de mostrar por pantalla

419
00:17:53,089 --> 00:17:55,369
es de las sentencias que hemos visto

420
00:17:55,369 --> 00:17:58,230
que coincidía que se escribían en una línea de código

421
00:17:58,230 --> 00:18:00,230
pues sí, coincidía que se escribían en una línea de código

422
00:18:00,230 --> 00:18:02,250
pero en el resto

423
00:18:02,250 --> 00:18:03,730
de sentencias no, no se van a escribir

424
00:18:03,730 --> 00:18:05,049
en una única línea de código

425
00:18:05,049 --> 00:18:08,109
bueno pues esta es la primera

426
00:18:08,109 --> 00:18:08,609
de ellas

427
00:18:08,609 --> 00:18:10,670
entonces

428
00:18:10,670 --> 00:18:13,410
la visualización gráfica está clara

429
00:18:13,410 --> 00:18:16,130
el algoritmo se parte en dos ramas

430
00:18:16,130 --> 00:18:18,150
pero eso no significa

431
00:18:18,150 --> 00:18:20,170
que el algoritmo haga dos cosas en paralelo

432
00:18:20,170 --> 00:18:22,130
nunca jamás hace dos cosas

433
00:18:22,130 --> 00:18:22,789
en paralelo

434
00:18:22,789 --> 00:18:25,369
el algoritmo o bien va por aquí

435
00:18:25,369 --> 00:18:27,930
o bien va por aquí

436
00:18:27,930 --> 00:18:29,569
depende de los datos de entrada

437
00:18:29,569 --> 00:18:32,130
en una ejecución a lo mejor va por aquí

438
00:18:32,130 --> 00:18:34,970
una única línea

439
00:18:34,970 --> 00:18:37,690
pero dentro de tres días lo vuelvo a ejecutar

440
00:18:37,690 --> 00:18:39,309
meto otros datos distintos

441
00:18:39,309 --> 00:18:40,650
y va por aquí

442
00:18:40,650 --> 00:18:43,009
luego solamente hay un camino

443
00:18:43,009 --> 00:18:45,430
ese camino, ¿qué toma?

444
00:18:45,609 --> 00:18:46,690
¿cuál es? pues depende

445
00:18:46,690 --> 00:18:49,009
a veces tomará uno, a veces tomará otro

446
00:18:49,009 --> 00:18:50,910
pero en cada ejecución

447
00:18:50,910 --> 00:18:52,990
solo toma uno, ¿vale?

448
00:18:53,029 --> 00:18:54,890
esto no es que haga varias cosas a la vez

449
00:18:54,890 --> 00:18:57,289
porque a veces el diagrama de flujos y vemos dos líneas

450
00:18:57,289 --> 00:18:59,230
y decimos, anda, está haciendo dos cosas a la vez

451
00:18:59,230 --> 00:19:00,089
no, está haciendo dos cosas

452
00:19:00,089 --> 00:19:02,990
o hace esto, o hace esto

453
00:19:02,990 --> 00:19:04,630
luego el algoritmo es una

454
00:19:04,630 --> 00:19:10,369
secuencia de cosas, pues esta lo es, esta, esta, esta, esta, esta y esta

455
00:19:10,369 --> 00:19:15,029
para un caso de datos de entrada, o esta, esta, esta, esta, esta y esta

456
00:19:15,029 --> 00:19:18,930
siempre es una secuencia de cosas, nunca se hacen en paralelo nada

457
00:19:18,930 --> 00:19:25,710
y aprovechando ya la visualización del gráfico

458
00:19:25,710 --> 00:19:29,930
la sentencia de decisión, las dos ramas, siempre se tienen que unir

459
00:19:29,930 --> 00:19:32,890
en algún punto, es decir, esta sentencia tiene que terminar

460
00:19:32,890 --> 00:19:35,130
esta sentencia arranca aquí

461
00:19:35,130 --> 00:19:37,490
cuando se evalúa

462
00:19:37,490 --> 00:19:38,869
la decisión, ahí arranca

463
00:19:38,869 --> 00:19:41,670
y termina cuando ya ha completado

464
00:19:41,670 --> 00:19:43,470
la rama que haya ejecutado

465
00:19:43,470 --> 00:19:44,769
¿vale?

466
00:19:45,210 --> 00:19:47,170
entonces, esta rama

467
00:19:47,170 --> 00:19:49,450
se une con esta otra

468
00:19:49,450 --> 00:19:51,569
y esta sentencia a veces

469
00:19:51,569 --> 00:19:53,509
irá por aquí o a veces irá

470
00:19:53,509 --> 00:19:55,609
por aquí, pero vaya por donde vaya

471
00:19:55,609 --> 00:19:57,710
siempre tiene que llegar al mismo punto

472
00:19:57,710 --> 00:19:59,650
siempre, y a partir

473
00:19:59,650 --> 00:20:01,349
de ese punto ya el programa sigue

474
00:20:01,349 --> 00:20:02,990
si es que tiene que hacer más cosas, ya sigue

475
00:20:02,990 --> 00:20:05,549
¿vale? siempre tiene que llegar al mismo punto

476
00:20:05,549 --> 00:20:07,450
no puede ser que esto se abra y a partir

477
00:20:07,450 --> 00:20:08,490
de aquí ya hagamos

478
00:20:08,490 --> 00:20:11,250
vida libre y esta otra hagamos

479
00:20:11,250 --> 00:20:12,849
vida libre, pues entonces habría dos fines

480
00:20:12,849 --> 00:20:15,289
no, solo hay un único

481
00:20:15,289 --> 00:20:17,210
fin, un punto de terminación

482
00:20:17,210 --> 00:20:19,450
solo hay uno, entonces estas dos ramas

483
00:20:19,450 --> 00:20:21,190
se han abierto en función de esta condición

484
00:20:21,190 --> 00:20:23,289
pero se unen cuando termina esta

485
00:20:23,289 --> 00:20:25,190
sentencia, se unen y a partir de aquí

486
00:20:25,190 --> 00:20:27,170
el programa sigue hasta llegar a su fin

487
00:20:27,170 --> 00:20:31,529
¿vale? puede ser

488
00:20:31,529 --> 00:20:32,930
que en una rama no nos interese hacer nada

489
00:20:32,930 --> 00:20:35,630
si es mayor que 0 mostrar R

490
00:20:35,630 --> 00:20:37,910
y si no, nos quedamos

491
00:20:37,910 --> 00:20:38,869
enmudecidos

492
00:20:38,869 --> 00:20:41,549
nada, esto se expresa así, ya está

493
00:20:41,549 --> 00:20:42,769
¿vale?

494
00:20:44,529 --> 00:20:45,009
claro

495
00:20:45,009 --> 00:20:47,009
no, no, no, esto se expresa así

496
00:20:47,009 --> 00:20:49,650
que se cumple, hago esto

497
00:20:49,650 --> 00:20:51,670
y me vengo a este punto, para ya seguir

498
00:20:51,670 --> 00:20:52,670
con el resto del programa

499
00:20:52,670 --> 00:20:55,250
que no se cumple, hago esto

500
00:20:55,250 --> 00:20:56,349
que es nada

501
00:20:56,349 --> 00:20:59,109
y me vengo a este punto, que implica seguir

502
00:20:59,109 --> 00:21:00,170
con el resto del programa

503
00:21:00,170 --> 00:21:02,670
¿vale? y podría también

504
00:21:02,670 --> 00:21:03,670
no tener nada esta

505
00:21:03,670 --> 00:21:06,329
y ser esta la que lo tiene

506
00:21:06,329 --> 00:21:08,430
podría también

507
00:21:08,430 --> 00:21:10,230
entonces esta pues estaría así

508
00:21:10,230 --> 00:21:11,130
y ya está

509
00:21:11,130 --> 00:21:14,470
lo que no tiene sentido es que no tuvieran nada las dos

510
00:21:14,470 --> 00:21:16,369
entonces esto directamente

511
00:21:16,369 --> 00:21:17,490
no sirve para nada

512
00:21:17,490 --> 00:21:20,109
pero una de las dos tiene que tener algo

513
00:21:20,109 --> 00:21:28,970
¿vale? bueno pues entonces

514
00:21:28,970 --> 00:21:30,930
ahora ya teniendo claro

515
00:21:30,930 --> 00:21:32,390
que es esto ahora ya si podemos

516
00:21:32,390 --> 00:21:34,690
codificar esto en lenguaje Java

517
00:21:34,690 --> 00:21:36,450
ya tenemos clarísimo que significa

518
00:21:36,450 --> 00:21:40,789
y como codificamos esto en lenguaje java

519
00:21:40,789 --> 00:21:42,490
lo voy a escribir aquí

520
00:21:42,490 --> 00:21:44,269
primero

521
00:21:44,269 --> 00:21:48,400
vale, pues nuestro programita

522
00:21:48,400 --> 00:21:50,779
ahora ya hacemos esto en lenguaje java

523
00:21:50,779 --> 00:21:53,400
me ahorro el main y todo eso

524
00:21:53,400 --> 00:21:55,000
esto primero de aquí

525
00:21:55,000 --> 00:21:58,220
ya lo sabemos hacer

526
00:21:58,220 --> 00:22:00,720
mi variable n la voy a leer del teclado

527
00:22:00,720 --> 00:22:02,700
supongo que tengo el escáner por ahí arriba

528
00:22:02,700 --> 00:22:08,500
a la leída

529
00:22:08,500 --> 00:22:11,099
mi variable m también

530
00:22:11,099 --> 00:22:23,720
Vale, ya he programado las dos primeras

531
00:22:23,720 --> 00:22:24,619
Tengo una duda

532
00:22:24,619 --> 00:22:26,160
Pero es más de estética

533
00:22:26,160 --> 00:22:27,099
Estética

534
00:22:27,099 --> 00:22:30,059
Cuando pones lo del lector

535
00:22:30,059 --> 00:22:32,359
¿Compensa ponerlo en mayúsculas porque es un objeto?

536
00:22:32,900 --> 00:22:33,759
No, no, no, no, no

537
00:22:33,759 --> 00:22:36,000
Porque lector es el nombre de la variable

538
00:22:36,000 --> 00:22:37,619
Los nombres de variable

539
00:22:37,619 --> 00:22:41,019
Es recomendable que empiecen siempre por minúsculo

540
00:22:41,019 --> 00:22:43,039
Da igual que sean variables tipo objeto

541
00:22:43,039 --> 00:22:45,099
Lo que sí que empieza por mayúsculas

542
00:22:45,099 --> 00:22:46,079
Es el nombre del tipo

543
00:22:46,079 --> 00:22:47,619
El nombre del tipo sí

544
00:22:47,619 --> 00:22:50,059
Escarne los mayúsculas, los nombres de las variables

545
00:22:50,059 --> 00:22:51,839
para que se vea, son variables

546
00:22:51,839 --> 00:22:54,079
para ver si son de tipo objeto o no

547
00:22:54,079 --> 00:22:55,640
uno se va al tipo de la declaración

548
00:22:55,640 --> 00:22:57,640
y dice, ah, entonces esto es tipo objeto

549
00:22:57,640 --> 00:23:00,730
vale, entonces

550
00:23:00,730 --> 00:23:03,190
ahora que nos falta, guardar una variable de resultado

551
00:23:03,190 --> 00:23:03,950
pues venga

552
00:23:03,950 --> 00:23:09,029
int r igual a n más m

553
00:23:09,029 --> 00:23:11,049
y ahora seguimos

554
00:23:11,049 --> 00:23:12,430
programando nuestro código

555
00:23:12,430 --> 00:23:14,849
y decimos, ah, ahora me viene una

556
00:23:14,849 --> 00:23:15,930
sentencia de decisión

557
00:23:15,930 --> 00:23:18,630
que es, evalúo una condición

558
00:23:18,630 --> 00:23:20,390
rama del sí

559
00:23:20,390 --> 00:23:21,769
rama del no

560
00:23:21,769 --> 00:23:25,210
vale, pues ahora ya nos vamos

561
00:23:25,210 --> 00:23:26,789
a la sentencia de decisión, toda esta

562
00:23:26,789 --> 00:23:29,089
pues toda esta sentencia de decisión

563
00:23:29,089 --> 00:23:29,630
¿cómo es?

564
00:23:30,849 --> 00:23:33,829
if entre paréntesis

565
00:23:33,829 --> 00:23:34,849
la condición

566
00:23:34,849 --> 00:23:37,190
una condición válida como las que ya sabemos

567
00:23:37,190 --> 00:23:38,470
hacer, condición

568
00:23:38,470 --> 00:23:40,789
todo lo larga o corta que

569
00:23:40,789 --> 00:23:42,950
nos interese, r

570
00:23:42,950 --> 00:23:44,309
es mayor que cero

571
00:23:44,309 --> 00:23:47,410
¿vale? y ahora en general

572
00:23:47,410 --> 00:23:48,529
la forma más general

573
00:23:48,529 --> 00:23:49,910
entre llaves

574
00:23:49,910 --> 00:23:53,049
que por cuestiones de estilo

575
00:23:53,049 --> 00:23:55,670
pues la llave de apertura

576
00:23:55,670 --> 00:23:56,970
la pongo detrás del if

577
00:23:56,970 --> 00:23:58,950
y la de cierre

578
00:23:58,950 --> 00:24:01,730
la pongo aquí a la misma altura

579
00:24:01,730 --> 00:24:04,009
que el if, para que el estilo quede bonito

580
00:24:04,009 --> 00:24:05,490
no es que sea obligatorio

581
00:24:05,490 --> 00:24:07,210
podría ponerlo todo seguido, todo abajo

582
00:24:07,210 --> 00:24:09,309
pero que haría un programa muy feo y con un estilo

583
00:24:09,309 --> 00:24:11,950
cero, con lo cual nadie os contrataría

584
00:24:11,950 --> 00:24:13,589
vale, pues aquí

585
00:24:13,589 --> 00:24:14,430
entre estas llaves

586
00:24:14,430 --> 00:24:17,109
lo que yo hago en la rama del sí

587
00:24:17,109 --> 00:24:19,289
que puede ser una o muchas sentencias

588
00:24:19,289 --> 00:24:21,269
no tiene por qué ser una, puede ser una

589
00:24:21,269 --> 00:24:22,930
muchas, yo en este caso solo tenía una

590
00:24:22,930 --> 00:24:24,569
que era mostrar el resultado

591
00:24:24,569 --> 00:24:26,029
pues en este caso

592
00:24:26,029 --> 00:24:29,430
solo tenía mostrar lo abrevio

593
00:24:29,430 --> 00:24:30,009
R

594
00:24:30,009 --> 00:24:33,150
y no tengo más, pero puede ser que aquí

595
00:24:33,150 --> 00:24:34,230
tuviera muchas cosas

596
00:24:34,230 --> 00:24:35,710
puede ser que tuviera muchas

597
00:24:35,710 --> 00:24:38,869
vale, pues la rama del sí ha terminado

598
00:24:38,869 --> 00:24:40,829
esta llave se cierra

599
00:24:40,829 --> 00:24:43,150
¿cómo expreso lo que se hace

600
00:24:43,150 --> 00:24:44,089
en la rama del no?

601
00:24:45,269 --> 00:24:46,529
pues poniendo un else

602
00:24:46,529 --> 00:24:49,109
abriendo otra llave

603
00:24:49,109 --> 00:24:51,269
que se cierra

604
00:24:51,269 --> 00:24:53,150
aquí por cuestiones de estilo

605
00:24:53,150 --> 00:24:55,470
también, y aquí pongo

606
00:24:55,470 --> 00:24:57,430
lo que se hace en esta

607
00:24:57,430 --> 00:24:59,329
rama, que de nuevo puede ser

608
00:24:59,329 --> 00:25:01,450
una o muchas, en este caso

609
00:25:01,450 --> 00:25:03,349
era mostrar no válido

610
00:25:03,349 --> 00:25:07,609
pues venga, no

611
00:25:07,609 --> 00:25:08,430
válido

612
00:25:08,430 --> 00:25:16,529
si, si, si

613
00:25:16,529 --> 00:25:18,509
estas llaves

614
00:25:18,509 --> 00:25:20,789
incluyen lo que se hace

615
00:25:20,789 --> 00:25:22,529
en la rama del sí, luego

616
00:25:22,529 --> 00:25:24,710
viene el se, y estas llaves incluyen lo que se

617
00:25:24,710 --> 00:25:25,549
hace en la rama del no

618
00:25:25,549 --> 00:25:30,049
Bueno, es que el ELSI ya significa

619
00:25:30,049 --> 00:25:31,390
Si esta no, va asociado a esta

620
00:25:31,390 --> 00:25:33,109
Va asociado al IF aunque vaya fuera

621
00:25:33,109 --> 00:25:36,069
Claro, claro, el ELSI siempre va con un IF

622
00:25:36,069 --> 00:25:38,069
Porque no ha puesto punto y coma para terminarla

623
00:25:38,069 --> 00:25:39,789
Claro, claro, el ELSI siempre va con un IF

624
00:25:39,789 --> 00:25:41,250
Siempre va con un IF

625
00:25:41,250 --> 00:25:44,150
El ELSI se refiere si la condición del IF

626
00:25:44,150 --> 00:25:44,589
Falsa

627
00:25:44,589 --> 00:25:47,589
El ELSI suelto nunca puede ir

628
00:25:47,589 --> 00:25:49,849
No va englobado como en el mismo

629
00:25:49,849 --> 00:25:52,349
Claro, pero

630
00:25:52,349 --> 00:25:56,549
Sí, claro

631
00:25:56,549 --> 00:25:58,750
True esto, false esto

632
00:25:58,750 --> 00:26:00,789
El else, si tú lo escribes solo en Java

633
00:26:00,789 --> 00:26:02,210
El else no te dice

634
00:26:02,210 --> 00:26:03,210
Y este else no ha salido

635
00:26:03,210 --> 00:26:05,529
Tiene que haber un if siempre antes

636
00:26:05,529 --> 00:26:06,950
Con unas sentencias metidas

637
00:26:06,950 --> 00:26:10,549
Vale, que alguna de las dos ramas no tiene nada

638
00:26:10,549 --> 00:26:12,269
Dejo esto en blanco

639
00:26:12,269 --> 00:26:12,710
Ya está

640
00:26:12,710 --> 00:26:15,029
No pasa nada, lo puedo dejar en blanco

641
00:26:15,029 --> 00:26:16,470
¿Vale?

642
00:26:17,009 --> 00:26:17,750
Una pregunta

643
00:26:17,750 --> 00:26:20,890
En Java, en este caso

644
00:26:20,890 --> 00:26:22,930
se va a identificar hasta else

645
00:26:22,930 --> 00:26:24,490
que acaba ahí en la sentencia if

646
00:26:24,490 --> 00:26:27,490
claro, entonces, cuando el else ya ha terminado

647
00:26:27,490 --> 00:26:29,549
este cuadrito

648
00:26:29,549 --> 00:26:32,430
es la sentencia if

649
00:26:32,430 --> 00:26:32,990
que yo digo

650
00:26:32,990 --> 00:26:34,950
que es esta, esto de aquí

651
00:26:34,950 --> 00:26:36,390
o sea, esto es esto

652
00:26:36,390 --> 00:26:40,089
la programación de esto es esto

653
00:26:40,089 --> 00:26:41,829
y eso es una única sentencia

654
00:26:41,829 --> 00:26:43,970
no

655
00:26:43,970 --> 00:26:46,130
no, porque es no

656
00:26:46,130 --> 00:26:48,490
o sea, sí o no

657
00:26:48,490 --> 00:26:49,589
no hay más opciones

658
00:26:49,589 --> 00:26:51,269
sí o no

659
00:26:51,269 --> 00:26:53,289
una condición no es sí o es no

660
00:26:53,289 --> 00:26:55,809
claro, puedes poner

661
00:26:55,809 --> 00:26:57,710
efectivamente más sí, pero eso

662
00:26:57,710 --> 00:26:59,009
es otra sentencia

663
00:26:59,009 --> 00:27:01,190
claro, es otra

664
00:27:01,190 --> 00:27:03,369
bueno, más que otra sentencia es otro formato

665
00:27:03,369 --> 00:27:04,589
de lo mismo

666
00:27:04,589 --> 00:27:07,309
pero sentencia de decisión como tal

667
00:27:07,309 --> 00:27:09,089
solo existe esto

668
00:27:09,089 --> 00:27:11,150
porque esto es lo único que vamos a hacer

669
00:27:11,150 --> 00:27:13,329
en función de la condición y me he formulado otro

670
00:27:13,329 --> 00:27:15,289
luego otra cosa es que hay situaciones

671
00:27:15,289 --> 00:27:17,210
concretas que con otra

672
00:27:17,210 --> 00:27:19,390
manera de describir esto a lo mejor nos es más fácil

673
00:27:19,390 --> 00:27:21,289
de escribir, eso ya lo hemos hablado, ¿vale?

674
00:27:21,390 --> 00:27:23,430
Pero esta es la única necesaria, no hace falta

675
00:27:23,430 --> 00:27:25,210
nada más, no hace falta nada más

676
00:27:25,210 --> 00:27:27,210
¿vale? Entonces

677
00:27:27,210 --> 00:27:29,670
importante, que veáis

678
00:27:29,670 --> 00:27:31,470
esto como una única sentencia

679
00:27:31,470 --> 00:27:33,190
entonces

680
00:27:33,190 --> 00:27:35,569
cuando Java ve el comienzo de un if

681
00:27:35,569 --> 00:27:37,650
ya sabe que tendrá una condición

682
00:27:37,650 --> 00:27:39,569
después, un bloque

683
00:27:39,569 --> 00:27:41,490
esto que está entre llaves lo llamamos bloque

684
00:27:41,490 --> 00:27:43,430
en general, lo que va

685
00:27:43,430 --> 00:27:45,349
un código entre llaves lo llamamos bloque

686
00:27:45,349 --> 00:27:47,549
¿vale? Entonces ya hemos

687
00:27:47,549 --> 00:27:49,670
visto en realidad antes un bloque

688
00:27:49,670 --> 00:27:51,190
porque cuando hacíamos el método main

689
00:27:51,190 --> 00:27:53,490
ya abríamos una llave

690
00:27:53,490 --> 00:27:55,509
y la cerrábamos, entonces ya

691
00:27:55,509 --> 00:27:57,549
hemos trabajado con bloques, lo que pasa es que hasta

692
00:27:57,549 --> 00:27:59,170
ahora nuestro bloque era

693
00:27:59,170 --> 00:28:01,569
todo el programa enterito, todo el programa

694
00:28:01,569 --> 00:28:03,630
que es lo que estaba en el main, todo era nuestro bloque

695
00:28:03,630 --> 00:28:05,549
ahora fijaos que dentro

696
00:28:05,549 --> 00:28:07,450
de todo nuestro programa

697
00:28:07,450 --> 00:28:09,549
hemos abierto un subbloque

698
00:28:09,549 --> 00:28:11,430
más pequeñito, eso tiene

699
00:28:11,430 --> 00:28:13,549
implicaciones que ahora tampoco nos vamos a meter

700
00:28:13,549 --> 00:28:15,289
en ellas, simplemente deciros

701
00:28:15,289 --> 00:28:17,349
que un código entre llaves

702
00:28:17,349 --> 00:28:19,650
se le llama bloque, en términos de

703
00:28:19,650 --> 00:28:20,849
programación se le llama bloque

704
00:28:20,849 --> 00:28:23,869
vale, pues entonces, la máquina virtual

705
00:28:23,869 --> 00:28:25,630
en cuanto ve un if, ya sabe

706
00:28:25,630 --> 00:28:27,589
que necesita una condición

707
00:28:27,589 --> 00:28:29,430
después, si no la ve te va a avisar

708
00:28:29,430 --> 00:28:30,569
te va a decidir la condición

709
00:28:30,569 --> 00:28:34,089
y luego ya sabe que vendrá un bloque de sentencias

710
00:28:34,089 --> 00:28:37,410
y luego ya sabe que vendrá

711
00:28:37,410 --> 00:28:39,250
opcionalmente

712
00:28:39,250 --> 00:28:41,309
o no un else, porque

713
00:28:41,309 --> 00:28:43,609
este no es obligatorio

714
00:28:43,609 --> 00:28:45,809
es decir, si nos ha

715
00:28:45,809 --> 00:28:47,309
quedado una sentencia if así

716
00:28:47,309 --> 00:28:49,470
podemos

717
00:28:49,470 --> 00:28:51,869
quitar esto, es decir

718
00:28:51,869 --> 00:28:52,930
podría yo poner esto

719
00:28:52,930 --> 00:28:55,609
y a Java le parece estupendo

720
00:28:55,609 --> 00:28:57,250
no pasa nada, pongo esto

721
00:28:57,250 --> 00:28:59,950
pero poner else sin nada

722
00:28:59,950 --> 00:29:02,150
adentro, se puede

723
00:29:02,150 --> 00:29:04,029
poner como quitar el else

724
00:29:04,029 --> 00:29:04,430
y ya está

725
00:29:04,430 --> 00:29:07,349
entonces si Java

726
00:29:07,349 --> 00:29:08,769
ve un if

727
00:29:08,769 --> 00:29:11,990
y ve que después del bloque de la rama

728
00:29:11,990 --> 00:29:13,990
del si no tiene nada aquí, no tiene

729
00:29:13,990 --> 00:29:15,990
el else, asume que se

730
00:29:15,990 --> 00:29:17,730
acabó, que terminó la sentencia ahí

731
00:29:17,730 --> 00:29:19,670
porque la rama del no, no existe

732
00:29:19,670 --> 00:29:22,269
con lo cual en ese caso la sentencia

733
00:29:22,269 --> 00:29:23,450
ha terminado aquí

734
00:29:23,450 --> 00:29:26,150
ahí terminó, y ya sigue

735
00:29:26,150 --> 00:29:27,450
con lo que venga a continuación

736
00:29:27,450 --> 00:29:29,950
que ya es otra sentencia distinta con lo que sea

737
00:29:29,950 --> 00:29:30,670
¿vale?

738
00:29:32,630 --> 00:29:33,750
¿que ve un else?

739
00:29:34,269 --> 00:29:36,029
vale, pues si ve

740
00:29:36,029 --> 00:29:37,930
un else, entonces

741
00:29:37,930 --> 00:29:38,569
ahora ya

742
00:29:38,569 --> 00:29:41,529
es porque hay sentencias

743
00:29:43,990 --> 00:29:45,470
Y hacer las sentencias que sean.

744
00:29:46,470 --> 00:29:46,650
¿Vale?

745
00:29:46,769 --> 00:29:48,650
Pero el else puede no existir.

746
00:29:49,329 --> 00:29:50,750
Pero siempre hay que poner i.

747
00:29:51,269 --> 00:29:52,029
Eso sí.

748
00:29:52,529 --> 00:29:53,329
Eso sí.

749
00:29:53,750 --> 00:29:54,049
Claro.

750
00:29:54,490 --> 00:29:56,470
Podría, imaginaos en el programa de antes,

751
00:29:57,130 --> 00:29:58,849
que lo que no se hace nada es aquí

752
00:29:58,849 --> 00:30:00,750
y aquí se hace una cosa.

753
00:30:01,349 --> 00:30:02,609
Llamémosle a por abreviar.

754
00:30:02,950 --> 00:30:04,190
Vamos a suponer que este es mi algoritmo,

755
00:30:04,269 --> 00:30:05,089
que ahí me ha salido así.

756
00:30:05,750 --> 00:30:07,809
Entonces yo pondría si r mayor que cero,

757
00:30:08,009 --> 00:30:08,650
i vacío.

758
00:30:09,309 --> 00:30:12,529
Y luego pondría else a.

759
00:30:12,529 --> 00:30:14,809
la codificación de esto

760
00:30:14,809 --> 00:30:16,869
es esto, claro, otra cosa

761
00:30:16,869 --> 00:30:18,170
es que queda horrible

762
00:30:18,170 --> 00:30:20,730
claro, para eso

763
00:30:20,730 --> 00:30:22,569
cambias la condición y pones la negada

764
00:30:22,569 --> 00:30:24,789
¿no? si ponemos

765
00:30:24,789 --> 00:30:26,809
la negada, lo que va

766
00:30:26,809 --> 00:30:28,829
en la rama del no pasa a la rama del sí

767
00:30:28,829 --> 00:30:30,910
y lo que va en la rama del sí pasa a la rama del no

768
00:30:30,910 --> 00:30:32,990
¿no? si esta condición

769
00:30:32,990 --> 00:30:34,890
se cumple hago esto, y si no se cumple

770
00:30:34,890 --> 00:30:36,750
hago esto, si la condición la pones al revés

771
00:30:36,750 --> 00:30:38,690
si esta condición no se cumple

772
00:30:38,690 --> 00:30:40,769
la rama del no pasa a la rama del sí

773
00:30:40,769 --> 00:30:42,650
y al revés, entonces para

774
00:30:42,650 --> 00:30:44,470
dejar este código así tan feo

775
00:30:44,470 --> 00:30:46,809
ponemos la condición al revés

776
00:30:46,809 --> 00:30:48,589
la negamos, no R

777
00:30:48,589 --> 00:30:50,730
mayor que 0, con lo cual este

778
00:30:50,730 --> 00:30:52,710
pasa aquí arriba y el

779
00:30:52,710 --> 00:30:53,849
else se ha quedado vacío

780
00:30:53,849 --> 00:30:56,289
y como ahora el else es el que se ha quedado vacío

781
00:30:56,289 --> 00:30:58,549
el else ya sí que lo puedo quitar

782
00:30:58,549 --> 00:31:00,650
entonces más bonito ese

783
00:31:00,650 --> 00:31:02,450
código que el anterior, más bonito

784
00:31:02,450 --> 00:31:04,630
¿vale? y luego ya

785
00:31:04,630 --> 00:31:06,430
si lo terminamos de arreglar, no R

786
00:31:06,430 --> 00:31:08,470
mayor que 0, hombre es más fácil poner

787
00:31:08,470 --> 00:31:10,069
R menor o igual que 0, ¿verdad?

788
00:31:10,069 --> 00:31:11,609
Pero es lo mismo

789
00:31:11,609 --> 00:31:13,690
Pero ya si lo queremos dejar más bonito

790
00:31:13,690 --> 00:31:15,250
Pues pondríamos R menor o igual que 0

791
00:31:15,250 --> 00:31:15,990
Que es la negada

792
00:31:15,990 --> 00:31:19,049
Pero eso ya, bueno, es solamente para retocar

793
00:31:19,049 --> 00:31:20,170
Nada más

794
00:31:20,170 --> 00:31:21,670
¿Vale?

795
00:31:22,230 --> 00:31:23,710
Entonces la sentencia aquí se

796
00:31:23,710 --> 00:31:27,490
Y esta es la única sentencia necesaria

797
00:31:27,490 --> 00:31:29,410
Lo que pasa es que, repito

798
00:31:29,410 --> 00:31:31,650
Luego hay muchas situaciones que se pueden repetir

799
00:31:31,650 --> 00:31:33,750
Muchas veces casos prácticos

800
00:31:33,750 --> 00:31:34,529
Pueden repetir

801
00:31:34,529 --> 00:31:37,150
Entonces observamos, uy, pues

802
00:31:37,150 --> 00:31:39,589
Ese caso práctico

803
00:31:39,589 --> 00:31:41,150
para programarlo con el if-else

804
00:31:41,150 --> 00:31:43,509
tengo que anidar un montón de if-else

805
00:31:43,509 --> 00:31:45,789
luego lo vemos, bueno pues te permite

806
00:31:45,789 --> 00:31:48,029
un atajo para escribirlo más rápidamente

807
00:31:48,029 --> 00:31:49,750
ya está, es un atajo para escribirlo

808
00:31:49,750 --> 00:31:51,890
más rápidamente, lo único que existe en realidad

809
00:31:51,890 --> 00:31:54,069
es esto, el if y el else

810
00:31:54,069 --> 00:31:55,890
es lo único que computacionalmente

811
00:31:56,609 --> 00:31:58,190
se ejecuta, lo único que se ejecuta

812
00:31:58,190 --> 00:32:00,089
vale, otra cosa es que lo podamos

813
00:32:00,089 --> 00:32:01,990
escribir de otra manera más abreviada

814
00:32:01,990 --> 00:32:03,890
en casos concretos

815
00:32:03,890 --> 00:32:08,700
bueno, pues entendidísimo

816
00:32:08,700 --> 00:32:09,119
esto

817
00:32:09,119 --> 00:32:11,759
vale, solo un

818
00:32:11,759 --> 00:32:15,299
pequeño matiz más ahora mismo, antes de hacer algún ejemplo

819
00:32:15,299 --> 00:32:17,720
con mi fielse. Cuando solo tenemos

820
00:32:17,720 --> 00:32:20,220
una sentencia dentro y solo una,

821
00:32:21,140 --> 00:32:23,720
las llaves son opcionales. No hace falta que estén.

822
00:32:24,619 --> 00:32:25,759
Si solo tenemos una,

823
00:32:26,859 --> 00:32:30,039
¿vale? En mi ejemplo de antes, cuando yo solo tenía el este,

824
00:32:30,339 --> 00:32:32,920
bla, bla, bla, bla, puedo quitar la llave.

825
00:32:36,000 --> 00:32:37,519
No, no pondría punto y coma.

826
00:32:38,319 --> 00:32:40,559
No pongo punto y coma en ningún lado. Bueno, perdón, aquí.

827
00:32:40,559 --> 00:32:41,619
Sí, sí, sí, aquí sí

828
00:32:41,619 --> 00:32:44,160
Claro, las sentencias que te referías

829
00:32:44,160 --> 00:32:46,059
Después de... vale, vale, sí, sí

830
00:32:46,059 --> 00:32:46,880
Ahí sí, claro

831
00:32:46,880 --> 00:32:50,480
Si solo tengo una

832
00:32:50,480 --> 00:32:52,259
Estas llaves son opcionales

833
00:32:52,259 --> 00:32:54,160
Si tengo más de una

834
00:32:54,160 --> 00:32:56,039
Esta, otra, otra, otra

835
00:32:56,039 --> 00:32:57,799
Tengo que englobarlas

836
00:32:57,799 --> 00:32:59,660
En un bloque, ¿vale?

837
00:32:59,700 --> 00:33:01,079
Porque si no, Java se hace un lío

838
00:33:01,079 --> 00:33:02,900
Porque fijaos la situación

839
00:33:02,900 --> 00:33:06,059
Imaginaos que yo quiero meter dos sentencias

840
00:33:06,059 --> 00:33:07,660
Esta y esta otra

841
00:33:07,660 --> 00:33:10,019
Y me he olvidado de poner las llaves

842
00:33:10,019 --> 00:33:12,980
me he olvidado de poner las llaves

843
00:33:12,980 --> 00:33:15,200
entonces, aquí se genera

844
00:33:15,200 --> 00:33:17,599
una ambigüedad gordísima

845
00:33:17,599 --> 00:33:19,839
la máquina virtual empieza a interpretar

846
00:33:19,839 --> 00:33:20,140
esto

847
00:33:20,140 --> 00:33:22,839
si la condición se cumple

848
00:33:22,839 --> 00:33:24,099
¿vale?

849
00:33:26,019 --> 00:33:27,859
la siguiente sentencia

850
00:33:27,859 --> 00:33:29,619
es esta, y él interpreta

851
00:33:29,619 --> 00:33:32,119
ah, vale, no hay un else, es un if sin else

852
00:33:32,119 --> 00:33:33,980
interpreta que este

853
00:33:33,980 --> 00:33:35,740
ya es fuera de la sentencia

854
00:33:35,740 --> 00:33:37,140
interpreta que ya es fuera

855
00:33:37,140 --> 00:33:39,819
¿vale? como no has puesto llaves

856
00:33:39,819 --> 00:33:42,079
pues entonces solo es una sentencia

857
00:33:42,079 --> 00:33:43,839
entonces interpreta

858
00:33:43,839 --> 00:33:45,440
que esta ya no hay un else

859
00:33:45,440 --> 00:33:46,519
y esta ya está fuera

860
00:33:46,519 --> 00:33:49,500
entonces si yo quiero que las dos se hagan

861
00:33:49,500 --> 00:33:50,380
en la rama del sí

862
00:33:50,380 --> 00:33:53,880
tengo que meterla entre llaves

863
00:33:53,880 --> 00:33:55,359
¿vale?

864
00:33:58,190 --> 00:33:59,329
es decir, en este caso

865
00:33:59,329 --> 00:34:01,349
las dos se hacen

866
00:34:01,349 --> 00:34:02,589
si la condición se cumple

867
00:34:02,589 --> 00:34:03,509
las dos

868
00:34:03,509 --> 00:34:05,930
pero si quito las llaves

869
00:34:05,930 --> 00:34:08,630
él asume que es solo la primera

870
00:34:08,630 --> 00:34:10,510
porque no hay llaves, solo la primera

871
00:34:10,510 --> 00:34:12,510
vale, pues la rama del sí es la primera

872
00:34:12,510 --> 00:34:14,389
y como luego no veo un else, dice

873
00:34:14,389 --> 00:34:16,570
será que no hay else porque no hay rama del no, no hay else

874
00:34:16,570 --> 00:34:18,929
y ya interpreta que esta ya

875
00:34:18,929 --> 00:34:20,969
es la que hay que hacer después de que la sentencia

876
00:34:20,969 --> 00:34:23,230
hizo acabado, después, la que vendría aquí abajo

877
00:34:23,230 --> 00:34:24,809
la hace

878
00:34:24,809 --> 00:34:27,130
y luego ya viene el se suelto, el se suelto no existe

879
00:34:27,130 --> 00:34:28,869
no tiene sentido, entonces te marca

880
00:34:28,869 --> 00:34:31,269
error de compilación, te dice y es el se suelto

881
00:34:31,269 --> 00:34:32,650
a que viene, vale

882
00:34:32,650 --> 00:34:35,269
entonces, para obtener esos errores

883
00:34:35,269 --> 00:34:37,050
lógicamente cuando son varias

884
00:34:37,050 --> 00:34:38,969
las sentencias es obligatorio

885
00:34:38,969 --> 00:34:44,590
obligatorio, es obligatorio que estén entre llaves, ¿vale? Si solo es una, pues no hace

886
00:34:44,590 --> 00:34:54,889
falta, ¿vale? Bueno, pues antes de complicarlo más, vamos a buscar algún ejemplo o algo

887
00:34:54,889 --> 00:35:23,019
para practicar. Vale, y ahora, pregunta sin ninguna trascendencia práctica. ¿Cuántos

888
00:35:23,019 --> 00:35:25,079
habéis acabado desconectando

889
00:35:25,079 --> 00:35:29,099
en todo el proyecto que he contado ahí?

890
00:35:29,679 --> 00:35:30,360
¿Lanzar la mano?

891
00:35:31,599 --> 00:35:32,760
No es para quedarme con vuestra casa,

892
00:35:32,780 --> 00:35:33,679
si con vuestra casa ya me he quedado.

893
00:35:34,579 --> 00:35:36,380
Es por tener esa alimentación.

894
00:35:36,480 --> 00:35:37,619
¿Cuándo se habéis acabado desconectando?

895
00:35:37,659 --> 00:35:39,039
¿De verdad, con absoluta sinceridad?

896
00:35:40,179 --> 00:35:41,119
No sé si entero.

897
00:35:42,119 --> 00:35:43,179
No sé si entero.

898
00:35:43,400 --> 00:35:44,039
La vez más y más.

899
00:35:45,380 --> 00:35:45,739
Vale.

900
00:35:46,400 --> 00:35:47,780
¿Los demás que han levantado la mano

901
00:35:47,780 --> 00:35:49,619
no han acabado desconectando y lo han seguido?

902
00:35:50,920 --> 00:35:52,679
Bueno, pues habéis desconectado unos cuantos.

903
00:35:53,019 --> 00:35:54,719
¿Y por qué habéis acabado desconectando?

904
00:35:54,719 --> 00:35:55,480
¿Por qué se ha terminado?

905
00:36:00,440 --> 00:36:04,360
¿Por qué mucho rato hablando seguido?

906
00:36:12,610 --> 00:36:14,590
Sí, pero bueno, a ver, si entiendes

907
00:36:14,590 --> 00:36:16,449
que si esta condición

908
00:36:16,449 --> 00:36:17,969
pones la negada,

909
00:36:18,550 --> 00:36:20,829
lo que toca hacer cuando esta condición se cumple

910
00:36:20,829 --> 00:36:22,789
tocaría hacerlo cuando no se cumple

911
00:36:22,789 --> 00:36:23,769
porque has puesto la negada.

912
00:36:24,909 --> 00:36:26,090
Y si tú esta condición,

913
00:36:26,550 --> 00:36:27,130
llámale A.

914
00:36:27,590 --> 00:36:29,329
Cuando A se cumple, haces esto.

915
00:36:29,469 --> 00:36:31,309
Y cuando A no se cumple, haces esto.

916
00:36:31,750 --> 00:36:33,769
Si en lugar de A pones

917
00:36:33,769 --> 00:36:37,159
si en lugar de A

918
00:36:37,159 --> 00:36:39,539
pones la negada de A,

919
00:36:40,699 --> 00:36:41,920
cuando A se cumple,

920
00:36:42,039 --> 00:36:43,219
entonces toca hacer lo que hay aquí.

921
00:36:43,500 --> 00:36:44,940
Y cuando no se cumple, toca hacer esto.

922
00:36:45,360 --> 00:36:48,039
Entonces, siempre que cambias con un negado delante

923
00:36:48,039 --> 00:36:49,300
la condición que hay aquí,

924
00:36:49,539 --> 00:36:51,380
lo que hay aquí pasa aquí, lo que hay aquí pasa aquí.

925
00:36:52,059 --> 00:36:53,599
Claro, y estás haciendo lo mismo, en realidad.

926
00:36:54,460 --> 00:36:54,639
¿Vale?

927
00:36:54,639 --> 00:36:56,920
Entonces, ¿eso para qué lo hemos hecho?

928
00:36:57,400 --> 00:36:59,000
Pues si te queda un if vacío

929
00:36:59,000 --> 00:37:00,920
Que queda muy feo, porque el if es obligatorio

930
00:37:00,920 --> 00:37:02,380
Y no lo puedes quitar, si te queda un if vacío

931
00:37:02,380 --> 00:37:05,000
Cámbiala, y lo del else pasa al if

932
00:37:05,000 --> 00:37:06,400
Y el if al else

933
00:37:06,400 --> 00:37:08,639
Y al else, como se queda vacío, lo puedes quitar

934
00:37:08,639 --> 00:37:11,780
Claro, para cambiar

935
00:37:11,780 --> 00:37:14,159
Esto pasa aquí y esto pasa aquí

936
00:37:14,159 --> 00:37:15,460
Si le pones el negado delante

937
00:37:15,460 --> 00:37:18,809
Bueno, pues a ver

938
00:37:18,809 --> 00:37:25,000
Tenemos aquí

939
00:37:25,000 --> 00:37:28,920
Unos cuantos ejercicios

940
00:37:28,920 --> 00:37:30,440
Bueno, algunos mejores que peores

941
00:37:30,440 --> 00:37:33,480
Unos más ilustrativos, otros menos

942
00:37:33,480 --> 00:37:35,460
Tampoco es que vaya en orden de dificultad

943
00:37:35,460 --> 00:37:37,179
Van un poco bueno

944
00:37:37,179 --> 00:37:39,699
Como hemos podido sobrevivir

945
00:37:39,699 --> 00:37:40,239
A ver

946
00:37:40,239 --> 00:37:58,730
Vale, pues venga

947
00:37:58,730 --> 00:38:00,050
Si volvemos al aula

948
00:38:00,050 --> 00:38:01,250
Ah, que ya los he descargado

949
00:38:01,250 --> 00:38:02,409
Ah, no, no los he descargado

950
00:38:02,409 --> 00:38:13,449
Ah, perdón

951
00:38:13,449 --> 00:38:24,190
Vale, pues sí

952
00:38:24,190 --> 00:38:25,670
¿Qué?

953
00:38:28,670 --> 00:38:29,929
¿Que lo adelantemos?

954
00:38:29,929 --> 00:38:33,909
Vale, lo adelantamos

955
00:38:33,909 --> 00:38:35,829
Venga, vale, paramos aquí