Saltar navegación

20251014 ProgEstr-EjerIf_3 - 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 19 de octubre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues ejercicios 00:00:00
Era el 00:00:05
El 8 sería, ¿verdad? 00:00:07
Era este 00:00:11
Entonces este ejercicio lo habíamos hecho 00:00:11
Sacando las centenas, unidades y decenas 00:00:14
Y sacando la cifra mayor, la mayor y la intermedia 00:00:17
Pero claro, este programa es válido 00:00:20
Si el número que me han introducido es positivo 00:00:23
Pero si el número que me han introducido es negativo 00:00:26
entonces 00:00:29
lo que me han 00:00:31
metido por consola 00:00:33
es, o sea, si me han metido 00:00:35
321 00:00:49
este programa funcionaba perfectamente 00:00:51
porque al hacer yo estas operaciones 00:00:53
sacaba el 3 00:00:55
el 2 y el 1 00:00:57
pero si me meten un número negativo 00:00:58
el menos 00:01:01
512 00:01:02
¿vale? entonces 00:01:04
bueno, las cifras las saco bien igualmente 00:01:07
si me metí un número negativo 00:01:09
las cifras las saco bien igualmente 00:01:11
pero luego el negativo 00:01:13
mayor posible 00:01:15
tiene que ir al revés 00:01:17
primero tiene que ir la cifra más pequeñita 00:01:19
luego la mayor y luego esta 00:01:21
el número negativo 00:01:23
más grande 00:01:26
que se puede construir con las cifras de 512 00:01:27
es el menos 125 00:01:30
este es el más grande 00:01:32
sin embargo si el número fuera positivo 00:01:33
el número más grande que se puede construir 00:01:36
es el 521 00:01:38
luego tenemos que 00:01:41
meter aquí un if que distinga 00:01:43
si el número es negativo o positivo 00:01:44
porque si es negativo 00:01:46
el número lo construyo 00:01:48
a la inversa 00:01:50
que si es positivo 00:01:52
¿está claro, no? 00:01:54
¿sí o no? 00:01:56
pero las cifras se sacan igual, ¿verdad? 00:01:58
si yo tengo el menos 00:02:01
el menos 125 00:02:02
por ejemplo 00:02:05
el cociente, el resto 00:02:06
todo eso será igual 00:02:09
lo que pasa es que 00:02:10
arrastraré el signo 00:02:13
vamos a comprobarlo 00:02:15
vamos a ver 00:02:16
vamos a añadir aquí 00:02:20
una comprobación que sea 00:02:23
decenas 00:02:26
que no lo veis 00:02:28
una comprobación que sea 00:02:30
vamos a ver las centenas del número 00:02:34
las centenas del número 00:02:36
será este 00:02:38
vamos a comprobar las decenas 00:02:40
del número 00:02:45
y vamos a comprobar 00:02:45
las unidades 00:02:55
vale, si ejecutamos el programa 00:02:58
metiendo un número positivo 00:03:08
ya sabemos lo que nos va a sacar 00:03:10
exactamente las centenas, las decenas y las unidades 00:03:11
le meto 00:03:14
el 3 cuadrado a este 00:03:18
y me saca centenas 4 00:03:20
decenas 5 00:03:22
y unidades 3 00:03:24
Y si le meto un número negativo 00:03:25
Vamos a ver 00:03:27
Que me saca 00:03:28
Centenas 8, decenas 7 00:03:32
Y unidades menos 1 00:03:35
¿Vale? 00:03:37
Entonces 00:03:40
Al sacarme las centenas 00:03:41
Las decenas y las unidades 00:03:44
Ya con el signo 00:03:46
Me lo hace bien igualmente 00:03:47
Es que no tenemos ni que tocar nada 00:03:50
Porque al 00:03:52
No tenemos ni que tocar nada 00:03:56
Fijaos que listo 00:03:57
No tenemos que tocar nada 00:03:59
Porque si el número es negativo 00:04:01
La operación que hemos hecho 00:04:04
Nos sale con número negativo 00:04:05
Con signo negativo 00:04:07
Esta operación 00:04:08
Que era el número 00:04:10
Entre 100 00:04:17
Esta operación 00:04:21
Ahora me da el menos 8 00:04:23
En el cociente de N 00:04:25
Entre 100 es 8 00:04:27
Pero como el 00:04:28
El signo de N es negativo 00:04:31
pues ya sabéis la regla de los signos de la división 00:04:32
luego esto es menos 8 00:04:34
las decenas como las sacábamos 00:04:36
las sacábamos 00:04:38
las unidades 00:04:40
las sacábamos como el resto de 00:04:43
las unidades 00:04:46
las sacábamos como el resto 00:04:52
de dividir entre 10 00:04:54
el resto de dividir entre 10 00:04:55
efectivamente 00:04:58
es 1 pero por la 00:05:00
regla de los signos como n es negativo 00:05:02
por la regla de los signos me saca menos 1 00:05:04
y las unidades 00:05:06
las sacábamos 00:05:08
el número entre 00:05:09
100 00:05:12
no, por ciento 00:05:13
100 y luego esto entre 10 00:05:16
¿vale? 00:05:19
y esto me saca 00:05:21
el menos 7 00:05:24
entonces me ha sacado 00:05:26
correctamente las centenas, las decenas 00:05:31
y las unidades pero me las ha sacado por la regla 00:05:33
de los signos, me la ha sacado con signo negativo 00:05:35
eso me permite 00:05:37
que ya el programa funcione bien 00:05:38
porque ahora al tener todas un signo negativo 00:05:40
¿cuál va a ser 00:05:43
la cifra mayor de todas? 00:05:44
esta va a ser la mayor 00:05:46
¿cuál va a ser la intermedia? esta 00:05:47
¿y cuál va a ser la más pequeña? esta 00:05:50
cuando el signo era positivo 00:05:53
la mayor era 8 00:05:55
porque esto era positivo 00:05:57
luego era 7 la intermedia 00:05:58
y luego 1 la más pequeña 00:06:01
pero al sacármelo todo con el signo al revés 00:06:02
al sacármelo con el signo al revés 00:06:05
pues la más pequeñita 00:06:07
ahora será el menos 8 00:06:11
la intermedia el menos 7 00:06:13
y la más grande la menos 1 00:06:15
al tener el signo 00:06:16
con lo cual cuando me reconstruya el número 00:06:17
multiplicando la más grande por 100 00:06:20
la intermedia por 10 00:06:22
y sumando las unidades 00:06:24
me lo hace correter también 00:06:25
es que no tenemos ni que 00:06:26
operar de forma distinta 00:06:30
no tenemos ni que distinguirse 00:06:31
el número es positivo o negativo 00:06:33
el programa que hemos hecho 00:06:34
ya me lo hace bien 00:06:35
Pero entendéis por qué, ¿no? 00:06:41
Porque menos 1 es mayor que menos 7, 00:06:42
que a su vez menos 7 es mayor que menos 8. 00:06:45
Sin embargo, 1 es menor que 7 y 1 es menor que 8. 00:06:49
Esto está claro, ¿no? 00:06:52
Entonces, cuando el número es negativo, 00:06:54
la que antes era la cifra más pequeña, 00:06:57
ahora se convierte en la cifra más grande. 00:07:00
Y la que antes era la cifra más grande, 00:07:03
ahora se convierte en la más pequeñita. 00:07:05
Luego, a la hora de reconstruir el número, 00:07:07
me sigue saliendo el más grande posible. 00:07:09
luego no tenemos ni que distinguir con un if 00:07:11
ni con nada 00:07:15
si hubiéramos hecho este programa usando 00:07:15
la clase string, descomponiendo el número 00:07:21
pasándolo a cadena 00:07:23
por cifras, pues sí 00:07:24
tendría que distinguir si es negativo o no 00:07:27
pero haciéndolo con cifras 00:07:29
bueno, pues con esto el ejercicio 8 00:07:30
no tenemos nada que añadir, está completo 00:07:39
vale 00:07:41
¿cuál otro decíais que hiciéramos? 00:07:44
vamos cogiendo al azar 00:07:48
me vais diciendo, ok 00:07:50
vienen a ser todos un poco lo mismo 00:07:51
venga, ¿cuál? 00:08:00
el 17, este 00:08:08
ah, perdón 00:08:09
hola 00:08:12
a ver, este en realidad 00:08:15
es una chorrada 00:08:18
es comprobar que el primer char 00:08:20
es este, el segundo este, el tercero este 00:08:22
y el cuarto este, ya está, nada más 00:08:24
claro, es que con if 00:08:26
es que hay pocas cosas que se puedan hacer 00:08:28
entonces, esto era 00:08:29
usando algoritmo distinto 00:08:33
pues convirtiéndolo al 00:08:35
string correspondiente y comparando 00:08:37
por ejemplo, vamos a hacer el 17 y 18 00:08:39
es una tontería, pero bueno, así practicamos con cosas 00:08:41
desde las más sencillitas 00:08:43
a las más raras 00:08:44
el 19 ahora lo haremos, tranquilos 00:08:46
vamos primero con cosas 00:08:51
más fáciles, porque habrá gente que esté un poquito más 00:08:53
más perdida 00:08:56
y necesite un poquito más de consolidación 00:08:58
17 y 18 00:09:00
vale, como vamos a recibir 00:09:02
por teclado 00:09:23
pues un escáner 00:09:24
como vamos a recibir por teclado 00:09:34
un escáner, vale 00:09:42
y ahora vamos a recibir 4 char 00:09:43
vamos a 00:09:46
fijarle al 00:09:48
que lo va a meter que char 00:09:50
enter, char, enter, char, enter 00:09:51
char, enter, con lo cual 4 lecturas 00:09:54
tenemos que hacer 00:09:56
si decidimos que lo haga así, separados por enter cada uno de ellos 00:09:56
pues venga 00:10:00
carácter1 igual a 00:10:01
scan.nextline 00:10:03
y como leíamos un carácter por teclado 00:10:06
scan next line 00:10:10
te lee lo que tú le hayas puesto hasta el enter 00:10:12
pero te lo guarda en formato string 00:10:14
entonces 00:10:16
nosotros lo queremos en char 00:10:18
pues como esto es un string 00:10:19
todo esto es un string 00:10:21
el string que me ha leído 00:10:23
es un objeto, objeto string 00:10:24
entonces yo puedo llamar a este método 00:10:27
y quedarme con el carácter 00:10:30
en posición 0 00:10:33
luego este es el string 00:10:34
la cadena que me han metido 00:10:37
se supone que es A 00:10:38
porque yo le estoy diciendo al tío 00:10:40
que es solo un carácter, A, vale 00:10:43
pero está guardado en formato string, como si fuera 00:10:45
el A con dobles comillas 00:10:47
pero yo lo quiero en formato 00:10:48
char, pues como esto es 00:10:51
un string, ya sabemos 00:10:53
y ya estamos usando de vez en cuando 00:10:54
funciones a las que 00:10:57
puede llamar el objeto string 00:10:59
y una de las funciones a la que puede llamar 00:11:00
el objeto string es esta 00:11:03
charA que tú le pasas aquí 00:11:05
un numerito y te da el carácter 00:11:07
de ese string en esa 00:11:10
posición, asumiendo que la primera 00:11:12
posición es la 0 00:11:14
luego esta es la forma más cómoda 00:11:15
de leer un char 00:11:18
pues vamos a hacer lo mismo con c1, c2, c3 00:11:19
y c4 00:11:23
pues ya tendremos 4 char 00:11:24
esto 00:11:38
a ver, esto es 00:11:44
una funcionalidad 00:11:46
a la que puede llamar cualquier objeto string, ¿vale? 00:11:48
Imagínate que tiene esto aquí, un objeto string, 00:11:51
este, vamos a darle, por ejemplo, este valor, ¿vale? 00:11:54
Esto es una variable string que esta en particular 00:12:00
tiene esta cadena, pero además de ser una variable 00:12:03
con un dato dentro, una cadena, además es un objeto 00:12:07
por ser string. 00:12:10
Entonces, por ser objeto, puede llamar a funcionalidades 00:12:13
que hacen cosas, a un montón de ellas 00:12:16
todas las que me aparecen 00:12:18
aquí cuando le doy al punto 00:12:20
bueno, pues en particular, puede llamar 00:12:21
a esta funcionalidad 00:12:24
que si tú le pasas aquí un numerito 00:12:25
por ejemplo, 4 00:12:28
te devuelve 00:12:30
el carácter en la posición 00:12:32
teniendo en cuenta que 00:12:37
la 0 es la primera 00:12:40
entonces, en este caso, ¿qué nos devolvería 00:12:41
esto? pues nos devolvería 00:12:44
0, 1, 2, 3 y 4 00:12:46
la Y 00:12:48
si yo muestro C 00:12:48
me devolverá la Y 00:12:50
¿vale? 00:12:53
pero sin embargo le digo charat 0 00:12:59
me devolverá 00:13:01
la J, porque la que está en la posición 00:13:03
0 y se asume que la primera 00:13:06
es la 0, Java lo asume 00:13:07
es la J 00:13:09
¿vale? y si le digo que me devuelva 00:13:11
el carácter en posición 1 00:13:13
pues me devolverá 00:13:16
la h 00:13:19
¿vale? 00:13:22
entonces 00:13:24
claro, entonces 0, 1, 2, 3 y 4 00:13:24
si yo le dijera 00:13:28
al carácter en posición 8 00:13:30
al compilador 00:13:32
le parece muy bien, el problema es cuando yo 00:13:34
luego lo ejecute, porque la posición 8 no existe 00:13:36
solo existen la 0, la 1, la 2 00:13:38
la 3 y la 4 en esta cadena 00:13:40
entonces si yo le pidiera la 8 00:13:42
cuidadito 00:13:44
porque este programa me diría 00:13:46
ups 00:13:47
me daría un error 00:13:49
que diría, perdona 00:13:52
el índice 8 está fuera 00:13:53
de los límites de ese string 00:13:56
¿vale? 00:13:57
entonces, como ya estamos empezando 00:14:00
a usar charac porque nos es útil 00:14:02
para acceder a caracteres de un string 00:14:04
acostumbrémonos ya 00:14:05
a ver sin miedo 00:14:08
a ver sin miedo 00:14:10
este error cuando nos dé 00:14:14
cuando nos da 00:14:17
este error, cuando ejecutamos un código 00:14:19
digamos, uy 00:14:21
estoy tratando de acceder a una posición 00:14:23
de un string que no existe 00:14:25
porque el string es más corto que esa posición 00:14:27
entonces si nos sale un error 00:14:29
string out of bound exception 00:14:31
pues ya 00:14:33
tratemos de asociar, uy 00:14:35
en algún sitio he tenido yo 00:14:37
que tratar de acceder a una posición 00:14:39
de un string que no existe 00:14:41
En este caso ha sido aquí 00:14:42
No existe la posición 8 00:14:45
Pero la 3 sí que existe 00:14:47
Entonces si yo ejecuto esto 00:14:49
Pues la 3 sí que existe 00:14:52
Que es la letra 1 00:14:53
Vale 00:14:54
Pues aprovechándonos de esto 00:14:55
Aprovechándonos de esto 00:14:59
Podemos aprovechar 00:15:01
Para leer un carácter del teclado 00:15:03
Y guardarlo en char 00:15:05
Porque recordamos que el next line 00:15:06
Me lee la cadena que yo le meta 00:15:09
hasta el salto de línea y me la guarda 00:15:11
en string 00:15:13
pero yo la quiero en formato char 00:15:13
pues como esa cadena que me han metido 00:15:16
yo asumo que es un único carácter 00:15:18
porque mi programa pide un único carácter 00:15:20
pues me quedo con de esa cadena que me han metido 00:15:22
el carácter en la posición 0 00:15:25
y ya me devuelve 00:15:26
ese carácter pero en char 00:15:28
vale, pues ya tengo leídos aquí 00:15:30
cuatro caracteres 00:15:32
para comprobar si los he metido en ese orden 00:15:33
tengo mil maneras de hacer eso 00:15:36
desde esta 00:15:38
Si C1 igual a G, ¿vale? Y C2 igual a A. Y C3 igual a T. Y C4 igual a O. 00:15:39
Pues aquí podríamos poner, un segundito, el orden es correcto. 00:16:10
y ya está, un momento 00:16:17
el orden es 00:16:18
correcto 00:16:20
a ver 00:16:25
y si no, podríamos plantar aquí un else 00:16:26
así, para ser 00:16:29
más cortos, abreviar, vale, dime 00:16:39
nosotros a falta de información añadida 00:16:41
los hemos dicho 00:16:53
vamos a asumirlo que lo introduce así 00:16:55
yo lo he decidido así para que viéramos 00:16:57
esto de leer un carácter suelto 00:16:59
Sí, en este caso cuatro 00:17:00
¿Vale? 00:17:07
Claro, entonces 00:17:15
Esta sería 00:17:16
Una forma de trabajar 00:17:18
Que es 00:17:21
Introduzca 00:17:21
Los caracteres 00:17:24
Separados 00:17:32
Por salto de línea 00:17:34
Esta sería una forma de trabajar 00:17:37
Vale, le decimos esto 00:17:38
Entonces ahora ya ejecutamos esto 00:17:41
Y ya está 00:17:43
Pues venga, caracteres separados por salto de línea 00:17:50
Pues G, A 00:17:52
T, I, O, el orden es correcto 00:17:54
Pues 00:17:59
Bueno, ya 00:18:01
T, I, O, no lo es 00:18:03
Vale, ya está 00:18:06
Vale, otra forma de hacer esto 00:18:07
Otra forma 00:18:11
Vale, pues vamos a seguir manteniendo 00:18:21
que el usuario meta los caracteres así 00:18:23
pero 00:18:25
en lugar de hacer esta condición tan fea 00:18:26
que es compararlos por separado 00:18:29
vamos a concatenarlos 00:18:31
para que formen una cadena 00:18:34
y comparo esa cadena directamente 00:18:35
con la cadena gato 00:18:37
entonces me queda 00:18:38
string palabra 00:18:40
que haríamos 00:18:43
c1 más 00:18:44
c2 más 00:18:46
más 00:18:49
¿Vale? 00:18:54
Y ahora 00:18:56
Aquí nos da un error de compilación 00:18:59
Que por estas particulares del char nos podíamos 00:19:02
Imaginar 00:19:04
Que es C1 00:19:05
Efectivamente 00:19:08
Están declarados aquí como char 00:19:09
¿Vale? C1 están declarados como char 00:19:12
Pero recordad que los char y los in 00:19:14
Son intercambiables 00:19:17
Y generan mucha confusión 00:19:19
Pues si yo pongo un operador más 00:19:20
entre dos char 00:19:23
aquí no interpretamos 00:19:24
que esto es una concatenación 00:19:27
solo interpretamos concatenación 00:19:28
cuando alguno de los dos operadores 00:19:31
es string, solo 00:19:33
es el único contexto en el cual 00:19:34
interpretamos concatenación 00:19:37
cuando alguno de los dos es string 00:19:38
aquí ninguno de los dos es string 00:19:40
es char, con lo cual 00:19:43
el este más lo interpreta como suma de enteros 00:19:45
y haría la suma del entero 00:19:47
que codifica C1 con el entero 00:19:49
que codifica C2, el de la tabla string 00:19:51
me daría un entero y cuando yo guardo 00:19:53
entero en palabra, pues no le vale 00:19:56
me dice, oye, esto es 00:19:58
un entero, una suma de números enteros 00:20:00
los enteros de la tabla ASTI 00:20:01
no pasa nada, lo podemos arreglar así 00:20:03
muy fácilmente 00:20:05
no hace falta que nos metamos en más complicaciones 00:20:07
de, ala, ya lo 00:20:09
tenemos arreglado 00:20:18
desde el momento en que estamos insertando 00:20:19
bueno, estas de aquí 00:20:21
me sobran, en realidad 00:20:24
a ver, no hace falta 00:20:25
porque ahora ya 00:20:30
a lo mejor hasta lo vemos más claro 00:20:31
si la ponemos al principio 00:20:37
del todo 00:20:39
ahora, concatenándolas 00:20:39
al principio ya está, porque ahora 00:20:44
¿qué hace la máquina virtual? como todos son 00:20:46
operadores de suma, no hay 00:20:48
prioridad de operadores, no hay una multiplicación entre 00:20:50
medias, pues como todos tienen la misma 00:20:52
prioridad, porque todos son sumas 00:20:53
luego todos tienen la misma prioridad, va de 00:20:56
izquierda a derecha 00:20:58
entonces al ir de izquierda a derecha, aquí ya ve 00:20:59
aquí ya ve 00:21:02
un string y un numerito int 00:21:05
pues string 00:21:08
más int es concatenación 00:21:10
pues entonces ya 00:21:12
concatena esto a string 00:21:14
y al concatenarlo 00:21:17
ya se queda con su versión char 00:21:18
claro, su versión char 00:21:20
y ahora el resultado de esta concatenación es un string 00:21:21
porque ha convertido esta string 00:21:24
a su versión char de la tabla 00:21:26
y lo ha concatenado 00:21:28
esto ya es un string 00:21:29
luego un string más lo que sea 00:21:30
de nuevo es concatenación 00:21:33
luego esto ya es concatenación también 00:21:35
porque lo que hay a la izquierda es un string 00:21:37
pues me queda otro string 00:21:38
ahora ya un string más este 00:21:40
es un string también 00:21:43
gana la concatenación 00:21:45
tengo el string y ahora a este string 00:21:46
le sumo este 00:21:49
como lo de la izquierda es un string 00:21:50
es concatenación 00:21:53
luego aunque lo ponga aquí al principio ya está 00:21:53
pero cuidadín 00:21:56
porque 00:22:02
si lo pusiéramos 00:22:02
al final 00:22:05
¿No borra? 00:22:14
¡Ay, qué tonterías! 00:22:16
¡Ay, Dios mío! 00:22:19
¡Qué desilusión! 00:22:22
¡Ay, no quería yo esto! 00:22:23
Sin embargo, si lo ponemos al final, 00:22:28
cuidado porque aquí sí sería un problema. 00:22:32
Porque el aire de izquierda a derecha 00:22:34
haría esta suma, 00:22:36
y eso es una suma de números. 00:22:38
Luego haría la suma, y luego haría esta suma, 00:22:40
y luego haría esta suma. 00:22:42
Y ya solo al final concatenaría 00:22:43
el resultado de la suma 00:22:45
de la codificación binaria 00:22:48
de esos caracteres. 00:22:50
Pero antes había hecho las sumas. 00:22:51
Entonces, al final no nos mola. 00:22:54
Vale, pues entonces, 00:22:58
hemos formado la palabra 00:23:00
y ahora ya mi condición se queda más sencilla. 00:23:02
Si palabra, 00:23:06
¿y cómo comparo dos strings entre sí? 00:23:07
Dijimos que jamás nunca lo comparo así. 00:23:10
Si palabra igual a la palabra gato, 00:23:13
Entonces 00:23:17
Vamos a ponerlo bien 00:23:19
El se 00:23:28
Mal 00:23:32
Esta condición 00:23:37
Es más bonita 00:23:40
Que esta de arriba 00:23:41
Más bonita que esta de aquí 00:23:43
¿Vale? 00:23:45
Pero ojo, dijimos en su momento 00:23:47
Y lo tenéis todo en la cabeza 00:23:50
Porque lo vais memorizando todo 00:23:51
Porque es importantísimo 00:23:53
Que nunca comparo la igualdad entre cadenas 00:23:54
con doble igual 00:23:58
solo comparo la igualdad con doble igual 00:23:59
de variables primitivas 00:24:02
no la de cadenas 00:24:03
la de din, la de double 00:24:06
porque los objetos 00:24:07
los objetos se almacenan de otra manera 00:24:09
recordad, el objeto en realidad 00:24:12
es su dirección 00:24:14
de memoria que me lleva al dato 00:24:16
entonces con doble igual 00:24:18
comparo la dirección de memoria donde está palabra 00:24:20
y la dirección de memoria donde está gato 00:24:22
y palabra 00:24:24
puede tener gato dentro 00:24:26
pero estar en una dirección de memoria 00:24:27
que no es en la que está esto 00:24:30
es lo normal de hecho 00:24:32
a menos que los casos que vimos 00:24:33
que él se hace un buffer para ahorrar espacio 00:24:35
entonces vamos a ejecutar esto 00:24:37
yo le voy a meter 00:24:39
G, A, P y O 00:24:43
el orden es correcto 00:24:46
pero si lo hago de la segunda manera 00:24:48
me dice mal, claro 00:24:51
porque esta condición está horriblemente mal 00:24:52
yo comparo la igualdad 00:24:54
entre dos objetos string 00:24:57
de esta manera 00:24:59
Así es como comparamos la igualdad 00:25:00
Entre dos objetos string 00:25:07
Poniendo aquí un objeto string 00:25:08
Y aquí dentro el otro 00:25:10
¿Vale? 00:25:12
Este es un objeto string 00:25:14
Porque algo entrecomillado es un objeto string 00:25:15
Y este es el otro objeto string 00:25:17
Los comparo así 00:25:20
Ahora ya sí 00:25:21
Si ejecuto esto 00:25:24
G, A, T y O 00:25:28
Ya sí que me dice que sí 00:25:31
Que son iguales los dos 00:25:33
vale 00:25:34
bueno, pues de nuevo 00:25:38
que cualquier 00:25:49
mínimo ejercicio os sepa 00:25:51
para terminar de interiorizar 00:25:53
ese que no lo tenéis hecho, que deberíais 00:25:55
el tema de las concatenaciones 00:25:56
cuando estamos mezclando 00:26:00
diferentes tipos de datos, char, números 00:26:01
string, pues el tema 00:26:03
de las concatenaciones, que lo termine 00:26:05
de tener claro, y 00:26:07
el tema de la igualdad 00:26:09
de variables string 00:26:10
vale 00:26:13
y ya de paso 00:26:14
pues seguir familiarizándonos con esto 00:26:16
para todo esto era 00:26:18
este ejercicio 00:26:20
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
19 de octubre de 2025 - 17:27
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
114.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid