Saltar navegación

20241008 ProgrEstruct-Decision-Ejer_9 - 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.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

¿En qué ejercicio se hace el switch? 00:00:00
¿En qué ejercicio se hace el switch? 00:00:02
¿En qué ejercicio se hace el switch? 00:00:03
¿En qué ejercicio se hace el switch? 00:00:05
¿Esto lo vamos a hacer ahora? 00:00:07
Sí, estoy preguntando. 00:00:08
Bueno, a ver, estos son ejercicios de decisión en general 00:00:11
y la decisión uno decide 00:00:13
luego como la plasma, si en un IF, un SIF, 00:00:15
un SWITCH. Nosotros ahora mismo 00:00:18
conocemos tres variantes para 00:00:19
tomar decisiones, o sea, no es que haya 00:00:21
ejercicios de IF, ejercicios de SWITCH. 00:00:23
A ver, IF, 00:00:26
SIF, IF, el IF, el SIF, 00:00:27
el SEIF y el switch case 00:00:29
a ver 00:00:31
el IFELS básico 00:00:35
el IF con el SEIF 00:00:37
claro 00:00:39
eso 00:00:41
vale, en cualquier caso son diferentes 00:00:43
formas de plantear la decisión, luego ya 00:00:45
cada ejercicio uno lo hace como 00:00:47
puede, ve, cree 00:00:49
o usa todas las sentencias 00:00:52
son ejercicios en general de decisión 00:00:53
por eso lo estoy metiendo todo en un proyecto 00:00:55
venga, 19 hemos quedado 00:00:57
Venga 00:00:59
A ver que nos sale 00:01:03
Ejercicio 19 00:01:18
Recibe 00:01:19
Pensemos 00:01:21
A ver 00:01:22
Recibe 3 caracteres 00:01:26
Y un int 00:01:29
Vamos a dar por sentado que lo que mete 00:01:30
Está bien, tres caracteres 00:01:33
Y un int 00:01:35
Para no tener que decir 00:01:37
Si no, bueno, nada 00:01:39
Vale, pues vamos a hacer 00:01:41
La parte de lectura de los datos 00:01:42
La primera de todas, venga, la parte de lectura 00:01:45
Y nos la quitamos de en medio 00:01:49
Ala, ya tenemos 00:01:50
La parte, bueno, hemos leído los datos 00:02:06
A ver, tenemos 00:02:08
Los 00:02:10
Vamos a declarar los 00:02:11
tres, joder 00:02:14
ay, es muy tarde ya 00:02:16
C1, C2 y C3 00:02:19
y el numerito N 00:02:22
nombres de variables horrorosos 00:02:24
pero bueno, es que hay que acortar 00:02:26
hay que acortar que nos alargamos mucho 00:02:28
eso 00:02:30
hay que reducir de donde sea 00:02:32
vale, pues venga, vamos a leer 00:02:34
le decimos primero 00:02:37
introduzca 00:02:40
tres 00:02:42
caracteres 00:02:43
vale, los voy a leer por separado 00:02:45
a ver, aquí se podría interpretar 00:02:50
que le decimos al tío que introduzca A, B, C 00:02:52
los tres seguidos, entonces lo podríamos leer 00:02:54
como una cadena y luego 00:02:56
separarlos, vale, no gracias 00:02:58
eso no gusta, venga, a ver 00:03:00
que otra oferta tenemos, vamos a decirle que 00:03:02
lo lea como, que lo introduzca como 00:03:04
el A, enter, B, enter C 00:03:06
que nos complica más la vida 00:03:08
pues 00:03:09
que introduzca tres caracteres 00:03:11
uno enter, otro enter, otro enter 00:03:14
vamos a asumir que lo va a hacer así 00:03:16
vale, pues venga 00:03:17
vamos a leer el primero 00:03:20
¿cómo leemos? 00:03:21
yo he dicho que con nextline 00:03:24
siempre podemos leer una cadena 00:03:25
siempre, con nextline 00:03:27
pero con nextline 00:03:29
yo leo lo que leo, se queda almacenado 00:03:31
en string, en realidad 00:03:34
pero el tiene introducido 00:03:35
vale, si yo me quedo 00:03:39
con la posición 0 de ese string 00:03:42
es decir, si lo que al tío 00:03:44
ha metido 00:03:46
yo me quedo con la 0 00:03:46
ya tengo el char 00:03:49
en realidad 00:03:51
¿verdad? y lo podría asignar a C1 00:03:52
directamente 00:03:56
¿verdad que puedo hacer esto para leer un char? 00:03:56
si me da la gana 00:04:00
con next line 00:04:00
leemos toda la cadena hasta el enter 00:04:02
y ahora 00:04:05
de toda esa cadena yo podría asignarla 00:04:07
un string y ahora ese string 00:04:09
quedarme con la posición 0 00:04:12
pero voy a 00:04:13
abreviar, entonces 00:04:16
todo esto 00:04:17
es la cadena 00:04:18
que me devuelve el next line 00:04:22
pues de toda esa cadena 00:04:23
me quedo con el char 0 00:04:25
a ver, repito para que quede claro 00:04:26
esto es lo mismo que si yo lo hubiera hecho por partes 00:04:29
leo primero 00:04:31
la cadena 00:04:34
así 00:04:34
y una vez que tengo esta cadena 00:04:36
me quedo 00:04:40
de esa cadena 00:04:42
con el char en la posición 0 00:04:46
¿vale? 00:04:47
es decir, esta es una forma 00:04:50
cómoda, tengo más opciones, pero bueno 00:04:52
es una forma cómoda de leer 00:04:54
una variable char 00:04:56
hago el next line que coge todo lo que 00:04:57
hay hasta el enter, que en este caso 00:05:00
es un único carácter 00:05:02
y lo guardo en un string, porque así funciona el next line 00:05:02
lo guardo en un string, no hay alternativa, lo guardo en un string 00:05:06
vale, y ahora de ese string me quedo 00:05:08
con la posición 0 00:05:10
ese me devuelve ya un char suelto 00:05:12
pues ese char hace 1, vale 00:05:14
entonces, esta es una forma 00:05:16
compactada 00:05:19
de ponerlo de arriba, pero es lo mismo 00:05:20
estoy haciendo lo mismo 00:05:22
vale, estoy diciendo 00:05:24
a todo el string que me devuelve 00:05:28
este, a todo este 00:05:30
a todo ese, ya quédate 00:05:31
con el 0 00:05:34
me estoy ahorrando esta variable intermedia 00:05:34
vale, pero esto 00:05:37
y esto tienen el mismo 00:05:39
efecto, guardar en c1 00:05:42
el char que se ha metido, tienen el mismo 00:05:44
efecto, esto y esto 00:05:46
el que veáis más claro 00:05:47
vale, yo este ahora mismo lo voy a dejar comentado 00:05:51
vale, y me quedo con este 00:05:54
y así me ahorro declarar esa variable 00:05:57
me ahorro declararla 00:05:59
pero si os hacéis más lío y lo veis más claro así 00:06:00
pues trabajáis así por ahora y ya está 00:06:03
no pasa nada 00:06:05
bueno, pues 00:06:06
Ya hemos leído el primer carácter 00:06:09
Vamos a leer los siguientes 00:06:11
Y C3 00:06:14
Vale, ya tenemos los tres 00:06:17
Y ahora 00:06:24
Vamos a leer el numerito entero 00:06:27
Leemos el numerito N 00:06:28
Aquí ya lo tenía declarado 00:06:41
N con scan.nextint 00:06:42
Ala, tenemos los tres datos de entrada 00:06:49
Y ahora ya es cuando habría que hacer 00:06:51
Todo el pifostio ese 00:06:54
Bueno, esta parte de lectura de los char ha quedado claro 00:06:56
O sea, en esta versión o en la de arriba 00:07:04
Vale, vamos a probar solo esta parte de lectura 00:07:05
A ver si nos va bien 00:07:13
Vale, voy a ejecutar 00:07:15
Vale, voy a ejecutar esto 00:07:22
Introduzca tres caracteres 00:07:29
R, W, A, introduzca número 00:07:34
Y el programa ha acabado porque no he hecho nada más 00:07:37
vamos a suponer que lo habéis hecho en orden inverso 00:07:39
que habéis decidido leer primero el número 00:07:44
no pasa nada 00:07:46
podéis haber decidido leer primero el número 00:07:48
ya está, habéis leído primero el número 00:07:51
ya después de haber leído el número 00:07:55
ya le pedís los caracteres, es lo mismo, me da igual 00:07:57
voy a quitarlo de aquí porque ya lo he leído arriba 00:08:00
bueno, pues habéis decidido hacerlo en orden inverso 00:08:03
Vale, solamente he subido esto arriba 00:08:07
Para leer primero el numerito 00:08:10
Y cuando he leído el numerito he metido eso 00:08:11
Vale, vamos a ejecutarlo ahora 00:08:14
Lo ejecuto, introduzca número 00:08:15
Si no hemos hecho nada 00:08:18
Y ya ha salido esto 00:08:22
Pues ya lo hemos liado 00:08:23
Fijaos que absurdo 00:08:26
Me he limitado a cambiar el orden 00:08:29
A la parte del número 00:08:31
En lugar de leerla después, leerla antes 00:08:33
Y me ha salido algo 00:08:35
desconcertante 00:08:36
ahora me explico 00:08:38
vale 00:08:41
me dice algo de 00:08:43
indesauros va a una excepción 00:08:44
la posición 0, leída 00:08:46
bueno, a ver, en resumen 00:08:49
¿qué ha pasado? 00:08:51
pues esto es por culpa de cómo 00:08:53
funciona el objeto escáner, entonces una vez que ya sabemos 00:08:55
por qué pasa 00:08:57
ya sabemos cómo arreglarlo, lo arregláis siempre 00:08:58
y se acabó, vale, ¿por qué pasa 00:09:01
esto? fijaos lo que 00:09:03
está pasando en realidad es 00:09:05
cuando el 00:09:06
objeto escáner 00:09:08
le mandamos leer un número 00:09:10
sea int o sea label 00:09:13
me da igual, o sea float, un número 00:09:15
cuando le mandamos leer un numerito 00:09:16
¿él qué hace? 00:09:18
como él está esperando un numerito 00:09:21
pues 00:09:23
una vez que ya ha llegado el número 00:09:24
coge el número 00:09:28
lo guarda en la variable correspondiente 00:09:30
lo guarda en la variable 00:09:33
pero claro, nosotros hemos metido el número 00:09:34
y además del número 00:09:37
hemos metido un enter 00:09:38
el enter lo hemos metido 00:09:40
cuando yo meto un número, meto 37 00:09:41
y enter 00:09:44
el next sin 00:09:45
ha cogido el 37 00:09:48
y el 37 se ha ido aquí 00:09:50
¿y qué ha pasado con el enter? 00:09:52
el enter es otro carácter en realidad 00:09:55
de hecho está en la tabla ASCII 00:09:56
en la tabla ASCII hay uno que es salto de línea 00:09:58
es otro carácter 00:10:00
¿qué ha pasado con ese carácter? 00:10:01
pues que está ahí cruzado de brazos en el buffer del teclado 00:10:04
esperando que digan, oye, ¿qué pasa conmigo? 00:10:06
Te has quedado con el 37 y lo has guardado en N, 00:10:08
muy bien, y yo, ¿qué pasa? 00:10:11
Pues ahí se queda esperando, 00:10:14
en el buffer del teclado, donde está la filita 00:10:15
de las cosas que yo he metido. 00:10:17
Cuando vosotros tecleáis en un teclado, 00:10:19
todo eso va a un buffer. 00:10:21
Y luego ya la aplicación que sea 00:10:23
va sacando del buffer según va necesitando. 00:10:25
Pues aquí hemos metido en el buffer 00:10:28
y el salto de línea. 00:10:30
Todo eso está en el buffer. 00:10:32
El 37 salió 00:10:34
porque lo sacó el next line para llevarlo 00:10:36
y salió, y está el salto de línea 00:10:38
cruzado de brazos, y ahí está 00:10:40
vale, pues el salto de línea, ¿quién lo chupa ahora? 00:10:42
lo chupa 00:10:45
este next line 00:10:46
la siguiente sentencia de entrada 00:10:48
esta 00:10:50
entonces, esta 00:10:51
no se queda esperando que le metamos 00:10:53
algo más, porque ya ve que hay un salto de línea 00:10:56
y se cree que es 00:10:59
eso lo que le hemos 00:11:00
metido, se cree que es eso, entonces lo 00:11:02
coge y como le hemos 00:11:04
dicho que vaya al carácter en posición 00:11:06
cero, dice, si no hay nada en la 00:11:08
posición cero, porque le hemos metido un string vacío. 00:11:10
Al dar al enter 00:11:14
él interpreta que no hay un string vacío, no hay nada. 00:11:14
Es lo que nos ha salido. 00:11:17
Indes va a una step y en la posición cero no existe. 00:11:18
A ver, más o menos 00:11:21
habéis entendido lo que ha pasado. 00:11:22
Ahora es más fácil entender la solución. 00:11:24
Esto cuando ocurre, 00:11:27
ocurre, 00:11:29
esta combinación se da 00:11:30
cuando hacéis una lectura 00:11:32
de número 00:11:34
y después hacéis una de cadena 00:11:35
esa combinación es la peligrosa 00:11:38
porque cuando hacéis 00:11:41
la de número, la de número deja el salto de línea 00:11:42
sin procesar 00:11:44
y luego la va a procesar este 00:11:45
entonces, y este 00:11:47
al ser un next line, al procesarla 00:11:50
va a decir, uy cadena vacía 00:11:52
cadena vacía, ya tengo cadena, no tengo que esperar 00:11:54
que me metas nada, pero claro, cadena vacía 00:11:56
cuando me voy aquí, falla 00:11:58
porque no tiene posición 0 la cadena vacía 00:12:00
la que pongas 00:12:02
la cadena vacía no tiene ninguna posición 00:12:06
no tiene ni la 0 ni la 1 ni la ninguna 00:12:08
entonces primero hay que aislar 00:12:10
que este problema se da 00:12:12
cuando hacemos la secuencia de 00:12:13
leer un numerito con next in next double 00:12:15
y después un next line 00:12:18
porque entre next line y next line 00:12:18
no se da 00:12:22
porque un next line el salto de línea también lo chupa 00:12:22
y lo quita 00:12:26
el problema es cuando leemos números 00:12:26
que el salto de línea no lo chupan 00:12:30
bueno, pues entonces 00:12:32
¿cómo lo arreglamos? cuando hemos 00:12:34
identificado que en nuestro código tenemos una 00:12:35
secuencia de lecturas 00:12:37
en las cuales estamos leyendo número 00:12:39
y después cadena 00:12:41
número y después cadena, tenemos que 00:12:43
hacer algo para quitar ese 00:12:46
salto de línea 00:12:48
no pasa nada, pues ¿cómo podemos hacer 00:12:48
quitar el salto de línea? 00:12:52
leyéndolo a lo bestia 00:12:54
lo leemos 00:12:55
ya está leído 00:12:56
y no lo asigno a nadie, lo tiro a la basura 00:13:01
no hace falta que se lo asigne a nadie 00:13:04
si yo no se lo asigno a nadie 00:13:06
es como tirarlo a la basura 00:13:08
se lo podría asignar 00:13:10
a una cadena, claro 00:13:12
entonces yo ahora mi programa así 00:13:13
ya sí va a funcionar 00:13:16
porque ¿qué es lo que hago? leo un numerito 00:13:18
el número va a N 00:13:20
se me ha quedado un salto de línea 00:13:21
ese salto de línea 00:13:24
que se lo traje este next line 00:13:26
y lo lleva aquí 00:13:28
y ahora ya, este ya se encuentra el buffer vacío 00:13:30
como se encuentra el buffer vacío 00:13:33
ya se queda esperando que yo le meta 00:13:35
mi char, ¿vale? 00:13:37
entonces 00:13:42
recopilando 00:13:43
esta situación anómala se da 00:13:44
cuando después de leer un número 00:13:46
leemos cadena con next line 00:13:48
para evitarla 00:13:50
intercalamos 00:13:52
entre la lectura de número 00:13:55
y la lectura de cadena 00:13:57
intercalamos una lectura de cadena 00:13:58
Para que quite eso, que se ha quedado ahí esperando 00:14:01
Vamos a probarlo 00:14:03
Para ver que ahora las lecturas no van a dar ese problema 00:14:05
Yo ahora introduzca 00:14:07
Número 87 00:14:09
¿Veis? Y ahora ya sé que funciona 00:14:10
D, F y H 00:14:12
Vale, ya me ha funcionado 00:14:14
¿Vale? 00:14:16
Ya por último, para que quede más bonito 00:14:18
Este string que leo 00:14:20
No necesito asignárselo a nadie 00:14:22
Es para nada 00:14:24
Es para sacarlo del buffer, pero me da igual 00:14:26
No quiero hacer nada con él 00:14:28
pues yo puedo 00:14:30
no asignárselo a nadie 00:14:31
puedo hacer esto 00:14:33
el compilador no tiene problema 00:14:35
coge el valor 00:14:37
y cuando toca asignarlo dice 00:14:39
uy, no me has dicho a quién se lo asigno 00:14:41
pues a la basura, ya está, no pasa nada 00:14:43
cuando nosotros cogemos 00:14:45
un valor y no se lo asignamos a nadie 00:14:48
la máquina virtual 00:14:50
lo hace desaparecer 00:14:51
y se acabó, entonces en este caso 00:14:53
me es más cómodo, como yo ese valor no lo quiero para nada 00:14:57
solo para sacarlo 00:14:59
pues lo dejo así y listo 00:15:00
¿vale? 00:15:08
entonces lo único, repito, ahora mismo 00:15:10
no hace falta que os volváis 00:15:12
locos, simplemente 00:15:14
cuando estáis haciendo un código y resulta 00:15:15
que después de un next in o un next 00:15:18
in, una lectura de número en general 00:15:20
tenéis que hacer una de cadena 00:15:22
acordaos de meter 00:15:24
una de estas, ya está 00:15:26
¿vale? y me diréis 00:15:27
seguramente, un segundo, me diréis 00:15:33
oye, pero ¿por qué no me ha pasado otras 00:15:35
veces cuando hemos leído 00:15:37
seguidos numeritos 00:15:39
porque hay veces 00:15:40
en los cuales hemos leído dos números 00:15:42
seguidos, hemos hecho dos next in 00:15:45
o tres números seguidos 00:15:47
cuando era el mayor de los tres, hemos hecho tres next in 00:15:49
y diréis, anda, y ahí porque no pasaba 00:15:51
porque yo metía el numerito 00:15:53
y el salto de línea se quedaba 00:15:54
porque este next in no lo cogía 00:15:56
porque el método next in 00:15:59
ignora 00:16:01
todo lo que no sean números 00:16:03
entonces, este next in 00:16:04
ha dejado un salto de línea, es verdad 00:16:07
pero este otro next in 00:16:09
ese salto de línea, como no es un número, lo ignora 00:16:10
y se va por los números 00:16:13
por eso no nos ha pasado eso 00:16:15
pero claro, cuando lo que tenemos es un next line 00:16:16
el next line no ignora nada, porque es una cadena 00:16:18
genérica, la que sea, no ignora nada 00:16:21
entonces, si había un salto de línea 00:16:23
del next in anterior, si lo había 00:16:25
esta no lo ignora y se lo queda 00:16:27
¿vale? 00:16:29
luego, lo que, dime 00:16:33
¿por qué no lo hace automáticamente? 00:16:34
porque 00:16:39
el ordenador no sabe hacer nada 00:16:39
eso tienes que decir tú, ¿por qué va a hacer 00:16:43
automáticamente eso? 00:16:44
no está el escáner programado para que después 00:16:48
de un int elimine el salto de línea 00:16:51
no está programado 00:16:52
¿eh? 00:16:54
y no existe un limpiar 00:16:56
buffer, no, con este objeto 00:16:57
escáner, este no es el único objeto 00:16:59
con el que se puede leer del teclado 00:17:01
hay más objetos 00:17:03
con otras funcionalidades 00:17:05
de distintos, pero este 00:17:07
a la hora de escribirlo 00:17:09
es el más sencillo 00:17:11
entonces por eso es el que al principio estamos usando 00:17:13
porque si usáramos otros objetos 00:17:15
pues tendríamos que saber más cosas de objetos 00:17:16
porque los métodos se usan de otra manera 00:17:19
pero este 00:17:21
en concreto tiene esta particularidad 00:17:23
pero no pasa nada, dime 00:17:24
no, no, no, no, esto es 00:17:26
imagina, no 00:17:33
si hemos hecho esto 00:17:35
y esto 00:17:37
o sea dos de número 00:17:38
esto no significa 00:17:42
que se hayan quedado dos en el buffer 00:17:44
Aquí este ha dejado uno 00:17:46
Pero este next in 00:17:49
Ha cogido el primero 00:17:50
Como no le interesa porque no es número, fuera, lo ha sacado ya 00:17:52
Coger su número 00:17:55
Y el que le queda a él, ese ya sí que lo deja 00:17:57
O sea, cada next in deja uno solo 00:17:59
Los que hubiera de antes ya se han eliminado 00:18:01
¿Vale? 00:18:03
Pero sí, es una 00:18:05
Buena pregunta, efectivamente, ¿vale? 00:18:06
¿Vale? Pues vale 00:18:10
Ya tenemos hecha la primera parte 00:18:11
Leer los char y el numerito 00:18:12
Y ahora ya viene el programa 00:18:15
que el programa era 00:18:16
cada char 00:18:19
por favor 00:18:22
sustituyalo con el char 00:18:23
que se encuentre en posiciones 00:18:26
después 00:18:28
vale, bueno, aquí tenemos que 00:18:29
entonces 00:18:32
si acaba el alfabeto 00:18:34
esta parte 00:18:37
vamos a incorporarla después 00:18:38
vamos a hacer primero como sin tener en cuenta 00:18:39
que se acabe el alfabeto o no 00:18:42
y luego ya nos planteamos 00:18:43
cómo incorporar en el caso de que se haya acabado el alfabeto. 00:18:46
Venga, pues 00:18:49
en este caso 00:18:50
como ya sabemos, aquí lo que tenemos 00:18:52
que hacer es automáticamente irnos 00:18:54
a la tabla ASCII a ver cómo están colocadas 00:18:56
las letras minúsculas. 00:18:58
Vale, pues aquí tenemos 00:19:07
una tabla ASCII 00:19:09
donde las letras minúsculas 00:19:15
están aquí 00:19:16
a la derecha. 00:19:21
Aquí están las letras minúsculas. 00:19:23
Desde el 97 00:19:26
hasta el 122 00:19:27
con lo cual, uy que suerte, están consecutivas 00:19:31
con lo cual llegar 00:19:33
de la A a 4 por debajo 00:19:35
es sumarle 4 00:19:38
llegar de la D a 4 por debajo 00:19:39
es sumarle 4 00:19:42
entonces, si nos olvidamos 00:19:42
del tema circular 00:19:46
que si me he saltado todo al principio 00:19:47
si nos olvidamos de esa parte 00:19:50
pues este programa se quedaría sencillito 00:19:51
ya, se quedaría 00:19:53
vamos a ver 00:19:56
Decía simplemente 00:19:57
Avanzar 00:20:00
Las letras en el alfabeto 00:20:01
El numerito que sea 00:20:04
El alfabeto después 00:20:04
Vale, pues entonces 00:20:07
Esto se nos quedaría 00:20:09
C1 igual a 00:20:10
C1 más 00:20:13
Más 00:20:17
N, vale 00:20:21
Vale, eso es lo primero que haríamos 00:20:24
¿No? C2 00:20:34
Es lo primero que se nos ocurre 00:20:35
C2 más N. 00:20:37
Y ahora C3 igual a C3 más N. 00:20:41
Vale, ahora aquí nos sale algo rojo. 00:20:46
De nuevo son las particularidades de los char. 00:20:49
Pero ya entendemos, sin ver lo que nos dice, ya lo podemos entender. 00:20:50
Vamos a ver. 00:20:55
Tenemos aquí un operador más que está sumando un char con un entero. 00:20:56
Sabemos que eso lo podemos hacer, no hay ningún problema. 00:21:02
¿Qué es lo que hace eso? 00:21:05
Entonces, el C1 lo interpreta como si fuera número entero. 00:21:07
Es decir, si C1 fuera A, lo interpreta como 97. 00:21:12
Ya sabemos lo que está pasando. 00:21:17
En cuanto el C1 está con un operador más, 00:21:19
C1 es interpretado como el numerito entero 97. 00:21:22
Al 97 le suma 3, el número que sea, 00:21:27
y te dará 100. 00:21:31
Te da un int. 00:21:33
y yo estoy intentando 00:21:34
guardarlo en un char 00:21:36
un int en un char no puedes 00:21:37
al revés sí 00:21:40
un char en un int sí, porque un char 00:21:41
siempre puede ser interpretado como entero 00:21:44
o sea, un char 00:21:46
admite ambas interpretaciones 00:21:48
o juega el papel de numerito entero 00:21:50
siendo su papel este 00:21:52
o juega el papel de char 00:21:54
puede jugar los dos 00:21:56
¿vale? pero el entero solo juega 00:21:57
el papel de entero 00:22:00
entonces, yo 00:22:01
un char a un entero puedo 00:22:03
es decir, yo 00:22:06
a una variable 00:22:08
entera num 00:22:10
¿vale? 00:22:12
¿le puedo dar un char? 00:22:16
no hay ningún problema 00:22:17
porque esto es un char, pero el char 00:22:18
tiene doble personalidad 00:22:20
y adopta la que necesitemos 00:22:21
aquí, como lo voy a asignar 00:22:24
a un número, adopta la 00:22:26
personalidad de entero 00:22:28
y su personalidad de entero es 97 00:22:29
con lo cual al numerito num 00:22:31
si yo lo miro por pantalla veo que tiene 00:22:34
97, ya está, no hay duda 00:22:36
y este tiene su doble personalidad 00:22:38
si yo este 00:22:41
lo uso para 00:22:42
asignárselo a un char, tampoco 00:22:44
hay ningún problema, el char 00:22:46
a se va a c, ningún problema 00:22:48
¿dónde viene el problema? 00:22:50
cuando yo lo que 00:22:53
quiero es a una variable char 00:22:54
¿vale? asignarle 00:22:56
un numerito 00:22:58
una variable entera. Tengo 00:23:00
mi variable 00:23:05
entera, n 00:23:06
vale, sí, 00:23:09
perdón, 00:23:14
mi numerita entera igual a 00:23:16
vale, y aquí le quiero asignar 00:23:17
num, ¿vale? 00:23:20
Aquí es donde no me deja. 00:23:24
Me dice, oye, 00:23:26
num es una variable entera 00:23:28
y las variables enteras 00:23:30
son variables enteras, 00:23:32
no pueden elegir, no pueden elegir, 00:23:34
Y entonces, como son variables enteras, a char no pueden ir. 00:23:36
Ese es el problema que nos hemos 00:23:39
encontrado aquí. 00:23:40
¿Vale? Es el problema que nos hemos encontrado aquí. 00:23:41
Vale. Pues entonces, 00:23:44
¿qué podemos hacer? 00:23:47
Claro, o bien, 00:23:57
declaro esto como enteros. 00:23:59
Declaro estos como enteros. 00:24:01
¿Vale? Los declaro como enteros. 00:24:03
Aquí, 00:24:04
lo que pasa es que están como echados. 00:24:09
Bueno, el casting era por eso que nos ahorrábamos el casting. 00:24:10
No lo podemos ahorrar en cualquier caso. 00:24:13
¿Vale? 00:24:15
Entonces, tengo que pasar esto a char. 00:24:15
¿Vale? 00:24:18
Tengo que pasar esto a char para volverlo a guardar. 00:24:19
Bueno, a ver, es que estoy intentando, perdón, 00:24:21
guardarlo en C1. 00:24:23
Voy a hacerlo en tres variables aparte. 00:24:24
Para, claro, en lugar de volverlo a guardar en C1, 00:24:27
que lo había hecho por comodidad para no tener más variables, 00:24:31
en lugar de guardarlo en C1, me voy a hacer yo tres variables 00:24:33
en la letra 1, en la letra 2 00:24:37
e en la letra 3, las modificadas 00:24:40
y esta va a ser la letra 1 00:24:43
esta va a ser la letra 2 00:24:46
y esta va a ser la letra 3 00:24:49
¿vale? 00:24:52
entonces, el charce 1 sumada a sus posiciones 00:24:55
el charce 1 que es A 00:24:59
pues A más 3 00:25:02
será 00:25:04
97 más 3, 100 00:25:05
pues el numerito 100 00:25:08
va aquí 00:25:10
el numerito 100 va aquí 00:25:11
ahora yo quiero mostrar esos caracteres 00:25:13
y ahora ya tenemos el problema 00:25:18
de siempre 00:25:22
que si los mostramos así 00:25:22
no me muestra esos caracteres 00:25:26
concatenados 00:25:28
sino que lo que me muestra es la suma 00:25:29
de los enteros 00:25:32
pero que hacíamos 00:25:33
lo poníamos con comillas 00:25:35
L1, aquí me sobra este 00:25:41
vale, pues vamos a probarlo poniendo que no se salte 00:25:50
del alfabeto, vamos a ponerle la A, la B y la C 00:25:58
y que avance tres posiciones, con lo cual nos tendrá que mostrar la D, la E 00:26:01
y la F, vamos a ver, si nos muestra la D 00:26:06
la E y la F nuestro programa, la D, la E 00:26:10
La F si le metemos la A, la B y la C 00:26:14
Y el número 3 00:26:16
Vamos a probar a hacer eso 00:26:17
A ver 00:26:19
Número 3 00:26:21
Caracteres A, B y C 00:26:27
¿Vale? 00:26:31
No nos ha mostrado eso 00:26:34
¿Vale? 00:26:36
¿Dónde estamos? Aquí 00:26:42
¿Vale? 00:26:44
¿Vale? Pues ¿qué tenemos que hacer? 00:26:46
L1 al estar declarada como int 00:26:48
Al estar declarada como int 00:26:51
cuando la máquina virtual ha intentado 00:26:53
hacer su casting 00:26:55
a string 00:26:56
ha hecho su casting al numerito entero 00:26:58
que representa 00:27:01
¿y qué numerito entero representaba? 00:27:02
100, 101 y 102 00:27:05
pues eso es lo que nos ha sacado 00:27:06
nos ha sacado 100, 101 y 102 00:27:08
vamos a volverlo a probar 00:27:12
no hace falta 00:27:13
porque lo tengo ya aquí 00:27:15
nos ha sacado el 100 00:27:16
el 101 y el 102 00:27:18
es decir, nos ha sacado 00:27:21
esto, 100 00:27:23
100, 101 00:27:24
y 102, es decir 00:27:28
el D, el E y el F 00:27:31
pero nos ha sacado como entero, y decíamos 00:27:32
pero si hemos hecho este ejercicio igual y me lo sacaba 00:27:35
como char al convertirlo a char 00:27:37
claro, pero porque estaba declarada 00:27:38
como char la variable 00:27:41
ahora está como int, con lo cual 00:27:41
cuando el operador más hace 00:27:44
la conversión a cadena de esta 00:27:46
mira si está declarada como char 00:27:49
como int. Si está declarada como 00:27:51
int, lo convierte a 00:27:53
esto. Y si está declarada 00:27:55
como 00:27:57
char, lo convierte 00:27:58
a esto otro. 00:28:01
Pero claro, decimos, jolín, 00:28:04
pues estoy en un callejón 00:28:05
sin salida, porque es que lo he tenido 00:28:07
que declarar como int precisamente para 00:28:09
poder hacer esta asignación aquí. Estoy en un callejón 00:28:11
sin salida, no lo puedo declarar como char. 00:28:13
Pero ahora ya aquí es cuando 00:28:14
no podemos escaparnos del casting. 00:28:17
En esta situación digo, vale, 00:28:19
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. 00:28:21
eh, cuidado, aunque estás declarado 00:28:43
como int, por favor 00:28:45
trabájame como char 00:28:47
¿vale? 00:28:48
¿vale? no hubiéramos tenido que hacer 00:29:04
el casting si estuviera declarado como char 00:29:06
lo hemos tenido que hacer porque está 00:29:08
como int, y está como int 00:29:10
para poder haber 00:29:12
hecho el avance 00:29:14
entonces 00:29:15
ahora ya ejecutamos 00:29:17
esto y suponemos 00:29:21
3, a 00:29:22
b y c 00:29:24
D, E y F 00:29:26
Vale, pues 00:29:27
Esto está 00:29:34
Salvo 00:29:36
Y aquí es donde vienen ya los if 00:29:39
Porque si no diríamos, aquí no hay que hacer if 00:29:41
Ni hay que hacer nada 00:29:43
Aquí donde vienen los if 00:29:44
Bueno, pues los if vienen porque dice, oye, cuidado 00:29:46
Si como consecuencia de hacer el salto 00:29:48
Te sales 00:29:51
Entonces 00:29:53
Vuelve arriba 00:29:56
Entonces aquí habrá que hacer un if 00:29:57
Porque si el resultado de esta suma, si L1 o L2 o L3, cualquiera de ellos, son mayores de 122, 00:30:00
entonces en ese caso tienes que hacer una corrección, que es restarle esta diferencia, 00:30:14
restarle el alfabeto para que se vaya aquí. 00:30:21
Si el alfabeto tiene 27 números, pues restarle 27 para que se vaya aquí. 00:30:24
eso ya lo pensáis vosotros 00:30:27
esa modificación 00:30:30
la podemos ver mañana o el próximo día 00:30:31
pero la idea es esa 00:30:34
la idea es si alguna de estas sumas 00:30:35
supera 122 00:30:37
hay que restarle la cantidad de caracteres 00:30:39
de alfabeto y ya está, nada más 00:30:42
lo pensáis y a ver 00:30:43
cómo os funciona 00:30:46
vale, y yo creo que 00:30:48
de todas las cosas raras que pueden tener 00:30:51
los sin, los char combinados, no sé qué 00:30:53
ya lo hemos contemplado todo 00:30:55
pero el resumen es 00:30:57
una variable char 00:31:00
un char en general 00:31:01
puede ser usado en una expresión 00:31:04
en una expresión como int o como char 00:31:07
¿de qué depende? 00:31:09
pues del operador con el que esté 00:31:11
si es más será usado como entero 00:31:12
si lo estoy asumiendo a un int 00:31:15
como entero, puede ser usado como entero 00:31:17
o como char, y un int no 00:31:19
un int solo como int 00:31:20
a menos que le hagamos el casting 00:31:22
si le hacemos el casting entonces ya es usado como char 00:31:24
pero si no lo hacemos el casting 00:31:26
siempre será usado como int 00:31:28
¿eso qué significa? 00:31:29
que lo, ya para terminar 00:31:32
que lo que yo había 00:31:34
la opción que yo había hecho antes 00:31:35
de, no me voy a inventar variables 00:31:38
nuevas, voy a hacerlo 00:31:40
con las mismas, con c1, c2 y c3 00:31:42
esta versión mía 00:31:45
c1, c2 y c3 00:31:46
que me daba problemas porque me decía 00:31:50
ojo que esto es un entero, no puede 00:31:52
a un char, pues esta versión mía 00:31:54
la podría haber arreglado 00:31:56
poniéndole 00:31:58
un casting en ese momento 00:32:00
digo, oye 00:32:02
si, tú eres un entero 00:32:04
pero tú me interesas trabajando como char 00:32:05
pues todo tú 00:32:08
te pongo el casting delante 00:32:09
¿vale? 00:32:11
nos ahorramos esas tres variables 00:32:14
¿y entonces arriba donde 00:32:27
por ahí está mi char? 00:32:29
no, es que esto 00:32:32
ya no me hace falta 00:32:33
estoy sobre la propia 00:32:34
C1 asignando la conversión 00:32:37
a char de este número entero 00:32:39
y ahora ya cuando muestre 00:32:40
los paréntesis sí que los tengo que poner 00:32:42
pero ya el casting a char 00:32:45
me lo ahorro 00:32:47
claro cuando 00:32:48
o sea este system de aquí 00:32:51
iría aquí 00:32:53
y para el de abajo 00:32:55
pues ya este no hace falta 00:32:58
porque para que voy a convertir 00:33:01
achar algo que haya achar 00:33:03
este C1 00:33:05
este C2 00:33:06
y este 00:33:09
vale, ya los tengo en char 00:33:12
no hace falta que haga el casting a char 00:33:15
eso sí, lo tengo que paginar 00:33:16
con esto porque si no el más lo volvería a convertir 00:33:19
a enter otra vez, volvería a convertir a 00:33:21
vale 00:33:23
vale, pues ya está, pero voy a probarlo 00:33:24
por si se ha escapado algo, a ver si 00:33:34
voy a comentar 00:33:36
esta parte de aquí, la versión 00:33:39
anterior la vamos a 00:33:41
comentar y vamos a dejar esta 00:33:43
solo 00:33:45
a ver si algo se nos ha escapado 00:33:46
que podría ser porque 00:33:49
A, B y C 00:33:50
D y F, vale 00:33:54
vale, venga, pues ahora 00:33:55
ya sí que nos vamos 00:34:00
incorporar la versión de 00:34:01
si me he salido del alfabeto 00:34:04
empieza por arriba otra vez, en plan círculo 00:34:06
vale 00:34:08
y ya está finito 00:34:09
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
15
Fecha:
10 de octubre de 2024 - 16:57
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
146.44 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid