Saltar navegación

20241010 ProgrEstruct-Decision-Ejer_10 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 10 de octubre de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Este ejercicio se había quedado sin IF, porque no le hacía ninguna falta tal y como estaba. 00:00:00
Entonces, la incorporación de la parte que queda, que es cuidado, si te has saltado, vuelve al principio. 00:00:10
La incorporación ahora ya es la que mete el IF. 00:00:18
Tengo dos situaciones, que como consecuencia de hacer esta suma, me haya salido del último char. 00:00:21
Pues ahí hay que meter el if 00:00:29
Entonces aquí tenemos que tener la tabla presente 00:00:30
Vale, esta tabla se veía más o menos bien 00:00:34
Vale, aquí tenemos los numeritos 00:00:46
No, perdón, estábamos hablando de letras minúsculas 00:00:50
Aquí, tenemos aquí las letras minúsculas 00:00:53
Que van desde la A, que es el 97 00:00:57
A la Z, que es el 122 00:01:03
Con lo cual, ¿cuántas letras hay? 00:01:06
Pues, ¿cuántas letras hay? 00:01:09
Habrá 123 menos 97, ¿no? 00:01:13
O sea, las del alfabeto menos la ñ 00:01:17
¿Cuántas letras hay en este alfabeto minúsculo? 00:01:19
A ver, que si lo habéis hecho me lo podéis decir 00:01:24
Porque tendréis que haber hecho el cálculo 00:01:26
¿No? 00:01:27
O sea, habrá tantas letras como 123 menos 97 00:01:32
O lo estoy diciendo mal, lo de los extremos 00:01:36
O 122 menos 96, la que sea 00:01:39
Entonces, a 122 que tengo hasta la Z 00:01:49
Le quito las 96 anteriores 00:01:53
A 122 que tengo 00:01:58
122 menos las 96 anteriores 00:02:00
Que no son letras minúsculas 00:02:06
Y me salen 26 letras 00:02:07
¿Vale? 00:02:11
Como tenía que ser 00:02:11
Porque el alfabeto español 00:02:12
Español siempre hemos dicho que eran 27, 27, 27, pero claro, por la E. 00:02:14
Aunque antiguamente en mis tiempos la EY contaba como letra y la CH, efectivamente. 00:02:19
Vale, pues entonces, que no se nos olvide, 26. 00:02:28
Bueno, pues entonces ahora ya aquí la modificación de este ejercicio implica 00:02:32
que en función del resultado de esta suma, la asignación a C1 es una o es otra. 00:02:36
Esa es la modificación 00:02:43
Vamos a hacerlo aquí aparte 00:02:45
Modificación 00:02:47
Considerando 00:02:52
La posibilidad 00:02:56
De salirnos del alfabeto 00:03:01
Vale, pues el meollo del asunto 00:03:02
Está aquí 00:03:09
Está aquí 00:03:10
Eso es lo que ya no puede ser así 00:03:13
Calcado, tal cual, ahí está el meollo del asunto 00:03:15
Nosotros antes 00:03:17
Hemos cogido nuestra letrita 00:03:19
la 101, por ejemplo, la que fuera 00:03:21
la 101, le hemos sumado el parámetro 4 00:03:26
pues nos hemos ido a la 105, ya está, y ahora la 105 pero 00:03:30
convertida a char, se la pasamos aquí, y no nos hemos cuestionado 00:03:34
nada más, vale, pues entonces ahora hay que cambiar porque en función 00:03:38
de si esto, la suma de mi letrita más 00:03:42
el salto, se sale 00:03:46
de 122 o no 00:03:48
la asignación es una u otra 00:03:51
claro, porque si no es menor de 122 00:03:53
tengo que asignarle otra cosa 00:03:58
habrá que ver cuál, tengo que volver 00:04:00
para arriba, vale, pues entonces 00:04:01
esto ya no nos gusta así 00:04:03
pues vamos a 00:04:06
vamos a 00:04:07
hacerlo directamente una por una y luego 00:04:09
ya, pues uno podría arreglar 00:04:11
el código por lo más bonito, pero vamos a dejar 00:04:13
claro cuál es el cambio 00:04:15
esencial, el cambio es 00:04:17
Cuidado, si C1 más 00:04:18
A ver, si C1 más N 00:04:21
Es, bueno, vamos a poner el caso bueno 00:04:23
Es menor o igual que 122 00:04:25
¿Verdad? 00:04:27
Es menor o igual que 122 00:04:29
Porque es 122, ¿no? La última, la Z 00:04:31
La Z es 122 00:04:33
Vale, si C1 más N es menor o igual que 122 00:04:35
Magnífico, no me he salido 00:04:38
Del alfabeto, entonces 00:04:39
Se queda esta, ¿vale? 00:04:41
Como he dicho que nos acostumbremos 00:04:44
A poner llaves 00:04:46
Para no liarnos 00:04:47
Y si no 00:04:49
Es que me he salido 00:04:51
Pues entonces 00:04:53
No le podemos asignar 00:04:54
A C1 directamente la suma 00:04:57
Sino que le tenemos que 00:05:00
Retroceder hacia atrás 00:05:02
Restarle 26 00:05:05
Es decir 00:05:06
Vamos a ver 00:05:09
Imagínate que a mí me han dado la Z 00:05:10
122 00:05:12
Entonces me dicen que avance 2 00:05:14
Me voy a 124 00:05:16
No, a 124 no tengo que irme 00:05:18
26 más arriba 00:05:20
Para ahora ya ir a la C 00:05:22
Claro 00:05:24
Vale 00:05:27
Entonces tengo que, pum, hacer el salto 00:05:28
Hacia atrás, vale, la comprobamos 00:05:32
Si es 26, 27, pero estoy pensando 00:05:34
En voz alta sin pensar en los límites 00:05:36
Entonces 00:05:37
Si no 00:05:39
¿Qué tenemos que hacer? Pues C1 00:05:41
será igual a la conversión 00:05:44
a char también, porque c1 es un char 00:05:46
pero no de c1 00:05:48
más n sin más, sino de c1 00:05:50
más n yéndome 00:05:52
hacia arriba, menos 26 00:05:54
vale 00:05:58
y esto mismo 00:05:59
con las 00:06:01
otras 00:06:04
quedan tres i, muy feo, pues 00:06:04
se podría cambiar, poner esto 00:06:07
esto se puede hacer con un operador 00:06:10
condicionado en una sola 00:06:12
línea, porque claro, ¿qué es lo que hago en el if 00:06:14
y en el else? a la misma 00:06:16
variable le asigno o una cosa 00:06:18
u otra, entonces cuando estamos en ese 00:06:19
caso concreto, que en mi rama 00:06:21
del if y en mi rama del else, lo único que se 00:06:24
hace es a la misma variable 00:06:26
o le asigno esto, le asigno esto 00:06:27
pues todo esto mismo lo podríamos haber puesto así también 00:06:29
c1 igual 00:06:32
y me pregunto 00:06:35
vamos a ver qué pasa con esto 00:06:37
¿qué pasa con esto? pues entonces 00:06:39
le asignamos esto 00:06:44
Y si no el otro 00:06:45
Vale 00:06:47
Y me ha faltado el 00:06:57
Menos 26 aquí 00:07:00
A ver, en esta línea estoy haciendo 00:07:01
El mismo código de arriba 00:07:06
Pero con este operador 00:07:07
Porque en el if de arriba 00:07:10
Estamos haciendo 00:07:12
A C1 le asigno esto 00:07:13
O a C1 le asigno esto 00:07:15
En función de una condición, luego esto es una asignación condicionada 00:07:17
Entonces otra forma de escribirlo 00:07:20
Otra forma de escribirlo 00:07:22
Sería esta, por ahora 00:07:23
Lo pongo en comentarios 00:07:25
Pero vamos, que lo dejamos aquí 00:07:27
Vale 00:07:29
Y esto mismo 00:07:39
Lo podríamos hacer con C2 y C3 00:07:41
Vale, lo que pasa es que 00:07:43
A ver, que tontería 00:07:52
A ver, yo estoy operando así en piloto automático 00:07:54
Pero 00:07:56
Vamos a ver 00:07:57
Ah, no, no, no, perdón, perdón, es que creían que eran consecutivas 00:07:59
C1, C2, C3, no tienen por qué serlo, nada, nada, no he dicho nada 00:08:03
Y C3 00:08:10
vale, pues si no me he equivocado en los copias 00:08:13
y pegas, cambiar los nombres de variables 00:08:23
y todo eso, debería 00:08:25
funcionar, pero 00:08:27
cuando uno hace las pruebas 00:08:29
es cuando realmente tiene la 00:08:31
casi garantía de que no 00:08:33
ha cometido ninguno 00:08:35
vale, bueno, pues venga 00:08:36
entonces lo que pasa es que voy 00:08:39
esta versión del código la voy 00:08:42
a comentar, vale 00:08:45
porque esta versión del código era 00:08:48
sin tener en cuenta, vale, todo esto era sin tener en cuenta 00:08:50
vale, sin tener en cuenta que me salga del alfabeto era esta parte de arriba 00:08:58
y ahora vamos a hacer la modificación, sería esta, entonces mi programa 00:09:16
ahora mismo se le queda solamente descomentado el leerlas, este, si ya está 00:09:20
vale, venga, pues vamos 00:09:24
a probarlo, ejercicio 19, vale, entonces 00:09:30
si le damos, por ejemplo, le damos 00:09:36
X, Y y Z 00:09:40
Y le decimos que salte 1 00:09:43
X, Y y Z tendría que darme 00:09:45
Y, Z y A 00:09:47
Y, Z y A 00:09:48
Vamos a ver 00:09:51
El numerito va a ser 1 00:09:52
Y la cadena hemos dicho que es 00:09:54
X, Y y Z 00:09:57
No, en minúscula porque si no 00:09:58
X, Y y Z 00:10:00
Es que 00:10:02
No, es que no lo he mostrado 00:10:04
Que no he hecho el system out 00:10:06
¿Vale? 00:10:07
Ah, no, pero sigue esperando algo. Ah, no, es que estoy... Ah, perdón, perdón, perdón, claro, porque he ido uno por uno, perdón, perdón. Vale, vale, vale. Ah, vale, sí, podría haber seguido, vale, pero bueno, ya lo había parado, pues lo hago otra vez. Vale, vale. Pues entonces ahora sí, el programa era uno y ahora X, Y y Z. 00:10:10
Y ahora sí que es que no lo he mostrado, ¿verdad? 00:10:35
Que no, que no, que no he hecho el system out aquí 00:10:38
Que he hecho el avance 00:10:43
Pero el system out este 00:10:44
Luego para mostrarlo, esto no lo he hecho 00:10:45
Aquí 00:10:48
Vale, entonces me falta mostrar el resultado 00:10:51
Era lo que no tenía 00:10:54
Pues venga, empezamos otra vez 00:10:56
X, Y y Z 00:11:00
Y, Z y A 00:11:02
Vale 00:11:04
Con letras 00:11:05
Cuales quiera, avanza 2 00:11:08
G, E 00:11:10
Y X 00:11:12
G, H, Y 00:11:14
Avanzado 2 00:11:17
E, avanzado 2 00:11:18
F, G 00:11:20
Y X, avanzado 2 00:11:23
Pero quería yo hacer 00:11:24
G, H 00:11:29
Y X 00:11:32
Que era la última, tendrá que saltar a la X 00:11:33
Y, Z 00:11:35
Efectivamente 00:11:36
Ha saltado 3 cada una de ellas 00:11:38
H, I, J 00:11:41
I, J, K 00:11:44
Y, Z y A 00:11:46
Vale, pues esa modificación ya la tenemos incorporada 00:11:48
¿Vale? 00:11:51
Vale, a ver 00:12:02
¿Algún ejercicio más? 00:12:06
¿O queréis que sigamos? 00:12:13
En el 19 hay un problema 00:12:14
¿Cuál? 00:12:16
Si pones un número 00:12:17
Mayor que el doble de 26 00:12:18
Sí, tienes razón 00:12:24
Luego, claro, cuando uno ya se mete en una fase de pruebas y empieza a hacer ya pruebas muy completas, pues se da cuenta, en la mayoría de los casos, que hay situaciones raras que no hemos contemplado. 00:12:27
Efectivamente, una de esas. Si le decimos que avance 87, pues cuando retroceda 26, no. Entonces, habría que hacer el resto de 87 entre 26 para ver los 26 ejes que se tiene que quitar de encima. 00:12:41
Pero bueno, vamos a asumir que... 00:12:57
Tú incorporalo si quieres, pero como si no hubiéramos dicho nada. 00:12:59
No vamos a complicarlo ahora. 00:13:01
Vale. 00:13:03
Venga, pues... 00:13:13
26. 00:13:15
Pedir día, mes y año. 00:13:18
Indicar si es una fecha válida. 00:13:19
Una fecha válida, según nuestro calendario. 00:13:21
Asumiendo los meses con la duración que tengan. 00:13:24
Venga. 00:13:29
Este es el 26. 00:13:30
Vale, pues a ver, pedir datos de entrada, pedir un día, un mes y un año. 00:13:59
Antes de seguir analizando ya el resto del ejercicio, vamos a pedir esos datos. 00:14:06
Entonces, aquí tenemos datos de diferentes tipos. 00:14:10
El día va a ser un numerito entero 00:14:12
Pero el mes 00:14:15
Va a ser una cadena 00:14:17
Y el año va a ser otro numerito entero 00:14:18
Vamos a pedirlo en ese orden 00:14:21
Y así nos vuelve a aparecer el problema 00:14:22
De que después de leer un número 00:14:24
Cuando lees una cadena tienes que limpiar el buffer, etc 00:14:25
Por lo pronto vamos a declarar las variables 00:14:28
Para leer esos datos 00:14:31
Vale, esto lo vamos a necesitar 00:14:32
Y ahora 00:14:41
Nuestras variables son 00:14:48
El año 00:14:51
Esto es porque como año tiene la ñ 00:14:52
Pues así es más cómodo 00:14:55
El día y el mes 00:14:57
Vale, entonces 00:14:59
Introduzca día 00:15:03
Entonces él va a leer 00:15:06
13, 12, 27, 314 00:15:12
Lo vamos a guardar aquí 00:15:17
Como esperamos que sea un entero 00:15:19
Lo leemos con nexting 00:15:24
Porque esperamos que sea un entero 00:15:25
Si luego lo mete un entero 00:15:27
Si no que mete pepito 00:15:28
El programa ya sabéis que va a dar una excepción 00:15:29
Y se va a detener 00:15:31
Y ahora mismo no podemos hacer otra cosa 00:15:32
Porque no sabemos hacer otra cosa 00:15:34
Vale, pues le decimos lo mismo 00:15:36
Ah, perdón 00:15:38
Que el mes no es entero 00:15:39
Vale 00:15:42
Sí, pero no 00:15:43
Vamos a decir febrero, marzo 00:15:45
Que me tal que sea 00:15:47
el mes 00:15:48
vale, pues venga, ahora 00:15:54
introduzca 00:15:57
el mes 00:15:58
e introduzca 00:16:02
el año 00:16:05
porque normalmente nos referimos 00:16:09
a los meses como enero, febrero, marzo 00:16:14
no sueles decir mes 1, mes 2, mes 3 00:16:15
bueno, pues vamos a pedir los datos 00:16:18
entonces 00:16:23
la parte de la interfaz de usuario 00:16:23
que en nuestro caso la interfaz de usuario son 00:16:26
los system out y los scan, no es otra cosa 00:16:28
la parte de la interfaz siempre hay que hacerla 00:16:30
no pensando en el código 00:16:32
hay que hacerla pensando en que hay un humano 00:16:34
sentado 00:16:36
porque si lo haces pensando en la facilidad 00:16:37
de tu código, vas a hacer una aplicación 00:16:40
efectivamente poco accesible, poco amable 00:16:42
entonces no le vamos a decir a un tío 00:16:44
mete el mes y esperar que nos diga 00:16:46
pero mete el mes por el numerito 00:16:48
hombre, a ver, uno se puede dar cuenta rápido 00:16:50
que julio es 7 o que agosto es 8 00:16:52
pero le complicamos la vida 00:16:54
entonces la interfaz 00:16:56
siempre hay que hacerla pensando en 00:16:59
vale, pues entonces 00:17:00
como el mes 00:17:04
es un 00:17:05
string, lo leemos con nextline 00:17:07
y como el año es un entero 00:17:09
lo leemos con nextline 00:17:12
entonces aquí que nos va a pasar, ya sabemos 00:17:14
lo que nos va a pasar, vamos a 00:17:16
ejecutar solamente esta parte 00:17:18
para ver si no sale ningún error y las lecturas 00:17:19
las hace, bueno vamos a 00:17:22
Hacer simplemente una comprobación 00:17:23
A ver si hemos leído bien las cosas 00:17:25
Que nos muestre el día 00:17:27
Concatenado 00:17:30
Con 00:17:32
El mes 00:17:34
Si, perdón, es que 00:17:37
Con el mes 00:17:39
Y concatenado 00:17:42
Con 00:17:46
El año 00:17:47
Vamos a hacer solamente 00:17:49
Esta primera prueba para ver si 00:17:52
la parte de lectura, está bien 00:17:53
entonces 00:17:55
ejecutamos esto 00:17:56
introduzca día, el día 5 00:18:00
y no nos deja 00:18:03
meter el mes 00:18:05
el mes lo salta 00:18:05
ya nos dice introduzca año 00:18:08
pues venga, el 765 00:18:10
y del mes efectivamente ha pasado 00:18:13
¿no? es el 5 00:18:16
del año 765 00:18:18
esto ya nos lo podíamos esperar 00:18:20
porque como 00:18:22
os enterasteis muy bien de la clase 00:18:24
del otro día y si no lo repasasteis 00:18:26
en casa y todo eso, ya no podíamos 00:18:28
esperar que aquí teníamos 00:18:30
la combinación 00:18:32
peligrosa, más que peligrosa 00:18:34
la combinación 00:18:36
conflictiva 00:18:37
estoy leyendo un número 00:18:39
y justo después de leer un número 00:18:42
leo un string 00:18:44
entonces 00:18:46
el número 00:18:47
ha sido recogido del buffer por next in 00:18:49
pero el salto de línea 00:18:52
no, luego next line 00:18:54
como next line 00:18:56
le vale cualquier cosa 00:18:57
no es como next in o next double 00:19:00
solo 00:19:01
esperan del buffer números y double 00:19:03
pero como next line espera cualquier cosa 00:19:06
ve el salto de línea y dice pues ya está, será esto 00:19:08
será la cadena vacía con un salto de línea 00:19:10
entonces ha cogido eso 00:19:12
y el mes ya se ha nutrido 00:19:13
ya se ha nutrido pero con quien, con la cadena vacía 00:19:15
y nos lo ha mostrado, si el programa 00:19:18
ha funcionado perfectamente, está aquí 00:19:20
lo que pasa es que no la vemos 00:19:22
Bueno es que me falta un 00:19:24
Para que se vea más claro 00:19:26
Me falta un guioncito ahí 00:19:27
Ahí 00:19:30
Me falta aquí un guion 00:19:33
Vale entonces efectivamente yo puedo ejecutar esto 00:19:34
Introduzca día 00:19:38
El 4 del año 00:19:39
El 23 00:19:41
Claro que ha cogido la cadena vacía 00:19:42
Entonces ha funcionado bien 00:19:45
Entonces el problema es 00:19:47
Que tenemos que identificar 00:19:49
Esa combinación 00:19:51
Después de un número estás leyendo la cadena 00:19:53
cuidado, después de un next in, un next double 00:19:55
un next float, estás leyendo 00:19:57
un next line 00:19:59
pues haces esto 00:20:00
y dices, a ver, este next line 00:20:04
es un 00:20:07
es un next line cuya única función 00:20:08
es quitar, leer 00:20:12
la cadena vacía que se ha quedado 00:20:14
después de next in, leerla 00:20:17
entonces como ya la habrá leído y no se la 00:20:18
asignamos a ningún lado 00:20:21
esto no hace falta que hagamos una asignación 00:20:21
si yo no hago una asignación aquí a nadie 00:20:24
de lo que he leído 00:20:26
lo quito esta parte 00:20:28
lo que significa es que eso que he leído 00:20:29
la máquina virtual dice, uy, ¿no me das 00:20:31
una caja para meterlo? Fuera 00:20:34
en nuestro caso no queremos una caja 00:20:35
para meter la cadena vacía, lo único que queríamos era 00:20:38
sacarla de ahí, pues no la meto en ninguna 00:20:39
caja vacía, fuera, y ahora 00:20:42
ya, como ya sí que se ha quedado el buffer 00:20:43
vacío, ya no hay nada, aquí 00:20:46
ya sí que se va a quedar esperando, no le va a quedar más remedio 00:20:48
porque ya hemos sacado la cadena vacía 00:20:50
que salió después del next in 00:20:52
que se quedó ahí, ya la hemos vaciado 00:20:53
entonces 00:20:55
Si ahora ejecutamos esto 00:20:57
Estamos a día 6 00:20:59
¿De qué mes de febrero? 00:21:00
¿De qué año del 2000? 00:21:03
Pues ya está 00:21:06
¿Vale? 00:21:07
Bueno, pues esto simplemente 00:21:09
Es los métodos 00:21:11
De scan que estamos 00:21:13
Que estamos usando 00:21:15
Estos más sencillos 00:21:17
Pues simplemente ocurre eso, que el nextin funciona así 00:21:18
Yo quiero números, pues me cojo los números 00:21:20
Y el salto de línea de después 00:21:23
no lo cojo, entonces el buffer del teclado 00:21:25
lo tiene ahí 00:21:27
que luego hago un next in después 00:21:28
no hay ese problema, como dijimos 00:21:31
el otro día, no lo hay, porque el next in 00:21:33
sigue queriendo números, con lo cual 00:21:35
ese primer salto de línea que estaba 00:21:37
de antes, lo ignora 00:21:39
lo saca y lo tira, y coge el número 00:21:42
que viene después, porque él está 00:21:43
esperando números, y vuelve 00:21:45
a dejar el salto de línea, pero si 00:21:47
después de una lectura de número 00:21:49
tenemos una lectura de cadena con next line 00:21:51
es cuando esa combinación se queda así 00:21:53
pues insertamos entre ambas 00:21:55
esto y se acabó 00:21:57
¿vale? 00:21:59
vale 00:22:01
bueno, pues entonces la lectura 00:22:02
de los primeros datos ya está 00:22:05
y ahora 00:22:06
¿qué dice el resto 00:22:09
del ejercicio? 00:22:11
indicar si la fecha es correcta 00:22:13
correcta significa que 00:22:15
sí está en el calendario 00:22:17
el 93 de Pepito 00:22:18
Pérez, pues no es correcta 00:22:21
los años nos valen todos 00:22:23
Asumimos que los años 00:22:25
Cualquier año que meta, existe 00:22:28
A ver, el único que no existiría 00:22:30
Sería el menos 100 millones 00:22:34
Antes de Cristo 00:22:36
Porque la Tierra no había existido 00:22:37
Pero hasta el menos 45 millones antes de Cristo 00:22:39
¿Eh? 00:22:41
No, no son 00:22:44
Ay, perdón 00:22:45
45.000 millones, vale 00:22:47
Eso sí, sí, son 45.000 millones 00:22:49
Vale, he dicho 45 millones 00:22:52
Bueno, pues si ponemos el 00:22:54
menos 100.000 millones 00:22:55
ese no sería válido 00:22:57
pero no vamos a poner 00:23:00
más que nada porque no va a caber 00:23:01
bueno, un alón yo creo que sí que cabe 00:23:03
pero no lo vamos a poner 00:23:05
entonces, con meses, una vez que analizamos 00:23:07
el ejercicio y le preguntamos 00:23:09
al tío y todo eso y lo entendemos, decimos 00:23:11
del año no tengo que hacer ninguna 00:23:13
validación, año me vale cualquiera 00:23:15
estupendo, mete el año que te dé la gana 00:23:17
a lo mejor nos dice, no, no, no, perdona 00:23:19
no quiero negativos 00:23:22
Solo estoy contando los años del 0 en adelante 00:23:23
Bueno, pues entonces sí que haríamos una validación 00:23:26
If año menor que 0 00:23:28
No válido, vale 00:23:30
Pero vamos a asumir que año nos vale cualquiera 00:23:31
Porque esa validación es la más sencilla 00:23:33
Vale, la complicada es la combinación de día y mes 00:23:35
La complicada es esa 00:23:38
Que el día sea válido dentro del mes 00:23:39
¿Por qué 00:23:41
No es tan sencilla? 00:23:43
Porque en función del mes 00:23:45
Hay días que valen o no 00:23:47
Si el mes es enero, 31 vale 00:23:48
Claro 00:23:50
Estamos aquí 00:23:55
Pones inviciestos para no hacer ese 00:23:58
Ejemplo, porque si es conviciesto 00:24:01
Pues efectivamente tienes que hacer la condición 00:24:04
De año viciesto, que ya la sabemos 00:24:06
Claro, entonces si es febrero 00:24:07
Y año viciesto, esto 00:24:10
Y si no, lo otro 00:24:11
Pero bueno, sería añadir un poquito más en la condición 00:24:13
Entonces, aquí se trata de 00:24:15
Tenemos que ver cómo plasmar 00:24:18
la condición de validez y esa condición sería 00:24:20
entre 0 y 31 00:24:23
perdón, entre 1 y 31 00:24:25
si es enero, marzo 00:24:28
julio, agosto 00:24:31
octubre y diciembre 00:24:36
y entre 1 y 30 00:24:38
si es el resto, menos febrero 00:24:41
y entre 1 y 28 si es febrero 00:24:44
¿Vale? Esa es la condición 00:24:46
Esa es la condición que tenemos que hacer 00:24:49
Y ahora ya, esa condición 00:24:50
¿Cómo la expresamos? 00:24:52
Pues cada uno habrá llegado a un concurso y lo ha puesto de otra manera 00:24:54
Vamos, por ejemplo, a 00:24:57
A poner 00:24:59
Podríamos hacer 00:24:59
Vamos a guardar, el resultado final es 00:25:04
¿Es válido o no válido? 00:25:10
Pues vamos a hacerlo en un boolean 00:25:13
¿Vale? Un boolean 00:25:15
Por ahora lo dejo sin valor 00:25:17
vale, y ahora 00:25:18
¿cómo podemos organizar esto? pues mira 00:25:20
vamos a usar el switch case ya que estamos 00:25:23
aquí 00:25:25
yo rápidamente identifico 00:25:26
que en función del mes 00:25:29
que esa ha sido la clave, en función del mes 00:25:30
la validez es una u otra 00:25:33
¿verdad? en función del mes 00:25:35
la validez es entre 1 y 31 00:25:37
o entre 1 y 30 00:25:39
o entre 1 y 28 00:25:41
bueno, pues entonces en cuanto he identificado 00:25:42
que en función del valor de una variable 00:25:45
o pasa una cosa o pasa otra 00:25:46
o pasa otra, ya tengo 00:25:48
un switch case ahí 00:25:50
llamándome, porque el switch case 00:25:52
es una sentencia if 00:25:54
es una sentencia de decisión 00:25:56
en la cual lo que se hace en cada rama depende 00:25:58
del valor de una variable 00:26:00
pues justo 00:26:01
aquí en función del valor de month 00:26:04
en función del valor de esta variable 00:26:06
boolean 00:26:08
se evalúa de una manera o se evalúa de otra 00:26:09
pues justo lo que he dicho en estas 00:26:12
palabras que en función del valor de una variable 00:26:14
o hago una cosa o hago otra 00:26:16
es justo el switch case 00:26:17
el switch case me dice 00:26:19
ojo 00:26:21
en función de 00:26:23
lo que valga la variable month 00:26:26
en función de lo que valga 00:26:31
esta variable 00:26:34
pues válido, se evalúa 00:26:35
de una manera o se evalúa de otra 00:26:40
vale, ¿cuáles van a ser las opciones? 00:26:42
entonces 00:26:45
podríamos 00:26:45
ponerlas aquí, en el caso de que 00:26:47
sea enero 00:26:50
Vale, pues en el caso 00:26:51
De que month sea enero 00:26:55
Válido va a ser igual a qué 00:26:57
A day 00:26:59
Mayor o igual que 1 00:27:01
Perdón 00:27:05
Y day menor o igual 00:27:08
Que 31 00:27:14
¿Vale? 00:27:15
¿No puedes añadir ahí enero en todos los meses? 00:27:18
Sí, pero vamos a irlo 00:27:20
Haciendo, entonces 1 pues 00:27:21
Bueno, aquí no se le olvida el break 00:27:23
¿Vale? 00:27:27
Entonces esta sería la switch case 00:27:29
Original de toda la vida 00:27:30
Yo tengo que distinguir los casos uno por uno 00:27:32
¿Vale? Entonces 00:27:34
Voy a poner los 00:27:35
Los tres primeros 00:27:46
Mayor o igual que uno 00:27:49
Menor o igual que veintiocho 00:27:50
Sí 00:27:52
Sí, a ver 00:27:56
Pero se lo podría decir al tío 00:27:58
Pero bueno, vamos a hacer una cosa 00:27:59
Sí, usando a ver un método 00:28:01
de string, pero como os dije que solo 00:28:05
memorizarais los tres, charad 00:28:07
pero venga, ala, como pedís tanto 00:28:08
pues ahora os vais a cagar 00:28:11
venga, vamos a 00:28:12
Ya, pero 00:28:14
es que hay que ir progresivamente 00:28:19
entonces nosotros ahora de la clase string 00:28:20
como todavía no tenemos muchos de objetos 00:28:22
pues no tiene sentido que nos metamos en los métodos 00:28:24
entonces, de la clase string usamos 00:28:27
los tres métodos y luego solo incorporamos 00:28:28
objetos, ¿vale? 00:28:30
Entonces, 00:28:32
uno podría seguir así hasta 00:28:33
abril, 00:28:36
mayo, 00:28:39
junio, julio, 00:28:42
etcétera, ¿verdad? 00:28:43
Entonces en cada uno lo que toque, menor o igual que 28, 00:28:44
en marzo menor o igual que 31, 00:28:46
en abril menor o igual que 30, 00:28:48
¿verdad? Y así con todos. 00:28:51
Vale. 00:28:53
Y así ha sido el 00:28:54
switch case de toda la vida. 00:28:56
Y vamos distinguiendo una por una. 00:28:58
¿Vale? Pero a partir de la versión no sé qué, 9, 10, 11, no sé cuál, se permite sintácticamente si varias posibilidades para esta variable, si varias conducen al mismo código, vamos a ponerlas todas juntitas separadas por com. 00:29:00
¿Vale? Pero os vais a encontrar en muchos casos que aunque sea la misma, no lo hacen así, porque a lo mejor la versión de la máquina virtual es anterior a esa modificación, entonces no lo puede ejecutar. 00:29:17
Pero bueno, en nuestro caso sí 00:29:29
Entonces, se va a quedar más corto el código 00:29:32
Si unimos enero, marzo 00:29:35
Enero, marzo, mayo 00:29:38
Julio, agosto 00:29:44
Julio, agosto 00:29:50
A ver, voy a poner aquí 00:29:59
Partiéndolo por la mitad, que queda muy feo 00:30:01
Pero para que se vea 00:30:04
Julio, agosto, octubre 00:30:06
Y diciembre 00:30:08
Vale, pues en 00:30:12
Cualquiera de esos casos 00:30:15
Vale 00:30:18
Vale 00:30:20
Sí, sí, sí 00:30:23
Porque como tengo febrero contemplado abajo 00:30:25
Pero bueno, en cualquiera de esos casos 00:30:28
La validez es esta, vale 00:30:29
Y aquí cuáles nos quedan 00:30:30
Aquí nos quedan 00:30:32
Febrero 00:30:34
Bueno, febrero se queda solito 00:30:36
Y ahora aquí ya nos quedan 00:30:38
Esta 00:30:41
Nos quedan 00:30:42
Abril 00:30:47
Junio 00:30:48
Septiembre 00:30:52
Y noviembre 00:30:53
Y ya no tengo más casos que considerar 00:30:55
Pero el switch case 00:31:08
Acordaos que admite 00:31:10
Un último 00:31:12
Caso que es 00:31:13
Si no es ninguno de los que están contemplado antes 00:31:15
Sería como un else, si no es ninguno 00:31:18
Entonces en el caso de que 00:31:20
No sea ninguno de los que están contemplado 00:31:22
antes, la fecha no va a ser 00:31:24
válida segura, porque el mes lo han metido 00:31:26
mal, ¿no? 00:31:28
Entonces, si no es ninguna de las anteriores 00:31:30
la fecha no va a ser 00:31:32
válida segura. Entonces 00:31:34
yo ya le he dado valor 00:31:36
a válido en función del mes. 00:31:40
Esta es una primera versión. 00:31:43
Ahora podemos 00:31:45
retocar algunas cosas. 00:31:46
Vale, aquí se acaba el switch. 00:31:48
Cuando ya uno 00:31:51
empieza a anidar muchas cosas, pues siempre está bien 00:31:52
que lo avise. Este ya es el fin del main. 00:31:54
De mi programa. 00:31:56
Entonces, ¿qué me falta? 00:31:58
Me falta mostrar el resultado, ¿no? 00:31:59
Entonces, aquí ya puedo poner directamente. 00:32:02
Oye, ¿es válido o no es válido? 00:32:08
Si es válido, pasa al system out, fecha válida. 00:32:11
Y si no es válida, pues pásale al system out, fecha no válida. 00:32:22
Y ya está, ya hacemos la primera prueba de esto 00:32:33
Ah bueno, lo de la entrada que decíais 00:32:42
Vale, vamos a hacer la interfaz de entrada un pelín más 00:32:45
Entonces, le podríamos decir aquí 00:32:48
Introduzcame es todo en minúscula 00:32:51
Vamos a dejarle que lo introduzca como sea 00:32:53
Entonces, cuando lo leemos 00:32:55
Esto es un string 00:32:58
Y recordad que los objetos 00:33:00
Como los strings 00:33:04
pueden además hacer cosas a través de su operador 00:33:05
punto, que son las cosas 00:33:08
que nosotros no sabemos de memoria que pueden hacer 00:33:09
sacar su longitud 00:33:12
con length, eso lo pueden hacer 00:33:14
sacar su longitud y devolvermela 00:33:15
que más otras cosas hemos visto que pueden hacer 00:33:17
decirme que carácter 00:33:20
tienen una posición, yo le doy 5 00:33:22
y me devuelven el carácter 00:33:24
y que otra cosa hemos dicho que pueden 00:33:25
hacer, que no, compararse 00:33:28
con otro string, para ver si 00:33:30
su sucesión de caracteres es igual 00:33:32
Vale, pero aparte de esas tres cosas 00:33:34
Pueden hacer muchas más 00:33:37
Por ejemplo, pueden 00:33:38
Convertirse a minúsculas 00:33:40
Se ha convertido a minúscula 00:33:42
Entonces ya me da igual como me haya metido el enero 00:33:46
O febrero, como me haya metido 00:33:48
Porque todo este string 00:33:49
Me lo va a convertir a minúscula 00:33:53
Entonces yo ya sé que va a estar en minúscula 00:33:55
Entonces ahora ya mi switch case 00:33:57
Ya me despreocupo, lo pongo en minúscula y ya está 00:33:58
Igual que tiene un to lower case 00:34:00
Tendrá tu uppercase y más métodos 00:34:03
Para hacer más cosas que ahora mismo 00:34:04
No nos interesan todavía 00:34:06
¿Vale? 00:34:08
Vale, pues hacemos 00:34:11
La primera prueba 00:34:12
Introduzca día, pues estoy en el día 3 00:34:13
¿De qué mes? 00:34:17
De febrero 00:34:18
¿De qué año? Del 2000 00:34:19
Ala, pues esta fecha es válida 00:34:21
Y ponemos una no válida 00:34:24
Pues en qué día estoy 00:34:26
En el 30 de febrero 00:34:27
Del 5000 00:34:30
y esa no es válida 00:34:32
claro, a ver, habría que hacer más pruebas 00:34:34
y todo eso, pero bueno, a vista del código 00:34:36
vemos que tiene sentido 00:34:38
vale, y llegados a la fase en la que 00:34:39
hemos concluido que esto, pues sí 00:34:44
esto funciona 00:34:46
pues hombre, ya podemos 00:34:47
a lo mejor hacer algún pequeño 00:34:49
cambio, que nos permita ir cogiendo 00:34:52
cada vez más soltura o más 00:34:54
aquí no estoy 00:34:55
repitiendo todo el rato lo de day mayor o igual que 1 00:34:58
es decir, que el día 00:35:00
sea mayor o igual que 1 00:35:03
es una condición para el mes 00:35:05
sea el que sea 00:35:07
la única condición que importa 00:35:08
perdón, que es distinta 00:35:10
en función del mes 00:35:13
es el límite superior 00:35:14
el límite inferior es igual para todos 00:35:15
entonces 00:35:18
voy a darle aquí a válido ya 00:35:20
esa primera parte de la condición 00:35:22
mayor o igual que 1 00:35:25
válido 00:35:29
esta condición 00:35:31
Es parte de ella, ya es parte de ella 00:35:32
Y luego, ¿vale? 00:35:35
Y luego el resto 00:35:38
La concateno con la que me falte 00:35:39
Vale, primero 00:35:42
Entended esto que he hecho aquí 00:35:48
¿Vale? 00:35:50
Entonces, la primera parte de este boolean 00:35:52
Es que el día sea mayor o igual que uno 00:35:54
Si es mayor o igual que uno, esto ya va a ser falso 00:35:56
Entonces ya 00:35:58
El resto es que va a ser falso siempre 00:36:00
Ya va a ser falso porque voy a estar haciendo 00:36:02
And con falso todo el rato 00:36:04
¿Vale? 00:36:05
De hecho, el siguiente arreglo que digamos es que si ya es falso desde aquí, ni te metas al switch, ni te metas, porque ya va a ser falso, pero ese arreglo lo hacemos después, ¿vale? 00:36:07
Pero este primer cambio está claro, ¿no? Válido es el AND de dos cosas, la primera en todos los casos es esta, de I mayor o igual que 1, y ahora ya en función del mes, a ese mismo válido que ya le he dado un primer valor, lo concateno con lo que falte. 00:36:16
Si es esto, con esto de aquí 00:36:33
Si es febrero, con esta 00:36:36
Y si es junio, con esta 00:36:37
Y de hecho ya si 00:36:38
Lo quisiéramos dejar 00:36:45
Yo creo que esto 00:36:49
Ay, no, de qué pena 00:36:51
No deja 00:36:54
Con 00:36:56
Igual que es el más igual 00:36:58
Menos igual 00:37:01
Ah, pero con uno solo 00:37:01
Sí, vale 00:37:09
Vale, es que esto no se usa nunca 00:37:10
Porque es que es tan complicado 00:37:14
Lo convierte en tan ilegible 00:37:16
Pero, o sea, que estaba ya 00:37:17
Para que no se nos olviden 00:37:20
Los operadores y todo 00:37:23
Compactándolo del todo 00:37:24
O sea, esta está clara, ¿no? 00:37:27
Esta está clara 00:37:29
A válido, la concateno con esto 00:37:30
Y su nuevo valor se lo asigno a válido 00:37:33
Eso es cuando hacíamos 00:37:35
Cuando nosotros hacíamos 00:37:37
n igual a n más 3 00:37:38
esto sabíamos que lo podíamos 00:37:42
compactar así 00:37:45
n más igual 3 00:37:47
concatenar la asignación con un operador 00:37:48
lo hemos hecho muchas veces y significaba 00:37:51
quita el igual, haces la operación 00:37:53
y ahora concatenas con la variable 00:37:55
que tienes a la izquierda del igual 00:37:57
que es n 00:37:59
pues yo he hecho esto mismo 00:38:00
con este, estoy válido igual a válido 00:38:03
and no sé qué 00:38:05
Pues en realidad según esa regla 00:38:06
Sería así 00:38:09
¿Vale? 00:38:11
Pero solo te deja 00:38:14
Si le ponemos un solo and 00:38:15
¿Vale? 00:38:17
Lo que pasa es que esto es muy 00:38:19
Es un poco feo a la vista 00:38:21
Pero vamos 00:38:23
Vamos a dejarlo así 00:38:24
Válido and esto 00:38:31
Igual a válido 00:38:36
Y ya lo último que podríamos hacer 00:38:37
Para compactar esto es lo que he dicho antes 00:38:41
A ver, si ya aquí 00:38:44
Válido es falso, esto no tengo 00:38:46
Ni que hacerlo, entonces el switch es 00:38:48
Una única sentencia en realidad, es una única 00:38:50
Entonces lo tengo muy cómodo 00:38:52
Me hago, si válido 00:38:54
Es decir, si válido 00:38:56
Pues hazme el switch dentro 00:38:58
Entonces ahora ya tabulo esto 00:39:00
Para que se vea claro que está ahí 00:39:02
Como tabulo para que 00:39:04
Alt F, no 00:39:08
Control F, no 00:39:11
Bueno, es por no tabularlo a mano 00:39:13
¿Vale? Pero los atajos 00:39:29
No hace falta ni todavía que os vayáis liando con ellos 00:39:31
¿Vale? Pues todavía así más 00:39:33
Eficiente 00:39:37
Si es válido, hazme esta vez 00:39:38
No he puesto llaves 00:39:40
¿Por qué no he puesto llaves? 00:39:41
Es una única sentencia 00:39:43
Esto no me lo ha tabulado 00:39:44
Pues vamos a ponerlo ahí 00:39:46
Vale 00:39:51
Como es una única sentencia 00:39:52
Repito, no hace falta ponerlas 00:40:09
Podría poner una llave 00:40:10
Que se abre aquí y otra llave que se abre aquí 00:40:12
Pero no hace falta 00:40:15
Esta ya sí que está fuera del if, obviamente 00:40:16
Vale, entonces 00:40:19
Me hago la primera condición de validez 00:40:20
Que esta ya es falsa, es que ya no mira nada más 00:40:22
Y me va a mostrar fecha no válida 00:40:25
Que esta es true 00:40:27
porque es mayor o igual que 1, ya me voy aquí 00:40:28
y le añado lo que falte 00:40:30
para cada mes 00:40:32
y ya la última, que sí, que vamos a parar 00:40:33
y ya la última 00:40:38
modificación, aunque no la diga el enunciado 00:40:41
sería 00:40:43
además ten en cuenta 00:40:44
si es BC Stone 00:40:46
la dejamos para que 00:40:47
la hagáis 00:40:50
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
10 de octubre de 2024 - 16:58
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
192.83 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid