1
00:00:00,000 --> 00:00:01,560
¿En qué ejercicio se hace el switch?

2
00:00:02,040 --> 00:00:03,040
¿En qué ejercicio se hace el switch?

3
00:00:03,799 --> 00:00:04,960
¿En qué ejercicio se hace el switch?

4
00:00:05,259 --> 00:00:07,580
¿En qué ejercicio se hace el switch?

5
00:00:07,679 --> 00:00:08,560
¿Esto lo vamos a hacer ahora?

6
00:00:08,980 --> 00:00:10,759
Sí, estoy preguntando.

7
00:00:11,099 --> 00:00:13,640
Bueno, a ver, estos son ejercicios de decisión en general

8
00:00:13,640 --> 00:00:15,560
y la decisión uno decide

9
00:00:15,560 --> 00:00:18,000
luego como la plasma, si en un IF, un SIF,

10
00:00:18,059 --> 00:00:19,739
un SWITCH. Nosotros ahora mismo

11
00:00:19,739 --> 00:00:21,839
conocemos tres variantes para

12
00:00:21,839 --> 00:00:23,820
tomar decisiones, o sea, no es que haya

13
00:00:23,820 --> 00:00:25,300
ejercicios de IF, ejercicios de SWITCH.

14
00:00:26,960 --> 00:00:27,859
A ver, IF,

15
00:00:27,859 --> 00:00:29,719
SIF, IF, el IF, el SIF,

16
00:00:29,719 --> 00:00:31,219
el SEIF y el switch case

17
00:00:31,219 --> 00:00:35,619
a ver

18
00:00:35,619 --> 00:00:37,460
el IFELS básico

19
00:00:37,460 --> 00:00:39,939
el IF con el SEIF

20
00:00:39,939 --> 00:00:41,880
claro

21
00:00:41,880 --> 00:00:43,219
eso

22
00:00:43,219 --> 00:00:45,960
vale, en cualquier caso son diferentes

23
00:00:45,960 --> 00:00:47,780
formas de plantear la decisión, luego ya

24
00:00:47,780 --> 00:00:49,759
cada ejercicio uno lo hace como

25
00:00:49,759 --> 00:00:52,219
puede, ve, cree

26
00:00:52,219 --> 00:00:53,659
o usa todas las sentencias

27
00:00:53,659 --> 00:00:55,520
son ejercicios en general de decisión

28
00:00:55,520 --> 00:00:57,560
por eso lo estoy metiendo todo en un proyecto

29
00:00:57,560 --> 00:00:59,700
venga, 19 hemos quedado

30
00:00:59,719 --> 00:01:03,259
Venga

31
00:01:03,259 --> 00:01:07,439
A ver que nos sale

32
00:01:18,180 --> 00:01:19,319
Ejercicio 19

33
00:01:19,319 --> 00:01:21,439
Recibe

34
00:01:21,439 --> 00:01:22,939
Pensemos

35
00:01:22,939 --> 00:01:26,469
A ver

36
00:01:26,469 --> 00:01:29,750
Recibe 3 caracteres

37
00:01:29,750 --> 00:01:30,290
Y un int

38
00:01:30,290 --> 00:01:33,390
Vamos a dar por sentado que lo que mete

39
00:01:33,390 --> 00:01:35,230
Está bien, tres caracteres

40
00:01:35,230 --> 00:01:37,069
Y un int

41
00:01:37,069 --> 00:01:39,010
Para no tener que decir

42
00:01:39,010 --> 00:01:41,030
Si no, bueno, nada

43
00:01:41,030 --> 00:01:42,950
Vale, pues vamos a hacer

44
00:01:42,950 --> 00:01:45,310
La parte de lectura de los datos

45
00:01:45,310 --> 00:01:49,310
La primera de todas, venga, la parte de lectura

46
00:01:49,310 --> 00:01:50,390
Y nos la quitamos de en medio

47
00:01:50,390 --> 00:02:06,900
Ala, ya tenemos

48
00:02:06,900 --> 00:02:08,879
La parte, bueno, hemos leído los datos

49
00:02:08,879 --> 00:02:10,419
A ver, tenemos

50
00:02:10,419 --> 00:02:11,539
Los

51
00:02:11,539 --> 00:02:14,620
Vamos a declarar los

52
00:02:14,620 --> 00:02:16,599
tres, joder

53
00:02:16,599 --> 00:02:19,080
ay, es muy tarde ya

54
00:02:19,080 --> 00:02:22,039
C1, C2 y C3

55
00:02:22,039 --> 00:02:24,479
y el numerito N

56
00:02:24,479 --> 00:02:26,199
nombres de variables horrorosos

57
00:02:26,199 --> 00:02:28,020
pero bueno, es que hay que acortar

58
00:02:28,020 --> 00:02:30,840
hay que acortar que nos alargamos mucho

59
00:02:30,840 --> 00:02:32,520
eso

60
00:02:32,520 --> 00:02:34,460
hay que reducir de donde sea

61
00:02:34,460 --> 00:02:37,080
vale, pues venga, vamos a leer

62
00:02:37,080 --> 00:02:40,419
le decimos primero

63
00:02:40,419 --> 00:02:42,280
introduzca

64
00:02:42,280 --> 00:02:43,539
tres

65
00:02:43,539 --> 00:02:45,740
caracteres

66
00:02:45,740 --> 00:02:50,669
vale, los voy a leer por separado

67
00:02:50,669 --> 00:02:52,590
a ver, aquí se podría interpretar

68
00:02:52,590 --> 00:02:54,770
que le decimos al tío que introduzca A, B, C

69
00:02:54,770 --> 00:02:56,770
los tres seguidos, entonces lo podríamos leer

70
00:02:56,770 --> 00:02:58,689
como una cadena y luego

71
00:02:58,689 --> 00:03:00,770
separarlos, vale, no gracias

72
00:03:00,770 --> 00:03:02,310
eso no gusta, venga, a ver

73
00:03:02,310 --> 00:03:04,650
que otra oferta tenemos, vamos a decirle que

74
00:03:04,650 --> 00:03:06,550
lo lea como, que lo introduzca como

75
00:03:06,550 --> 00:03:08,669
el A, enter, B, enter C

76
00:03:08,669 --> 00:03:09,750
que nos complica más la vida

77
00:03:09,750 --> 00:03:11,349
pues

78
00:03:11,349 --> 00:03:14,129
que introduzca tres caracteres

79
00:03:14,129 --> 00:03:16,030
uno enter, otro enter, otro enter

80
00:03:16,030 --> 00:03:17,389
vamos a asumir que lo va a hacer así

81
00:03:17,389 --> 00:03:20,069
vale, pues venga

82
00:03:20,069 --> 00:03:21,169
vamos a leer el primero

83
00:03:21,169 --> 00:03:24,069
¿cómo leemos?

84
00:03:24,430 --> 00:03:25,889
yo he dicho que con nextline

85
00:03:25,889 --> 00:03:27,750
siempre podemos leer una cadena

86
00:03:27,750 --> 00:03:29,870
siempre, con nextline

87
00:03:29,870 --> 00:03:31,969
pero con nextline

88
00:03:31,969 --> 00:03:34,430
yo leo lo que leo, se queda almacenado

89
00:03:34,430 --> 00:03:35,729
en string, en realidad

90
00:03:35,729 --> 00:03:38,469
pero el tiene introducido

91
00:03:38,469 --> 00:03:39,150
B

92
00:03:39,150 --> 00:03:42,150
vale, si yo me quedo

93
00:03:42,150 --> 00:03:44,289
con la posición 0 de ese string

94
00:03:44,289 --> 00:03:46,090
es decir, si lo que al tío

95
00:03:46,090 --> 00:03:46,669
ha metido

96
00:03:46,669 --> 00:03:49,750
yo me quedo con la 0

97
00:03:49,750 --> 00:03:51,610
ya tengo el char

98
00:03:51,610 --> 00:03:52,509
en realidad

99
00:03:52,509 --> 00:03:56,069
¿verdad? y lo podría asignar a C1

100
00:03:56,069 --> 00:03:56,770
directamente

101
00:03:56,770 --> 00:03:59,789
¿verdad que puedo hacer esto para leer un char?

102
00:04:00,110 --> 00:04:00,949
si me da la gana

103
00:04:00,949 --> 00:04:02,729
con next line

104
00:04:02,729 --> 00:04:05,729
leemos toda la cadena hasta el enter

105
00:04:05,729 --> 00:04:07,770
y ahora

106
00:04:07,770 --> 00:04:09,789
de toda esa cadena yo podría asignarla

107
00:04:09,789 --> 00:04:12,150
un string y ahora ese string

108
00:04:12,150 --> 00:04:13,430
quedarme con la posición 0

109
00:04:13,430 --> 00:04:16,209
pero voy a

110
00:04:16,209 --> 00:04:17,730
abreviar, entonces

111
00:04:17,730 --> 00:04:18,649
todo esto

112
00:04:18,649 --> 00:04:22,250
es la cadena

113
00:04:22,250 --> 00:04:23,589
que me devuelve el next line

114
00:04:23,589 --> 00:04:25,290
pues de toda esa cadena

115
00:04:25,290 --> 00:04:26,829
me quedo con el char 0

116
00:04:26,829 --> 00:04:29,129
a ver, repito para que quede claro

117
00:04:29,129 --> 00:04:31,709
esto es lo mismo que si yo lo hubiera hecho por partes

118
00:04:31,709 --> 00:04:34,250
leo primero

119
00:04:34,250 --> 00:04:34,970
la cadena

120
00:04:34,970 --> 00:04:36,829
así

121
00:04:36,829 --> 00:04:40,870
y una vez que tengo esta cadena

122
00:04:40,870 --> 00:04:42,529
me quedo

123
00:04:42,529 --> 00:04:46,000
de esa cadena

124
00:04:46,000 --> 00:04:47,899
con el char en la posición 0

125
00:04:47,899 --> 00:04:49,839
¿vale?

126
00:04:50,459 --> 00:04:52,360
es decir, esta es una forma

127
00:04:52,360 --> 00:04:54,220
cómoda, tengo más opciones, pero bueno

128
00:04:54,220 --> 00:04:56,199
es una forma cómoda de leer

129
00:04:56,199 --> 00:04:57,180
una variable char

130
00:04:57,180 --> 00:05:00,259
hago el next line que coge todo lo que

131
00:05:00,259 --> 00:05:02,100
hay hasta el enter, que en este caso

132
00:05:02,100 --> 00:05:02,939
es un único carácter

133
00:05:02,939 --> 00:05:06,180
y lo guardo en un string, porque así funciona el next line

134
00:05:06,180 --> 00:05:08,439
lo guardo en un string, no hay alternativa, lo guardo en un string

135
00:05:08,439 --> 00:05:10,819
vale, y ahora de ese string me quedo

136
00:05:10,819 --> 00:05:12,040
con la posición 0

137
00:05:12,040 --> 00:05:14,420
ese me devuelve ya un char suelto

138
00:05:14,420 --> 00:05:16,100
pues ese char hace 1, vale

139
00:05:16,100 --> 00:05:19,040
entonces, esta es una forma

140
00:05:19,040 --> 00:05:20,899
compactada

141
00:05:20,899 --> 00:05:22,800
de ponerlo de arriba, pero es lo mismo

142
00:05:22,800 --> 00:05:24,100
estoy haciendo lo mismo

143
00:05:24,100 --> 00:05:28,560
vale, estoy diciendo

144
00:05:28,560 --> 00:05:30,680
a todo el string que me devuelve

145
00:05:30,680 --> 00:05:31,920
este, a todo este

146
00:05:31,920 --> 00:05:34,339
a todo ese, ya quédate

147
00:05:34,339 --> 00:05:34,939
con el 0

148
00:05:34,939 --> 00:05:37,959
me estoy ahorrando esta variable intermedia

149
00:05:37,959 --> 00:05:39,660
vale, pero esto

150
00:05:39,660 --> 00:05:42,199
y esto tienen el mismo

151
00:05:42,199 --> 00:05:44,160
efecto, guardar en c1

152
00:05:44,160 --> 00:05:46,079
el char que se ha metido, tienen el mismo

153
00:05:46,079 --> 00:05:47,519
efecto, esto y esto

154
00:05:47,519 --> 00:05:51,079
el que veáis más claro

155
00:05:51,079 --> 00:05:54,279
vale, yo este ahora mismo lo voy a dejar comentado

156
00:05:54,279 --> 00:05:57,620
vale, y me quedo con este

157
00:05:57,620 --> 00:05:59,560
y así me ahorro declarar esa variable

158
00:05:59,560 --> 00:06:00,639
me ahorro declararla

159
00:06:00,639 --> 00:06:03,480
pero si os hacéis más lío y lo veis más claro así

160
00:06:03,480 --> 00:06:05,680
pues trabajáis así por ahora y ya está

161
00:06:05,680 --> 00:06:06,300
no pasa nada

162
00:06:06,300 --> 00:06:09,519
bueno, pues

163
00:06:09,519 --> 00:06:11,279
Ya hemos leído el primer carácter

164
00:06:11,279 --> 00:06:12,579
Vamos a leer los siguientes

165
00:06:12,579 --> 00:06:14,660
C2

166
00:06:14,660 --> 00:06:17,360
Y C3

167
00:06:17,360 --> 00:06:24,310
Vale, ya tenemos los tres

168
00:06:24,310 --> 00:06:27,110
Y ahora

169
00:06:27,110 --> 00:06:28,769
Vamos a leer el numerito entero

170
00:06:28,769 --> 00:06:41,439
Leemos el numerito N

171
00:06:41,439 --> 00:06:42,740
Aquí ya lo tenía declarado

172
00:06:42,740 --> 00:06:49,319
N con scan.nextint

173
00:06:49,319 --> 00:06:51,699
Ala, tenemos los tres datos de entrada

174
00:06:51,699 --> 00:06:54,579
Y ahora ya es cuando habría que hacer

175
00:06:54,579 --> 00:06:56,139
Todo el pifostio ese

176
00:06:56,139 --> 00:07:04,139
Bueno, esta parte de lectura de los char ha quedado claro

177
00:07:04,139 --> 00:07:05,959
O sea, en esta versión o en la de arriba

178
00:07:05,959 --> 00:07:13,829
Vale, vamos a probar solo esta parte de lectura

179
00:07:13,829 --> 00:07:15,670
A ver si nos va bien

180
00:07:15,670 --> 00:07:22,579
Vale, voy a ejecutar

181
00:07:22,579 --> 00:07:29,370
Vale, voy a ejecutar esto

182
00:07:29,370 --> 00:07:34,259
Introduzca tres caracteres

183
00:07:34,259 --> 00:07:37,579
R, W, A, introduzca número

184
00:07:37,579 --> 00:07:39,939
Y el programa ha acabado porque no he hecho nada más

185
00:07:39,939 --> 00:07:44,600
vamos a suponer que lo habéis hecho en orden inverso

186
00:07:44,600 --> 00:07:46,959
que habéis decidido leer primero el número

187
00:07:46,959 --> 00:07:48,500
no pasa nada

188
00:07:48,500 --> 00:07:51,060
podéis haber decidido leer primero el número

189
00:07:51,060 --> 00:07:55,180
ya está, habéis leído primero el número

190
00:07:55,180 --> 00:07:57,819
ya después de haber leído el número

191
00:07:57,819 --> 00:08:00,600
ya le pedís los caracteres, es lo mismo, me da igual

192
00:08:00,600 --> 00:08:03,560
voy a quitarlo de aquí porque ya lo he leído arriba

193
00:08:03,560 --> 00:08:07,379
bueno, pues habéis decidido hacerlo en orden inverso

194
00:08:07,379 --> 00:08:10,699
Vale, solamente he subido esto arriba

195
00:08:10,699 --> 00:08:11,920
Para leer primero el numerito

196
00:08:11,920 --> 00:08:14,139
Y cuando he leído el numerito he metido eso

197
00:08:14,139 --> 00:08:15,980
Vale, vamos a ejecutarlo ahora

198
00:08:15,980 --> 00:08:18,180
Lo ejecuto, introduzca número

199
00:08:18,180 --> 00:08:18,720
7

200
00:08:18,720 --> 00:08:22,439
Si no hemos hecho nada

201
00:08:22,439 --> 00:08:23,500
Y ya ha salido esto

202
00:08:23,500 --> 00:08:26,120
Pues ya lo hemos liado

203
00:08:26,120 --> 00:08:29,300
Fijaos que absurdo

204
00:08:29,300 --> 00:08:31,459
Me he limitado a cambiar el orden

205
00:08:31,459 --> 00:08:33,580
A la parte del número

206
00:08:33,580 --> 00:08:35,500
En lugar de leerla después, leerla antes

207
00:08:35,500 --> 00:08:36,740
Y me ha salido algo

208
00:08:36,740 --> 00:08:38,320
desconcertante

209
00:08:38,320 --> 00:08:41,440
ahora me explico

210
00:08:41,440 --> 00:08:43,379
vale

211
00:08:43,379 --> 00:08:44,440
me dice algo de

212
00:08:44,440 --> 00:08:46,940
indesauros va a una excepción

213
00:08:46,940 --> 00:08:49,179
la posición 0, leída

214
00:08:49,179 --> 00:08:51,320
bueno, a ver, en resumen

215
00:08:51,320 --> 00:08:52,460
¿qué ha pasado?

216
00:08:53,179 --> 00:08:55,200
pues esto es por culpa de cómo

217
00:08:55,200 --> 00:08:57,580
funciona el objeto escáner, entonces una vez que ya sabemos

218
00:08:57,580 --> 00:08:58,820
por qué pasa

219
00:08:58,820 --> 00:09:01,320
ya sabemos cómo arreglarlo, lo arregláis siempre

220
00:09:01,320 --> 00:09:03,500
y se acabó, vale, ¿por qué pasa

221
00:09:03,500 --> 00:09:05,320
esto? fijaos lo que

222
00:09:05,320 --> 00:09:06,519
está pasando en realidad es

223
00:09:06,519 --> 00:09:08,519
cuando el

224
00:09:08,519 --> 00:09:10,700
objeto escáner

225
00:09:10,700 --> 00:09:13,100
le mandamos leer un número

226
00:09:13,100 --> 00:09:15,080
sea int o sea label

227
00:09:15,080 --> 00:09:16,799
me da igual, o sea float, un número

228
00:09:16,799 --> 00:09:18,940
cuando le mandamos leer un numerito

229
00:09:18,940 --> 00:09:20,299
¿él qué hace?

230
00:09:21,220 --> 00:09:23,100
como él está esperando un numerito

231
00:09:23,100 --> 00:09:24,720
pues

232
00:09:24,720 --> 00:09:28,730
una vez que ya ha llegado el número

233
00:09:28,730 --> 00:09:30,230
coge el número

234
00:09:30,230 --> 00:09:33,090
lo guarda en la variable correspondiente

235
00:09:33,090 --> 00:09:34,289
lo guarda en la variable

236
00:09:34,289 --> 00:09:37,409
pero claro, nosotros hemos metido el número

237
00:09:37,409 --> 00:09:38,970
y además del número

238
00:09:38,970 --> 00:09:40,309
hemos metido un enter

239
00:09:40,309 --> 00:09:41,929
el enter lo hemos metido

240
00:09:41,929 --> 00:09:44,730
cuando yo meto un número, meto 37

241
00:09:44,730 --> 00:09:45,990
y enter

242
00:09:45,990 --> 00:09:48,809
el next sin

243
00:09:48,809 --> 00:09:50,070
ha cogido el 37

244
00:09:50,070 --> 00:09:52,330
y el 37 se ha ido aquí

245
00:09:52,330 --> 00:09:54,549
¿y qué ha pasado con el enter?

246
00:09:55,049 --> 00:09:56,889
el enter es otro carácter en realidad

247
00:09:56,889 --> 00:09:58,149
de hecho está en la tabla ASCII

248
00:09:58,149 --> 00:10:00,269
en la tabla ASCII hay uno que es salto de línea

249
00:10:00,269 --> 00:10:01,750
es otro carácter

250
00:10:01,750 --> 00:10:03,990
¿qué ha pasado con ese carácter?

251
00:10:04,509 --> 00:10:06,990
pues que está ahí cruzado de brazos en el buffer del teclado

252
00:10:06,990 --> 00:10:08,710
esperando que digan, oye, ¿qué pasa conmigo?

253
00:10:08,950 --> 00:10:11,070
Te has quedado con el 37 y lo has guardado en N,

254
00:10:11,230 --> 00:10:13,309
muy bien, y yo, ¿qué pasa?

255
00:10:14,009 --> 00:10:15,149
Pues ahí se queda esperando,

256
00:10:15,549 --> 00:10:17,509
en el buffer del teclado, donde está la filita

257
00:10:17,509 --> 00:10:18,669
de las cosas que yo he metido.

258
00:10:19,309 --> 00:10:20,970
Cuando vosotros tecleáis en un teclado,

259
00:10:21,129 --> 00:10:22,110
todo eso va a un buffer.

260
00:10:23,409 --> 00:10:25,110
Y luego ya la aplicación que sea

261
00:10:25,110 --> 00:10:27,230
va sacando del buffer según va necesitando.

262
00:10:28,029 --> 00:10:29,629
Pues aquí hemos metido en el buffer

263
00:10:29,629 --> 00:10:30,850
37

264
00:10:30,850 --> 00:10:32,629
y el salto de línea.

265
00:10:32,629 --> 00:10:33,889
Todo eso está en el buffer.

266
00:10:34,590 --> 00:10:36,090
El 37 salió

267
00:10:36,090 --> 00:10:38,809
porque lo sacó el next line para llevarlo

268
00:10:38,809 --> 00:10:40,830
y salió, y está el salto de línea

269
00:10:40,830 --> 00:10:42,090
cruzado de brazos, y ahí está

270
00:10:42,090 --> 00:10:44,710
vale, pues el salto de línea, ¿quién lo chupa ahora?

271
00:10:45,850 --> 00:10:46,470
lo chupa

272
00:10:46,470 --> 00:10:48,769
este next line

273
00:10:48,769 --> 00:10:50,429
la siguiente sentencia de entrada

274
00:10:50,429 --> 00:10:51,870
esta

275
00:10:51,870 --> 00:10:53,789
entonces, esta

276
00:10:53,789 --> 00:10:56,809
no se queda esperando que le metamos

277
00:10:56,809 --> 00:10:59,070
algo más, porque ya ve que hay un salto de línea

278
00:10:59,070 --> 00:11:00,970
y se cree que es

279
00:11:00,970 --> 00:11:02,850
eso lo que le hemos

280
00:11:02,850 --> 00:11:04,789
metido, se cree que es eso, entonces lo

281
00:11:04,789 --> 00:11:06,870
coge y como le hemos

282
00:11:06,870 --> 00:11:08,769
dicho que vaya al carácter en posición

283
00:11:08,769 --> 00:11:10,750
cero, dice, si no hay nada en la

284
00:11:10,750 --> 00:11:13,110
posición cero, porque le hemos metido un string vacío.

285
00:11:14,110 --> 00:11:14,769
Al dar al enter

286
00:11:14,769 --> 00:11:16,649
él interpreta que no hay un string vacío, no hay nada.

287
00:11:17,470 --> 00:11:18,269
Es lo que nos ha salido.

288
00:11:18,750 --> 00:11:20,669
Indes va a una step y en la posición cero no existe.

289
00:11:21,769 --> 00:11:22,610
A ver, más o menos

290
00:11:22,610 --> 00:11:23,669
habéis entendido lo que ha pasado.

291
00:11:24,629 --> 00:11:26,110
Ahora es más fácil entender la solución.

292
00:11:27,649 --> 00:11:28,750
Esto cuando ocurre,

293
00:11:29,129 --> 00:11:29,690
ocurre,

294
00:11:30,870 --> 00:11:32,190
esta combinación se da

295
00:11:32,190 --> 00:11:34,909
cuando hacéis una lectura

296
00:11:34,909 --> 00:11:35,470
de número

297
00:11:35,470 --> 00:11:38,730
y después hacéis una de cadena

298
00:11:38,730 --> 00:11:41,389
esa combinación es la peligrosa

299
00:11:41,389 --> 00:11:42,990
porque cuando hacéis

300
00:11:42,990 --> 00:11:44,950
la de número, la de número deja el salto de línea

301
00:11:44,950 --> 00:11:45,649
sin procesar

302
00:11:45,649 --> 00:11:47,570
y luego la va a procesar este

303
00:11:47,570 --> 00:11:50,350
entonces, y este

304
00:11:50,350 --> 00:11:52,850
al ser un next line, al procesarla

305
00:11:52,850 --> 00:11:54,350
va a decir, uy cadena vacía

306
00:11:54,350 --> 00:11:56,629
cadena vacía, ya tengo cadena, no tengo que esperar

307
00:11:56,629 --> 00:11:58,570
que me metas nada, pero claro, cadena vacía

308
00:11:58,570 --> 00:12:00,330
cuando me voy aquí, falla

309
00:12:00,330 --> 00:12:02,629
porque no tiene posición 0 la cadena vacía

310
00:12:02,629 --> 00:12:06,610
la que pongas

311
00:12:06,610 --> 00:12:08,110
la cadena vacía no tiene ninguna posición

312
00:12:08,110 --> 00:12:10,149
no tiene ni la 0 ni la 1 ni la ninguna

313
00:12:10,149 --> 00:12:12,250
entonces primero hay que aislar

314
00:12:12,250 --> 00:12:13,570
que este problema se da

315
00:12:13,570 --> 00:12:15,990
cuando hacemos la secuencia de

316
00:12:15,990 --> 00:12:18,090
leer un numerito con next in next double

317
00:12:18,090 --> 00:12:18,950
y después un next line

318
00:12:18,950 --> 00:12:22,389
porque entre next line y next line

319
00:12:22,389 --> 00:12:22,889
no se da

320
00:12:22,889 --> 00:12:26,149
porque un next line el salto de línea también lo chupa

321
00:12:26,149 --> 00:12:26,610
y lo quita

322
00:12:26,610 --> 00:12:30,110
el problema es cuando leemos números

323
00:12:30,110 --> 00:12:32,350
que el salto de línea no lo chupan

324
00:12:32,350 --> 00:12:34,450
bueno, pues entonces

325
00:12:34,450 --> 00:12:35,990
¿cómo lo arreglamos? cuando hemos

326
00:12:35,990 --> 00:12:37,990
identificado que en nuestro código tenemos una

327
00:12:37,990 --> 00:12:39,549
secuencia de lecturas

328
00:12:39,549 --> 00:12:41,590
en las cuales estamos leyendo número

329
00:12:41,590 --> 00:12:43,509
y después cadena

330
00:12:43,509 --> 00:12:46,110
número y después cadena, tenemos que

331
00:12:46,110 --> 00:12:48,049
hacer algo para quitar ese

332
00:12:48,049 --> 00:12:48,710
salto de línea

333
00:12:48,710 --> 00:12:52,230
no pasa nada, pues ¿cómo podemos hacer

334
00:12:52,230 --> 00:12:53,769
quitar el salto de línea?

335
00:12:54,250 --> 00:12:55,450
leyéndolo a lo bestia

336
00:12:55,450 --> 00:12:56,649
lo leemos

337
00:12:56,649 --> 00:13:01,080
ya está leído

338
00:13:01,080 --> 00:13:04,600
y no lo asigno a nadie, lo tiro a la basura

339
00:13:04,600 --> 00:13:06,200
no hace falta que se lo asigne a nadie

340
00:13:06,200 --> 00:13:08,399
si yo no se lo asigno a nadie

341
00:13:08,399 --> 00:13:10,379
es como tirarlo a la basura

342
00:13:10,379 --> 00:13:12,720
se lo podría asignar

343
00:13:12,720 --> 00:13:13,659
a una cadena, claro

344
00:13:13,659 --> 00:13:16,539
entonces yo ahora mi programa así

345
00:13:16,539 --> 00:13:18,120
ya sí va a funcionar

346
00:13:18,120 --> 00:13:20,340
porque ¿qué es lo que hago? leo un numerito

347
00:13:20,340 --> 00:13:21,720
el número va a N

348
00:13:21,720 --> 00:13:24,659
se me ha quedado un salto de línea

349
00:13:24,659 --> 00:13:26,700
ese salto de línea

350
00:13:26,700 --> 00:13:28,220
que se lo traje este next line

351
00:13:28,220 --> 00:13:30,080
y lo lleva aquí

352
00:13:30,080 --> 00:13:33,620
y ahora ya, este ya se encuentra el buffer vacío

353
00:13:33,620 --> 00:13:35,679
como se encuentra el buffer vacío

354
00:13:35,679 --> 00:13:37,379
ya se queda esperando que yo le meta

355
00:13:37,379 --> 00:13:40,500
mi char, ¿vale?

356
00:13:42,460 --> 00:13:43,019
entonces

357
00:13:43,019 --> 00:13:44,740
recopilando

358
00:13:44,740 --> 00:13:46,580
esta situación anómala se da

359
00:13:46,580 --> 00:13:48,659
cuando después de leer un número

360
00:13:48,659 --> 00:13:50,860
leemos cadena con next line

361
00:13:50,860 --> 00:13:52,879
para evitarla

362
00:13:52,879 --> 00:13:55,340
intercalamos

363
00:13:55,340 --> 00:13:57,259
entre la lectura de número

364
00:13:57,259 --> 00:13:58,320
y la lectura de cadena

365
00:13:58,320 --> 00:14:01,179
intercalamos una lectura de cadena

366
00:14:01,179 --> 00:14:03,120
Para que quite eso, que se ha quedado ahí esperando

367
00:14:03,120 --> 00:14:05,179
Vamos a probarlo

368
00:14:05,179 --> 00:14:07,440
Para ver que ahora las lecturas no van a dar ese problema

369
00:14:07,440 --> 00:14:09,679
Yo ahora introduzca

370
00:14:09,679 --> 00:14:10,860
Número 87

371
00:14:10,860 --> 00:14:12,679
¿Veis? Y ahora ya sé que funciona

372
00:14:12,679 --> 00:14:14,500
D, F y H

373
00:14:14,500 --> 00:14:16,059
Vale, ya me ha funcionado

374
00:14:16,059 --> 00:14:18,159
¿Vale?

375
00:14:18,539 --> 00:14:20,200
Ya por último, para que quede más bonito

376
00:14:20,200 --> 00:14:22,039
Este string que leo

377
00:14:22,039 --> 00:14:24,940
No necesito asignárselo a nadie

378
00:14:24,940 --> 00:14:26,700
Es para nada

379
00:14:26,700 --> 00:14:28,940
Es para sacarlo del buffer, pero me da igual

380
00:14:28,940 --> 00:14:30,000
No quiero hacer nada con él

381
00:14:30,000 --> 00:14:31,559
pues yo puedo

382
00:14:31,559 --> 00:14:33,320
no asignárselo a nadie

383
00:14:33,320 --> 00:14:35,139
puedo hacer esto

384
00:14:35,139 --> 00:14:37,799
el compilador no tiene problema

385
00:14:37,799 --> 00:14:39,620
coge el valor

386
00:14:39,620 --> 00:14:41,700
y cuando toca asignarlo dice

387
00:14:41,700 --> 00:14:43,340
uy, no me has dicho a quién se lo asigno

388
00:14:43,340 --> 00:14:45,840
pues a la basura, ya está, no pasa nada

389
00:14:45,840 --> 00:14:48,039
cuando nosotros cogemos

390
00:14:48,039 --> 00:14:50,000
un valor y no se lo asignamos a nadie

391
00:14:50,000 --> 00:14:51,659
la máquina virtual

392
00:14:51,659 --> 00:14:53,399
lo hace desaparecer

393
00:14:53,399 --> 00:14:57,080
y se acabó, entonces en este caso

394
00:14:57,080 --> 00:14:59,279
me es más cómodo, como yo ese valor no lo quiero para nada

395
00:14:59,279 --> 00:15:00,159
solo para sacarlo

396
00:15:00,159 --> 00:15:08,779
pues lo dejo así y listo

397
00:15:08,779 --> 00:15:09,080
¿vale?

398
00:15:10,100 --> 00:15:12,500
entonces lo único, repito, ahora mismo

399
00:15:12,500 --> 00:15:14,679
no hace falta que os volváis

400
00:15:14,679 --> 00:15:15,740
locos, simplemente

401
00:15:15,740 --> 00:15:18,759
cuando estáis haciendo un código y resulta

402
00:15:18,759 --> 00:15:20,779
que después de un next in o un next

403
00:15:20,779 --> 00:15:22,200
in, una lectura de número en general

404
00:15:22,200 --> 00:15:24,460
tenéis que hacer una de cadena

405
00:15:24,460 --> 00:15:26,519
acordaos de meter

406
00:15:26,519 --> 00:15:27,720
una de estas, ya está

407
00:15:27,720 --> 00:15:33,710
¿vale? y me diréis

408
00:15:33,710 --> 00:15:35,850
seguramente, un segundo, me diréis

409
00:15:35,850 --> 00:15:37,649
oye, pero ¿por qué no me ha pasado otras

410
00:15:37,649 --> 00:15:39,330
veces cuando hemos leído

411
00:15:39,330 --> 00:15:40,830
seguidos numeritos

412
00:15:40,830 --> 00:15:42,450
porque hay veces

413
00:15:42,450 --> 00:15:45,830
en los cuales hemos leído dos números

414
00:15:45,830 --> 00:15:47,309
seguidos, hemos hecho dos next in

415
00:15:47,309 --> 00:15:49,330
o tres números seguidos

416
00:15:49,330 --> 00:15:51,909
cuando era el mayor de los tres, hemos hecho tres next in

417
00:15:51,909 --> 00:15:53,889
y diréis, anda, y ahí porque no pasaba

418
00:15:53,889 --> 00:15:54,870
porque yo metía el numerito

419
00:15:54,870 --> 00:15:56,730
y el salto de línea se quedaba

420
00:15:56,730 --> 00:15:59,370
porque este next in no lo cogía

421
00:15:59,370 --> 00:16:01,750
porque el método next in

422
00:16:01,750 --> 00:16:03,629
ignora

423
00:16:03,629 --> 00:16:04,669
todo lo que no sean números

424
00:16:04,669 --> 00:16:07,549
entonces, este next in

425
00:16:07,549 --> 00:16:09,190
ha dejado un salto de línea, es verdad

426
00:16:09,190 --> 00:16:10,990
pero este otro next in

427
00:16:10,990 --> 00:16:13,610
ese salto de línea, como no es un número, lo ignora

428
00:16:13,610 --> 00:16:15,250
y se va por los números

429
00:16:15,250 --> 00:16:16,490
por eso no nos ha pasado eso

430
00:16:16,490 --> 00:16:18,990
pero claro, cuando lo que tenemos es un next line

431
00:16:18,990 --> 00:16:21,509
el next line no ignora nada, porque es una cadena

432
00:16:21,509 --> 00:16:23,250
genérica, la que sea, no ignora nada

433
00:16:23,250 --> 00:16:25,330
entonces, si había un salto de línea

434
00:16:25,330 --> 00:16:27,330
del next in anterior, si lo había

435
00:16:27,330 --> 00:16:29,409
esta no lo ignora y se lo queda

436
00:16:29,409 --> 00:16:30,490
¿vale?

437
00:16:33,620 --> 00:16:34,960
luego, lo que, dime

438
00:16:34,960 --> 00:16:37,059
¿por qué no lo hace automáticamente?

439
00:16:39,370 --> 00:16:39,730
porque

440
00:16:39,730 --> 00:16:43,289
el ordenador no sabe hacer nada

441
00:16:43,289 --> 00:16:44,690
eso tienes que decir tú, ¿por qué va a hacer

442
00:16:44,690 --> 00:16:46,230
automáticamente eso?

443
00:16:48,769 --> 00:16:51,110
no está el escáner programado para que después

444
00:16:51,110 --> 00:16:52,629
de un int elimine el salto de línea

445
00:16:52,629 --> 00:16:54,809
no está programado

446
00:16:54,809 --> 00:16:56,009
¿eh?

447
00:16:56,009 --> 00:16:57,929
y no existe un limpiar

448
00:16:57,929 --> 00:16:59,690
buffer, no, con este objeto

449
00:16:59,690 --> 00:17:01,389
escáner, este no es el único objeto

450
00:17:01,389 --> 00:17:03,909
con el que se puede leer del teclado

451
00:17:03,909 --> 00:17:05,170
hay más objetos

452
00:17:05,170 --> 00:17:07,150
con otras funcionalidades

453
00:17:07,150 --> 00:17:09,750
de distintos, pero este

454
00:17:09,750 --> 00:17:11,029
a la hora de escribirlo

455
00:17:11,029 --> 00:17:13,130
es el más sencillo

456
00:17:13,130 --> 00:17:15,049
entonces por eso es el que al principio estamos usando

457
00:17:15,049 --> 00:17:16,789
porque si usáramos otros objetos

458
00:17:16,789 --> 00:17:19,369
pues tendríamos que saber más cosas de objetos

459
00:17:19,369 --> 00:17:21,529
porque los métodos se usan de otra manera

460
00:17:21,529 --> 00:17:23,130
pero este

461
00:17:23,130 --> 00:17:24,970
en concreto tiene esta particularidad

462
00:17:24,970 --> 00:17:26,430
pero no pasa nada, dime

463
00:17:26,430 --> 00:17:33,710
no, no, no, no, esto es

464
00:17:33,710 --> 00:17:35,269
imagina, no

465
00:17:35,269 --> 00:17:37,049
si hemos hecho esto

466
00:17:37,049 --> 00:17:38,349
y esto

467
00:17:38,349 --> 00:17:42,230
o sea dos de número

468
00:17:42,230 --> 00:17:44,309
esto no significa

469
00:17:44,309 --> 00:17:46,990
que se hayan quedado dos en el buffer

470
00:17:46,990 --> 00:17:49,230
Aquí este ha dejado uno

471
00:17:49,230 --> 00:17:50,829
Pero este next in

472
00:17:50,829 --> 00:17:52,650
Ha cogido el primero

473
00:17:52,650 --> 00:17:55,450
Como no le interesa porque no es número, fuera, lo ha sacado ya

474
00:17:55,450 --> 00:17:57,329
Coger su número

475
00:17:57,329 --> 00:17:59,670
Y el que le queda a él, ese ya sí que lo deja

476
00:17:59,670 --> 00:18:01,769
O sea, cada next in deja uno solo

477
00:18:01,769 --> 00:18:03,930
Los que hubiera de antes ya se han eliminado

478
00:18:03,930 --> 00:18:04,490
¿Vale?

479
00:18:05,569 --> 00:18:06,609
Pero sí, es una

480
00:18:06,609 --> 00:18:09,410
Buena pregunta, efectivamente, ¿vale?

481
00:18:10,410 --> 00:18:11,329
¿Vale? Pues vale

482
00:18:11,329 --> 00:18:12,750
Ya tenemos hecha la primera parte

483
00:18:12,750 --> 00:18:15,170
Leer los char y el numerito

484
00:18:15,170 --> 00:18:16,750
Y ahora ya viene el programa

485
00:18:16,750 --> 00:18:19,730
que el programa era

486
00:18:19,730 --> 00:18:22,289
cada char

487
00:18:22,289 --> 00:18:23,190
por favor

488
00:18:23,190 --> 00:18:26,230
sustituyalo con el char

489
00:18:26,230 --> 00:18:28,430
que se encuentre en posiciones

490
00:18:28,430 --> 00:18:29,369
después

491
00:18:29,369 --> 00:18:32,289
vale, bueno, aquí tenemos que

492
00:18:32,289 --> 00:18:34,210
entonces

493
00:18:34,210 --> 00:18:36,390
si acaba el alfabeto

494
00:18:37,009 --> 00:18:38,210
esta parte

495
00:18:38,210 --> 00:18:39,390
vamos a incorporarla después

496
00:18:39,390 --> 00:18:42,089
vamos a hacer primero como sin tener en cuenta

497
00:18:42,089 --> 00:18:43,670
que se acabe el alfabeto o no

498
00:18:43,670 --> 00:18:46,130
y luego ya nos planteamos

499
00:18:46,130 --> 00:18:48,430
cómo incorporar en el caso de que se haya acabado el alfabeto.

500
00:18:49,289 --> 00:18:50,349
Venga, pues

501
00:18:50,349 --> 00:18:52,250
en este caso

502
00:18:52,250 --> 00:18:54,250
como ya sabemos, aquí lo que tenemos

503
00:18:54,250 --> 00:18:56,130
que hacer es automáticamente irnos

504
00:18:56,130 --> 00:18:58,210
a la tabla ASCII a ver cómo están colocadas

505
00:18:58,210 --> 00:18:59,710
las letras minúsculas.

506
00:19:07,960 --> 00:19:09,400
Vale, pues aquí tenemos

507
00:19:09,400 --> 00:19:15,079
una tabla ASCII

508
00:19:15,079 --> 00:19:16,920
donde las letras minúsculas

509
00:19:16,920 --> 00:19:21,359
están aquí

510
00:19:21,359 --> 00:19:22,480
a la derecha.

511
00:19:23,539 --> 00:19:25,140
Aquí están las letras minúsculas.

512
00:19:26,000 --> 00:19:27,460
Desde el 97

513
00:19:27,460 --> 00:19:31,269
hasta el 122

514
00:19:31,269 --> 00:19:33,910
con lo cual, uy que suerte, están consecutivas

515
00:19:33,910 --> 00:19:35,329
con lo cual llegar

516
00:19:35,329 --> 00:19:38,190
de la A a 4 por debajo

517
00:19:38,190 --> 00:19:39,009
es sumarle 4

518
00:19:39,009 --> 00:19:42,029
llegar de la D a 4 por debajo

519
00:19:42,029 --> 00:19:42,910
es sumarle 4

520
00:19:42,910 --> 00:19:46,269
entonces, si nos olvidamos

521
00:19:46,269 --> 00:19:47,349
del tema circular

522
00:19:47,349 --> 00:19:50,230
que si me he saltado todo al principio

523
00:19:50,230 --> 00:19:51,509
si nos olvidamos de esa parte

524
00:19:51,509 --> 00:19:53,609
pues este programa se quedaría sencillito

525
00:19:53,609 --> 00:19:56,690
ya, se quedaría

526
00:19:56,690 --> 00:19:57,809
vamos a ver

527
00:19:57,809 --> 00:20:00,490
Decía simplemente

528
00:20:00,490 --> 00:20:01,470
Avanzar

529
00:20:01,470 --> 00:20:04,049
Las letras en el alfabeto

530
00:20:04,049 --> 00:20:04,970
El numerito que sea

531
00:20:04,970 --> 00:20:07,430
El alfabeto después

532
00:20:07,430 --> 00:20:09,650
Vale, pues entonces

533
00:20:09,650 --> 00:20:10,950
Esto se nos quedaría

534
00:20:10,950 --> 00:20:13,549
C1 igual a

535
00:20:13,549 --> 00:20:16,230
C1 más

536
00:20:16,230 --> 00:20:17,329
N

537
00:20:17,329 --> 00:20:21,910
Más

538
00:20:21,910 --> 00:20:24,869
N, vale

539
00:20:24,869 --> 00:20:34,119
Vale, eso es lo primero que haríamos

540
00:20:34,119 --> 00:20:35,460
¿No? C2

541
00:20:35,460 --> 00:20:37,180
Es lo primero que se nos ocurre

542
00:20:37,180 --> 00:20:40,660
C2 más N.

543
00:20:41,460 --> 00:20:45,720
Y ahora C3 igual a C3 más N.

544
00:20:46,579 --> 00:20:48,759
Vale, ahora aquí nos sale algo rojo.

545
00:20:49,240 --> 00:20:50,779
De nuevo son las particularidades de los char.

546
00:20:50,779 --> 00:20:54,759
Pero ya entendemos, sin ver lo que nos dice, ya lo podemos entender.

547
00:20:55,319 --> 00:20:56,079
Vamos a ver.

548
00:20:56,680 --> 00:21:01,779
Tenemos aquí un operador más que está sumando un char con un entero.

549
00:21:02,700 --> 00:21:04,460
Sabemos que eso lo podemos hacer, no hay ningún problema.

550
00:21:05,700 --> 00:21:06,599
¿Qué es lo que hace eso?

551
00:21:07,180 --> 00:21:11,700
Entonces, el C1 lo interpreta como si fuera número entero.

552
00:21:12,119 --> 00:21:17,099
Es decir, si C1 fuera A, lo interpreta como 97.

553
00:21:17,779 --> 00:21:19,099
Ya sabemos lo que está pasando.

554
00:21:19,819 --> 00:21:21,859
En cuanto el C1 está con un operador más,

555
00:21:22,400 --> 00:21:25,900
C1 es interpretado como el numerito entero 97.

556
00:21:27,079 --> 00:21:30,900
Al 97 le suma 3, el número que sea,

557
00:21:31,599 --> 00:21:33,200
y te dará 100.

558
00:21:33,819 --> 00:21:34,440
Te da un int.

559
00:21:34,440 --> 00:21:36,599
y yo estoy intentando

560
00:21:36,599 --> 00:21:37,420
guardarlo en un char

561
00:21:37,420 --> 00:21:40,019
un int en un char no puedes

562
00:21:40,019 --> 00:21:41,119
al revés sí

563
00:21:41,119 --> 00:21:44,240
un char en un int sí, porque un char

564
00:21:44,240 --> 00:21:46,559
siempre puede ser interpretado como entero

565
00:21:46,559 --> 00:21:48,000
o sea, un char

566
00:21:48,000 --> 00:21:50,039
admite ambas interpretaciones

567
00:21:50,039 --> 00:21:52,119
o juega el papel de numerito entero

568
00:21:52,119 --> 00:21:54,339
siendo su papel este

569
00:21:54,339 --> 00:21:56,420
o juega el papel de char

570
00:21:56,420 --> 00:21:57,640
puede jugar los dos

571
00:21:57,640 --> 00:22:00,339
¿vale? pero el entero solo juega

572
00:22:00,339 --> 00:22:01,000
el papel de entero

573
00:22:01,000 --> 00:22:03,940
entonces, yo

574
00:22:03,940 --> 00:22:06,559
un char a un entero puedo

575
00:22:06,559 --> 00:22:08,660
es decir, yo

576
00:22:08,660 --> 00:22:10,960
a una variable

577
00:22:10,960 --> 00:22:12,519
entera num

578
00:22:12,519 --> 00:22:14,660
¿vale?

579
00:22:16,039 --> 00:22:17,200
¿le puedo dar un char?

580
00:22:17,619 --> 00:22:18,420
no hay ningún problema

581
00:22:18,420 --> 00:22:20,720
porque esto es un char, pero el char

582
00:22:20,720 --> 00:22:21,880
tiene doble personalidad

583
00:22:21,880 --> 00:22:24,900
y adopta la que necesitemos

584
00:22:24,900 --> 00:22:26,920
aquí, como lo voy a asignar

585
00:22:26,920 --> 00:22:28,740
a un número, adopta la

586
00:22:28,740 --> 00:22:29,640
personalidad de entero

587
00:22:29,640 --> 00:22:31,940
y su personalidad de entero es 97

588
00:22:31,940 --> 00:22:34,579
con lo cual al numerito num

589
00:22:34,579 --> 00:22:36,720
si yo lo miro por pantalla veo que tiene

590
00:22:36,720 --> 00:22:38,559
97, ya está, no hay duda

591
00:22:38,559 --> 00:22:41,000
y este tiene su doble personalidad

592
00:22:41,000 --> 00:22:42,339
si yo este

593
00:22:42,339 --> 00:22:44,599
lo uso para

594
00:22:44,599 --> 00:22:46,519
asignárselo a un char, tampoco

595
00:22:46,519 --> 00:22:48,700
hay ningún problema, el char

596
00:22:48,700 --> 00:22:50,700
a se va a c, ningún problema

597
00:22:50,700 --> 00:22:52,819
¿dónde viene el problema?

598
00:22:53,640 --> 00:22:54,619
cuando yo lo que

599
00:22:54,619 --> 00:22:56,660
quiero es a una variable char

600
00:22:56,660 --> 00:22:58,960
¿vale? asignarle

601
00:22:58,960 --> 00:23:00,920
un numerito

602
00:23:00,920 --> 00:23:05,430
una variable entera. Tengo

603
00:23:05,430 --> 00:23:06,170
mi variable

604
00:23:06,170 --> 00:23:09,289
entera, n

605
00:23:09,289 --> 00:23:14,359
vale, sí,

606
00:23:14,599 --> 00:23:15,039
perdón,

607
00:23:16,000 --> 00:23:17,420
mi numerita entera igual a

608
00:23:17,420 --> 00:23:20,400
vale, y aquí le quiero asignar

609
00:23:20,400 --> 00:23:22,339
num, ¿vale?

610
00:23:24,619 --> 00:23:25,859
Aquí es donde no me deja.

611
00:23:26,980 --> 00:23:28,220
Me dice, oye,

612
00:23:28,339 --> 00:23:30,400
num es una variable entera

613
00:23:30,400 --> 00:23:32,460
y las variables enteras

614
00:23:32,460 --> 00:23:33,819
son variables enteras,

615
00:23:34,200 --> 00:23:36,140
no pueden elegir, no pueden elegir,

616
00:23:36,140 --> 00:23:38,240
Y entonces, como son variables enteras, a char no pueden ir.

617
00:23:39,220 --> 00:23:40,119
Ese es el problema que nos hemos

618
00:23:40,119 --> 00:23:40,779
encontrado aquí.

619
00:23:41,839 --> 00:23:43,339
¿Vale? Es el problema que nos hemos encontrado aquí.

620
00:23:44,960 --> 00:23:46,539
Vale. Pues entonces,

621
00:23:47,380 --> 00:23:49,880
¿qué podemos hacer?

622
00:23:57,240 --> 00:23:58,839
Claro, o bien,

623
00:23:59,160 --> 00:24:00,440
declaro esto como enteros.

624
00:24:01,359 --> 00:24:02,619
Declaro estos como enteros.

625
00:24:03,079 --> 00:24:04,180
¿Vale? Los declaro como enteros.

626
00:24:04,279 --> 00:24:04,460
Aquí,

627
00:24:09,339 --> 00:24:10,480
lo que pasa es que están como echados.

628
00:24:10,480 --> 00:24:12,559
Bueno, el casting era por eso que nos ahorrábamos el casting.

629
00:24:13,019 --> 00:24:14,720
No lo podemos ahorrar en cualquier caso.

630
00:24:15,440 --> 00:24:15,619
¿Vale?

631
00:24:15,660 --> 00:24:17,500
Entonces, tengo que pasar esto a char.

632
00:24:18,619 --> 00:24:19,019
¿Vale?

633
00:24:19,039 --> 00:24:21,400
Tengo que pasar esto a char para volverlo a guardar.

634
00:24:21,460 --> 00:24:23,380
Bueno, a ver, es que estoy intentando, perdón,

635
00:24:23,819 --> 00:24:24,700
guardarlo en C1.

636
00:24:24,779 --> 00:24:27,380
Voy a hacerlo en tres variables aparte.

637
00:24:27,380 --> 00:24:30,880
Para, claro, en lugar de volverlo a guardar en C1,

638
00:24:31,000 --> 00:24:33,660
que lo había hecho por comodidad para no tener más variables,

639
00:24:33,839 --> 00:24:37,099
en lugar de guardarlo en C1, me voy a hacer yo tres variables

640
00:24:37,099 --> 00:24:40,799
en la letra 1, en la letra 2

641
00:24:40,799 --> 00:24:43,519
e en la letra 3, las modificadas

642
00:24:43,519 --> 00:24:46,200
y esta va a ser la letra 1

643
00:24:46,200 --> 00:24:49,559
esta va a ser la letra 2

644
00:24:49,559 --> 00:24:52,980
y esta va a ser la letra 3

645
00:24:52,980 --> 00:24:53,880
¿vale?

646
00:24:55,180 --> 00:24:59,619
entonces, el charce 1 sumada a sus posiciones

647
00:24:59,619 --> 00:25:02,819
el charce 1 que es A

648
00:25:02,819 --> 00:25:04,500
pues A más 3

649
00:25:04,500 --> 00:25:05,579
será

650
00:25:05,579 --> 00:25:08,500
97 más 3, 100

651
00:25:08,500 --> 00:25:10,380
pues el numerito 100

652
00:25:10,380 --> 00:25:11,640
va aquí

653
00:25:11,640 --> 00:25:13,539
el numerito 100 va aquí

654
00:25:13,539 --> 00:25:18,470
ahora yo quiero mostrar esos caracteres

655
00:25:18,470 --> 00:25:22,359
y ahora ya tenemos el problema

656
00:25:22,359 --> 00:25:22,980
de siempre

657
00:25:22,980 --> 00:25:26,220
que si los mostramos así

658
00:25:26,220 --> 00:25:28,680
no me muestra esos caracteres

659
00:25:28,680 --> 00:25:29,759
concatenados

660
00:25:29,759 --> 00:25:32,539
sino que lo que me muestra es la suma

661
00:25:32,539 --> 00:25:33,440
de los enteros

662
00:25:33,440 --> 00:25:35,779
pero que hacíamos

663
00:25:35,779 --> 00:25:41,430
lo poníamos con comillas

664
00:25:41,430 --> 00:25:50,559
L1, aquí me sobra este

665
00:25:50,559 --> 00:25:58,140
vale, pues vamos a probarlo poniendo que no se salte

666
00:25:58,140 --> 00:26:01,539
del alfabeto, vamos a ponerle la A, la B y la C

667
00:26:01,539 --> 00:26:06,140
y que avance tres posiciones, con lo cual nos tendrá que mostrar la D, la E

668
00:26:06,140 --> 00:26:10,339
y la F, vamos a ver, si nos muestra la D

669
00:26:10,339 --> 00:26:14,279
la E y la F nuestro programa, la D, la E

670
00:26:14,279 --> 00:26:16,279
La F si le metemos la A, la B y la C

671
00:26:16,279 --> 00:26:17,299
Y el número 3

672
00:26:17,299 --> 00:26:19,440
Vamos a probar a hacer eso

673
00:26:19,440 --> 00:26:21,200
A ver

674
00:26:21,200 --> 00:26:27,150
Número 3

675
00:26:27,150 --> 00:26:31,410
Caracteres A, B y C

676
00:26:31,410 --> 00:26:32,250
¿Vale?

677
00:26:34,910 --> 00:26:36,269
No nos ha mostrado eso

678
00:26:36,269 --> 00:26:37,390
¿Vale?

679
00:26:42,299 --> 00:26:44,019
¿Dónde estamos? Aquí

680
00:26:44,019 --> 00:26:45,079
¿Vale?

681
00:26:46,319 --> 00:26:47,799
¿Vale? Pues ¿qué tenemos que hacer?

682
00:26:48,000 --> 00:26:51,319
L1 al estar declarada como int

683
00:26:51,319 --> 00:26:53,220
Al estar declarada como int

684
00:26:53,220 --> 00:26:55,819
cuando la máquina virtual ha intentado

685
00:26:55,819 --> 00:26:56,880
hacer su casting

686
00:26:56,880 --> 00:26:58,140
a string

687
00:26:58,140 --> 00:27:01,740
ha hecho su casting al numerito entero

688
00:27:01,740 --> 00:27:02,779
que representa

689
00:27:02,779 --> 00:27:04,880
¿y qué numerito entero representaba?

690
00:27:05,019 --> 00:27:06,440
100, 101 y 102

691
00:27:06,440 --> 00:27:08,460
pues eso es lo que nos ha sacado

692
00:27:08,460 --> 00:27:12,119
nos ha sacado 100, 101 y 102

693
00:27:12,119 --> 00:27:13,579
vamos a volverlo a probar

694
00:27:13,579 --> 00:27:15,559
no hace falta

695
00:27:15,559 --> 00:27:16,420
porque lo tengo ya aquí

696
00:27:16,420 --> 00:27:18,160
nos ha sacado el 100

697
00:27:18,160 --> 00:27:21,440
el 101 y el 102

698
00:27:21,440 --> 00:27:23,220
es decir, nos ha sacado

699
00:27:23,220 --> 00:27:24,599
esto, 100

700
00:27:24,599 --> 00:27:28,779
100, 101

701
00:27:28,779 --> 00:27:31,279
y 102, es decir

702
00:27:31,279 --> 00:27:32,380
el D, el E y el F

703
00:27:32,380 --> 00:27:35,059
pero nos ha sacado como entero, y decíamos

704
00:27:35,059 --> 00:27:37,119
pero si hemos hecho este ejercicio igual y me lo sacaba

705
00:27:37,119 --> 00:27:38,500
como char al convertirlo a char

706
00:27:38,500 --> 00:27:41,019
claro, pero porque estaba declarada

707
00:27:41,019 --> 00:27:41,980
como char la variable

708
00:27:41,980 --> 00:27:44,880
ahora está como int, con lo cual

709
00:27:44,880 --> 00:27:46,640
cuando el operador más hace

710
00:27:46,640 --> 00:27:49,099
la conversión a cadena de esta

711
00:27:49,099 --> 00:27:51,200
mira si está declarada como char

712
00:27:51,200 --> 00:27:53,200
como int. Si está declarada como

713
00:27:53,200 --> 00:27:55,160
int, lo convierte a

714
00:27:55,160 --> 00:27:57,220
esto. Y si está declarada

715
00:27:57,220 --> 00:27:58,460
como

716
00:27:58,460 --> 00:28:01,319
char, lo convierte

717
00:28:01,319 --> 00:28:03,200
a esto otro.

718
00:28:04,140 --> 00:28:05,160
Pero claro, decimos, jolín,

719
00:28:05,240 --> 00:28:07,019
pues estoy en un callejón

720
00:28:07,019 --> 00:28:09,039
sin salida, porque es que lo he tenido

721
00:28:09,039 --> 00:28:11,099
que declarar como int precisamente para

722
00:28:11,099 --> 00:28:13,220
poder hacer esta asignación aquí. Estoy en un callejón

723
00:28:13,220 --> 00:28:14,380
sin salida, no lo puedo declarar como char.

724
00:28:14,960 --> 00:28:17,099
Pero ahora ya aquí es cuando

725
00:28:17,099 --> 00:28:19,059
no podemos escaparnos del casting.

726
00:28:19,700 --> 00:28:21,099
En esta situación digo, vale,

727
00:28:21,200 --> 00:28:43,670
Te he declarado como int, con lo cual cuando te conviertas a string te vas a convertir como esto, no me interesa. Quiero que te conviertas a string como el char que representas, no como esto, como el char que representas. Pues entonces esto ahora ya le hacemos el casting, que esto le obliga.

728
00:28:43,670 --> 00:28:45,710
eh, cuidado, aunque estás declarado

729
00:28:45,710 --> 00:28:47,769
como int, por favor

730
00:28:47,769 --> 00:28:48,990
trabájame como char

731
00:28:48,990 --> 00:28:50,910
¿vale?

732
00:29:04,599 --> 00:29:06,740
¿vale? no hubiéramos tenido que hacer

733
00:29:06,740 --> 00:29:08,559
el casting si estuviera declarado como char

734
00:29:08,559 --> 00:29:10,819
lo hemos tenido que hacer porque está

735
00:29:10,819 --> 00:29:12,619
como int, y está como int

736
00:29:12,619 --> 00:29:14,180
para poder haber

737
00:29:14,180 --> 00:29:15,720
hecho el avance

738
00:29:15,720 --> 00:29:17,680
entonces

739
00:29:17,680 --> 00:29:21,079
ahora ya ejecutamos

740
00:29:21,079 --> 00:29:22,779
esto y suponemos

741
00:29:22,779 --> 00:29:24,319
3, a

742
00:29:24,319 --> 00:29:26,079
b y c

743
00:29:26,079 --> 00:29:27,640
D, E y F

744
00:29:27,640 --> 00:29:34,130
Vale, pues

745
00:29:34,130 --> 00:29:36,710
Esto está

746
00:29:36,710 --> 00:29:39,130
Salvo

747
00:29:39,130 --> 00:29:41,450
Y aquí es donde vienen ya los if

748
00:29:41,450 --> 00:29:43,349
Porque si no diríamos, aquí no hay que hacer if

749
00:29:43,349 --> 00:29:44,109
Ni hay que hacer nada

750
00:29:44,109 --> 00:29:46,009
Aquí donde vienen los if

751
00:29:46,009 --> 00:29:48,950
Bueno, pues los if vienen porque dice, oye, cuidado

752
00:29:48,950 --> 00:29:51,910
Si como consecuencia de hacer el salto

753
00:29:51,910 --> 00:29:53,890
Te sales

754
00:29:53,890 --> 00:29:56,549
Entonces

755
00:29:56,549 --> 00:29:57,890
Vuelve arriba

756
00:29:57,890 --> 00:30:00,569
Entonces aquí habrá que hacer un if

757
00:30:00,569 --> 00:30:13,250
Porque si el resultado de esta suma, si L1 o L2 o L3, cualquiera de ellos, son mayores de 122,

758
00:30:14,210 --> 00:30:20,950
entonces en ese caso tienes que hacer una corrección, que es restarle esta diferencia,

759
00:30:21,309 --> 00:30:23,930
restarle el alfabeto para que se vaya aquí.

760
00:30:24,430 --> 00:30:27,349
Si el alfabeto tiene 27 números, pues restarle 27 para que se vaya aquí.

761
00:30:27,349 --> 00:30:30,750
eso ya lo pensáis vosotros

762
00:30:30,750 --> 00:30:31,549
esa modificación

763
00:30:31,549 --> 00:30:34,329
la podemos ver mañana o el próximo día

764
00:30:34,329 --> 00:30:35,269
pero la idea es esa

765
00:30:35,269 --> 00:30:37,710
la idea es si alguna de estas sumas

766
00:30:37,710 --> 00:30:39,789
supera 122

767
00:30:39,789 --> 00:30:42,329
hay que restarle la cantidad de caracteres

768
00:30:42,329 --> 00:30:43,869
de alfabeto y ya está, nada más

769
00:30:43,869 --> 00:30:46,170
lo pensáis y a ver

770
00:30:46,170 --> 00:30:48,109
cómo os funciona

771
00:30:48,109 --> 00:30:51,930
vale, y yo creo que

772
00:30:51,930 --> 00:30:53,910
de todas las cosas raras que pueden tener

773
00:30:53,910 --> 00:30:55,930
los sin, los char combinados, no sé qué

774
00:30:55,930 --> 00:30:57,230
ya lo hemos contemplado todo

775
00:30:57,230 --> 00:31:00,009
pero el resumen es

776
00:31:00,009 --> 00:31:01,730
una variable char

777
00:31:01,730 --> 00:31:04,450
un char en general

778
00:31:04,450 --> 00:31:07,210
puede ser usado en una expresión

779
00:31:07,210 --> 00:31:09,230
en una expresión como int o como char

780
00:31:09,230 --> 00:31:10,369
¿de qué depende?

781
00:31:11,029 --> 00:31:12,309
pues del operador con el que esté

782
00:31:12,309 --> 00:31:15,390
si es más será usado como entero

783
00:31:15,390 --> 00:31:17,029
si lo estoy asumiendo a un int

784
00:31:17,029 --> 00:31:19,269
como entero, puede ser usado como entero

785
00:31:19,269 --> 00:31:20,890
o como char, y un int no

786
00:31:20,890 --> 00:31:22,130
un int solo como int

787
00:31:22,130 --> 00:31:24,349
a menos que le hagamos el casting

788
00:31:24,349 --> 00:31:26,490
si le hacemos el casting entonces ya es usado como char

789
00:31:26,490 --> 00:31:28,109
pero si no lo hacemos el casting

790
00:31:28,109 --> 00:31:29,809
siempre será usado como int

791
00:31:29,809 --> 00:31:32,589
¿eso qué significa?

792
00:31:32,970 --> 00:31:34,589
que lo, ya para terminar

793
00:31:34,589 --> 00:31:35,950
que lo que yo había

794
00:31:35,950 --> 00:31:38,269
la opción que yo había hecho antes

795
00:31:38,269 --> 00:31:40,670
de, no me voy a inventar variables

796
00:31:40,670 --> 00:31:42,470
nuevas, voy a hacerlo

797
00:31:42,470 --> 00:31:45,029
con las mismas, con c1, c2 y c3

798
00:31:45,029 --> 00:31:46,670
esta versión mía

799
00:31:46,670 --> 00:31:50,170
c1, c2 y c3

800
00:31:50,170 --> 00:31:52,329
que me daba problemas porque me decía

801
00:31:52,329 --> 00:31:54,170
ojo que esto es un entero, no puede

802
00:31:54,170 --> 00:31:56,490
a un char, pues esta versión mía

803
00:31:56,490 --> 00:31:58,730
la podría haber arreglado

804
00:31:58,730 --> 00:32:00,769
poniéndole

805
00:32:00,769 --> 00:32:02,230
un casting en ese momento

806
00:32:02,230 --> 00:32:04,410
digo, oye

807
00:32:04,410 --> 00:32:05,369
si, tú eres un entero

808
00:32:05,369 --> 00:32:08,589
pero tú me interesas trabajando como char

809
00:32:08,589 --> 00:32:09,930
pues todo tú

810
00:32:09,930 --> 00:32:11,809
te pongo el casting delante

811
00:32:11,809 --> 00:32:14,049
¿vale?

812
00:32:14,569 --> 00:32:27,289
nos ahorramos esas tres variables

813
00:32:27,289 --> 00:32:29,069
¿y entonces arriba donde

814
00:32:29,069 --> 00:32:30,910
por ahí está mi char?

815
00:32:32,029 --> 00:32:33,150
no, es que esto

816
00:32:33,150 --> 00:32:34,210
ya no me hace falta

817
00:32:34,210 --> 00:32:37,490
estoy sobre la propia

818
00:32:37,490 --> 00:32:39,529
C1 asignando la conversión

819
00:32:39,529 --> 00:32:40,730
a char de este número entero

820
00:32:40,730 --> 00:32:42,730
y ahora ya cuando muestre

821
00:32:42,730 --> 00:32:45,509
los paréntesis sí que los tengo que poner

822
00:32:45,509 --> 00:32:47,529
pero ya el casting a char

823
00:32:47,529 --> 00:32:48,990
me lo ahorro

824
00:32:48,990 --> 00:32:51,450
claro cuando

825
00:32:51,450 --> 00:32:53,109
o sea este system de aquí

826
00:32:53,109 --> 00:32:55,309
iría aquí

827
00:32:55,309 --> 00:32:58,750
y para el de abajo

828
00:32:58,750 --> 00:33:01,650
pues ya este no hace falta

829
00:33:01,650 --> 00:33:03,529
porque para que voy a convertir

830
00:33:03,529 --> 00:33:05,009
achar algo que haya achar

831
00:33:05,009 --> 00:33:06,349
este C1

832
00:33:06,349 --> 00:33:09,589
este C2

833
00:33:09,589 --> 00:33:11,730
y este

834
00:33:11,730 --> 00:33:12,849
C3

835
00:33:12,849 --> 00:33:15,509
vale, ya los tengo en char

836
00:33:15,509 --> 00:33:16,849
no hace falta que haga el casting a char

837
00:33:16,849 --> 00:33:19,509
eso sí, lo tengo que paginar

838
00:33:19,509 --> 00:33:21,589
con esto porque si no el más lo volvería a convertir

839
00:33:21,589 --> 00:33:23,210
a enter otra vez, volvería a convertir a

840
00:33:23,210 --> 00:33:24,910
vale

841
00:33:24,910 --> 00:33:34,200
vale, pues ya está, pero voy a probarlo

842
00:33:34,200 --> 00:33:36,220
por si se ha escapado algo, a ver si

843
00:33:36,220 --> 00:33:39,960
voy a comentar

844
00:33:39,960 --> 00:33:41,859
esta parte de aquí, la versión

845
00:33:41,859 --> 00:33:43,500
anterior la vamos a

846
00:33:43,500 --> 00:33:45,700
comentar y vamos a dejar esta

847
00:33:45,700 --> 00:33:46,019
solo

848
00:33:46,019 --> 00:33:49,500
a ver si algo se nos ha escapado

849
00:33:49,500 --> 00:33:50,579
que podría ser porque

850
00:33:50,579 --> 00:33:54,119
A, B y C

851
00:33:54,119 --> 00:33:55,539
D y F, vale

852
00:33:55,539 --> 00:34:00,670
vale, venga, pues ahora

853
00:34:00,670 --> 00:34:01,890
ya sí que nos vamos

854
00:34:01,890 --> 00:34:04,670
incorporar la versión de

855
00:34:04,670 --> 00:34:06,470
si me he salido del alfabeto

856
00:34:06,470 --> 00:34:08,630
empieza por arriba otra vez, en plan círculo

857
00:34:08,630 --> 00:34:09,389
vale

858
00:34:09,389 --> 00:34:12,210
y ya está finito