1
00:00:00,110 --> 00:00:05,030
Entonces, voy a grabar esta clase, si habláis me dais consentimiento para que pueda grabar vuestra voz

2
00:00:05,030 --> 00:00:11,449
Entonces, aquí, hoy vamos a ver una cosa nueva que son las estructuras de control

3
00:00:11,449 --> 00:00:18,269
Hasta ahora, en todos los ejercicios que nosotros hemos visto, hemos hecho ejercicios secuenciales

4
00:00:18,269 --> 00:00:24,829
Es decir, que voy instrucción por instrucción y hago todas las instrucciones desde la primera hasta la última

5
00:00:24,829 --> 00:00:28,750
Puede que hemos visto el operador ternario

6
00:00:28,750 --> 00:00:31,390
Que es el operador un poquito más complejo

7
00:00:31,390 --> 00:00:33,229
Y que nos da un poquito más de juego

8
00:00:33,229 --> 00:00:39,250
Que hoy sustancialmente sustituiremos con una cosa más eficaz

9
00:00:39,250 --> 00:00:40,229
Que es el if

10
00:00:40,229 --> 00:00:46,070
Pero aún cuando ejecuto un ternario

11
00:00:46,070 --> 00:00:48,409
Estoy ejecutando toda esa expresión

12
00:00:48,409 --> 00:00:49,969
Estoy evaluando toda esa expresión

13
00:00:49,969 --> 00:00:56,170
Y se hace paso por paso una instrucción tras instrucción tras instrucción, ¿vale?

14
00:00:56,170 --> 00:01:08,250
Las estructuras de control, sostancialmente, son elementos del lenguaje que permiten cambiar la forma con que se ejecutan las instrucciones.

15
00:01:08,489 --> 00:01:17,709
Nos permiten cambiar el flujo lógico, la secuencia con que hago las instrucciones de alguna forma, ¿vale?

16
00:01:17,709 --> 00:01:29,469
En vez de hacerlas en secuencial, como ahora, una tras otra, puedo llegar a momentos de decir, un bloque me lo ejecutas y otro no, entonces me salto un bloque, ¿vale?

17
00:01:29,469 --> 00:01:48,650
O podría decirle, este bloque lo ejecutas varias veces, o le podría decir, cuando llegas a esta instrucción, párate allí, vete a otro lado, a otro fichero donde tengo algo de código allí, ejecutas ese código de allí, y cuando has acabado ese código de allí, vuelves a este.

18
00:01:50,650 --> 00:01:54,430
Esto, por lo general, las estructuras de control.

19
00:01:54,430 --> 00:02:02,629
Cuando se habla de flujo de ejecución, se entiende el orden con que se ejecutan un conjunto de instrucciones

20
00:02:02,629 --> 00:02:06,769
Normalmente secuenciales, uno tras otro, pero repito, con esto lo puedo romper

21
00:02:06,769 --> 00:02:12,210
¿Qué tipos de sentencias de control existen?

22
00:02:12,210 --> 00:02:19,449
Tres tipos, condicionales, iterativas y llamadas a métodos

23
00:02:19,449 --> 00:02:28,710
Los condicionales son ejecuto un trozo de código si una condición es verdadera

24
00:02:28,710 --> 00:02:33,030
Parecido, muy parecido al ternario

25
00:02:33,030 --> 00:02:35,849
Pero os recuerdo que el ternario es una instrucción

26
00:02:35,849 --> 00:02:38,550
Es una expresión, perdón

27
00:02:38,550 --> 00:02:42,770
Es algo que evalúo y al final me vale algo

28
00:02:42,770 --> 00:02:48,129
Hago todo este ternario y al final es un char lo que sale

29
00:02:48,129 --> 00:02:49,430
Es un string lo que sale

30
00:02:49,430 --> 00:02:52,669
Pero es una operación, es un operador, de hecho, el tornario.

31
00:02:53,430 --> 00:02:57,949
Sin embargo, aquí no estamos hablando de una operación, estamos hablando de un conjunto de operaciones,

32
00:02:58,069 --> 00:03:03,509
de una serie de instrucciones que se ejecutan si una condición es verdadera.

33
00:03:05,349 --> 00:03:10,509
En otra versión está el switch, ¿vale? Veremos los dos con calma.

34
00:03:10,509 --> 00:03:20,530
En el que ejecuto distintas instrucciones en base al valor de una determinada variable

35
00:03:20,530 --> 00:03:25,469
Si la variable vale 1 hago esto, si vale 2 hago esto, si vale 3 hago otra cosa

36
00:03:25,469 --> 00:03:35,610
Las sentencias iterativas son las que me permiten repetir un trozo de código varias veces

37
00:03:35,610 --> 00:03:44,889
¿os acordáis cuando antes hablábamos de tengo una palabra y quiero cambiar cada uno de los carácteres de esta palabra

38
00:03:44,889 --> 00:03:46,909
y por ejemplo ponerla mayúscula?

39
00:03:47,550 --> 00:03:51,569
pues con un iterativo yo puedo decir empieza desde el principio de la palabra

40
00:03:51,569 --> 00:03:57,050
llega hasta el final de la palabra y por cada carácter de esta palabra haz algo

41
00:03:57,050 --> 00:04:04,550
repetiré el código que hace algo, en nuestro caso es que cambia mayúscula

42
00:04:04,550 --> 00:04:07,930
por cada una de las letras de esta palabra.

43
00:04:08,090 --> 00:04:12,689
Independientemente de si la palabra son tres letras, son cinco, son veinticinco.

44
00:04:14,050 --> 00:04:18,990
Entonces, las sentencias de control iterativa me permiten pillar un trocito de código

45
00:04:18,990 --> 00:04:20,649
y repetirlo varias veces.

46
00:04:21,509 --> 00:04:22,689
Pensad a una calculadora.

47
00:04:23,329 --> 00:04:27,329
Yo hago una calculadora que me dice, dame un número, dame otro número, y lo suma.

48
00:04:27,649 --> 00:04:27,910
Ya está.

49
00:04:28,769 --> 00:04:32,290
Podría ser que al final de esta suma le diga,

50
00:04:32,290 --> 00:04:35,269
¿Y quieres volver a hacer otra suma?

51
00:04:35,810 --> 00:04:43,509
Y si me dice que sí, pues vuelve al principio y me vuelve a pedir un número, otro número, y lo suma.

52
00:04:43,769 --> 00:04:45,389
Y me dice, ¿quieres hacer otra operación?

53
00:04:45,629 --> 00:04:47,610
Y si tú le dices que sí, vuelve al principio y lo hace.

54
00:04:47,870 --> 00:04:50,230
Hasta que tú le digas que no, entonces sale.

55
00:04:50,790 --> 00:04:51,829
Eso sería iterativo.

56
00:04:53,170 --> 00:04:54,490
¿Sí? Lo veremos.

57
00:04:55,209 --> 00:04:56,730
Y luego las llamadas a métodos.

58
00:04:57,050 --> 00:04:59,110
Nosotros las llamadas a métodos ya las hemos usado.

59
00:04:59,550 --> 00:05:01,629
¿Cuándo hemos usado llamadas a métodos?

60
00:05:06,160 --> 00:05:32,620
Por ejemplo, cuando hago scan.nexint, pues ese es un método. ¿Qué quiere decir? Que yo estoy ejecutando mi programita, llego al scan.nexint y lo que hace es pararse mi programita en un cierto sentido, se va a un código que no he escrito yo, que está en la clase scanner y que ha escrito otra persona, ejecuto ese código que me permite leer de teclado,

61
00:05:32,620 --> 00:05:34,759
Y cuando he hecho este código allí

62
00:05:34,759 --> 00:05:36,079
Vuelvo a mi programa

63
00:05:36,079 --> 00:05:37,019
Y sigo adelante

64
00:05:37,019 --> 00:05:40,819
Otro método que hemos usado

65
00:05:40,819 --> 00:05:47,220
System.out no es un método

66
00:05:47,220 --> 00:05:48,980
Pero

67
00:05:48,980 --> 00:05:51,879
Pero

68
00:05:51,879 --> 00:05:54,100
Length es un método

69
00:05:54,100 --> 00:05:56,839
Println si es un método

70
00:05:56,839 --> 00:05:58,500
System.out

71
00:05:58,500 --> 00:06:00,240
Es el objeto sobre lo que llamo

72
00:06:00,240 --> 00:06:02,319
Y println si que es un método

73
00:06:02,319 --> 00:06:04,319
Todo lo que tiene paréntesis

74
00:06:04,319 --> 00:06:05,740
Sostancialmente redondas

75
00:06:05,740 --> 00:06:08,139
Punto no se que paréntesis

76
00:06:08,139 --> 00:06:09,639
Pues esos han sido métodos

77
00:06:09,639 --> 00:06:13,879
El length, el uppercase, el charat

78
00:06:13,879 --> 00:06:18,360
Son todos trozos de códigos que no tengo allí

79
00:06:18,360 --> 00:06:19,620
Que ha escrito otra persona

80
00:06:19,620 --> 00:06:23,279
Que cuando mi flujo de información llega a esa llamada

81
00:06:23,279 --> 00:06:27,000
Suspende el código que he escrito yo

82
00:06:27,000 --> 00:06:28,759
Se va a otro lado

83
00:06:28,759 --> 00:06:30,720
Hace las instrucciones del otro lado

84
00:06:30,720 --> 00:06:31,519
Y luego vuelve

85
00:06:31,519 --> 00:06:33,519
Pues esas son llamadas a métodos

86
00:06:33,519 --> 00:06:38,480
rompen con la normal secuencialidad de las instrucciones

87
00:06:38,480 --> 00:06:42,720
porque cuando llego a esa instrucción no sigo con la siguiente sino me voy a otro lado

88
00:06:42,720 --> 00:06:44,579
¿Se entiende?

89
00:06:45,220 --> 00:06:49,439
Entonces, estos son los tres tipos de sentencias que me permiten

90
00:06:49,439 --> 00:06:53,879
modificar, cambiar el flujo de información

91
00:06:53,879 --> 00:06:59,139
y hacer más complejos y más completos mis programas

92
00:06:59,139 --> 00:07:03,050
Condicionales

93
00:07:03,050 --> 00:07:11,649
Los condicionales sirven para proporcionar distintos caminos lógicos, es decir, distintas opciones en una ejecución.

94
00:07:12,649 --> 00:07:20,050
Dependiendo de una cierta condición, el camino que tengo que seguir puede ser este bloque o un bloque distinto.

95
00:07:22,389 --> 00:07:31,529
Se evaluará una condición, es decir, que habrá una condición booleana, se evalúa, esta condición me dará true o false.

96
00:07:31,529 --> 00:07:33,790
Si es true, haré una cosa

97
00:07:33,790 --> 00:07:35,810
Si es false, haré otra cosa distinta

98
00:07:35,810 --> 00:07:37,970
¿Dudas hasta aquí?

99
00:07:39,170 --> 00:07:39,370
Vale

100
00:07:39,370 --> 00:07:42,069
Esta es un esquemita

101
00:07:42,069 --> 00:07:43,370
En flujo de

102
00:07:43,370 --> 00:07:45,209
Diagrama de flujo

103
00:07:45,209 --> 00:07:46,810
De cómo funciona el if

104
00:07:46,810 --> 00:07:49,329
Y su hermano el if-else

105
00:07:49,329 --> 00:07:50,029
¿Vale?

106
00:07:51,129 --> 00:07:53,610
El if tiene una condición

107
00:07:53,610 --> 00:07:55,990
Si esta condición es verdadera

108
00:07:55,990 --> 00:07:58,050
Ejecuta un bloque de instrucciones

109
00:07:58,050 --> 00:07:59,790
Si es falsa

110
00:07:59,790 --> 00:08:01,769
Este bloque de instrucción se lo salta

111
00:08:01,769 --> 00:08:03,029
Ya está

112
00:08:03,029 --> 00:08:05,990
Entonces es un comando

113
00:08:05,990 --> 00:08:08,350
Que me dice que este bloque de aquí

114
00:08:08,350 --> 00:08:10,269
Se ejecutará si solo si

115
00:08:10,269 --> 00:08:11,509
Se verifica una condición

116
00:08:11,509 --> 00:08:13,209
Si no se verifica me la salto

117
00:08:13,209 --> 00:08:18,990
Hay una versión

118
00:08:18,990 --> 00:08:22,449
Con esto sería suficiente

119
00:08:22,449 --> 00:08:24,189
Podría hacer dos if

120
00:08:24,189 --> 00:08:26,029
Uno que verifica

121
00:08:26,029 --> 00:08:27,769
Una condición y uno que verifica

122
00:08:27,769 --> 00:08:29,370
El opuesto de esta condición

123
00:08:29,370 --> 00:08:32,169
y podría hacer todo lo que me interesa, ¿vale?

124
00:08:32,269 --> 00:08:39,429
Pero por comodidad, los lenguajes proporcionan un constructo que se llama IFELS, ¿vale?

125
00:08:39,850 --> 00:08:45,429
El IFELS funciona que hay una condición, si esta condición es verdadera, hago un bloque,

126
00:08:46,529 --> 00:08:55,690
si no, ELS, ¿vale? ELS quiere decir, en otro caso, hago un bloque distinto, ¿sí?

127
00:08:55,690 --> 00:08:59,529
Entonces la condición se evaluará en verdadero o falso

128
00:08:59,529 --> 00:09:02,029
Si es verdadero ejecuto el bloque a la izquierda

129
00:09:02,029 --> 00:09:03,750
Si es falso ejecuto el bloque a la derecha

130
00:09:03,750 --> 00:09:04,909
Y luego sigue adelante

131
00:09:04,909 --> 00:09:07,230
Más o menos la idea

132
00:09:07,230 --> 00:09:08,950
¿Sí?

133
00:09:10,169 --> 00:09:11,389
¿Cómo se hace en Java?

134
00:09:12,269 --> 00:09:12,470
¿Vale?

135
00:09:13,649 --> 00:09:15,990
Pongamos entre x igual a 5

136
00:09:15,990 --> 00:09:16,950
Una variable

137
00:09:16,950 --> 00:09:19,889
Si x es menor que 5

138
00:09:19,889 --> 00:09:21,549
Esta cosa de aquí

139
00:09:21,549 --> 00:09:23,750
Luego

140
00:09:23,750 --> 00:09:25,750
sin este punto println, en fin

141
00:09:25,750 --> 00:09:28,169
si yo ejecuto

142
00:09:28,169 --> 00:09:29,529
este código, ¿qué obtengo?

143
00:09:34,019 --> 00:09:34,740
solo esto

144
00:09:34,740 --> 00:09:36,299
¿por qué?

145
00:09:37,360 --> 00:09:39,139
porque esta instrucción de aquí

146
00:09:39,139 --> 00:09:41,360
se ejecuta

147
00:09:41,360 --> 00:09:43,919
si, solo si, x es menor que 5

148
00:09:43,919 --> 00:09:47,279
como x no es

149
00:09:47,279 --> 00:09:48,759
menor que 5

150
00:09:48,759 --> 00:09:50,460
porque es igual a 5

151
00:09:50,460 --> 00:09:53,220
pues entonces esto me lo salto

152
00:09:53,220 --> 00:09:54,899
y voy directamente a este

153
00:09:54,899 --> 00:09:57,960
¿dudas?

154
00:10:01,139 --> 00:10:02,019
switch no lo hemos dado

155
00:10:02,019 --> 00:10:15,879
Otro ejemplo de if, int x es igual a 5, si x es menor o igual a 6, abro un bloque, digo estas cosas, cierro el bloque, fin

156
00:10:15,879 --> 00:10:27,879
¿Qué me escribe? Pues evalúa esta expresión, 5 es menor que 6, sí, por lo tanto va a ejecutar este bloque entero

157
00:10:27,879 --> 00:10:38,460
Es decir, que escribirá resultado y luego escribirá menor que 6 y luego después habrá acabado este bloque, llega aquí y ejecuta fin.

158
00:10:39,299 --> 00:10:42,279
Entonces aparecerá resultado menor que 6 y fin.

159
00:10:46,399 --> 00:10:51,000
Algo que nos torna, os parezca complejo o no entendáis.

160
00:10:51,000 --> 00:11:00,139
Si x es igual a 5

161
00:11:00,139 --> 00:11:02,919
Si x es igual a 5

162
00:11:02,919 --> 00:11:04,799
Si x es menor que 5

163
00:11:04,799 --> 00:11:05,879
Este bloque

164
00:11:05,879 --> 00:11:08,080
Else este bloque

165
00:11:08,080 --> 00:11:10,179
System.auto.println

166
00:11:10,179 --> 00:11:11,259
Fin

167
00:11:11,259 --> 00:11:12,559
¿Qué escribe?

168
00:11:19,500 --> 00:11:20,220
¿Qué escribe? Perdón

169
00:11:20,220 --> 00:11:22,039
El else

170
00:11:22,039 --> 00:11:24,340
Verifica esto

171
00:11:24,340 --> 00:11:25,700
Esto es falso

172
00:11:25,700 --> 00:11:27,419
Se salta este bloque

173
00:11:27,419 --> 00:11:29,659
Hay un comando else

174
00:11:29,659 --> 00:11:30,799
Por lo tanto dice

175
00:11:30,799 --> 00:11:33,899
Si esta es falsa, es esto lo que tienes que hacer

176
00:11:33,899 --> 00:11:36,320
Escribe mayor o igual a 5

177
00:11:36,320 --> 00:11:39,379
Y luego ha acabado el bloque if

178
00:11:39,379 --> 00:11:42,279
Y por lo tanto ejecuta este de aquí que está detrás

179
00:11:42,279 --> 00:11:51,149
Tú das int x es igual a 5

180
00:11:51,149 --> 00:11:54,669
Si x es menor que 5, hace esta cosa de aquí

181
00:11:54,669 --> 00:12:00,549
Si no, si x es igual a 5, hace esta cosa de aquí

182
00:12:00,549 --> 00:12:02,590
Y si no, esta cosa de aquí

183
00:12:02,590 --> 00:12:13,259
Esta es otra cosa que se puede hacer, que es un else if

184
00:12:13,259 --> 00:12:17,879
Que sustancialmente me permite hacer tres opciones

185
00:12:17,879 --> 00:12:20,759
Si es menor que 5, si es igual

186
00:12:20,759 --> 00:12:22,879
Y si llega a este de aquí

187
00:12:22,879 --> 00:12:26,720
Es que no es ni menor que 5, ni igual a 5

188
00:12:26,720 --> 00:12:28,940
Por lo tanto será mayor que 5

189
00:12:28,940 --> 00:12:30,620
Este bloque aquí

190
00:12:30,620 --> 00:12:34,529
Este es sintaxis

191
00:12:34,529 --> 00:12:35,690
¿Vale?

192
00:12:35,909 --> 00:12:38,110
Por ahora este el shift no lo usamos

193
00:12:38,110 --> 00:12:39,830
Usamos solo if-else

194
00:12:39,830 --> 00:12:42,649
Luego un poquito más adelante empezamos con este shift

195
00:12:42,649 --> 00:12:44,409
Pero para que sepáis que existe

196
00:12:44,409 --> 00:12:49,129
¿Qué escribe esto?

197
00:13:07,440 --> 00:13:09,379
Miro este if, el if azul

198
00:13:09,379 --> 00:13:11,740
¿X es menor que 5?

199
00:13:12,919 --> 00:13:13,519
No

200
00:13:13,519 --> 00:13:15,480
Por lo tanto voy al bloque else

201
00:13:15,480 --> 00:13:17,100
Entro aquí dentro

202
00:13:17,100 --> 00:13:18,740
Llego al if

203
00:13:18,740 --> 00:13:20,000
Moral

204
00:13:20,000 --> 00:13:23,139
Si, X es igual a 5

205
00:13:23,139 --> 00:13:24,500
X es igual a 5

206
00:13:24,500 --> 00:13:26,419
Si, por lo tanto

207
00:13:26,419 --> 00:13:28,120
Esto lo ejecuto

208
00:13:28,120 --> 00:13:29,879
Y esto me lo salto

209
00:13:29,879 --> 00:13:32,139
Ejecuto esta cosa aquí

210
00:13:32,139 --> 00:13:33,879
Y luego escribo fin

211
00:13:33,879 --> 00:13:36,559
Entonces pondría igual a 5 y fin

212
00:13:36,559 --> 00:13:39,240
¿Sí?

213
00:13:39,779 --> 00:13:43,759
Y si aquí pongo 4, ¿qué escribe?

214
00:13:48,889 --> 00:13:49,830
Entraría aquí

215
00:13:49,830 --> 00:13:52,289
Se salta todo el else azul

216
00:13:52,289 --> 00:13:53,470
¿Vale?

217
00:13:53,889 --> 00:13:55,169
Y luego aquí escribiría fin

218
00:13:55,169 --> 00:13:59,250
¿Claro?

219
00:14:02,120 --> 00:14:03,220
Entonces, ¿esto qué hace?

220
00:14:37,750 --> 00:14:38,769
Esto es un problema

221
00:14:38,769 --> 00:14:39,750
¿Vale?

222
00:14:39,750 --> 00:14:44,009
Porque yo no sé si este else es de este if

223
00:14:44,009 --> 00:14:46,309
O de este if

224
00:14:46,309 --> 00:14:55,759
Los bloques no son necesarios

225
00:14:55,759 --> 00:15:03,419
Si hago un if así, quiere decir que dentro del bloque está solo esta

226
00:15:03,419 --> 00:15:07,980
O sea, este if solo se refiere a esta instrucción, a la siguiente instrucción

227
00:15:07,980 --> 00:15:13,899
Ahora, como consejo, usad siempre los bloques, siempre

228
00:15:13,899 --> 00:15:17,419
Hasta si hay una sola instrucción

229
00:15:17,419 --> 00:15:22,899
Para que se quede claro y no haya situaciones como estas

230
00:15:22,899 --> 00:15:32,750
Pues este de aquí depende

231
00:15:32,750 --> 00:15:35,230
Porque si este if está aquí, no escribiría nada

232
00:15:35,230 --> 00:15:40,529
Ni tú ni nadie

233
00:15:40,529 --> 00:15:44,590
Eso depende de cómo funciona el lenguaje

234
00:15:44,590 --> 00:15:46,289
Y cómo interpreta esta cosa de aquí

235
00:15:46,289 --> 00:15:49,610
Y como no lo sabemos, y es complejo

236
00:15:49,610 --> 00:15:51,429
Lo más probable es que no escriba nada

237
00:15:51,429 --> 00:15:52,990
Que salte todo esto

238
00:15:52,990 --> 00:15:56,629
Pero como no lo sabemos, pues entonces ponemos las paréntesis

239
00:15:56,629 --> 00:16:15,379
dudas hasta aquí, entonces vamos a hacer un par de ejemplos con if, hagamos un ejemplo de un ejercicio

240
00:16:15,379 --> 00:16:32,659
por ejemplo de dame un número y dime si es positivo o negativo, entonces scanner, scan es igual a new

241
00:16:32,659 --> 00:16:34,220
Scanner de

242
00:16:34,220 --> 00:16:36,720
System.in

243
00:16:36,720 --> 00:16:44,019
Si so

244
00:16:44,019 --> 00:16:46,580
Dame

245
00:16:46,580 --> 00:16:48,259
Un número

246
00:16:48,259 --> 00:16:50,940
Int

247
00:16:50,940 --> 00:16:52,700
N es igual a

248
00:16:52,700 --> 00:16:54,379
Scan.nextint

249
00:16:54,379 --> 00:16:56,700
He leído un número

250
00:16:56,700 --> 00:16:57,820
Si

251
00:16:57,820 --> 00:17:02,610
Ahora tengo que decir si es positivo

252
00:17:02,610 --> 00:17:03,149
O negativo

253
00:17:03,149 --> 00:17:06,329
Nosotros esto lo sabemos ya hacer con

254
00:17:06,329 --> 00:17:07,670
Operador ternario

255
00:17:07,670 --> 00:17:09,329
Vamos a hacerlo con el if

256
00:17:09,329 --> 00:17:21,720
Si n es mayor o igual que 0, asumamos que 0 sea positivo

257
00:17:21,720 --> 00:17:31,089
String resultado es igual positivo

258
00:17:31,089 --> 00:17:45,720
El c, string resultado es negativo

259
00:17:45,720 --> 00:17:53,670
Si so, res

260
00:17:53,670 --> 00:17:56,069
¿Os gusta?

261
00:17:56,069 --> 00:18:16,630
en informatikese

262
00:18:16,630 --> 00:18:18,230
¿vale?

263
00:18:18,450 --> 00:18:21,690
o sea, usando lenguaje informático

264
00:18:21,690 --> 00:18:25,309
me decís por qué esto se enfada

265
00:18:25,309 --> 00:18:42,039
es un problema de

266
00:18:42,039 --> 00:19:00,220
pero eso no es informatikese

267
00:19:00,220 --> 00:19:03,079
es un problema de

268
00:19:03,079 --> 00:19:12,490
es un problema de

269
00:19:12,490 --> 00:19:14,630
que no estudiáis en casa

270
00:19:14,630 --> 00:19:25,940
Es un problema de ámbito de variables

271
00:19:25,940 --> 00:19:29,319
Esta variable aquí, ¿dónde existe?

272
00:19:31,599 --> 00:19:32,759
Dentro de este bloque

273
00:19:32,759 --> 00:19:35,539
Y esta, aquí

274
00:19:35,539 --> 00:19:40,299
Por lo tanto, cuando llego aquí e intento imprimirla, me dice no existe

275
00:19:40,299 --> 00:19:42,619
¿Cómo lo puedo resolver?

276
00:19:43,619 --> 00:19:56,410
Fijaos que ahora se enfada aquí, porque estoy creando una variable que ya existe

277
00:19:56,410 --> 00:19:58,890
Por lo tanto lo quito así

278
00:19:58,890 --> 00:20:02,380
Podría hacer así, mira

279
00:20:02,380 --> 00:20:07,160
Asumo que ha habido un error

280
00:20:07,160 --> 00:20:10,660
Si me entrará aquí o aquí

281
00:20:10,660 --> 00:20:11,859
Lo sobrescribirá

282
00:20:11,859 --> 00:20:13,279
Entonces todo habrá funcionado bien

283
00:20:13,279 --> 00:20:14,779
Si por alguna razón

284
00:20:14,779 --> 00:20:17,079
Explot, no sé qué, no pasa por aquí

285
00:20:17,079 --> 00:20:18,200
Y llega a imprimirla

286
00:20:18,200 --> 00:20:19,279
Pues me dirá que ha habido un error

287
00:20:19,279 --> 00:20:23,029
Nunca pasará

288
00:20:23,029 --> 00:20:24,970
Pero como idea

289
00:20:24,970 --> 00:20:27,450
Vamos a ver si funciona

290
00:20:27,450 --> 00:20:29,529
Lanzo esto

291
00:20:29,529 --> 00:20:30,769
Le doy 5

292
00:20:30,769 --> 00:20:31,829
Y me dice positivo

293
00:20:31,829 --> 00:20:36,490
Alzo esto, menos 4, me dice negativo

294
00:20:36,490 --> 00:20:39,470
Perfecto

295
00:20:39,470 --> 00:20:41,529
Ahora, la cosa interesante del if

296
00:20:41,529 --> 00:20:45,470
Es que nosotros aquí lo hemos usado un poquito pensando al

297
00:20:45,470 --> 00:20:47,589
¿Cómo se llama esto?

298
00:20:47,930 --> 00:20:49,170
Lo diré

299
00:20:49,170 --> 00:20:51,950
Al operador ternario

300
00:20:51,950 --> 00:20:56,730
Es decir, hacemos operaciones para que esto me dé un resultado

301
00:20:56,730 --> 00:20:59,650
Pero ahora con el if

302
00:20:59,650 --> 00:21:03,130
yo puedo directamente

303
00:21:03,130 --> 00:21:06,950
usar comandos

304
00:21:06,950 --> 00:21:22,000
aquí dentro, ¿sí?

305
00:21:22,920 --> 00:21:27,759
El if ahora, mientras en el condicional, en el ternario

306
00:21:27,759 --> 00:21:31,440
los dos ramas que tenía, que al fin y al cabo era

307
00:21:31,440 --> 00:21:35,140
sí, este es verdadero y este es falso, pero tienen que ser expresiones

308
00:21:35,140 --> 00:21:39,660
evaluables, ahora yo aquí dentro puedo meter

309
00:21:39,660 --> 00:21:41,640
uno o varios

310
00:21:41,640 --> 00:21:42,440
o mil

311
00:21:42,440 --> 00:21:45,519
instrucciones distintas

312
00:21:45,519 --> 00:21:51,859
esto en el ternario

313
00:21:51,859 --> 00:21:53,900
no lo puede hacer, yo no puedo hacer

314
00:21:53,900 --> 00:21:54,799
en el ternario

315
00:21:54,799 --> 00:21:57,319
n mayor o igual a cero

316
00:21:57,319 --> 00:21:59,140
interrogación

317
00:21:59,140 --> 00:22:02,039
si sostén punto out

318
00:22:02,039 --> 00:22:03,000
punto println

319
00:22:03,000 --> 00:22:15,160
porque

320
00:22:15,160 --> 00:22:16,599
esto

321
00:22:16,599 --> 00:22:18,880
es un valor

322
00:22:18,880 --> 00:22:20,420
y esto no es un valor

323
00:22:20,420 --> 00:22:22,740
¿qué valor es este? no lo entiendo

324
00:22:22,740 --> 00:22:28,079
no es un valor, no es una expresión

325
00:22:28,079 --> 00:22:30,119
es un

326
00:22:30,119 --> 00:22:32,079
comando, pero no es una instrucción

327
00:22:32,079 --> 00:22:33,539
no es una suma, no es un

328
00:22:33,539 --> 00:22:34,700
no tiene operadores

329
00:22:34,700 --> 00:22:36,240
¿qué es esto?

330
00:22:38,960 --> 00:22:41,579
¿dónde lo guardo esto? ¿qué tipo tiene esta cosa aquí?

331
00:22:43,680 --> 00:22:45,880
¿vale? y entonces es problemático

332
00:22:45,880 --> 00:22:47,480
sin embargo ahora sí puede hacerlo

333
00:22:47,480 --> 00:22:49,019
¿vale?

334
00:22:53,150 --> 00:22:53,670
¿dudas?

335
00:23:04,819 --> 00:23:07,019
si la quieres usar fuera o algo así

336
00:23:07,019 --> 00:23:10,339
Si tú quieres

337
00:23:10,339 --> 00:23:11,299
La variable

338
00:23:11,299 --> 00:23:13,339
Si la usas solo aquí dentro

339
00:23:13,339 --> 00:23:22,009
Pero no solo los del if

340
00:23:22,009 --> 00:23:24,109
Cualquier bloque es independiente de los otros

341
00:23:24,109 --> 00:23:27,329
Vamos a hacer otro ejercicio

342
00:23:27,329 --> 00:23:30,230
Otro ejercicio que puede ser

343
00:23:30,230 --> 00:23:35,130
Dame una palabra

344
00:23:35,130 --> 00:23:36,950
De dos letras

345
00:23:36,950 --> 00:23:37,690
¿Vale?

346
00:23:37,690 --> 00:23:39,369
Y si esta palabra

347
00:23:39,369 --> 00:23:40,990
De dos letras

348
00:23:40,990 --> 00:23:43,690
Te la transformo en mayúscula

349
00:23:43,930 --> 00:24:30,789
suena de algo, dame una palabra de dos letras, ¿sí?, intern es igual a, no, string, S, he leído una palabra de dos letras, ¿vale?, primero me pregunto, si S, ¿cómo me puedo preguntar si es de verdad de dos letras?, ¿sí?,

350
00:24:30,789 --> 00:24:40,309
Si la longitud de este string es igual a 2, entonces vemos ahora qué hacemos.

351
00:24:40,849 --> 00:24:49,380
Si no, imprimo palabra no válida.

352
00:24:56,309 --> 00:24:56,990
¿Qué hago aquí?

353
00:25:00,799 --> 00:25:04,160
Ahora sé que son dos letras, no tengo un iterativo.

354
00:25:04,160 --> 00:25:08,680
Aquí sería bonito poder hacer lo mismo dos veces con un iterativo

355
00:25:08,680 --> 00:25:11,380
Pero todavía no tengo ni while, ni for, ni nada

356
00:25:11,380 --> 00:25:13,920
Por lo tanto, tengo que hacer dos veces lo mismo

357
00:25:13,920 --> 00:25:14,839
¿Vale?

358
00:25:15,559 --> 00:25:17,900
Entonces, ahora puedo hacer char

359
00:25:17,900 --> 00:25:24,960
Usando char

360
00:25:24,960 --> 00:25:34,019
Char letra 1 es igual a s.charAt 0

361
00:25:34,019 --> 00:25:36,339
Hagamos charL 0

362
00:25:36,339 --> 00:25:50,019
Y char L1 es igual a S.charAt1, ¿sí?

363
00:25:51,240 --> 00:26:19,900
Ahora me puedo preguntar, si L0 como int es mayor que 65

364
00:26:19,900 --> 00:26:27,420
Y este señor de aquí lo mismo

365
00:26:27,420 --> 00:26:34,980
Y siempre la letra como int es menor o igual que 90

366
00:26:34,980 --> 00:26:40,730
Quiere decir que

367
00:26:40,730 --> 00:26:45,339
Si este es verdadero, ¿qué quiere decir?

368
00:26:46,220 --> 00:26:53,109
Que es mayúscula

369
00:26:53,109 --> 00:26:54,049
¿Vale?

370
00:26:54,769 --> 00:26:59,049
Si no, es minúscula

371
00:26:59,049 --> 00:27:02,210
Nosotros hemos dicho que el objetivo es

372
00:27:02,210 --> 00:27:05,190
Dame una palabra y te la escribo toda en mayúscula

373
00:27:05,190 --> 00:27:05,430
¿Vale?

374
00:27:05,730 --> 00:27:08,289
Entonces fijaos que si esto es verdadero

375
00:27:08,289 --> 00:27:09,569
¿Qué tengo que hacer?

376
00:27:16,250 --> 00:27:17,069
Sustantemente nada

377
00:27:17,069 --> 00:27:20,250
Y si no, transformar

378
00:27:20,250 --> 00:27:22,269
El L1

379
00:27:22,269 --> 00:27:25,109
El L0 en mayúscula

380
00:27:25,109 --> 00:27:26,789
Su correspondiente mayúscula

381
00:27:26,789 --> 00:27:27,029
¿Vale?

382
00:27:27,349 --> 00:27:29,049
Entonces lo voy a hacer un poquito distinto

383
00:27:29,049 --> 00:27:31,569
Como aquí no lo toco L0

384
00:27:31,569 --> 00:27:33,170
Si

385
00:27:33,170 --> 00:27:35,849
Si entro aquí dentro y no lo toco

386
00:27:35,849 --> 00:27:36,509
No haría nada

387
00:27:36,509 --> 00:27:38,150
Me quedaría con L0

388
00:27:38,150 --> 00:27:40,170
Pues lo que puedo hacer es esto

389
00:27:40,170 --> 00:27:50,700
He invertido

390
00:27:50,700 --> 00:27:53,079
He puesto un NOT

391
00:27:53,079 --> 00:27:55,559
NOT

392
00:27:55,559 --> 00:27:57,579
Mayúscula

393
00:27:57,579 --> 00:28:00,279
Si no hay mayúscula

394
00:28:00,279 --> 00:28:02,019
Ahora la converto a mayúscula

395
00:28:02,019 --> 00:28:04,160
¿Cómo la converto a mayúscula?

396
00:28:04,660 --> 00:28:05,539
L0

397
00:28:05,539 --> 00:28:08,440
Es igual

398
00:28:08,440 --> 00:28:14,160
L0

399
00:28:14,160 --> 00:28:14,980
Menos 32

400
00:28:14,980 --> 00:28:38,369
Ah, espera

401
00:28:38,369 --> 00:28:45,990
si no es

402
00:28:45,990 --> 00:28:48,250
una letra mayúscula

403
00:28:48,250 --> 00:28:50,150
porque está

404
00:28:50,150 --> 00:28:51,289
fuera de este rango

405
00:28:51,289 --> 00:28:53,789
aquí me estoy preguntando

406
00:28:53,789 --> 00:28:55,430
si está dentro de este rango

407
00:28:55,430 --> 00:28:58,210
de 65 a 90, pero le he metido un no

408
00:28:58,210 --> 00:28:58,789
delante

409
00:28:58,789 --> 00:29:02,150
si no es esta cosa aquí

410
00:29:02,150 --> 00:29:03,769
pues entonces píllate

411
00:29:03,769 --> 00:29:06,109
esa letra, transformala

412
00:29:06,109 --> 00:29:08,190
en un entero, quítale 32

413
00:29:08,190 --> 00:29:09,829
y el resultado

414
00:29:09,829 --> 00:29:14,289
lo transformas en un char, y lo guardas

415
00:29:14,289 --> 00:29:17,369
¿dónde? en la misma

416
00:29:17,369 --> 00:29:22,170
¿cómo se llama esta? en la misma variable, es decir

417
00:29:22,170 --> 00:29:25,589
que pasado esto, ¿qué tendré en el 0?

418
00:29:28,839 --> 00:29:32,140
siempre, si era mayúscula

419
00:29:32,140 --> 00:29:36,039
porque esto se lo ha saltado y se queda mayúscula, y si era minúscula

420
00:29:36,039 --> 00:29:40,180
porque ha entrado aquí dentro y lo ha cambiado a mayúscula, entonces pasado esto

421
00:29:40,180 --> 00:29:43,319
Dentro del L0 tengo la letra en mayúscula

422
00:29:43,319 --> 00:29:45,279
¿Lo veis?

423
00:29:47,529 --> 00:29:50,049
Pues hago lo mismo, pero con L1

424
00:29:50,049 --> 00:29:57,500
Me pregunto si L1 es una mayúscula

425
00:29:57,500 --> 00:30:00,079
Si no es una mayúscula

426
00:30:00,079 --> 00:30:03,880
Y si no es una mayúscula, en L1 hago la conversión

427
00:30:03,880 --> 00:30:09,359
Ahora, cuando estoy aquí

428
00:30:09,359 --> 00:30:14,680
En este punto

429
00:30:14,680 --> 00:30:17,240
L0 y L1

430
00:30:17,240 --> 00:30:19,259
Contienen

431
00:30:19,259 --> 00:30:21,980
Letras

432
00:30:21,980 --> 00:30:24,740
Mayúsculas

433
00:30:24,740 --> 00:30:28,559
¿Sí o no?

434
00:30:30,960 --> 00:30:31,200
Sí

435
00:30:31,200 --> 00:30:34,240
¿Dónde?

436
00:30:49,059 --> 00:30:50,099
Ahora que estamos en if

437
00:30:50,099 --> 00:30:53,660
A ver, no te cambia el hecho

438
00:30:53,660 --> 00:30:56,079
El discurso es que yo aquí estoy en if

439
00:30:56,079 --> 00:30:58,740
Pero estoy trabajando con carácteres

440
00:30:58,740 --> 00:31:00,180
¿Vale?

441
00:31:00,180 --> 00:31:01,960
Entonces, no, no tengo un método

442
00:31:01,960 --> 00:31:03,279
Porque carácter no tiene método

443
00:31:03,279 --> 00:31:05,619
y es lo de siempre

444
00:31:05,619 --> 00:31:07,759
¿por qué yo uso esto si tengo

445
00:31:07,759 --> 00:31:09,819
tu uppercase?

446
00:31:10,440 --> 00:31:12,480
porque tú estás aprendiendo a programar

447
00:31:12,480 --> 00:31:14,200
y no te puedo

448
00:31:14,200 --> 00:31:16,079
poner ahora ejercicios

449
00:31:16,079 --> 00:31:17,220
de hazme un aeropuerto

450
00:31:17,220 --> 00:31:19,400
porque no lo vas a saber hacer

451
00:31:19,400 --> 00:31:22,200
entonces vamos a manejar las cosas sencillas

452
00:31:22,200 --> 00:31:23,299
este de aquí

453
00:31:23,299 --> 00:31:25,680
te hace razonar sobre

454
00:31:25,680 --> 00:31:27,839
tipos de datos distintos

455
00:31:27,839 --> 00:31:30,259
te hace razonar sobre casting

456
00:31:30,259 --> 00:31:32,000
te hace razonar sobre

457
00:31:32,000 --> 00:31:33,599
cuando puedes hacer una operación

458
00:31:33,599 --> 00:31:34,140
con

459
00:31:34,140 --> 00:31:36,539
me explico

460
00:31:36,539 --> 00:31:38,880
y luego

461
00:31:38,880 --> 00:31:41,180
ok, esto es un método

462
00:31:41,180 --> 00:31:43,000
que funciona, vale, o sea

463
00:31:43,000 --> 00:31:44,400
y tengo tu upper string

464
00:31:44,400 --> 00:31:46,180
tu upper case

465
00:31:46,180 --> 00:31:49,920
y si ahora quiero un método que la primera letra

466
00:31:49,920 --> 00:31:51,539
me la pone en mayúscula, segunda en minúscula

467
00:31:51,539 --> 00:31:53,160
tercera en mayúscula, cuarta en minúscula

468
00:31:53,160 --> 00:31:54,759
eso no lo tienes, y que haces

469
00:31:54,759 --> 00:31:56,240
no lo sé hacer

470
00:31:56,240 --> 00:31:59,019
tendrá que saber hacer también esas cosas

471
00:31:59,019 --> 00:32:02,859
no, no, no

472
00:32:02,859 --> 00:32:05,039
Pilla el punto

473
00:32:05,039 --> 00:32:05,740
¿Sí?

474
00:32:07,160 --> 00:32:09,480
Entonces, ahora tengo L, C, R, L, 1

475
00:32:09,480 --> 00:32:10,640
Que son mayúsculas, ¿qué hago?

476
00:32:26,259 --> 00:32:26,519
Sí

477
00:32:26,519 --> 00:32:35,450
Ya está

478
00:32:35,450 --> 00:32:46,460
Si lanzo esto y pongo

479
00:32:46,460 --> 00:32:49,460
Más grande

480
00:32:49,460 --> 00:32:51,000
No me deja

481
00:32:51,000 --> 00:32:55,000
Si lanzo esto y lo pongo más pequeño

482
00:32:55,000 --> 00:32:55,680
No me deja

483
00:32:55,680 --> 00:32:59,140
Y fijaos que

484
00:32:59,140 --> 00:33:01,640
No obstante esto se mantenga

485
00:33:01,640 --> 00:33:02,779
engorroso

486
00:33:02,779 --> 00:33:06,119
porque lo es engorroso

487
00:33:06,119 --> 00:33:07,779
¿vale? pero es

488
00:33:07,779 --> 00:33:10,119
un poquito más leíble con respecto a antes

489
00:33:10,119 --> 00:33:11,920
y ahora sí que puedo hacer

490
00:33:11,920 --> 00:33:13,819
estas declaraciones aquí

491
00:33:13,819 --> 00:33:15,900
dentro, ¿os acordáis que

492
00:33:15,900 --> 00:33:17,880
antes, en el ejercicio que hemos hecho antes

493
00:33:17,880 --> 00:33:18,759
es esto

494
00:33:18,759 --> 00:33:23,839
aquí dentro, cuando estoy

495
00:33:23,839 --> 00:33:25,680
en el

496
00:33:25,680 --> 00:33:28,079
operador ternario

497
00:33:28,079 --> 00:33:29,660
no puedo declarar variables

498
00:33:29,660 --> 00:33:31,640
aquí dentro, aquí dentro va una

499
00:33:31,640 --> 00:33:33,579
expresión, no

500
00:33:33,579 --> 00:33:35,920
instrucciones, sin embargo ahora

501
00:33:35,920 --> 00:33:37,799
tengo la libertad de dentro

502
00:33:37,799 --> 00:33:39,700
de un bloque if, hacer todas las

503
00:33:39,700 --> 00:33:40,759
instrucciones que yo quiera

504
00:33:40,759 --> 00:33:54,769
es un poco engorroso trabajar con char

505
00:33:54,769 --> 00:33:55,269
pues si

506
00:33:55,269 --> 00:34:01,980
vale, pero si ahora yo pillo

507
00:34:01,980 --> 00:34:04,019
esto, lo ejecuto

508
00:34:04,660 --> 00:34:06,440
y le pongo

509
00:34:06,440 --> 00:34:07,720
esta cosa aquí

510
00:34:07,720 --> 00:34:09,800
pues me dice que es una palabra no válida

511
00:34:09,800 --> 00:34:10,440
pero no dos

512
00:34:10,440 --> 00:34:12,820
pongo esta cosa aquí

513
00:34:12,820 --> 00:34:14,420
pues me sale esto

514
00:34:14,420 --> 00:34:22,630
¿cómo podría yo hacer

515
00:34:22,630 --> 00:34:25,309
algo

516
00:34:25,309 --> 00:34:27,789
por aquí

517
00:34:27,789 --> 00:34:32,590
para estar seguro que

518
00:34:32,590 --> 00:34:34,769
esto funcione

519
00:34:34,769 --> 00:34:36,489
que no me dé cosas raras

520
00:34:36,489 --> 00:34:58,500
vale, ¿y cómo puedo

521
00:34:58,500 --> 00:34:59,659
decirle, oye mira

522
00:34:59,659 --> 00:35:01,679
hazme esto

523
00:35:01,679 --> 00:35:05,679
pero solo

524
00:35:05,679 --> 00:35:19,179
si es una letra minúscula, entendamos, no

525
00:35:19,179 --> 00:35:23,340
ahora mismo, este de aquí, ¿qué hace? hace esta operación

526
00:35:23,340 --> 00:35:26,519
siempre que no sea

527
00:35:26,519 --> 00:35:33,250
una mayúscula, ¿sí? porque la condición que he

528
00:35:33,250 --> 00:35:37,210
elegido usar es, si no es mayúscula, ahora

529
00:35:37,210 --> 00:35:41,210
uno, es una mayúscula, no

530
00:35:41,210 --> 00:35:42,909
y por lo tanto me hará esta operación

531
00:35:42,909 --> 00:35:48,730
No, hay una forma mejor o una condición distinta

532
00:35:48,730 --> 00:35:50,989
Que podría poner aquí

533
00:35:50,989 --> 00:35:54,409
Para que luego no me haga esta cosa rara aquí

534
00:35:54,409 --> 00:35:58,110
Pongamos que la palabra sea 12, esta cosa de aquí

535
00:35:58,110 --> 00:36:01,090
¿Qué me esperaría que ponga? ¿Cómo es 1 en mayúscula?

536
00:36:07,480 --> 00:36:09,659
1, sería igual

537
00:36:09,659 --> 00:36:14,019
Entonces, ¿no podría cambiar un poco el algoritmo que he escrito

538
00:36:14,019 --> 00:36:18,539
para hacer de tal forma que esta conversión me las haga

539
00:36:18,539 --> 00:36:22,820
solo cuando es necesario hacer esa conversión.

540
00:36:37,190 --> 00:36:42,030
¿Sabéis cuando os digo, razonad sobre los algoritmos

541
00:36:42,030 --> 00:36:44,050
y buscad el algoritmo que os convenga?

542
00:36:44,050 --> 00:36:50,050
Pues aquí la idea es hacer esto solo cuando esto es minúscula.

543
00:36:51,269 --> 00:36:55,050
Solo cuando esto representa una palabra minúscula.

544
00:36:55,050 --> 00:37:22,440
Una letra minúscula. Por lo tanto, cambio y ¿qué condición pongo? Aquí no estamos con objetos. Es más sencillo, es eso. Es simplemente que en vez de ir a buscar si no es una mayúscula, voy a buscar si es una minúscula.

545
00:37:22,440 --> 00:37:26,239
O sea, entre 97 y 122

546
00:37:26,239 --> 00:37:33,760
Si es mayor que 97 y menor que 122

547
00:37:33,760 --> 00:37:35,179
Entonces me la conviertes

548
00:37:35,179 --> 00:37:37,119
Cualquier otra me la dejas como está

549
00:37:37,119 --> 00:37:39,039
Si es mayúscula me la dejas como está

550
00:37:39,039 --> 00:37:40,159
Si es un número me la dejas como está

551
00:37:40,159 --> 00:37:41,739
Si es un punto me lo dejas como está

552
00:37:41,739 --> 00:37:49,780
¿Lo entendéis?

553
00:37:51,440 --> 00:37:51,980
O sea, cuidado

554
00:37:51,980 --> 00:37:57,219
Porque lo que tendéis a hacer es complicaros la vida

555
00:37:57,219 --> 00:38:00,380
O sea, vosotros tendéis a pillar esto

556
00:38:00,380 --> 00:38:02,159
Y ahora meter otro if fuera

557
00:38:02,159 --> 00:38:03,880
Que comprobara que no fuera

558
00:38:03,880 --> 00:38:06,800
Pues está más sencillo

559
00:38:06,800 --> 00:38:08,699
Y debería funcionar

560
00:38:08,699 --> 00:38:10,099
Ahora miro

561
00:38:10,099 --> 00:38:12,800
A A me lo escribe en mayúscula

562
00:38:12,800 --> 00:38:14,480
Si pongo 12

563
00:38:14,480 --> 00:38:15,619
Es que 12

564
00:38:15,619 --> 00:38:21,739
Ahora lo bonito aquí sería

565
00:38:21,739 --> 00:38:23,800
Que yo escribiera esto

566
00:38:23,800 --> 00:38:24,719
Una vez sola

567
00:38:24,719 --> 00:38:27,860
Y que el L en automático me hiciera esto varias veces

568
00:38:27,860 --> 00:38:29,179
Una vez para L0

569
00:38:29,179 --> 00:38:31,780
Una vez para L1, una vez para L2, una vez para L3

570
00:38:31,780 --> 00:38:34,679
Pero todavía no lo sabemos hacer

571
00:38:34,679 --> 00:38:39,090
Guay

572
00:38:39,090 --> 00:38:42,190
Esto necesita un iterativo

573
00:38:42,190 --> 00:38:45,530
Un for probablemente

574
00:38:45,530 --> 00:38:54,440
Necesitas algo que te diga

575
00:38:54,440 --> 00:38:56,139
Si es larga 5

576
00:38:56,139 --> 00:38:57,960
Hazlo de 0 al 4

577
00:38:57,960 --> 00:38:59,500
Eso es un iterativo

578
00:38:59,500 --> 00:39:02,670
¿Dudas hasta aquí?

579
00:39:11,860 --> 00:39:13,539
Y no sé

580
00:39:13,539 --> 00:39:15,760
Hacemos otro de otro tipo

581
00:39:15,760 --> 00:39:16,800
¿Qué queréis hacer?

582
00:39:26,579 --> 00:39:27,920
Bueno, estamos trabajando

583
00:39:27,920 --> 00:39:29,559
Todo el tiempo

584
00:39:29,559 --> 00:39:36,579
Hagamos un clásico, me das dos números y te digo si el primero es múltiplo del segundo.

585
00:39:39,780 --> 00:40:06,070
Dame el primer número, leo un número, leo otro número.

586
00:40:11,719 --> 00:40:18,340
¿Cómo puedo decirte si el primer número es múltiplo del segundo?

587
00:40:18,340 --> 00:40:31,579
Quiero, tengo n1, n2, dos números

588
00:40:31,579 --> 00:40:35,619
Quiero saber si n1 es un múltiplo de n2

589
00:40:35,619 --> 00:40:40,940
Es decir, si existe un número x, que si hago n2 por x me da n1

590
00:40:40,940 --> 00:41:08,860
A ver, dime, entre paréntesis

591
00:41:08,860 --> 00:41:44,179
Luego que, if, así

592
00:41:44,179 --> 00:41:47,300
No, n1 es múltiplo de n2

593
00:41:47,300 --> 00:41:55,579
Y si no

594
00:41:55,579 --> 00:42:13,920
Dos y cuatro

595
00:42:13,920 --> 00:42:16,260
Dos no es múltiplo de cuatro

596
00:42:16,260 --> 00:42:16,840
Bueno

597
00:42:16,840 --> 00:42:20,000
Cuatro y dos

598
00:42:20,000 --> 00:42:21,719
Cuatro es múltiplo de dos

599
00:42:21,719 --> 00:42:28,260
Fácil el if

600
00:42:28,260 --> 00:42:30,420
¿Sí?

601
00:42:30,519 --> 00:42:31,719
A nivel de sintaxi

602
00:42:31,719 --> 00:42:34,079
Fácil

603
00:42:34,079 --> 00:42:35,960
Lo único ahora es

604
00:42:35,960 --> 00:42:38,440
Luchar un poco con esto

605
00:42:38,440 --> 00:42:40,139
¿Queréis hacer uno con string?

606
00:42:40,900 --> 00:42:41,179
Vale

607
00:42:41,179 --> 00:42:56,780
Leo una palabra

608
00:42:56,780 --> 00:43:02,780
dame tu nombre

609
00:43:02,780 --> 00:43:10,199
lo que quiero es

610
00:43:10,199 --> 00:43:12,860
si el nombre es de una persona

611
00:43:12,860 --> 00:43:13,659
autorizada

612
00:43:13,659 --> 00:43:16,079
que son la persona autorizada

613
00:43:16,079 --> 00:43:17,340
Stefano

614
00:43:17,340 --> 00:43:21,559
Marta

615
00:43:21,559 --> 00:43:24,679
Antonio

616
00:43:24,679 --> 00:43:27,360
y Sara

617
00:43:27,360 --> 00:43:35,210
entonces

618
00:43:35,210 --> 00:43:38,050
listas de rey que son

619
00:43:38,050 --> 00:43:39,130
en febrero

620
00:43:39,130 --> 00:43:42,789
si tengo esto

621
00:43:42,789 --> 00:43:47,389
Si lo que he leído es uno de estos

622
00:43:47,389 --> 00:43:48,610
Entonces dirá

623
00:43:48,610 --> 00:43:50,030
Estás autorizado

624
00:43:50,030 --> 00:43:51,590
Si no, no

625
00:43:51,590 --> 00:43:52,590
¿Qué hago?

626
00:43:55,670 --> 00:43:55,989
If

627
00:43:55,989 --> 00:44:00,849
Señores

628
00:44:00,849 --> 00:44:23,400
No lo sé

629
00:44:23,400 --> 00:44:24,440
Decidme vosotros

630
00:44:24,440 --> 00:44:25,739
Poneos de acuerdo

631
00:44:25,739 --> 00:44:30,829
¿Qué hago?

632
00:44:44,199 --> 00:44:44,900
No, no he entendido

633
00:44:44,900 --> 00:44:45,219
Así

634
00:44:45,219 --> 00:45:06,659
Scan.next

635
00:45:06,659 --> 00:45:27,900
Vale

636
00:45:27,900 --> 00:45:33,619
Sí

637
00:45:33,619 --> 00:45:35,719
Esto es true

638
00:45:35,719 --> 00:45:38,340
Oh, esto es true

639
00:45:38,340 --> 00:45:40,500
Oh, esto es true

640
00:45:40,500 --> 00:45:42,039
¿Sí?

641
00:45:42,420 --> 00:45:44,179
Entonces, ¿con qué uno de estos sea true?

642
00:45:49,989 --> 00:45:50,590
Autorizado

643
00:45:50,590 --> 00:45:52,849
¿Sí?

644
00:45:54,150 --> 00:45:56,070
Entonces, dame tu nombre

645
00:45:56,070 --> 00:45:58,329
Paco

646
00:45:58,329 --> 00:46:00,070
No me dice nada

647
00:46:00,070 --> 00:46:02,170
pongo

648
00:46:02,170 --> 00:46:03,070
Estefano

649
00:46:03,070 --> 00:46:05,010
autorizado

650
00:46:05,010 --> 00:46:07,349
pongo

651
00:46:07,349 --> 00:46:08,670
Estefano

652
00:46:08,670 --> 00:46:19,170
depende, si yo quiero exactamente

653
00:46:19,170 --> 00:46:20,389
estos los dejo así

654
00:46:20,389 --> 00:46:22,809
una opción podría ser esta

655
00:46:22,809 --> 00:46:30,989
y antes de comprobarlo

656
00:46:30,989 --> 00:46:43,179
tú me has dado

657
00:46:43,179 --> 00:46:45,119
lo que sea, yo me lo pongo

658
00:46:45,119 --> 00:46:47,559
en minúscula y luego lo comparo

659
00:46:47,559 --> 00:46:48,519
con los números en minúscula

660
00:46:48,519 --> 00:46:51,440
entonces si tú ahora me dices que te llamas

661
00:46:51,440 --> 00:47:01,579
Depende de mi programa que quiera hacer

662
00:47:01,579 --> 00:47:03,719
A lo mejor yo quiero que sea que es sensitive

663
00:47:03,719 --> 00:47:10,820
Para una contraseña quiero que sea que es sensitive

664
00:47:10,820 --> 00:47:12,940
Para un email, por ejemplo, no

665
00:47:12,940 --> 00:47:16,440
Depende de lo que quiera hacer yo

666
00:47:16,440 --> 00:47:17,800
Pero puedo hacer las dos cosas

667
00:47:17,800 --> 00:47:24,170
Vale, la última cosa que quería probar a hacer

668
00:47:24,170 --> 00:47:32,250
Ahí sí está

669
00:47:32,250 --> 00:47:41,429
Leo una palabra, dame tu nombre, y te digo la segunda letra de tu nombre

670
00:47:41,429 --> 00:47:53,960
Quiero imprimir por pantalla la segunda letra de tu nombre

671
00:47:53,960 --> 00:48:08,360
¿Qué hago? Ya lo he leído, está aquí

672
00:48:08,360 --> 00:48:19,760
¿Qué hago? Venga, no escribe en pantalla charla de terror

673
00:48:19,760 --> 00:48:27,150
Ay, señores, venga, ya lo tienes

674
00:48:27,150 --> 00:48:37,429
Segunda letra

675
00:48:37,429 --> 00:48:42,579
¿Me entregáis esto?

676
00:48:42,739 --> 00:48:43,679
¿Cuántos habéis sacado?

677
00:48:46,900 --> 00:48:47,400
Mirad

678
00:48:47,400 --> 00:48:49,800
Me llamo ese

679
00:48:49,800 --> 00:48:50,760
¡Bum!

680
00:48:56,590 --> 00:48:58,269
El problema mío es si me llamo ese

681
00:48:58,269 --> 00:49:08,360
No lo sé, decidme vosotros qué tengo que hacer

682
00:49:08,360 --> 00:49:12,869
Os doy una pista

683
00:49:12,869 --> 00:49:14,269
Son ejercicios sobre if

684
00:49:14,269 --> 00:49:15,769
¿Qué diríais vosotros?

685
00:49:16,650 --> 00:49:17,530
Es lo que decíamos

686
00:49:17,530 --> 00:49:19,650
Ejercicio de if sin if

687
00:49:19,650 --> 00:49:54,280
No puedo

688
00:49:54,280 --> 00:49:59,210
Venga, pues eso puedo

689
00:49:59,210 --> 00:50:01,190
oiga vosotros

690
00:50:01,190 --> 00:50:03,449
¿por qué estáis riendo tanto?

691
00:50:03,789 --> 00:50:04,510
yo no lo entiendo

692
00:50:04,510 --> 00:50:06,750
¡Lanzo! me llamo

693
00:50:06,750 --> 00:50:08,469
Estefano, no puedo

694
00:50:08,469 --> 00:50:24,179
¿así?

695
00:50:37,860 --> 00:50:38,500
venga

696
00:50:38,500 --> 00:50:42,059
entonces me llamo Estefano

697
00:50:42,059 --> 00:50:43,340
me pillate

698
00:50:43,340 --> 00:50:45,159
me llamo

699
00:50:45,159 --> 00:50:47,940
como los americanos, JJ

700
00:50:47,940 --> 00:50:49,099
no puedo

701
00:50:49,099 --> 00:50:56,809
si me llamo JJ, ¿no quieres darme el segundo?

702
00:50:57,710 --> 00:50:58,309
no sé

703
00:50:58,309 --> 00:51:06,210
menor que 100

704
00:51:06,210 --> 00:51:22,599
¿Dónde está el problema, señores?

705
00:51:24,940 --> 00:51:26,239
¿Dónde está el problema?

706
00:51:30,949 --> 00:51:32,550
¿Cuándo surge el problema?

707
00:51:36,349 --> 00:51:38,650
Cuando mi nombre es menor que dos letras.

708
00:51:38,650 --> 00:52:00,840
Si tu nombre de dos letras o más, lo puedo hacer. Y si no te diré, no puedo. Menor que dos mil, distinto de siete. Pero, señores, razonamos un poquito.

709
00:52:00,840 --> 00:52:05,920
Lo que quería hacer también es otra cosa

710
00:52:05,920 --> 00:52:50,219
Te quiero dar la segunda letra de tu nombre

711
00:52:50,219 --> 00:52:54,840
Pero los nombres con la segunda letra T me molestan

712
00:52:54,840 --> 00:52:56,340
Entonces eso no

713
00:52:56,340 --> 00:53:03,219
Un ejercicio claramente interesante y de uso común

714
00:53:03,219 --> 00:53:05,619
¿Funciona esto?

715
00:53:11,519 --> 00:53:12,880
Es esto, ¿no?

716
00:53:12,880 --> 00:53:14,619
Estefano

717
00:53:14,619 --> 00:53:16,780
No puedo, perfecto

718
00:53:16,780 --> 00:53:18,860
Porque yo lo escribo con segunda letra T

719
00:53:18,860 --> 00:53:20,400
Pero Antonio

720
00:53:20,400 --> 00:53:21,719
Sí

721
00:53:21,719 --> 00:53:23,760
¿Están de acuerdo todos así?

722
00:53:24,659 --> 00:53:34,670
Vale, esto explota

723
00:53:34,670 --> 00:53:41,139
¿Qué diferencia hay entre este y este?

724
00:53:42,239 --> 00:53:43,139
Y la pregunta es

725
00:53:43,139 --> 00:53:44,159
¿Funcionan los dos?

726
00:53:44,320 --> 00:53:45,300
Mira, eh

727
00:53:45,300 --> 00:53:48,119
Porque vosotros no me creáis

728
00:53:48,119 --> 00:53:50,380
Estefano, no puedo

729
00:53:50,380 --> 00:53:54,360
Antonio

730
00:53:54,360 --> 00:53:55,519
N

731
00:53:55,519 --> 00:54:02,579
No lo sé, decídmelo vosotros

732
00:54:02,579 --> 00:54:05,579
¿Qué diferencia hay entre

733
00:54:05,579 --> 00:54:07,920
A mí también me suena que lo dije

734
00:54:07,920 --> 00:54:09,679
Si no, no te lo preguntaba

735
00:54:09,679 --> 00:54:11,980
Vale, diferencia hay entre este y este

736
00:54:11,980 --> 00:54:12,900
Sobre todo son

737
00:54:12,900 --> 00:54:15,000
En este caso de aquí

738
00:54:15,000 --> 00:54:17,179
Si me entregáis esto

739
00:54:17,179 --> 00:54:20,019
O me entregáis esto, vuestra nota cambia

740
00:54:20,019 --> 00:54:34,739
Cuanto más send

741
00:54:34,739 --> 00:54:36,239
Más nota, este es un 10

742
00:54:36,239 --> 00:54:45,000
No, el nivel de vista es mayor o menor

743
00:54:45,000 --> 00:55:16,480
menor o cosa por el estilo que pero son otra cosa mira si mal por qué porque si

744
00:55:16,480 --> 00:55:22,420
os acordáis en la diferencia entre un solo end o dos end es que esto es el

745
00:55:22,420 --> 00:55:30,039
operador perezoso leggi entre este aquí no éste siempre evaluará los dos lados

746
00:55:30,039 --> 00:55:36,940
del end luego hará el end entre los dos y bs es verdadero o falso que pasa que

747
00:55:36,940 --> 00:55:38,280
si le meto solo un S

748
00:55:38,280 --> 00:55:41,280
esto de aquí será falso

749
00:55:41,280 --> 00:55:42,539
pero

750
00:55:42,539 --> 00:55:44,280
aun si esto es falso

751
00:55:44,280 --> 00:55:46,880
él irá a comprobar esta cosa

752
00:55:46,880 --> 00:55:49,360
aquí y al acceder

753
00:55:49,360 --> 00:55:51,000
a la posición 2

754
00:55:51,000 --> 00:55:53,159
a la segunda

755
00:55:53,159 --> 00:55:55,179
letra de una string

756
00:55:55,179 --> 00:55:56,519
que tiene una letra sola

757
00:55:56,519 --> 00:55:57,760
explota

758
00:55:57,760 --> 00:56:01,300
con un string index

759
00:56:01,300 --> 00:56:02,659
out of bound exception

760
00:56:02,659 --> 00:56:05,059
porque el índice 1 es fuera

761
00:56:05,059 --> 00:56:07,119
de los límites

762
00:56:07,119 --> 00:56:09,320
si en vez

763
00:56:09,320 --> 00:56:10,719
pongo dos end

764
00:56:10,719 --> 00:56:13,440
cuando esto

765
00:56:13,440 --> 00:56:14,460
sea falso

766
00:56:14,460 --> 00:56:17,280
él no va a ejecutar esto

767
00:56:17,280 --> 00:56:19,139
se lo salta

768
00:56:19,139 --> 00:56:21,440
porque tanto falso y cualquier cosa

769
00:56:21,440 --> 00:56:22,880
siempre será falso

770
00:56:22,880 --> 00:56:24,019
entonces no

771
00:56:24,019 --> 00:56:27,420
tiene sentido ir a trabajar con esto

772
00:56:27,420 --> 00:56:29,239
esta es la diferencia entre la end

773
00:56:29,239 --> 00:56:30,219
y la end-end

774
00:56:30,219 --> 00:56:33,340
ya que estamos, que el otro día lo decimos pero no lo probamos

775
00:56:33,340 --> 00:56:34,340
pues ahora lo hemos probado

776
00:56:34,340 --> 00:56:55,030
Entonces te viene útil usar uno si tú por alguna razón del multiverso quieres que todas las condiciones que tú pongas allí sean ejecutadas.

777
00:56:55,349 --> 00:57:02,849
Por ejemplo, si este de aquí fuera un método que además de calcular eso hace una cosa lateral, hace otra actividad.

778
00:57:02,849 --> 00:57:05,789
¿Vale? Y tú quieres ejecutarla

779
00:57:05,789 --> 00:57:07,309
Cada vez que se hace este if

780
00:57:07,309 --> 00:57:09,190
Pues entonces lo metes así

781
00:57:09,190 --> 00:57:11,429
Y tú sabes que siempre se ejecuta

782
00:57:11,429 --> 00:57:15,019
¿Dudas?

783
00:57:16,639 --> 00:57:17,280
¿Preguntas?

784
00:57:18,920 --> 00:57:19,559
Vale

785
00:57:19,559 --> 00:57:21,019
Entonces tenéis

786
00:57:21,019 --> 00:57:23,440
Vuestros ejercicios