Saltar navegación

20241015 ResolExam14oct_1 - 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 16 de octubre de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues la primera parte ya decimos que esta ya la hacemos tal cual 00:00:00
ya ni pensamos, que nuestro dato de entrada es un número entero 00:00:05
pues me hago el objeto para leer por teclado, declaro una variable 00:00:09
de tipo compatible a lo que voy a leer, número n 00:00:13
bueno, n 00:00:17
una variable un poco fea, pero bueno, y la leo, pues ya está 00:00:19
vale, pues esta parte ya no nos exige pensar demasiado 00:00:25
no se exige pensar demasiado 00:00:42
si quiero que me quede más cortito 00:00:44
pues ya a lo mejor se la declaro 00:00:47
aquí me queda un poquito más cortito el código 00:00:49
pero vamos 00:00:51
estos son detalles ahora mismo 00:00:53
sin mayor importancia 00:00:55
vale, ahora ya es cuando pensamos ya un poco más 00:00:56
en la estructura de mi aplicación 00:00:59
para plantar esa estructura 00:01:01
e irla luego perfilando, ir luego ya metiendo los detalles 00:01:03
vale, pues 00:01:05
este 00:01:07
este ejercicio decía 00:01:07
el programa tiene que escribir un mensaje por pantalla 00:01:10
pero ese mensaje tiene dos posibilidades 00:01:15
ese mensaje es 00:01:18
o bien la letra correspondiente 00:01:19
a este numerito N 00:01:22
según la tablástica que acompañaba aquí 00:01:24
o bien no es una letra 00:01:26
entonces el resultado 00:01:30
el resultado es un string 00:01:32
un string 00:01:35
¿vale? pero este string 00:01:36
tiene dos opciones 00:01:38
Y esas dos opciones dependen de qué. Vamos a ver el enunciado para ver la tabla hastia. Tengo internet. 00:01:39
Sí, pero es para proyectar la tabla hastia ahí. Sí, está aquí. Vale. 00:01:59
Entonces tenemos dos opciones. Que el carácter se corresponda a una letra, tanto mayúscula como minúscula, o que no. 00:02:09
luego esta variable resultado 00:02:16
va a ser 00:02:19
o bien 00:02:21
va a ser 00:02:23
tenemos dos posibilidades 00:02:25
o esta variable resultado es 00:02:27
el carácter 00:02:29
y aquí 00:02:34
luego habría que ver en las pruebas si no funciona o no 00:02:36
concatenamos directamente 00:02:38
con lo que me han metido 00:02:41
concatenamos directamente con lo que me han metido 00:02:42
o bien 00:02:45
tengo estas dos opciones 00:02:47
tengo dos posibles salidas 00:02:56
o result es esto o result es lo de abajo 00:02:59
entonces tiene que haber 00:03:01
una condición, como siempre, tiene que haber 00:03:03
una condición que me diga, oye result ¿qué es? 00:03:05
¿esto de arriba 00:03:09
o esto de abajo? 00:03:09
pues depende, ¿de qué va a depender? 00:03:11
de si el numerito entero 00:03:14
que me han dado se corresponde 00:03:15
con una letra 00:03:18
o no, vale 00:03:18
pero el concepto de corresponderse 00:03:21
con una letra, ahora tenemos que 00:03:23
traducirlo a una condición, como nosotros 00:03:25
conocemos, vale, pues corresponderse 00:03:27
con letra mayúscula 00:03:30
es muy fácil, que el numerito n sea 00:03:31
mayor o igual que 65 00:03:33
y menor o igual que 90 00:03:35
y corresponderse 00:03:38
con una letra minúscula es 00:03:39
que sea mayor o igual que 97 00:03:41
y que sea menor o igual que 00:03:43
122, porque dijimos que letras con tilde 00:03:45
y eso no nos contaban 00:03:47
bueno, pues entonces ya hemos dicho 00:03:48
con palabras la condición que estamos buscando 00:03:51
Que la letra sea mayor o igual que 65, el número entero, perdón, o menor o igual que 90, o, perdón, sí, y menor o igual que 90, o que sea mayor o igual que 97 y menor o igual que 122. 00:03:53
Ya está, ya tenemos la condición, pues ya tenemos el programa hecho. 00:04:09
Entonces, result va a depender, o bien result es esto, o bien result es lo otro, dependiendo de qué. 00:04:12
De esa condición que acabo de decir 00:04:27
Entonces yo podría plantar aquí 00:04:29
Esa condición que he dicho directamente 00:04:32
Y el programa ya se ha terminado y el ejercicio está terminado 00:04:33
¿Vale? 00:04:35
Pero bueno, para que no se me quede la línea tan larguísima 00:04:37
Voy a poner la condición aparte en un boolean 00:04:40
Solamente para que no me quede la 00:04:42
Condición tan larga y se vea bien 00:04:43
La condición desletra la acabo de decir 00:04:45
O que n sea mayor o igual 00:04:49
Que 00:04:52
65 y menor o igual 00:04:52
Que 90 00:04:58
Y n sea menor o igual que 90 00:04:59
Si cumple esto, mayor o igual que esto 00:05:08
Y simultáneamente, menor o igual que 90 00:05:11
Va a ser una letra mayúscula 00:05:14
Pero también vale si es minúscula 00:05:15
Luego, o esto, o 00:05:19
Y me falta el o 00:05:22
O que n sea el intervalo correspondiente a la minúscula 00:05:24
Vale, y el intervalo correspondiente a la minúscula es 97, 122. 00:05:36
97, 122. 00:05:47
Vale, pues la condición de ser letra ya está. 00:05:51
La condición de ser letra es esta. 00:05:53
Que el número n que me han metido esté comprendido en ese intervalo. 00:05:56
Vale, pues la condición de ser letra es la que me marca cómo es mi resultado. 00:06:00
si es el carácter es y la letra concatenada 00:06:07
o no es una letra 00:06:10
aquí tendríamos ya una 00:06:12
primera versión 00:06:15
entonces ahora uno hace una prueba 00:06:17
a ver si le ha olvidado algo, si esto funciona o no funciona 00:06:19
pero en principio ya estaría terminado 00:06:21
vamos a probarlo 00:06:22
vamos a probarlo 00:06:25
yo estoy reproduciendo 00:06:28
lo que vosotros 00:06:30
pues en principio 00:06:31
el proceso mental vuestro en un examen 00:06:32
el deseable 00:06:35
¿Vale? Entonces ahora 00:06:35
Uno hace una primera prueba de esto 00:06:38
A ver si lo ha tenido todo en cuenta 00:06:39
Y está todo bien 00:06:42
Entonces ejecuta esto 00:06:43
Y introduzca número 00:06:45
Vamos a meterle una letra 00:06:49
Una letra, entonces le vamos a meter el 110 00:06:51
Que sería la N minúscula 00:06:54
La N minúscula 00:06:56
110 00:06:59
¿Vale? 00:07:00
Ay, que no he puesto el system out 00:07:03
¿Vale? Primera cosa 00:07:04
De la que uno se da cuenta cuando hace las pruebas 00:07:05
Hombre, si no muestro el resultado, complicado 00:07:07
Claro, podríamos meter esto en el system.out 00:07:09
Directamente y ya el programa nos queda 00:07:12
De una línea, o sea, si no hacemos 00:07:14
Una condición aparte y encima metemos esto del system.out 00:07:15
Este ejercicio era una línea de código 00:07:18
Muy larga, eso sí, muy larga, pero una línea 00:07:20
Vale 00:07:22
Vale, volvemos a ejecutar 00:07:24
Volvemos a meterle 110 00:07:31
Y nos dice 00:07:32
Uy, mi programa está casi bien 00:07:34
Pero no está bien del todo, porque me tenía que haber sacado 00:07:36
N minúscula, no pasa nada 00:07:38
Nos vamos, aquí decimos 00:07:40
Vale, nosotros hemos dicho siempre 00:07:42
Que 00:07:45
Los caracteres 00:07:46
Y los números enteros 00:07:50
Son perfectamente intercambiables 00:07:51
Según la tabla ASCII 00:07:53
Entonces según esto 00:07:54
Uno podría pensar 00:07:56
A ver, ojo, estoy concatenando 00:07:57
Estoy concatenando 00:08:00
Con lo cual esto debería convertirlo 00:08:02
Al char que representa 00:08:05
Cuidado, porque acordaos 00:08:07
que eso depende de cómo esté declarada 00:08:09
depende, está declarada 00:08:11
como int, porque hemos dicho que se lee 00:08:13
un número entero, si está 00:08:15
declarada como int 00:08:17
a la hora de el operador más 00:08:18
convertirlo a cadena 00:08:21
lo va a convertir en la cadena del numerito 00:08:22
que representa, que en este caso es 110 00:08:25
¿vale? 00:08:26
pero si estuviera declarada como char 00:08:29
entonces no 00:08:31
aunque yo a ese char le hubiera metido 00:08:32
el 110 00:08:35
¿vale? 00:08:35
Imaginaos que yo hago esto, ¿vale? 00:08:39
O hago esto otro, ¿vale? 00:08:42
Entonces, yo aquí, si concateno con N, me va a salir 110. 00:08:51
Pero si concateno con C, me va a salir el char correspondiente a 110. 00:09:00
¿Por qué? Porque está declarada como char. 00:09:05
¿Vale? Esto ya lo vimos en un par de ejercicios. 00:09:08
entonces, cuidado cuando 00:09:10
lo de que los char y los int 00:09:13
son intercambiables según la tabla 00:09:15
ASTI 00:09:17
es así, porque de hecho 00:09:17
a esta variable char 00:09:20
yo le he dado el 110 00:09:23
y cuando luego la muestro aquí me va a mostrar 00:09:24
la n minúscula o la que sea 00:09:27
pero claro, porque está declarada como char 00:09:28
porque está declarada como char 00:09:31
esta está declarada como entero 00:09:33
está declarada como entero 00:09:35
entonces va a trabajar como entero 00:09:36
A menos que le hagamos el famoso casting a char 00:09:39
¿Vale? 00:09:42
Entonces una vez que uno hace esta prueba 00:09:43
Ya dice, ah espera que me sigue faltando el detallito 00:09:45
¿Qué detallito me faltaba? 00:09:47
Cuidado, me faltaba este detalle 00:09:49
¿Vale? 00:09:51
Entonces ahora ejecutamos esto 00:10:04
Le ponemos 110 00:10:07
Y el carácter es n minúscula 00:10:10
Que le ponemos uno que está afuera 00:10:11
200 creo que está afuera, ¿no? 00:10:14
No es una letra 00:10:16
Pues ya está 00:10:17
este era este ejercicio 00:10:21
leer el número 00:10:22
entonces la dificultad 00:10:24
de este ejercicio 00:10:25
era establecer esta condición 00:10:25
pero bueno 00:10:27
tenéis la tabla ASTI 00:10:28
para establecer esa condición 00:10:29
de ser letra o no ser letra 00:10:31
y luego 00:10:32
pues darse cuenta 00:10:33
de que tengo dos posibilidades 00:10:36
que dependen de una condición 00:10:37
y a la hora de mostrar el carácter 00:10:39
si lo mostráis tal cual 00:10:42
como está declarado como entero 00:10:44
va a mostrar el número entero 00:10:45
no queréis mostrarlo como entero 00:10:46
sino como char 00:10:49
pues entonces toca hacer el casting 00:10:50
vale, bueno, hicimos un ejercicio 00:10:51
o dos que más o menos hacían esto 00:10:55
pero eran más complicados, era una versión 00:10:57
más complicada, este era una versión 00:10:59
sencilla, de eso que habíamos 00:11:01
hecho en clase 00:11:03
vale, bueno, pues este primero 00:11:04
está, entonces 00:11:07
esto se puede hacer con un if else 00:11:11
claro, pero en este decía que 00:11:12
no usaréis un if else, con lo cual 00:11:15
con esto, que lo hemos usado hasta aburrirnos 00:11:17
lo hemos usado un montón de veces 00:11:19
eso me asustó 00:11:20
eso también cuenta como condicional 00:11:23
no, no, no, por eso especificé 00:11:25
sentencias if else 00:11:27
o if else if y switch case 00:11:29
me asusté un poco 00:11:31
es que si no, no se puede, o sea, si un programa tiene 00:11:32
varias posibilidades y no puedes usar 00:11:35
le pedí a chat 00:11:37
que vete en mi casa 00:11:39
que hiciese sin condicional 00:11:40
el 10 o ni nada 00:11:43
y me hizo una palafada 00:11:44
inmensa para que 00:11:47
restase el resultado que no es 00:11:48
el correcto al número 00:11:50
no sé 00:11:52
a ver, es que hay casos 00:11:53
si tú haciendo una operación matemática 00:12:01
puedes, o sea, poniendo aquí 00:12:02
el carácter es, y aquí 00:12:05
con patenas, con una operación matemática 00:12:06
que, pero 00:12:09
es que no, ni siquiera se me ocurre cómo 00:12:10
habría que ver qué te ha dicho, pero se me hace muy raro 00:12:12
sí, me dice la cosa muy extraña 00:12:15
Sí, no lo sé. Se me hace muy raro porque 00:12:16
en algún momento vas a tener que tomar una decisión. 00:12:18
Pero bueno, no lo sé. No sé 00:12:20
qué haría. Vale, pues este está. 00:12:21
Cuidado. 00:12:26
A ver, que yo misma lo hago 00:12:27
mucho porque necesito saber 00:12:28
en qué mundo estamos. 00:12:30
Pero cuidado con las consultas a ChatGPT, 00:12:32
a Gemini, porque ya sabéis 00:12:34
que... 00:12:36
Eso fue un poco para quitarme curiosidad. 00:12:38
Claro, o sea, no, por favor, no dejéis 00:12:40
vuestra educación en sus manos. 00:12:42
Porque llegan hasta donde llegan. 00:12:44
vale, eso no significa que no sea 00:12:46
una ayuda interesante, claro 00:12:49
venga, ejercicio 2 00:12:50
entrada, dos numeritos 00:12:53
enteros y un char 00:12:55
vale, eso sabemos hacerlo, sabemos leerlo, se acabó 00:12:57
ahora, damos por sentado 00:12:59
que op solo va a tomar, el char este 00:13:01
va a tomar estos valores, y ahora 00:13:03
tres apartaditos 00:13:05
hacer la suma, la resta 00:13:06
la multiplicación o la división 00:13:09
de n1 y n2, dependiendo 00:13:11
del operador op, eso 00:13:13
Pues clama al cielo un switch case 00:13:15
Con ese carácter y hacer la operación 00:13:17
Y se acabó, no hay más que hacer 00:13:19
Si n1 es múltiplo de n2 00:13:20
Eso lo hemos hecho 00:13:23
Incluso en las dos posibilidades 00:13:24
Y escribirlos también 00:13:28
O sea, esto lo hemos hecho en clase 00:13:29
Todo esto 00:13:31
En versión más complicada que esta 00:13:33
En este caso se traduciría a 00:13:35
Vale, pues entonces 00:13:37
Leer por teclado 00:13:51
Esto, pero con otro numerito más 00:13:53
Y un char 00:13:59
Perdón 00:13:59
Hombre, a ver, es un comentario 00:14:04
Hombre, es que no pinta nada 00:14:09
Los comentarios, la idea es que 00:14:12
Te ayuden 00:14:14
Pero un todo el código aquí 00:14:16
No te ayuda nada ese comentario 00:14:17
Venga, pues el numerito en E1 00:14:19
Vamos a leer el numerito 2 00:14:21
Y vamos a leer un char 00:14:25
Le vamos a poner el mensajito 00:14:36
Que introduzca 00:14:42
O más 00:14:43
o menos 00:14:48
o por 00:14:50
división 00:14:57
vale 00:14:59
y ahora ya esto es un char 00:15:00
como hemos leído char nosotros 00:15:03
otras veces no hay un next char 00:15:05
en realidad 00:15:07
pero como lo hacíamos 00:15:08
pues hacemos el next line 00:15:17
que sirve para leer todo 00:15:19
cualquier cosa que tú le metas hasta el salto de línea 00:15:20
la traga cualquier cosa 00:15:23
Y ahora ya, como sabemos que solo va a haber metido 00:15:24
Un único char, que es solo lo que nos interesa 00:15:28
Pues nos quedamos con el carácter en la primera posición 00:15:31
Y ya está 00:15:33
¿Vale? Eso es como lo hemos leído otras veces 00:15:34
Leo todo lo que me metas 00:15:37
Y me quedo con el carácter en la primera posición 00:15:40
Que esto ya sí que es un char 00:15:42
¿Vale? Pues ya tenemos los datos de entrada 00:15:43
Y ahora 00:15:47
Hacemos los tres apartados 00:15:48
Por libres 00:15:51
esto, pues esto el resultado es 00:15:52
o n1 más n2 o n1 menos n2 00:15:56
o n1 por n2 o n1 entre n2 00:15:58
hay que hacer una de esas cuatro cosas 00:16:00
vale, cuatro ramas 00:16:03
tiene mi aplicación 00:16:04
¿de qué dependen esas cuatro ramas? 00:16:05
del valor de una variable 00:16:08
claro, cuando identificamos la situación 00:16:09
que mi programa hace varias cosas 00:16:12
dependiendo del valor de una variable 00:16:14
ahí como programadores 00:16:16
elegantes ponemos un switch case 00:16:18
pues venga 00:16:20
en función del valor de mi char 00:16:21
que mi char 00:16:24
resulta que es 00:16:27
el char 00:16:28
más 00:16:30
¿vale? recordad que los char 00:16:31
se indican con comillas simples, no dobles 00:16:34
¿vale? 00:16:37
que mi char 00:16:40
es el char más 00:16:41
aquí si uno pone comillas 00:16:42
dobles 00:16:45
no le va a valer porque op está declarado 00:16:45
como char 00:16:51
entonces char no puede ser igual a un string 00:16:51
son tipos de datos distintos 00:16:54
son tipos de datos distintos 00:16:56
esto ya sí que es un 00:16:57
char 00:16:59
si alguno aquí quería ponerlo con doble comilla 00:17:00
luego lo único es que tiene que convertir 00:17:04
op a string 00:17:06
pero ya sabemos que concatenándolo con una cadena vacía 00:17:07
ya estaría con string 00:17:10
claro en ese caso 00:17:11
pues podrías haber convertido esto a string 00:17:17
y ya está, que aquí yo creo que no te deja 00:17:19
Directamente 00:17:21
O si te deja directamente 00:17:22
Si mira 00:17:25
Entonces 00:17:29
Al poner esto en doble comillas 00:17:31
Lo que hay aquí tiene que ser un string 00:17:33
No hay tutía 00:17:35
Entonces si tú al char ople concatenas con algo 00:17:36
Ya sabéis que eso automáticamente fuerza la conversión a string 00:17:38
Pero vamos 00:17:41
Que era mucho más sencillo 00:17:42
Pues como char es un carácter 00:17:44
Así 00:17:47
Vale, en el caso de que sea más 00:17:47
Pues ya sabemos 00:17:50
N1 más N2 00:17:51
Y break para no sacar todo lo demás 00:17:56
Y ya está 00:18:00
Y así todo 00:18:02
Más menos por 00:18:04
Y división 00:18:23
N1 menos N2 00:18:29
n1 por n2 00:18:33
y n1 entre n2, que en este caso va a ser 00:18:36
el cociente entero, porque como son 00:18:38
números enteros, vale, como no 00:18:40
en el enunciado decía 00:18:42
que partamos de que va a ser el operador 00:18:43
solo uno de estos, pues no hace falta 00:18:46
ni poner un default, pero vamos, que uno podría 00:18:48
poner un default si quiere 00:18:50
y poner el operador, no es correcto y ya está 00:18:51
pero no tenemos 00:18:54
ni que contemplar ese caso, porque nos han dicho 00:18:56
que lo va a meter bien siempre 00:18:58
Esto es como fregar la vajilla dos veces 00:19:02
Con una es suficiente 00:19:06
Vale, pero obviamente 00:19:07
Entre haber elegido un switch 00:19:13
Y haber elegido un if, el save 00:19:15
Hay más nota con un switch 00:19:17
Claro, porque 00:19:19
De alguna 00:19:22
No, por eso no suspendes el ejercicio 00:19:23
Ni de lejos 00:19:27
Pero se puntúa más si has elegido la estructura 00:19:28
Adecuada 00:19:31
si, y si funciona 00:19:33
no se puntúa mal, pero el 10 00:19:42
es si tú además has elegido un switch case 00:19:44
porque has identificado que 00:19:47
un programa con varias ramas 00:19:48
que dependen de una variable, eso es lo que 00:19:50
no, no, yo dije que ahí podíais usar 00:19:52
la que quisierais, pero vamos 00:20:00
Lo hice precisamente pensando que tú ibas a puntuar más 00:20:02
si no usábamos sentencias condicionales. 00:20:05
Bueno, no pasa nada. 00:20:07
De todas formas, no dices que también lo tienes ya mal por el... 00:20:09
Tampoco puedo adivinar lo que piensas que tienes que usar. 00:20:12
Sí, pero sí que hemos dicho varias veces, 00:20:16
y si no, pues seguimos insistiendo en ello ahora, 00:20:19
que hay diferentes formas de hacer un programa 00:20:21
y que tenemos que intentar acostumbrarnos a hacer códigos 00:20:23
que sean lo más legibles posibles, 00:20:25
Que se adapten mejor a las pautas de programación generales. 00:20:27
Las pautas del examen, los ejercicios anteriores. 00:20:32
Ya, ya, ya. Sí, sí, sí. 00:20:35
¿Sabes lo que te quiero decir? 00:20:36
Sí, no, sí te entiendo. Sí, sí, sí, tiene sentido. 00:20:37
Vale, a ver, entonces, ya está, el apartado este ya está. 00:20:41
Apartado 1 ya está, apartado 2. 00:20:48
El apartado 2 decía, decir sin eno es múltiplo de eno 2. 00:20:57
Aquí estamos otra vez con que no podemos usar 00:21:01
Sentencias condicionales 00:21:03
Pues aquí es que esto lo hemos hecho mil veces 00:21:05
Sabemos que el resultado 00:21:07
Tenemos dos posibilidades 00:21:09
¿Es múltiplo o no? 00:21:11
Esto nos hemos hartado 00:21:14
De hacerlo al principio antes de ver los if 00:21:15
El tropecientan mil veces 00:21:17
¿Es múltiplo o 00:21:18
No es múltiplo? 00:21:21
Vale, ¿de qué depende? 00:21:27
Que yo muestre una cosa o muestre la otra 00:21:28
De si n1 es múltiplo de n2 o no 00:21:29
Luego la condición, si n1 00:21:32
el resto de dividirlo entre n2 00:21:34
es igual a 0 00:21:36
o no lo es 00:21:37
de eso va a depender 00:21:38
bueno pues ya está 00:21:40
el apartado 2 se acabó 00:21:44
apartado 3 00:21:46
vale el apartado 3 00:21:51
algo similar 00:21:55
ordenados de menor a mayor 00:21:56
aquí solo tenemos dos números 00:21:59
con lo cual yo muestro 00:22:01
o n1 concatenado con n2 00:22:03
o n2 concatenado con n1 00:22:05
luego otra vez lo mismo 00:22:07
Mi resultado es 00:22:08
Hacer un system out con 00:22:09
O un mensaje o con otro 00:22:11
O con N1 concatenado con N2 00:22:13
O con N2 concatenado con N1 00:22:15
¿De qué va a depender que yo muestre un mensaje o el otro? 00:22:17
¿De si N1 es mayor que N2 o no? 00:22:19
Pues el apartado de abajo es idéntico 00:22:21
Que el de arriba pero cambiando la condición 00:22:24
Y los mensajes de salida, claro 00:22:26
El apartado 3 es lo mismo en realidad 00:22:27
N1 es mayor 00:22:32
Que N2 00:22:35
Pues entonces lo que yo tengo que mostrar 00:22:38
Primero n2 que es el más pequeño 00:22:42
Y luego n1 00:22:48
Intercalando esto por medio 00:22:49
Claro porque si no me haría la suma de los números enteros 00:22:52
Me haría la suma intercalando esto por medio 00:22:55
Claro 00:22:57
Que no, pues al revés 00:22:57
Esto mismo pero al revés 00:23:00
Porque entonces es n1 el más pequeño 00:23:02
Y si son iguales 00:23:04
Los va a mostrar los dos 00:23:12
Uno detrás de otro 00:23:14
Si son iguales se va a ir aquí 00:23:14
Pero es que me lo va a hacer bien 00:23:16
Porque 3, 3 va a estar ordenado 00:23:18
Vale, pues ya está 00:23:20
El apartado 3 ya está 00:23:23
Es lo mismo las dos veces 00:23:25
Tengo dos posibilidades 00:23:26
Dependen de una condición 00:23:28
Tengo dos posibilidades 00:23:29
Dependen de una condición 00:23:30
Probamos porque podemos haber hecho 00:23:31
Cualquier cosa mal 00:23:34
Introduzca número 1 00:23:36
Número 2 00:23:41
¿Ves? Algo mal hemos hecho 00:23:44
Algo mal hemos hecho 00:23:46
Porque 00:23:48
ahora es cuando 00:23:49
el string in this bound exception 00:23:53
ya nos suena que 00:23:54
¿por qué no salía eso? 00:23:56
¿cuándo nos ha salido esto? ¿por qué no salía? 00:23:59
porque no estaba esperando 00:24:02
eso cuando no estaba esperando 00:24:05
salía el input mismatch exception 00:24:07
esto no salía cuando después 00:24:08
de un número le hacíamos un next line 00:24:11
y entonces el next in 00:24:13
se quedaba con el salto de línea 00:24:15
claro, entonces aquí se me ha olvidado 00:24:16
para limpiar 00:24:19
esto, entonces estas cosas 00:24:21
pues uno se da 00:24:23
cuenta si lo prueba, a ver esto no es 00:24:24
un error de programación 00:24:27
grave ni nada, ni que penalice 00:24:29
especialmente ni nada, que bueno 00:24:31
vale 00:24:33
entonces lo volvemos a ejecutar 00:24:35
vamos a restar 00:24:40
menos 11 00:24:43
45 no es múltiplo de 56 00:24:45
Y de menor a mayor son esos 00:24:48
Vale, vamos a hacer uno al revés 00:24:50
Que sea múltiplo 00:24:52
Porque si uno tiene tiempo 00:24:53
Mejor hacer, hombre, los tres pruebas 00:24:55
Vale, vamos a poner 00:24:57
El 8 y el 4 00:24:59
Y vamos a hacer la multiplicación 00:25:07
Vale 00:25:11
El primero si es múltiplo del segundo 00:25:12
Y en orden de menor a mayor es 48 00:25:15
Bueno, pues ya está, el programa ya está hecho 00:25:18
Ya está 00:25:20
¿Vale? Un switch case 00:25:22
Entonces son más fáciles que los que hemos hecho en clase 00:25:23
Reconocedlo, son ejercicios más fáciles 00:25:27
Venga 00:25:29
Este ya está 00:25:31
Ejercicio 3 00:25:33
Leer una palabra, es decir, leer una línea 00:25:35
Next line 00:25:37
Y ahora ya, ya con if, con lo que nos dé la gana 00:25:38
Aquí ya tenemos libertad de hacer esto 00:25:42
Venga, pues vamos a leer la palabrita 00:25:44
Ejercicio 3 00:25:47
Pues venga, ejercicio 3 00:25:49
Esto 00:26:03
Introduzca 00:26:06
Palabra 00:26:25
Vale 00:26:29
Una palabra puede ser cualquier cosa 00:26:30
Pues lo leemos con nextline 00:26:33
Y con nextline lo que obtenemos es un string 00:26:34
Pues lo guardamos aquí 00:26:36
¡Hala! Ya tenemos la palabra 00:26:38
Ahora 00:26:47
Hay que hacer 00:26:48
Tres cositas 00:26:50
Primera, decir si es palíndroma 00:26:51
O no 00:26:55
Entonces, la primera 00:26:55
Apartado 1 00:26:57
Esto lo podríamos hacer también con el operador condicional 00:26:59
Si queremos, pero vamos a hacerlo 00:27:04
Con el if, para variar 00:27:06
Aquí el resultado es 00:27:07
O mostrar es palíndroma, o mostrar no lo es 00:27:09
¿De qué va a depender? 00:27:12
De si el primer char 00:27:14
Y el 00:27:17
otros son iguales 00:27:19
¿vale? entonces aquí podríamos 00:27:21
hacer, o sea estoy haciendo el programa 00:27:23
como estoy haciendo el examen ahora mismo, estoy leyendo el enunciado 00:27:25
lo voy haciendo 00:27:27
¿vale? pues venga 00:27:28
si palabra.char 00:27:31
0, resulta que 00:27:35
este char es igual, y aquí sí que comparo con 00:27:37
doble igual, pues estoy hablando de char 00:27:39
los char son variables primitivas, se comparan con doble igual 00:27:40
solo los string se comparan 00:27:43
con igual 00:27:45
es igual 00:27:45
a la posición 3 00:27:48
entonces 00:27:55
yo puedo mostrar 00:27:57
vale 00:27:59
que no 00:28:06
pues lo mismo pero no 00:28:09
vale, entonces yo sigo leyendo 00:28:11
estoy aquí en mi examen un poco 00:28:24
bloqueado y digo 00:28:26
si la palabra es de 4 la escribo al revés 00:28:28
digo uy espera, espera, espera 00:28:30
tengo que retocar esto, me he puesto a hacer esto 00:28:32
a capón, espera 00:28:35
lo de arriba lo tengo que hacer en el caso 00:28:37
de que sea de tres letras 00:28:39
en el caso de que sea de cuatro este 00:28:40
y en cualquier otro caso estoy aquí 00:28:42
cuidado, aquí tengo un if, el seif 00:28:45
claro 00:28:46
claro 00:28:48
si es de tres hay un if dentro de ese 00:28:49
sí, bueno, claro, sí, sí 00:28:56
o sea, tengo un if, el seif y luego en cada caso 00:28:58
ya lo que sea 00:29:00
pero claro, digo, espera, espera 00:29:01
entonces ahí viene lo que a veces 00:29:03
a uno le ocurre que no ha leído bien el enunciado 00:29:06
no lo ha leído al completo 00:29:08
entonces cuando aquí uno lo lee al completo 00:29:09
y lo entiende bien, dice, ah, espérate 00:29:12
es que aquí tengo una primera estructura, que es 00:29:13
¿en qué caso estoy? ¿en 3, en 4 00:29:15
o en este? ¿en qué caso estoy? 00:29:18
tengo tres posibilidades 00:29:20
voy a hacer un if, el save, porque esas posibilidades 00:29:21
dependen del valor de una variable, no 00:29:24
si cada una de estas tres posibilidades 00:29:25
dependieran del valor de una variable 00:29:28
haría un switch case, pero no 00:29:30
dependen de una condición que es 00:29:32
que la longitud sea de 3 o que sea de 4 00:29:34
o que no, entonces esa condición 00:29:36
no es el valor de una variable, es otra, entonces aquí 00:29:38
lo que pega es un if, el save 00:29:40
¿vale? entonces digo, a ver 00:29:41
ojo, no vale empezar a 00:29:43
resolver tal cual 00:29:46
siempre uno se lee el enunciado completo 00:29:47
completo 00:29:50
y entiende bien 00:29:51
la estructura del programa 00:29:53
¿vale? entonces digo, ah, vale, vale, vale, yo me he puesto aquí 00:29:55
a programar lo bestia y no, esto va a ir 00:29:58
dentro de un if, el save, no, esta estructura no es 00:30:00
¿vale? yo aquí 00:30:02
Podía haber seguido como a piñón fijo 00:30:04
Con el primer ejercicio 00:30:05
Porque el primero eran cosas independientes 00:30:06
Eran cosas que iban en secuencia 00:30:08
Por eso las he puesto así 00:30:09
Porque eran cosas que iban en secuencia 00:30:11
Pero este no, este no va en secuencia 00:30:12
Entonces si ya me he puesto en piloto automático 00:30:15
Y sigo programando así 00:30:16
Entonces esto no va en secuencia 00:30:17
¿Qué pasa? 00:30:20
Que está lloviendo 00:30:27
Pero no veo la lluvia 00:30:28
Ah, sí, la veo ahí 00:30:31
Sobre la... vale, vale 00:30:33
Entonces aquí vamos a tener 00:30:34
esto 00:30:37
vale, mi programa va a ser esto 00:30:38
en realidad, si tiene tres letras 00:30:50
bla bla bla 00:30:52
si tiene cuatro 00:30:53
bla bla bla 00:30:55
y si no tiene ni tres ni cuatro, bla bla bla 00:30:57
este va a ser mi programa, ahora sí 00:30:59
este es mi programa al completo 00:31:01
vale, entonces voy a poner las condiciones 00:31:03
si la longitud de la palabra 00:31:06
resulta que es igual a tres 00:31:10
Entonces lo que toque 00:31:14
Si no es igual a 3 00:31:16
Pero es igual a 4 00:31:18
Entonces lo que toque 00:31:21
Y si no, lo que toque 00:31:24
Que lo que toque esta parte 00:31:26
La más fácil la puedo incorporar desde ya 00:31:27
Que es palabra no válida 00:31:30
Esta parte es la más fácil 00:31:31
A ver, estoy haciendo la estructura de mi programa 00:31:33
Luego lo voy rellenando, claro 00:31:40
Lo que intento 00:31:42
Tramitaros en otra vez es que no programéis de arriba a abajo 00:31:44
No programéis en secuencia 00:31:47
Porque eso te va a confundir 00:31:48
Y lo normal es que llegues a soluciones 00:31:51
Que no son válidas o que tienes luego que empezar a retocar 00:31:53
Vale, pues ahora ya sigo 00:31:55
Venga, este caso lo tengo resuelto 00:31:57
Uy, sí, sí, ya lo había hecho antes 00:31:59
Es esto, pues nada 00:32:00
Todo esto 00:32:02
Lo meto aquí dentro 00:32:04
Ala, ya está, si es 3 00:32:05
Miro a ver si es palindromano 00:32:11
Si es 4 00:32:14
Si es 4, ¿qué había que hacer? 00:32:16
Escribirlas al revés 00:32:17
Pues escribirlas al revés 00:32:21
Efectivamente es esto 00:32:23
Vale, ya terminamos 00:32:25
Escribir primero la posición 3 00:32:27
A 2, a 1 y a 0 00:32:29
Entonces aquí tendremos que hacer 00:32:30
Lo voy a construir arriba 00:32:34
Para que se vea mejor el string 00:32:37
Porque si no se va la línea demasiado a la derecha 00:32:39
Y será 00:32:44
Palabra.charat3 00:32:46
Más 00:32:51
Y lo paso abajo 00:32:53
Palabra.charat2 00:32:54
Más 00:33:01
Palabra.charat1 00:33:03
Más 00:33:05
Palabra.charat0 00:33:08
Vale 00:33:13
Y ahora 00:33:15
Aquí tengo que poner 00:33:20
Al revés 00:33:21
Vale 00:33:22
Y aquí 00:33:25
Me da el error de compilación 00:33:28
Que nos podíamos 00:33:31
Que ya nos ha pasado un montón de veces 00:33:32
Que el operador más 00:33:34
Cuando lo que tiene a los dos lados 00:33:38
Claro, cuando lo que tiene a los dos lados 00:33:40
Cuando no tiene un string 00:33:43
a alguno de los dos lados 00:33:47
automáticamente es la suma aritmética 00:33:48
aquí no tiene un string a ninguno de los dos lados 00:33:50
tiene char a los dos lados 00:33:53
que el char es un int 00:33:55
internamente 00:33:57
entonces te dice, cuidado, esto es la suma 00:33:58
de números enteros, un entero 00:34:01
a un string no puede 00:34:03
no, si los puede sumar, pero entonces yo tendría 00:34:04
que declarar esto como entero 00:34:08
entonces sí, pero claro, yo no quiero la suma 00:34:09
de eso 00:34:12
entonces ahora sí que 00:34:13
Tengo que poner esto aquí 00:34:16
Esto aquí 00:34:21
Esto aquí 00:34:24
Y ya está 00:34:27
Vale, pues ya está, ya tengo el programa hecho 00:34:29
Vamos a hacer una prueba antes de parar 00:34:34
Y ya paramos 00:34:35
Bueno, aparte si hay 40 cuando toca, se ha adelantado 00:34:37
Venga, vamos a poner 00:34:40
Una 00:34:47
De tres 00:34:49
Ah, como no he quitado el código de abajo 00:34:51
Por eso me ha salido dos veces 00:34:56
Pero vamos, da igual, o sea, cuando he hecho el copia y pega 00:34:57
De este, no he hecho 00:34:59
Corta y pega, he hecho copia y pega 00:35:01
Pero vamos, está bien 00:35:03
Vale, vamos a volver a ejecutarlo 00:35:04
Vamos a darle ahora una de 00:35:06
Eh, cuatro 00:35:09
Gato 00:35:13
Vale, vale, está bien 00:35:14
Aquí, vamos, le damos una a cualquiera 00:35:17
Que no tenga cuatro 00:35:22
Y palabra no válida 00:35:23
aquí de nuevo, a uno le podría otra vez 00:35:24
ir la duda de siempre, decir, oye, espérate, si esto se puede 00:35:28
en realidad es el entero que tiene dentro, de hecho cuando yo no tenía el doble 00:35:31
asterisco lo estaba interpretando como entero, ¿por qué me está mostrando el char 00:35:36
y no el numerito entero? por lo de siempre, porque esto está declarado 00:35:40
como char, porque charar te devuelve el char 00:35:44
entonces eso está declarado como char 00:35:48
si estuviera declarado como entero 00:35:49
me lo concatenaría con el número entero 00:35:53
de la tabla ASTI 00:35:56
a ver 00:35:57
que uno por las dudas 00:36:00
le quiere plantar un casting a char 00:36:02
se lo puede plantar pero es que en este caso es que ya es de tipo char 00:36:04
de hecho no sé si te deja 00:36:07
hacer un casting al mismo tipo al que ya eres 00:36:08
te deja 00:36:10
ah claro 00:36:12
pero si pongo un int 00:36:15
entonces sí que me va a mostrar el numerito entero 00:36:16
Vale, pues este tercero ya estaría 00:36:18
Venga, vamos a parar aquí 00:36:21
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
16 de octubre de 2024 - 21:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 25″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
170.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid