Saltar navegación

20260925 Ejercicios_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 25 de septiembre de 2026 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues el procedimiento que yo os había propuesto, se nos ocurre, vamos a pasar la cifra decimal dos posiciones a la derecha, porque así, haciendo un casting, quitamos todo esto que es lo que nos sobra, eso lo queremos quitar, porque eso nos sobra. 00:00:01
Entonces, sabemos quitar una parte decimal con el casting, pero claro, para eso tendría que estar la coma aquí, pero no pasa nada porque, ¿cómo podemos avanzar la coma dos posiciones a la derecha? Haciendo qué operación. 00:00:20
Multiplicando por 100, ¿verdad? 00:00:33
Pues entonces, vamos a hacerlo paso por paso. 00:00:36
Yo tengo mi result1 igual a result1 multiplicado por 100. 00:00:39
Vale. 00:00:49
Con esto ya lo tengo con dos posiciones avanzado aquí. 00:00:50
Vale. 00:00:57
Ahora vamos a hacer un casting para quitar esta parte. 00:00:58
Un casting entero. 00:01:02
Con el pequeño problema de que nos va a quedar el entero 2.232 00:01:02
Pero bueno, ahora ya seguimos trabajando a partir de ahí 00:01:08
Venga, pues ponemos aquí otro numerito 00:01:11
Para hacerlo por partes, un numerito entero 00:01:15
Que va a ser el casting entero de result1 00:01:18
¿Vale? 00:01:26
entonces 00:01:28
este ya va a ser 00:01:34
el número 00:01:37
original bueno 00:01:39
pero sin toda esta 00:01:40
morralla de aquí 00:01:43
pero con la coma 00:01:44
pero en plan entero 00:01:46
o sea, ahí no me vale en entero 00:01:49
yo ahora quiero dividirlo otra vez 00:01:50
entre 100 para que la coma 00:01:53
vaya a la derecha, esa sería la idea 00:01:55
pero claro, yo no puedo hacer esto 00:01:57
Vamos a hacerlo en otra variable 00:02:01
Int num2 00:02:07
Igual a num1 00:02:08
Entre 100 00:02:11
¿Qué me está diciendo aquí? 00:02:12
Ah, es que es num, perdón 00:02:26
Vale 00:02:27
Es num 00:02:28
Entre 100, ¿y qué me dice aquí? 00:02:32
Ah, que num2 00:02:36
Ya existe, vale, vale 00:02:36
Entonces, result1, los voy a ir 00:02:38
Cambiando de nombre 00:02:40
Result2 00:02:41
result 2 00:02:43
y este result 3 00:02:48
entonces esto 00:02:51
no me soluciona la vida 00:02:54
porque haciendo esto, ¿qué habré conseguido? 00:02:55
vale, con la primera operación 00:02:59
multiplicado por 100 00:03:00
me llevo la coma hasta aquí, muy bien 00:03:02
con la segunda 00:03:04
que es el casting 00:03:11
con esta de aquí que es el casting 00:03:12
vale, con esta de aquí 00:03:14
quito esta parte y me quedo con 00:03:17
dos mil doscientos treinta y dos 00:03:19
pero como entero, guardado como entero 00:03:21
entonces si yo ahora lo divido 00:03:23
entre cien, es un entero 00:03:25
entre un entero, esto no va a ser 00:03:27
el efecto mover la coma a la izquierda 00:03:29
porque estoy trabajando con enteros 00:03:31
luego va a ser la división entera 00:03:33
y la división entera es el cociente 00:03:35
de dividir 00:03:37
dos mil doscientos treinta y dos entre cien 00:03:39
¿cuál es el cociente? veintidós 00:03:41
no quiero eso 00:03:42
no quiero el cociente 00:03:44
no quiero el cociente, quiero la división entera 00:03:47
con decimales 00:03:49
para que no me dé 22 00:03:50
que es el cociente entre 2232 00:03:52
entre 100 00:03:55
sino que me haga la división decimal 00:03:56
la que realmente mueve las comas 00:03:58
vale, pues para que este operador 00:04:00
de aquí 00:04:03
ya no sea el operador cociente 00:04:04
sino que sea la división decimal 00:04:07
y por tanto lo que haga realmente 00:04:09
sea tratar este como decimal 00:04:11
mover la coma 00:04:13
para que este deje de comportarse como cociente 00:04:14
y se comporte como división decimal 00:04:17
¿qué cambio podría hacer yo en esta expresión? 00:04:19
no, no, no, no, entonces estaría haciendo el resto 00:04:28
no, lo que yo quiero es que esto 00:04:31
que es el cociente 00:04:32
no funcione como cociente sino como división decimal 00:04:33
pero ahora mi pregunta es 00:04:37
¿vale? 00:04:44
es, está claro que con esto 00:04:45
yo me he quitado toda la parte decimal 00:04:49
esta de aquí 00:04:51
me he quitado la parte decimal de aquí a la derecha 00:04:52
al hacer el casting 00:05:01
pero claro, al hacer el casting en este punto 00:05:04
me he quedado con un número entero 00:05:06
que es 2232, vale 00:05:08
y ahora querría este número 00:05:10
hacerle una división entre 100 00:05:12
que ya sabemos que implica que la coma se va a la izquierda 00:05:15
pero claro, eso cuando la división es decimal 00:05:17
Entonces yo digo, vale, pues voy a hacer 00:05:20
Result 2 00:05:22
Que es el 22.232 00:05:23
Sin la comita esta 00:05:26
Sin esto 00:05:28
22.200 00:05:28
O sea, 2.232 00:05:31
Entre 100, que es lo que estoy haciendo aquí 00:05:33
¿No? 00:05:36
2.232 entre 100 00:05:36
Vale, pero esto ya sabemos 00:05:40
Cómo funciona en Java 00:05:42
Número entero 00:05:43
Porque Result 2 es entero porque he tenido que hacer el casting 00:05:44
Y no me ha quedado más remedio 00:05:47
he tenido que hacer el casting para quitar esto 00:05:48
exacto, número entero 00:05:50
entre número entero 00:05:53
entonces yo soy cociente 00:05:55
si eres cociente 00:05:57
el cociente de dividir 00:05:59
2.232 entre 100 es 00:06:01
22 y resto 32 00:06:03
pues no me vale, yo no quiero 00:06:04
que esto sea el cociente, quiero que sea la división 00:06:07
con decimales 00:06:09
¿cómo podemos hacer para convertir esto en división con decimales? 00:06:10
con que 00:06:15
uno de los dos operandos 00:06:15
el que sea, con que uno de los dos sea decimal, automáticamente el operador se convierte 00:06:17
a división decimal, con que uno de los dos lo sea. Esa es la regla que conocemos. Pues 00:06:23
voy a convertir a 100 en decimal. Convertimos a 100 en decimal y ya está. Pero claro, ahora 00:06:30
esto es una división decimal. Este result promociona decimal y hace división decimal 00:06:45
con el 100. Lo tengo que guardar en decimal, lógicamente, que es lo que yo pretendo. Y 00:06:51
ahora ya este es mi result 3, que puede que ya lo hayamos hecho bien. Vale, pues ejecutamos 00:06:58
Ejecutamos esto, introduzca número decimal, 34, patata. 00:07:08
Introduzca otro, 23, no sé cuántos. 00:07:20
Introduzca otro, 12, no sé qué. 00:07:24
El promedio es 23,73. 00:07:27
El promedio real habría sido 23,73, pero al haberlo multiplicado por 100, 00:07:30
Primero hemos hecho el 2373, le hemos quitado la parte decimal y luego lo hemos vuelto a dividir, ¿vale? 00:07:38
Entonces, toda esta serie de pequeños procedimientos, pues son el concepto de algoritmo, una secuencia de pasos para conseguir algo. 00:07:46
Entonces, hemos encontrado una secuencia de pasos para conseguir que un double con una parte decimal muy grande se convierta en un double con una parte decimal de 2. 00:07:56
Hemos seguido un algoritmo de tres pasos. 00:08:05
Multiplicar por 100, hacer un casting y dividir entre 100. 00:08:08
Hemos hecho ese algoritmo que hemos tenido que pensar y diseñar. 00:08:12
Y eso es la programación, pues pensar yo en algoritmos, secuencias de pasos. 00:08:16
Y una vez que tengo las secuencias de pasos pensadas, pues ya puedo programar. 00:08:21
¿Vale? Hemos hecho este pequeño algoritmo para que se quede con dos cifras decimales. 00:08:26
Vale 00:08:31
¿Alguna duda? 00:08:36
Pues nada 00:08:42
Estos dos de aquí 00:08:49
Vamos a hacerlos rápidamente 00:08:50
Por si alguien tiene alguna duda sobre variables booleanas 00:08:52
Y condiciones 00:08:54
Vale 00:08:56
Eh... 00:09:00
Tres, venga 00:09:02
Ala 00:09:03
Programa que lea una variable booleana 00:09:22
Para representar 00:09:28
Si un estudiante ha aprobado un examen 00:09:30
true se aprobó, false si no 00:09:33
aquí lo que pasa 00:09:35
es que claro, yo me había dado cuenta con este 00:09:36
que leer por teclado solamente hemos visto 00:09:39
leer un número, next in 00:09:41
y leer un número entero 00:09:42
next in, leer un número decimal 00:09:45
leer un true o un false 00:09:46
pues en lugar de 00:09:48
con read in, read double 00:09:51
pues será con read boolean 00:09:52
no sé si más o menos 00:09:54
pues habéis 00:09:55
Vamos, que es un poco tonto esto 00:09:57
Pero bueno, es un poco tonto 00:10:05
Pero vamos a hacerlo, tiene más interés el 4 00:10:12
En el que tú ya construyes la condición 00:10:14
En lugar de darle directamente el true 00:10:16
Pero bueno 00:10:18
Vamos a hacerlo 00:10:19
A ver 00:10:22
Como vamos a leer del teclado, escáner sí o sí 00:10:22
Eso sí que no cambia 00:10:26
Vamos a leer del teclado 00:10:28
Pues esto, plantar 00:10:30
al principio de todo 00:10:31
y así no ensucia el resto del código 00:10:34
y ahora 00:10:36
lo que vamos a leer 00:10:39
no es un int ni un double, es un boolean 00:10:41
con lo cual 00:10:42
pero esto es rarísimo 00:10:45
lo de leer un boolean 00:10:47
con lo cual 00:10:48
lo vamos a llamar 00:10:51
el boolean aprobado 00:10:53
los nombres de los boolean 00:10:54
que se correspondan con lo que expresan 00:10:56
aprobado true, aprobado false 00:10:58
Y tendrá que haber, igual que hay un next int para leer un entero, un next double para leer un decimal, seguramente haya un next boolean o algo parecido para leer un boolean. 00:10:59
Pues tiene toda la pinta de que lo hay porque lo he escrito y no me da error. 00:11:17
Tiene toda la pinta de que lo hay porque lo he escrito y no me da error. 00:11:22
Deduciéndolo por contexto de si next int es para leer un int, next double es para leer un double, porque next boolean es para leer un boolean. 00:11:27
vale, entonces 00:11:33
y ahora le tenemos que decir aquí 00:11:35
introduzca 00:11:38
true o false 00:11:39
en función de si has aprobado o no 00:11:40
vale, para 00:11:47
que se vea 00:11:51
como yo tengo el texto muy grande, voy a poner 00:11:53
voy a dividir el string en dos 00:11:55
concatenados para poder ponerlos en líneas 00:11:57
separadas 00:11:59
true o false 00:12:00
porque todavía no conocemos los multilíneas 00:12:02
En función de si has aprobado o no 00:12:09
Vale 00:12:21
Y ahora me decía simplemente que mostrara 00:12:23
El estudiante aprobado seguido de true o false 00:12:29
Que será seguido de la variable que yo he introducido 00:12:34
Aprobado 00:12:36
Seguido de esto 00:12:44
vale, pues este programa 00:12:47
nos vale única y exclusivamente 00:12:51
bueno, para 00:12:53
ver que yo puedo introducir 00:12:55
directamente true o false 00:12:57
por el teclado 00:12:59
vale 00:13:01
y ya está 00:13:02
y no tiene ningún interés 00:13:04
vamos a probarlo 00:13:07
a ver, ejecutar 00:13:09
introduzca 00:13:13
oh ya está 00:13:16
le introduzco true porque es un posible 00:13:20
valor de boolean y muy bien 00:13:21
le introduzco false 00:13:23
que es un posible valor de boolean 00:13:25
y muy bien, si le introduzco 00:13:27
cualquier otra cosa que no sea true o false 00:13:29
me dice, me has introducido 00:13:31
algo que no casa con el valor boolean 00:13:33
vale 00:13:35
nos podríamos plantear si es capaz 00:13:37
como otros lenguajes de programación 00:13:39
o otros contextos de programación 00:13:42
a transformar 00:13:43
el 0 a false y el 1 a true 00:13:45
que es como una especie de 00:13:48
convenio que se ha 00:13:49
usado muchas veces en programación 00:13:51
en lenguaje C, lenguaje Python 00:13:53
en muchos lenguajes como que se 00:13:55
ha usado un convenio de que el 0 00:13:57
es equivalente al false 00:13:59
y que un número diferente de 0 00:14:02
es equivalente al true 00:14:03
eso puede generar muchos efectos secundarios 00:14:04
porque 00:14:07
a lo mejor tú estás confundiendo sin querer 00:14:09
números con booleanos, entonces Java no permite 00:14:11
eso, pero vamos a probar 00:14:14
esto es por probar, no lo sé 00:14:15
si el next boolean 00:14:16
si el next boolean por lo que sea 00:14:19
este método tan raro 00:14:21
si es capaz cuando tú le introduces 0 00:14:23
asumir que estás metiendo false 00:14:25
y cuando le introduces otra cosa que no es 0 asumir que estás metiendo true 00:14:27
a lo mejor por compatibilidad 00:14:30
con otros lenguajes está programado 00:14:32
así esta función por dentro 00:14:34
está programado así 00:14:36
por curiosidad solo, vamos a probarlo 00:14:37
bueno 00:14:40
es java estricto 00:14:42
le tienes que introducir o true 00:14:43
o false 00:14:45
¿Vale? 00:14:46
Y no tiene ningún interés más 00:14:49
Este código 00:14:51
Bueno, si tiene el interés 00:14:52
El stream multilínea 00:14:56
¿Vale? 00:15:01
Que solamente afectos 00:15:03
De que quede bonito el código 00:15:05
Da igual 00:15:06
Yo aquí, por ejemplo 00:15:07
Como tengo la letra muy grande 00:15:08
En todo esto 00:15:09
Si yo ponía este stream todo seguido 00:15:10
Pues el código queda muy feo 00:15:13
Para quien lo abra 00:15:15
porque tiene que irse a la derecha con el cursor 00:15:16
para leer todo el mensaje 00:15:19
el que está revisando el código 00:15:20
pero luego cuando se ejecuta 00:15:22
que más da, que esté toda la línea entera 00:15:25
o no, pero para el que está mirando el código 00:15:27
que he hecho yo 00:15:29
pues si yo hubiera puesto estos dos seguido 00:15:30
pipipipipi, le obligo a 00:15:33
seguirlo, entonces 00:15:35
pues para que quede el código más legible 00:15:36
yo lo he concatenado 00:15:39
mediante dos partes distintas 00:15:42
He puesto dos partes y lo he concatenado con el más 00:15:45
Y así me he bajado esto debajo 00:15:48
Y se veía, ¿vale? 00:15:50
Entonces a veces ocurre eso, que tenemos textos muy largos 00:15:51
Para escribir dentro del código 00:15:54
Un stream muy largote 00:15:57
Y ese stream muy largote 00:15:58
Queda feo 00:16:00
Que a la máquina actual le da igual, la ejecución es de la misma 00:16:01
Pero queda feo 00:16:04
Entonces, o bien lo partimos así 00:16:05
O bien hay una cosa 00:16:08
Que está desde no sé qué versión de Java 00:16:10
Porque cada versión de Java se inventa alguna chorradita 00:16:12
pues para que parezca que los que 00:16:14
actualizan Java pues hacen algo 00:16:17
y una de esas chorraditas 00:16:19
es el string multilínea, que juraría que es 00:16:21
no estoy muy segura 00:16:23
empiezas el string con 3 comas 00:16:24
y entonces el ya interpreta 00:16:27
que el string no acaba 00:16:29
hasta que no has puesto otras 3 comas 00:16:31
o algo así 00:16:33
o tienes que poner algo antes o no sé qué 00:16:39
a ver vamos a 00:16:41
ver como era el string multilínea 00:16:47
stream multilínea 00:16:49
así como lo he puesto yo 00:16:57
tres comillas 00:17:09
y tres comillas 00:17:10
debe ser que no lo admite como parámetro 00:17:12
de una función 00:17:17
pero es así, lo que empieces en tres comillas 00:17:17
todo lo que viene después 00:17:21
se supone que forma parte 00:17:23
del mismo stream 00:17:25
no tienes que andar ahí concatenando 00:17:25
para saltarte a línea siguiente 00:17:28
ni nada de eso 00:17:30
Entonces 00:17:31
Aquí 00:17:32
A ver 00:17:34
Ah, vale 00:17:38
Porque debe ser que hay un salto de línea 00:17:41
O sea, que tienes que poner un salto de línea 00:17:44
Ahora sí que me lo ha cogido 00:17:45
Vamos a ver 00:17:47
Vale, debe ser que entre las primeras tres comillas 00:17:48
Y la primera línea 00:17:56
Hay que ponerle un salto de línea 00:17:57
¿Vale? 00:18:00
Bueno 00:18:03
Se podría recolocar para que quedara más bonito 00:18:03
Y aquí esto también 00:18:05
Vale 00:18:11
Pues nada, esta chorradita 00:18:14
Si tenemos que hacer un stream muy largo 00:18:15
Pues lo podemos hacer 00:18:18
En líneas separadas 00:18:20
Y no empieza y no acaba 00:18:21
Hasta estas tres comillas 00:18:24
Vale 00:18:26
Bueno, pues nada 00:18:26
Sin dudas, ni problemas 00:18:31
Pues siguiente 00:18:35
Cosa 00:18:38
Y ya descansamos un ratito antes de que sigáis 00:18:38
haciendo más ejercicio vosotros 00:18:44
cuatro 00:18:45
leer por teclado un entero 00:18:47
y luego mostrar 00:18:50
un mensaje seguido de true o false 00:18:51
en función de una condición 00:18:53
pues sabemos hacer condiciones 00:18:55
pues ya está, sabremos 00:18:57
hacer esto 00:18:59
ejercicio cuatro 00:19:00
vale, nos ha dicho 00:19:11
que hay que leer una edad por teclado 00:19:17
pues una edad 00:19:20
por teclado, ya sé que me va a obligar 00:19:21
a usar el escáner, pues ala 00:19:23
Ahí planto el escáner. 00:19:25
Vale. 00:19:27
Ahora, datos de entrada. 00:19:28
Un valor que va a ser una edad, solo uno. 00:19:31
Pues una única variable. 00:19:33
Vamos a darle un nombrecito explicativo. 00:19:36
Si va a guardar una edad, pues edad. 00:19:39
Vale. 00:19:41
Venga, este es el dato que vamos a leer por teclado. 00:19:42
Pues ya está. 00:19:45
Introduzca edad. 00:19:50
¿Cómo leemos del teclado? 00:19:52
pues ya sabemos, ya todo esto lo hacemos 00:19:54
de corrido porque ya lo sabemos de memoria 00:19:56
no tenemos ni que pensar 00:19:58
que leemos del teclado de esta manera 00:19:59
ya está, esa parte la tenemos 00:20:01
la parte de lectura 00:20:06
de datos es que esa ya la podemos hacer 00:20:08
de corrido, sabemos ya toda la parte de lectura 00:20:10
de datos, el escáner 00:20:12
y luego ya el método que sea 00:20:14
la variable declarada, poner mensajitos 00:20:15
para que quede feo, para que quede bonito 00:20:18
todo eso ya lo sabemos de corrido 00:20:20
y ahí no nos tenemos que detener más 00:20:22
vale, ahora vamos a ver que me pide el programa 00:20:23
pues el programa me pide 00:20:25
mostrar un mensajito 00:20:29
el estudiante 00:20:31
aprobado, seguido de algo 00:20:34
que sea true o false 00:20:36
en función de, ya veremos que 00:20:37
luego, mi programa 00:20:39
hará cosas 00:20:42
las que sean 00:20:44
hará cosas las que sean 00:20:45
pero yo sé 00:20:51
que al punto al que tengo que llegar 00:20:53
al punto al que tengo que llegar 00:20:55
es este 00:20:57
Eres mayor de edad, creo que era, si no da igual 00:20:57
Eres mayor de edad 00:21:02
Seguido de algo que sea true o false 00:21:07
Algo que es true o false, ¿qué es? 00:21:14
Una variable booleana 00:21:16
Entonces, pues debería yo tener una variable booleana 00:21:18
Que represente la condición de ser mayor edad 00:21:25
porque es lo que tengo que mostrar aquí después 00:21:29
tengo que mostrar algo que es true o false 00:21:32
algo que es true o false 00:21:35
es una variable booleana 00:21:36
pues tendré que tener una variable booleana 00:21:37
por aquí 00:21:40
para mostrar su contenido 00:21:41
boolean 00:21:44
mayor edad 00:21:46
vale 00:21:49
entonces esa variable 00:21:51
booleana lo ideal es 00:21:54
elegir un nombre que explique lo que representa 00:21:55
pues que va a representar true 00:21:57
si es mayor de edad, 00:21:59
false si no, porque es lo que acompaña 00:22:01
el mensaje. Bueno, pues 00:22:03
este es gran parte de mi 00:22:05
programa, casi todo. Tengo 00:22:07
que mostrar este texto 00:22:08
seguido de algo que sea true o false, 00:22:10
o lo que es lo mismo un boolean. 00:22:13
¿Vale? Pues a la siguiente pregunta, ¿y este 00:22:15
boolean cuándo va a ser 00:22:17
true y cuándo va a ser false? Esa es la 00:22:19
siguiente pregunta que me hago. 00:22:21
Pues vuelvo al enunciado y el enunciado 00:22:23
me dice 00:22:25
que sea true si tú eres mayor de edad, 00:22:26
¿Sabemos qué significa ser mayor de edad? 00:22:29
Sí, tener más de 18 00:22:31
Y falsa si no lo es 00:22:32
¿Vale? Pues entonces 00:22:34
Esta variable booleana tiene que ser true 00:22:36
Si edad es mayor o igual de 18 00:22:39
¿Vale? ¿Sabemos expresar eso en Java? 00:22:42
Que una variable contenga un valor mayor o igual que algo 00:22:47
Claro que sabemos expresarlo 00:22:50
Pues entonces esta variable booleana 00:22:51
Sabemos ya representarla perfectamente 00:22:54
¿Vale? Pero hemos ido interpretando 00:22:57
En nuestro propio lenguaje lo que me han pedido 00:23:03
Hemos partido 00:23:05
Del final, a ver 00:23:07
Tengo que mostrar 00:23:09
Esto, esto que va a ser 00:23:11
True, si soy mayor de edad 00:23:13
False, si no, ¿qué significa ser 00:23:15
Mayor de edad? 00:23:17
Que mi edad sea mayor o igual de 18 00:23:18
¿Sé expresar 00:23:21
Edad mayor o igual que 18 en Java? 00:23:22
Si, si me hubieran dicho, llueve 00:23:26
¿Y cómo expreso yo que llueve en Java? 00:23:27
No tengo ni idea 00:23:29
pero que una edad sea mayor o igual que 18 00:23:30
si sé expresarlo 00:23:32
pues que suerte, otra cosa no habría sabido 00:23:33
pero esto sí, pues que el contenido 00:23:36
de mi variable sea mayor o igual que 18 00:23:38
ahora ya 00:23:40
ejecutamos 00:23:42
este código, vamos a poner un espacio 00:23:45
para que no quede tan pegado 00:23:47
¿cuántos años tienes? 00:23:48
12, falso 00:23:53
no eres mayor de edad 00:23:55
¿cuántos años tienes? 00:23:56
34, true, eres mayor de edad 00:23:59
vale 00:24:01
no es un conjunto de pruebas muy amplio 00:24:02
como para concluir que el programa es válido 00:24:05
pero en este que son cuatro líneas 00:24:07
es sencillo, suponemos que sí 00:24:09
¿que podríamos habernos ahorrado 00:24:11
esta variable booleana 00:24:18
y poner esto directamente aquí? 00:24:18
pues claro 00:24:21
podríamos habernos ahorrado 00:24:21
esta variable boolean 00:24:25
y poner directamente ahí eso 00:24:27
pero igual lo hace más confuso 00:24:29
eso ya va en gustos 00:24:34
no pasa nada por usar variables 00:24:35
adicionales, si dejan las cosas 00:24:38
más claras, no pasa 00:24:40
nada, vale 00:24:42
yo lo puedo poner ahí, sí 00:24:43
pero cuidado, vale, cuidado 00:24:46
porque 00:24:48
esto 00:24:49
me interpreta la concatenación 00:24:51
de aquí, vale 00:24:54
y luego un string 00:24:56
mayor o igual que 18, no tiene sentido 00:24:58
entonces cuidado 00:25:00
cuidado y vamos a 00:25:01
vamos a usar 00:25:04
los paréntesis, que esto va junto 00:25:06
Cuidado 00:25:08
Cuando en una expresión mezclamos varios operadores 00:25:08
Cuidadín 00:25:12
Porque si la precedencia no está clara 00:25:14
O sea, si la precedencia es igual 00:25:15
Se puede hacer de izquierda a derecha 00:25:17
Bueno, yo quiero que se haga primero esto 00:25:19
Mayor o igual que 18, que me dará true o false 00:25:21
Y ahora concaténame esto con true 00:25:23
O con false, con lo que sea 00:25:25
Esto ya sea la concatenación de un string 00:25:27
Con lo que sea 00:25:29
¿Vale? 00:25:30
Pues de nuevo, cuidado con los paréntesis 00:25:33
¿Vale? 00:25:35
sin dudas 00:25:44
bueno 00:25:47
pues 00:25:54
trabajad 00:25:55
ahora vosotros un rato 00:25:59
los siguientes, que es un poco para 00:26:02
practicar lo mismo 00:26:05
vale, cuando ya empieza esto 00:26:05
de aquí no, vale 00:26:15
con esto no, pero todos estos 00:26:17
son para practicar un poco estas cositas básicas 00:26:19
del principio 00:26:21
pues venga 00:26:22
ponemos a los dos a practicar con esto 00:26:25
¡Gracias! 00:26:27
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
25 de septiembre de 2026 - 13:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 29″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
112.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid