Saltar navegación

20251020 ProgEstr-EjerDecision_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 20 de octubre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos con el 31, que es un poco así rarito, ¿verdad? 00:00:00
¿Alguno de vosotros lo ha hecho? 00:00:06
¿Has dado tiempo a hacerlo? 00:00:09
Vale. 00:00:11
¿Perdón? 00:00:13
¿Que deje el qué? 00:00:15
Vale, pero lo tienes en tu pantalla también. 00:00:18
Vale. 00:00:22
Bueno, entonces, primero lo de siempre es leerlo, 00:00:24
entender lo que hay que hacer, 00:00:28
y luego hacerse una primera composición del lugar en la cabeza. 00:00:29
Ahora mismo, como son IF y SWITCH y operador ternario, 00:00:32
lo que estamos haciendo, operador ternario y IF y SWITCH, 00:00:35
es decir, lógica booleana. 00:00:37
Sobre todo aquí la clave es encontrar cuántas ramas tiene mi programa 00:00:38
y fijar las condiciones para cada una de las ramas. 00:00:44
Es el único pensamiento lógico ahora mismo que estamos teniendo. 00:00:47
Darnos cuenta de que el enunciado que nos plantean 00:00:50
va a tener varias posibilidades de actuación 00:00:52
e identificar qué condición está asociada 00:00:55
a cada una de esas posibilidades de actuación 00:00:59
y luego ya plasmar eso en un código 00:01:00
que normalmente, pues, no se unir. 00:01:03
Si son dos posibilidades de actuación, 00:01:06
unif el save.pelota. 00:01:07
Si son varias, unif el save, el save, el save. 00:01:09
Y si son varias, dependiendo del valor de una variable, 00:01:13
pues, en lugar de unif el save, el save, 00:01:18
pues, un switch case que queda más claro. 00:01:20
De eso se trata. 00:01:22
Es el único pensamiento ahora que tenemos en la cabeza. 00:01:23
a eso y bueno, luego ya, claro, 00:01:25
manejar, tener claro el funcionamiento 00:01:27
de los tipos de datos, las variables 00:01:29
y todo eso. A ver, 00:01:30
tú me ibas a preguntar algo. 00:01:33
Ah, dime, dime. 00:01:35
¿El examen va a ser 00:01:36
con esa característica de PINODE, que era 00:01:38
la PINODE y era con ASPEN? 00:01:40
¿Va a aparecer eso o no? 00:01:44
No sé si se va a aparecer. 00:01:46
Hasta mañana por la mañana no lo sabré. 00:01:48
Pero no va a ser 00:01:51
difícil, no va a ser difícil, 00:01:52
no va a ser difícil 00:01:54
es un ejercicio más y ni siquiera 00:01:55
de los difíciles, hay de más fáciles 00:01:58
hay de más difíciles, pues ni siquiera de los difíciles 00:02:00
¿vale? pero no obsesionéis 00:02:02
tanto con el examen 00:02:04
¿cómo? 00:02:05
pues no lo sé 00:02:10
no sé, decirte 00:02:12
pues 00:02:13
todo puede ser fácil y difícil 00:02:15
o sea, si tú a largo lo llamas difícil 00:02:17
pues hombre, este es largo 00:02:19
porque tienes un montón de posibilidades 00:02:21
Si es 40, 50, 60 00:02:23
¿Vale? 00:02:24
Esto, sin embargo, pues sabiendo Arraiz 00:02:26
Y otras cosas, pues a lo mejor se queda más cortito 00:02:28
No lo sé 00:02:31
¿A ti te parece difícil? 00:02:33
Pregunto 00:02:36
Tú dirías que no 00:02:36
Pues entonces, maravilloso 00:02:38
No tienes por qué preocuparte 00:02:41
¿Vale? 00:02:43
Bueno, pues entonces, este programa 00:02:45
Con lo que sabemos ahora, se trata de 00:02:47
¿Cuántas posibilidades tengo? 00:02:49
hombre, pues a ver, como tener tengo un montón 00:02:51
tantas como números me hayan dado 00:02:53
¿no? desde el 0, 1, 2, 3 00:02:55
claro, entonces no puedo hacer un 00:02:57
sí, tendría siempre una opción 00:02:59
estupenda, que es hacer 00:03:01
un switch case con un 00:03:03
case que tenga 100 ramas 00:03:05
y sí, el programa 00:03:07
funciona, y desde luego 00:03:09
va a ser computacionalmente 00:03:11
niquelado 00:03:13
pero a nivel de código pesadísimo 00:03:14
¿vale? a nivel de código muy pesado 00:03:17
entonces, entendéis que con un switch case 00:03:18
a lo que me refiero, ¿no? sería case 0, 0 00:03:21
case 1, 1, case 2, 2 00:03:23
¿vale? pues si uno tiene la paciencia de escribirlo así 00:03:25
pues el programa está estupendamente hecho y va a pasar 00:03:27
toda la fase de pruebas 00:03:29
la va a pasar con una nota muy alta 00:03:31
porque computacionalmente va a tener muy poco coste 00:03:33
¿vale? en cuanto lleguemos al case 00:03:35
listo, pero 00:03:37
a nivel de elegibilidad de código 00:03:39
pues un poco pesado, un poco largo 00:03:41
y sobre todo vamos a practicarlo 00:03:42
a plantearlo de otra manera en la que podamos 00:03:44
practicar un poco más 00:03:47
entonces 00:03:48
aquí imagino lo que habéis pensado 00:03:49
lo que lo habéis abordado es 00:03:52
bueno, puedo dividirlo al menos 00:03:54
subramas, o sea la rama 00:03:59
de si es 00:04:02
el 20, bueno 00:04:04
por ejemplo la rama de todos los 50 00:04:06
pues todos empiezan igual 00:04:08
50 y, 50 y 00:04:10
entonces todo eso lo puede meter en una sola rama 00:04:12
que es cuando tenga una cifra 00:04:14
decimal 5 00:04:16
sé que va a funcionar como 50i 00:04:17
y el otro concatenado con lo que sea 00:04:20
vale, si es un 1, pues 1 00:04:22
entonces, puedo hacerlo con ramas y subramas 00:04:24
vale, englobando 00:04:27
en función de la decena 00:04:28
en la que esté, en función de la decena 00:04:30
actúo de una manera 00:04:32
entonces, si yo trabajo en función 00:04:34
de la decena, ya lo he reducido 00:04:36
a 10 posibilidades 00:04:38
al menos, ya un switch case con 10 00:04:40
posibilidades, ya es un switch case 00:04:42
muy manejable, un switch case con 10 00:04:44
posibilidades podemos necesitarlo 00:04:46
muy a menudo. Entonces, 00:04:48
si lo rebajamos a la decena, 00:04:50
ya tenemos un switch case de 10 posibilidades. 00:04:52
Y ahora ya sí, dentro 00:04:55
de ese case, pues ahora 00:04:56
tendré que distinguir 00:04:58
si la unidad es 1, 00:05:00
es 2, es 3. 00:05:02
Ese podría ser el primer planteamiento. 00:05:04
Vamos a reducirlo a 00:05:06
10 caminos basándonos 00:05:08
en la decena, y luego 00:05:10
ya a partir de ahí seguimos trabajando. 00:05:12
Es lo primero que se nos ocurriría. 00:05:14
Entonces si lo planteamos así tenemos que sacar la decena y la unidad, claro, pero eso ya sabemos hacerlo porque recordad que siempre todos los problemas nos apoyamos en cosas que ya hemos resuelto y que como ya la hemos resuelto pues ya la tenemos en la cabeza, entonces ya hemos resuelto sacar decenas, centenas, unidades y podríamos resolver sacar unidades de millar, decenas de millar, 00:05:16
Pero como eso ya se debería hacer en un bucle 00:05:39
Para que no se haga muy pesado 00:05:42
Pues ya lo haremos cuando veamos el bucle 00:05:43
Bueno, pues nos apoyamos en esa situación 00:05:45
De sacar la decena y la centena 00:05:48
Y la unidad que ya hemos resuelto 00:05:51
Y empezamos a trabajar así 00:05:53
¿Vale? 00:05:54
Imagino que es como lo habéis planteado, ¿no? 00:05:55
Pues entonces 00:06:00
Aquí 00:06:01
Como tenemos que leer el numerito 00:06:02
Vale 00:06:06
Pues nada 00:06:26
un numerito 00:06:28
a ver, otra cosa os digo 00:06:31
también de cara a mañana 00:06:42
si alguien 00:06:43
se atasca por algo que tiene que tener 00:06:46
en la cabeza, eso también es 00:06:47
un problema, por ejemplo 00:06:49
uy, es que no me acuerdo 00:06:51
de escribir esto 00:06:53
y es que es una chorrada 00:06:55
es una chorrada 00:06:57
por esto no me puede girar, pues sí 00:06:59
porque esto 00:07:02
son cosas básicas, uno no puede fallar 00:07:03
temas básicos de memoria o de habilidad 00:07:06
para ver cómo sacarlo si no se acuerda 00:07:08
hay un montón de habilidades 00:07:09
que uno tiene que tener frescas y 00:07:11
trabajadas si quiere ser programador 00:07:13
entonces, es que no me he acordado 00:07:15
de esto, por esto no puede ser que 00:07:17
sí, porque que tú te acuerdes 00:07:19
de las cosas, es algo básico 00:07:22
si quieres ser desarrollador 00:07:24
otra cosa es que bueno, que yo que sé 00:07:25
que 00:07:27
que haya una chorrada 00:07:28
que claramente, pues porque sea 00:07:32
traspapelada la de escribir, pues falta un punto y coma 00:07:34
pues si no funciona 00:07:36
ese tipo de chorradas, pues hay algunas que se 00:07:37
asocian claramente 00:07:40
pero porque no recordéis las cosas 00:07:41
eso sí lo tengo 00:07:44
muy en cuenta, la memoria es fundamental 00:07:46
¿vale? 00:07:48
pues hala 00:07:52
un numerito que asumimos que es de dos 00:07:53
cifras, de 0 a 99 00:07:55
bueno, de 1 a 2 cifras 00:07:57
de verdad que el ruido 00:07:58
de fondo me hace desvariar 00:08:01
y no saber lo que digo 00:08:03
Pues venga 00:08:05
Las unidades sabemos como sacarlas 00:08:12
Que es el resto de dividir el número 00:08:17
Entre 10 00:08:19
Si el número tiene dos cifras 00:08:21
El resto de dividirlo entre 10 00:08:24
Serán las unidades 00:08:27
Si el número está entre 0 y 9 00:08:28
Es decir, solo tiene una cifra 00:08:31
También me da las unidades 00:08:33
Por ejemplo, el resto de dividir 00:08:36
3 entre 10 es 3 00:08:38
Las unidades 00:08:39
el resto de dividir, 5 entre 10 es 5 00:08:40
las unidades, luego 00:08:42
para el subcaso de que el número 00:08:44
tenga solo una cifra, es decir, de 0 a 9 00:08:46
también 00:08:48
este operador resto me devolvería 00:08:49
las unidades, que serían el propio número 00:08:52
claro, y ahora 00:08:54
las decenas 00:08:56
las decenas 00:08:58
serían el cociente de dividirlo 00:09:00
entre 10 00:09:03
si el número 00:09:04
está entre 10 y 99, está claro 00:09:06
que me da las decenas 00:09:08
Y si el número está entre 0 y 9, que son los casos raros, pues también me da las decenas, porque me daría 0 el cociente, que es justo, decenas 0. 00:09:10
Entonces, cuando uno hace un programa general, pues normalmente uno lo piensa para los casos estándar. 00:09:22
En este caso, si uno está pensando en unidades y decenas, pues uno ya inconscientemente piensa en números de dos cifras. 00:09:29
Pero 00:09:36
Uno tiene que situarse 00:09:38
También lo que llamamos 00:09:40
En teoría 00:09:42
De pruebas 00:09:44
Los casos raros 00:09:46
¿Vale? Y los casos raros 00:09:47
En este caso serían 00:09:50
Uy, es en el que inconscientemente me estoy poniendo 00:09:51
En el que no tiene decenas 00:09:55
¿En el que no tiene decenas todavía funciona? Pues sí 00:09:55
Sí me funciona 00:09:58
Pues venga, y ahora ya 00:09:59
Podemos hacer nuestra primera 00:10:03
caja gorda con subcajitas 00:10:06
y esa caja gorda 00:10:08
con subcajitas la podemos ir completando 00:10:10
y esa caja gorda 00:10:12
ya hemos dicho que puede ser un switch 00:10:14
que se base en las decenas 00:10:16
porque es el primer planteamiento 00:10:18
que nos hemos hecho, yo voy a reducir 00:10:20
en lugar de las 100 ramas 00:10:22
que tengo, voy a reducir a 10 00:10:24
basado en las decenas, ya tengo una 00:10:26
primer esqueleto 00:10:28
una primera estructura y a partir de ahí 00:10:30
podemos ir refinando y ir llenando 00:10:32
las cajas, que una vez tenemos 00:10:34
una versión digo, ojo, pero si esto lo podía hacer 00:10:36
más fácil así, puedo quitar esto, puedo meter 00:10:38
esto aquí, puedo hacer, pues ya está 00:10:40
vamos iterando y nos vamos dando cuenta 00:10:41
anda, pero esto lo puedo meter aquí, pues venga, lo meto 00:10:43
pero idealmente, una vez que uno tiene 00:10:45
la cabeza, su composición del lugar 00:10:48
sobre por donde van a ir los tiros 00:10:50
pues se hace su arquitectura 00:10:51
su esqueleto con sus cajitas negras 00:10:54
y luego va rellenando 00:10:56
pues aquí ese primer esqueleto nuestro 00:10:57
sería el switch case 00:11:00
un switch 00:11:01
Basado en las decenas 00:11:04
Y ahora ya pues tenemos 00:11:05
Tantos casos como decenas 00:11:10
Uy, perdón 00:11:12
Que he puesto punto y coma en vez de dos puntos 00:11:24
Vale 00:11:26
1, 2, 3, 4, 5 00:11:27
1, 2, 3 00:11:38
1, 2, bueno lo voy poniendo así 00:11:46
Y así sé rápidamente cuando he terminado 00:11:49
Caso 1 00:11:51
Caso 2 00:11:53
Y me faltaba el 9 00:12:02
Vale, pues este ya es 00:12:20
Un primer esqueleto con el que podemos 00:12:33
Empezar a trabajar 00:12:35
¿Vale? 00:12:36
Los casos 0 y 1 00:12:41
Son los más raros 00:12:43
Porque no siguen un patrón 00:12:44
No es 11, 12, 13 00:12:46
No siguen un patrón 00:12:49
De 2 hasta 9 son casos más 00:12:50
Más 00:12:53
Sencillos 00:12:55
Entonces nuestro resultado va a ser 00:12:58
Mostrar una cadena, ¿verdad? 00:13:00
Pues entonces, nuestro resultado, que sea este, el result. 00:13:02
Ahora, nos vamos al 2 directamente. 00:13:06
El result sabemos que será algo como esto. 00:13:09
Será algo como esto, pero lo que irá detrás será 1, 2, 3, 4, 5, 6, 7, 8, 9, en función de la otra. 00:13:30
¿Verdad? 00:13:40
Entonces, ahora ya sí que, perdón que no lo he repetido, es que se me había puesto el switch. 00:13:44
Unidades 00:14:26
Ahora lo mostramos entero 00:14:26
Claro, ahora lo mostramos entero 00:14:43
Dentro del 00:14:57
Estamos haciendo los 20 00:14:59
7, 8 00:15:00
Me faltaría el 9 00:15:12
Y si no es ninguno de los anteriores 00:15:13
Que si no es ninguno de los anteriores sería el 0 00:15:20
Vale, entonces 00:15:22
Dentro de mi case este de aquí 00:15:25
este 00:15:28
cierra aquí 00:15:30
vale, entonces 00:15:32
dentro del caso 2 00:15:38
sé que el texto va a empezar con 20 00:15:39
y luego a result le tendré 00:15:42
que concatenar 1 o 2 00:15:44
o 3 o 4, no lo sé 00:15:46
dependiendo de cuáles sean las 00:15:48
unidades 00:15:50
entonces, pues yo dentro 00:15:51
de aquí puedo poner 00:15:54
todo el bloque de sentencias que yo quiera y necesite 00:15:56
todo el que a mí me dé la gana puedo poner 00:15:58
Pues en particular voy a poner 00:16:00
Primero el prefijo del numerito 00:16:02
Primero el prefijo, que es 20 00:16:05
Y luego, ¿qué voy a hacer? 00:16:06
Pues no lo sé, le tendré que concatenar con 1, con 2 o con 3 00:16:08
No lo sé qué hacer 00:16:11
¿Vale? Pues 00:16:12
De nuevo tendré que abrir ahí 00:16:14
Las ramas correspondientes, tantas como 00:16:16
Posibles unidades 00:16:18
¿Vale? 00:16:20
Si las unidades son 1 00:16:32
A mi resultado le concateno el 1 00:16:34
y lo vuelvo a asignar 00:16:37
al resultado 00:16:40
y lo mismo con lo demás 00:16:41
porque a lo que tenía 00:16:44
result de antes, que es a 20 00:17:14
result ya tenía un valor de antes 00:17:16
entonces le concatenas 00:17:18
lo nuevo 00:17:20
y el resultado se lo vuelves a asignar 00:17:21
a result para que sobrescriba lo que tenía 00:17:24
que eso es lo que hace el max igual 00:17:26
el max igual resulta que 00:17:28
acuérdate que lo que hace es como si el igual no existiera 00:17:29
entonces te concatena result 00:17:32
que en este caso es 20 00:17:34
con lo que tú le digas 00:17:35
y ahora, ¿dónde te lo asigna? 00:17:38
te lo asigna a la variable 00:17:40
que esté puesta aquí 00:17:42
entonces 00:17:44
esto es lo mismo, claro, esto es lo mismo 00:17:46
que hacer result igual 00:17:48
lo pongo abajo 00:17:50
esta sentencia de arriba 00:17:51
sería lo mismo que hacer esta 00:17:53
result más 00:17:55
¿Vale? Sería lo mismo que esta de aquí 00:18:00
Serían iguales esta sentencia 00:18:03
Al result 00:18:08
Que era 20 00:18:10
Le concatenas en este caso 1 00:18:12
Porque son 1 y que haces con ese 21 00:18:14
Se lo asignas a result 00:18:16
Para que pise el valor que tenía 00:18:18
Y ese ya será lo que tú muestres 00:18:20
Pero lo mostramos al final 00:18:22
Ya del switch case, claro 00:18:24
Vale, entonces me da igual poner esto 00:18:25
Que poner result más igual 1 00:18:28
Es el mismo operador 00:18:29
3, 4, 5 00:18:30
y en el caso de que las 00:18:59
unidades no sean 00:19:00
del 1 al 9, sino que sea 0 00:19:02
result debería ser 20 00:19:04
no 20, que se queda un poco feo 00:19:07
pues ese sería el caso del default 00:19:08
el default es si no es ni 1, ni 2, ni 3 00:19:10
Pues en el caso del default 00:19:13
Result igual a 20 00:19:15
Y ya está 00:19:17
Entonces el caso 2 00:19:20
Ya está 00:19:23
El default es 00:19:24
Si no ha entrado en ninguno de los case anteriores 00:19:26
Es porque son 0 00:19:28
Las unidades si son 0 00:19:30
Result será 20 00:19:31
Claro el default es 00:19:33
Como un else 00:19:36
Si no has entrado en ninguna de las anteriores 00:19:37
Entras aquí 00:19:40
Entras ahí 00:19:41
vale, bueno pues entonces 00:19:43
hemos podido hacer este ejercicio 00:19:49
primero recopilando un poco 00:19:51
estamos pudiendo 00:19:52
hacer este ejercicio con switch case 00:19:55
¿por qué? porque todas las 00:19:57
ramas de actuación dependen 00:19:59
del valor de una variable 00:20:01
en este caso las unidades 00:20:02
o las decenas, entonces cuando todas 00:20:04
las ramas de actuación dependen del valor de una 00:20:07
variable, el switch case 00:20:09
queda muy bien y pega muy bien 00:20:11
eso por un lado 00:20:13
Segunda cosa 00:20:15
Dentro de cada una de mis ramas del switch 00:20:17
Es decir 00:20:20
Dentro de cada case 00:20:22
Yo ahí meto todas las sentencias de código 00:20:23
Que necesite, todas las que quiera 00:20:26
Aquí he necesitado un montón 00:20:28
Estoy en el que he hecho es el 2 00:20:29
El 2 es el que he hecho, pues he necesitado muchas 00:20:31
He necesitado primero 00:20:34
Aquí, perdón 00:20:36
No lo encontraba 00:20:42
En el caso 2 de las decenas 00:20:43
en el caso 2, pues necesito 00:20:45
meter dentro un montón de cosas, primero 00:20:48
darle el prefijo al resultado 00:20:49
y ahora en función 00:20:51
de las unidades 00:20:53
concatenar con lo que toque 00:20:54
si las unidades 00:20:58
no son ni 1, ni 2 00:21:02
ni 3, ni hasta 9 00:21:04
pues entrará aquí que será 20 00:21:06
y ahora esto mismo, tal cual 00:21:07
lo podríamos copiar y pegar 00:21:11
que no lo voy a hacer para que no sea pesado 00:21:13
en el 30, 40, 50, hasta el 90 00:21:15
porque todos funcionan igual 00:21:17
Entonces el 0 y el 1 00:21:18
Pues aquí hay que distinguir más casos 00:21:21
Pero es lo mismo 00:21:23
El caso de que las decenas sean 0 00:21:23
Pues entonces 00:21:27
Si es 1, 1 00:21:29
Si es 2, 2, es que no hay otra 00:21:30
Habría que distinguir de nuevo otras 10 ramas 00:21:32
Con un switch case 00:21:35
Y sería copiar y pegar y simplemente cambiar el 20 00:21:35
Claro, en el resto 00:21:38
Cambiar el 20 por lo que toque y lo demás 00:21:41
Copiar y pegar 00:21:42
Y aquí en este de que las decenas sean 0 00:21:43
Sería copiar y pegar este directamente 00:21:47
Porque en función de las unidades 00:21:49
Es o uno o dos o tres 00:21:50
Copiar y pegar este switch 00:21:51
El result nada 00:21:53
¿Vale? 00:21:54
En el caso de que sea uno 00:21:59
Aquí 00:22:00
Vamos a 00:22:02
Voy a copiar y pegar el del cero 00:22:04
Porque va a surgir un error 00:22:06
Que quiero que 00:22:08
El del cero 00:22:09
Vamos a hacer ese 00:22:10
Repito 00:22:11
Del tres hacia adelante 00:22:12
Serían calcados como el de arriba 00:22:13
Cambiando el veinte por treinta y 00:22:15
Treinta y uno 00:22:17
Cambiando el cuarenta 00:22:18
Por 40 y vale 00:22:19
Del 3 al 9 serían calcados al 20 00:22:21
Pero cambiando solo 00:22:24
El 20 por 40 y 00:22:25
50 y lo que sea ya está 00:22:27
El 0 y el 1 serían más especiales 00:22:29
El 0 00:22:31
Sería esto de aquí 00:22:32
Simplemente voy a copiar 00:22:35
Y pegar este switch 00:22:38
Vale en el 0 00:22:40
Las decenas son 0 00:22:47
Luego aquí el resultado se basa 00:22:49
En las unidades si es 1 o 1 00:22:51
Si es 2, 2 00:22:53
Si es 3, 3 00:22:54
Contempla el ejercicio que podamos meter el 0 00:22:55
Para que diga 0 00:22:59
Sí, pues entonces 00:23:01
Aquí el default 00:23:03
Es cuando es 0 00:23:04
Y entonces aquí en lugar de 20 tendríamos que poner 0 00:23:06
Claro 00:23:08
Y el número es como el 3 00:23:09
El 15 00:23:13
Ese serían las decenas 1 00:23:13
Que ahora las hacemos 00:23:16
Claro 00:23:17
Vamos al 0 primero porque quería yo provocar 00:23:19
este error, entonces en el caso 00:23:23
de que las decenas sean cero, aquí es un único switch 00:23:25
case en el cual el resultado se basa 00:23:27
en función de las unidades, o es uno o es dos 00:23:29
pero claro, si 00:23:31
hacemos esto, copiamos y pegamos esto 00:23:33
aquí me sale un rojo 00:23:35
de compilación 00:23:36
¿por qué creéis que me sale este error 00:23:38
de compilación? 00:23:41
claro, porque yo 00:23:43
he copiado y pegado y esta sentencia 00:23:45
que dice tal cual, a lo que tuviera 00:23:47
result, concaténale 00:23:49
uno y eso se lo asignas 00:23:51
a result, entonces 00:23:53
él me dice, ¿y qué tiene result? me voy 00:23:55
arriba, result no tiene nada 00:23:57
entonces él no puede hacer 00:23:59
esa sentencia de asignación 00:24:01
porque para hacerla 00:24:03
result tendría que tener algo, ¿verdad? 00:24:04
porque recordad que esta 00:24:08
sentencia de aquí es igual que esta de abajo 00:24:09
es la misma, entonces para 00:24:11
que la máquina virtual pueda ejecutar 00:24:13
esto, todos los operandos 00:24:15
todos tienen que tener valor 00:24:18
si no lo tiene, el compilador ya me dice 00:24:19
no, no, no, uno de los operandos no tiene valor 00:24:21
lo siento, este lo tiene 00:24:23
porque es la propia cadena 1 00:24:25
y result, pues él se va a mirar hacia 00:24:26
atrás, qué valor tiene 00:24:29
para tomarlo, para hacer la operación 00:24:31
y se da cuenta de que no tiene ninguno 00:24:33
por eso me dice, perdona, pero esta operación 00:24:34
no puedo hacerla 00:24:37
vale, aquí tenemos dos formas de arreglarlo 00:24:38
una, darnos cuenta 00:24:42
de que aquí yo no quiero concatenar lo anterior 00:24:43
por aquí no hay un 20, no hay un 30 00:24:45
No quiero concatenar, aquí yo lo que quiero es asignar 00:24:47
Directamente, entonces le quito el más 00:24:49
¿Vale? Yo lo que quiero es asignar 00:24:51
Entonces aquí le quitaría 00:24:53
El más y ya está 00:24:57
Pero no pueden poner el string 00:25:01
Por su 00:25:11
Igual comita 00:25:12
Sí, esa era la segunda 00:25:14
Solución que iba a decir, vale 00:25:16
Esto sería una opción, asignarlo 00:25:18
Y ya está, vale 00:25:21
Pero que por alguna razón, vete a saber 00:25:21
Puede ser que este código lo tengamos 00:25:24
en una función aparte, aunque ahora todavía no sabemos 00:25:26
hacerlo, imaginaos que yo 00:25:28
este código por lo que sea no lo puedo 00:25:30
cambiar, esta parte no la puedo 00:25:32
cambiar, porque tiene que ser 00:25:34
igual de esta de aquí abajo, porque se hace 00:25:36
llamando una función aparte y entonces 00:25:38
si se hace llamando una función aparte 00:25:40
esa función tiene el más igual y 00:25:42
no lo puedo tocar, imaginaos 00:25:44
que por la razón que sea yo esto 00:25:46
de aquí no lo puedo tocar 00:25:48
pues como podemos arreglarlo 00:25:50
pues efectivamente lo que decía él 00:25:52
inicializarlo a la 00:25:54
cadena vacía, entonces 00:25:56
si lo inicializamos a la cadena vacía 00:25:58
ahora ya result 00:26:01
más 1 será cadena 00:26:04
vacía más 1, que será 1 00:26:06
y ahora ese 1 ya va a result 00:26:08
otra vez, vale 00:26:11
entonces de nuevo 00:26:12
importante 00:26:14
que sigamos 00:26:19
teniendo claro 00:26:21
que 00:26:22
cuando 00:26:25
ponemos una expresión 00:26:27
para asignarla a una variable 00:26:28
todos los operandos de esa expresión 00:26:31
todos tienen que tener un valor 00:26:33
asignado, todos 00:26:35
la máquina virtual nunca va a tomar uno por defecto 00:26:36
ni nada, nunca, todos tienen que tener un valor 00:26:39
y ya el compilador 00:26:41
se encarga, yendo hacia arriba 00:26:43
de mirar que valor es, a ver si realmente 00:26:45
lo tiene 00:26:47
si ve que no tiene un valor 00:26:47
pues te va a avisar 00:26:50
de que lo siento, no puedes seguir 00:26:52
hay un error de compilación porque 00:26:54
alguno de los operandos no tiene valor 00:26:56
entonces una vez 00:26:58
perdón, una vez que identificamos 00:27:02
de donde viene el error, que es que alguno de los operandos 00:27:04
no tiene valor, lo solucionamos 00:27:06
pues como veamos que tiene coherencia a solucionarlo 00:27:08
¿vale? 00:27:10
o sea, pero eso solo pasa 00:27:11
si yo declaro la variable 00:27:13
y luego la uso 00:27:16
claro, claro, claro, si yo declaro esta variable 00:27:16
por ejemplo, antes de tener esto 00:27:20
de aquí, antes de tener este código 00:27:22
o sea, si la variable no está usada 00:27:24
en ningún momento, no te va a dar error 00:27:29
claro, pero porque con el if 00:27:31
abres el compilador 00:27:47
no interpreta realmente 00:27:48
un caso real de lo que va a ocurrir 00:27:51
el compilador sirve de unas reglas sintácticas 00:27:52
y él cuando ve un if 00:27:55
él dice, esta rama 00:27:56
puede que se haga, puede que no 00:27:58
a lo mejor tú sabes por tu 00:28:01
programa que siempre se va a hacer 00:28:02
en ciertos casos y siempre se va a inicializar la variable 00:28:04
pero él ve un if y dice 00:28:06
esto yo no cuento con que se haga 00:28:08
entonces como no cuenta con que se haga 00:28:10
no cuenta con que la variable vaya a tener valor siempre 00:28:12
el compilador sigue reglas 00:28:14
sintácticas fijas y aunque tú 00:28:16
sepas que tu programa va a funcionar porque siempre 00:28:18
entra en ese if una primera vez 00:28:21
con lo cual se inicializa la variable 00:28:22
el compilador eso yo no lo tiene en cuenta 00:28:23
Bueno, declararla antes de usarla siempre 00:28:26
O sea, declararla es decidir su nombre 00:28:31
Y su tipo de dato, esto es declararla 00:28:34
Y luego ya inicializarla 00:28:35
Es darle un valor 00:28:38
Siempre habrá que darle un valor 00:28:39
Fuera de todo if 00:28:41
Si en alguna parte de tu código la usas 00:28:43
Aunque luego ese valor se pise 00:28:45
Y no valga para nada 00:28:47
En este caso es que este valor 00:28:49
No lo queremos, pues vacío 00:28:51
Para que la concatenación se concatene sobre el vacío 00:28:53
Bueno, vale, vale, entonces ahora este más igual y ahora el 0, el 0 es más rollo, porque claro, perdón, el 1, el 1, el 0 es el que acabamos de hacer, el 1 es más rollo, ¿vale? 00:28:55
Porque 11, 12, 13, 14, 15 van por libre y luego los otros ya van juntos, entonces esto se podría hacer por libre en el caso de que las decenas de unidades sean 0 y ahora vamos a ver cuantas llevo, en el caso de que las unidades sean 0, 00:29:14
Uno, dos 00:30:26
Tres 00:30:29
Cuatro 00:30:36
Cinco 00:30:38
Seis 00:30:40
Siete, ocho y nueve 00:30:43
Me faltan tres 00:30:45
Nueve, cinco, seis 00:30:46
Siete 00:30:55
Ocho 00:30:57
Y nueve 00:30:59
Vale, en el caso de que sean cero, uno, dos 00:31:00
Esas van por libre 00:31:03
Entonces en este caso 00:31:04
Result será igual a 00:31:06
Ay, perdón, que estoy en el 00:31:19
Perdón, sí, sí, sí, jolines 00:31:27
Estoy siempre 00:31:29
12, 13 00:31:35
Y 15, y ya acabamos con los que van por libre 00:31:59
Vale, entonces 00:32:13
los demás, 16, 17, 18 00:32:21
y 19, eso si sigue en un patrón 00:32:23
que es el 10 00:32:26
¿vale? entonces 00:32:27
se puede sacar 00:32:31
result a 10 y antes 00:32:35
y luego concatenar 00:32:37
pero la verdad es que teniendo en cuenta que los keys ya los 00:32:38
hemos sacado, o se puede poner directamente 00:32:41
result 16, 17, tampoco ganamos 00:32:43
¿vale? 00:32:45
entonces, haciéndolo así directamente 00:32:51
a mano, nos quedaría la primera versión 00:32:52
Versión que luego 00:32:55
Seguro que se puede retocar 00:32:57
Para compactar a lo mejor alguna otra cosa 00:32:59
Vale, pues a falta de completar los 00:33:23
30, 40, que eso sí que sería un compi 00:33:34
Y pega, tendríamos la primera versión 00:33:36
Que uno podría hacer unas primeras pruebas 00:33:38
Vamos a hacer alguna prueba 00:33:41
Sin darle números mayor de 20 00:33:42
Porque esos no los hemos puesto 00:33:44
Vale, pues le damos 00:33:45
Uy, el 1 00:33:54
Ah, que no he puesto el mostrar claro 00:33:56
He hecho el result 00:34:01
Pero luego me falta cuando el programa termina 00:34:02
Que termina aquí 00:34:04
Me falta mostrar el resultado 00:34:05
Al final de todo, claro 00:34:09
He construido el resultado, lo he construido 00:34:10
Con todos esos switch case, lo he construido 00:34:12
Pero no he mostrado, efectivamente 00:34:14
Vale, pues le damos el 1 00:34:15
Y el 1 00:34:18
Le damos el 14 00:34:19
Y el 14 00:34:23
Le damos el 27 00:34:24
Y el 27 00:34:27
Le damos el 20 00:34:28
Y el 20 00:34:31
Bueno, funciona 00:34:32
En una primera versión 00:34:34
Efectivamente muy larga 00:34:37
Pero 00:34:39
Pero esto 00:34:41
Podríamos 00:34:49
Ahora que ya más o menos 00:34:51
Tenemos una primera versión 00:34:53
Que ya hemos entendido lo que hay que hacer 00:34:55
Aquí una vez que uno ve todo esto 00:34:56
Aquí 00:34:59
Lo que pasa es que ves todas esas copias y pegas 00:35:00
Estamos viendo 00:35:03
Que los casos 1 00:35:05
De todos los 20 00:35:07
hacia arriba y los casos 00:35:10
2 de todos los 20 hacia arriba 00:35:12
son iguales, que es concatenar 00:35:14
con esto dependiendo de las unidades 00:35:16
entonces, no podríamos reducirlo 00:35:17
haciendo 00:35:20
una segunda variable 00:35:22
result 2 00:35:23
esa segunda variable 00:35:25
darle 1, 2 00:35:27
o 3 en función de las unidades 00:35:30
y ahora a 20 concatenarlo 00:35:31
con lo que tenga esa segunda variable 00:35:34
por ejemplo 00:35:36
¿no? 00:35:36
no me lo habéis dicho ninguno 00:35:39
según lo íbamos haciendo 00:35:40
lo he hecho como acabo de decir 00:35:43
claro 00:35:47
claro 00:35:48
vale 00:35:50
así 00:35:53
así hemos trabajado 00:35:55
pues hemos 00:35:58
hemos pensado lo que tenemos que hacer 00:35:59
y nos hemos puesto a hacerlo 00:36:02
pipi pipi pipi 00:36:03
lo hemos completado 00:36:04
y ya está 00:36:05
y nuestra versión funciona 00:36:06
y no pasa nada 00:36:07
y tiene un código muy largo pero funciona 00:36:08
pero luego 00:36:09
pues uno puede refinar, ir pensando 00:36:11
y se dando cuenta de las cosas 00:36:14
y aquí en realidad para todos los 00:36:15
casos 2 en adelante 00:36:18
se trata de a 20 concatenarle 00:36:19
la misma variable 00:36:22
en todos los casos dependiendo de 00:36:24
entonces 00:36:26
podemos hacernos un prefijo 00:36:27
y un posfijo, por ejemplo 00:36:30
una variable que sea el prefijo y otra que sea el posfijo 00:36:31
y en función de las decenas 00:36:34
unidades, pues concatenar el prefijo 00:36:36
al posfijo y no tenemos que estar todo el rato 00:36:38
con estos keys de aquí 00:36:40
¿vale? vamos a 00:36:41
parar un momentito 00:36:44
el resultado 00:36:45
es cuando ya hemos acabado todo 00:36:50
todo enterito, o sea el switch 00:36:54
gordote 00:36:55
cuando este switch 00:36:56
gordote ha terminado, que es aquí 00:37:00
ya el result está 00:37:02
podría no estar inicializada 00:37:05
pues porque 00:37:11
revisa tus ramas 00:37:12
si en todas las ramas 00:37:14
le has dado valor 00:37:17
en todas 00:37:18
pues si uno no tiene valor 00:37:19
tendrás que inicializarlo arriba 00:37:22
claro porque la máquina 00:37:24
el compilador dice 00:37:30
podrías no entrar en alguna rama 00:37:32
entonces si no entras en alguna rama 00:37:34
yo tengo que usar el valor por defecto 00:37:35
vale entonces vamos a 00:37:37
Sí. 00:37:39
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:
4
Fecha:
20 de octubre de 2025 - 17:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
144.51 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid