Saltar navegación

20251201 ExamenSol_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 3 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues ¿qué es lo primero que hemos dicho después del ejercicio? Pues vamos a leer un número validando. Pues nada, ahí ya sabemos cómo hacerlo. Lo podéis haber organizado de muchas maneras, pero si este es el numerito que yo voy a leer, por ejemplo n, pues esto es una forma muy cómoda de hacerlo. 00:00:00
Mientras n, siendo n el resultado de leer por teclado un numerito entero, sea menor o igual que 1, 00:00:23
necesitábamos que fuera mayor que 1, entonces el número no va a valer. 00:00:37
Pues tienes que, ahí podríamos hasta dejarlo vacío, pero entonces, hombre, se queda sin mensaje. 00:00:45
Introduzca número. 00:00:54
este mensajito, mejor también 00:00:55
si lo ponemos fuera, porque si no para la primera 00:00:58
lectura 00:01:00
se queda ahí, vale 00:01:00
este me sobra 00:01:03
vale, pues ya está 00:01:06
entonces que nos acongoja 00:01:08
un poco lo de 00:01:11
en la expresión n menor o igual que 00:01:12
1 a la vez que hago la expresión 00:01:15
n menor o igual que 1 a la vez 00:01:17
asignar un valor 00:01:19
bueno, pues leemos el primer valor fuera 00:01:20
y no pasa nada, lo leemos fuera una primera 00:01:23
vez 00:01:25
Esto es lo más cómodo en realidad para escribir de código 00:01:26
Pero si esto nos 00:01:29
Lía un poquito 00:01:30
Bueno, pues no pasa nada, leemos el primer valor 00:01:33
¿Que ese primer valor es menor o igual que 1? 00:01:36
Pues entonces, ¿qué tendremos que hacer? 00:01:40
Mientras n sea menor o igual que 1 00:01:42
Pues vuélvelo a leer otra vez 00:01:44
Y así todo el rato 00:01:46
¿Vale? Este código que he escrito 00:01:48
Es el mismo idéntico que el anterior 00:01:52
Lo que pasa es que, bueno, que este me obliga 00:01:55
hacer la primera lectura afuera, en el anterior yo lo estaba haciendo aquí 00:01:58
tal cual cogía el valor n para compararlo 00:02:02
con el menor igual que 1, tal cual cogía ya le daba valor 00:02:06
con lo cual me ahorraba leerlo aquí y me ahorraba leerlo aquí 00:02:09
eso ya bueno, va en gustos relativos 00:02:14
si nos acostumbramos a hacer los programas cada vez más claros mejor 00:02:19
o en este caso este tendría que introduzca el número 00:02:22
tendría que ir aquí, lógicamente, si no queda un poco 00:02:26
raro el programa, vale 00:02:28
pues esta versión, o esto otro 00:02:32
que hemos dicho, que sería más bonito 00:02:34
que lo ponemos aquí en comentarios 00:02:36
Wailene 00:02:38
siendo en el resultado de 00:02:57
leerlo 00:02:59
perdón, que lo tenía que poner abajo 00:03:02
vale, pues 00:03:13
o este bucle tal cual 00:03:29
con el mensajito, primero 00:03:31
claro, ahí, a ver si lo dejo 00:03:33
ya bonito, vale, o esto 00:03:49
O si no os gusta, a la vez que usáis una variable dentro de una condición, a la vez que la usáis dentro de la condición, darle un valor en ese momento, pues bueno, podríamos hacerlo así, como digo aquí, ¿vale? Es lo mismo, es el mismo código, este código y este ejecutan exactamente la misma cosa, pero bueno, este mejor, más elegante, este de abajo, ¿vale? 00:03:51
bueno, pues entonces ya hemos hecho la validación 00:04:16
y ahora 00:04:19
vamos a generar 00:04:20
una secuencia de numeritos 00:04:22
partiendo del original 00:04:24
y cuántos 00:04:26
no lo sé, hasta que lleguemos a uno 00:04:28
como no lo sé, ahí nunca arrancaríamos 00:04:31
con un for, lógicamente 00:04:33
como no sé cuántos voy a tener que generar 00:04:35
pues aquí arrancamos 00:04:37
con un while 00:04:39
aquí arrancamos con un while 00:04:39
y aquí vamos a tener que mostrar 00:04:42
Los números, aquí lo que tenemos que hacer es 00:04:44
Mostrar 00:04:47
El número generado 00:04:48
¿Vale? 00:04:50
Esto lo habéis hecho más 00:04:53
Compacto, pero voy a hacerlo 00:04:54
Como a pasitos 00:04:57
Entonces el bucle que va a hacer 00:04:58
Mostrar un número que yo genero 00:05:00
¿Vale? 00:05:03
El número que yo genero, el número generado 00:05:04
Y ese número generado 00:05:06
¿Cómo va a ser? 00:05:08
¿Vale? Pues ese número generado 00:05:10
Depende 00:05:12
De si n es par o es impar. 00:05:13
Entonces, si n es par, ¿vale? 00:05:19
Si n es par, pues entonces el número generado que va a ser era n entre 2, creo, ¿no? 00:05:29
n entre 2. 00:05:37
Y si n fuera impar, el número generado es n por 3 más 1, n por 3 más 1, ¿vale? 00:05:39
Entonces, y mostramos el número generado, ¿vale? 00:05:57
Esto mientras el número generado sea mayor que 1, ¿verdad? 00:06:02
Mayor o igual que 1, porque hasta llegar a 1, vale. 00:06:12
Los que vas a ir mostrando, lo estoy haciendo como desglosado todo por partes, 00:06:19
entonces claro, ahora diríamos, el número generado, 00:06:24
o sea, lo estoy haciendo como el bucle, como si estuviéramos pensando todo despacito desde el principio. 00:06:28
Este bucle me va a mostrar números, ¿vale? 00:06:33
Entonces, esos números vienen de aquí 00:06:38
Como la condición 00:06:41
Número generado mayor o igual que 1 00:06:43
Está aquí, no lo puedo declarar aquí 00:06:46
Lo tengo que declarar fuera, lógicamente 00:06:48
Vale 00:06:50
¿Con qué valor tengo que inicializar 00:06:51
Número generado? 00:06:54
Pues con n, porque n es el primer número 00:06:55
De la secuencia, el número generado se inicializa 00:06:58
Con n 00:07:00
Y ahora 00:07:00
Este int ya se quita 00:07:03
Y ahora, ¿qué nos falta 00:07:05
por depurar aquí, que si yo he entendido bien 00:07:08
el ejercicio, cada número se genera 00:07:12
desde el anterior, desde el anterior, no desde el primero 00:07:15
luego aquí no será n, sino número generado, cada número 00:07:19
se genera desde el anterior, inicialmente se genera 00:07:24
desde n, por eso lo he inicializado, inicialmente se genera desde n 00:07:27
porque no estoy pensando en global, estoy pensando 00:07:31
como si yo no sé o sé poco 00:07:36
y lo voy haciendo como por partes 00:07:38
entonces voy a hacer un bucle que muestra números 00:07:40
pues este es mi número, luego ya según voy puliendo 00:07:41
pues ya me voy dando cuenta de las cosas 00:07:44
¿vale? 00:07:46
entonces, el número generado 00:07:47
se apoya 00:07:50
cada vez en el anterior 00:07:51
pues entonces aquí no va a ser en mayúsculas 00:07:53
sino que va a ser 00:07:56
número generado 00:07:57
número generado 00:08:00
¿vale? voy a bajarlo aquí abajo 00:08:02
para que se vea mejor 00:08:08
vale, pues ya tengo un bucle 00:08:09
que me genera una secuencia de números 00:08:20
empezando desde el número que me han dado ya validado 00:08:23
y me la va generando de esa manera 00:08:27
cada número se genera en función del anterior 00:08:30
de esta manera dependiendo de si es par o impar 00:08:33
vale, entonces generar la secuencia ya está 00:08:37
se van generando y así hasta llegar al 1 00:08:41
¿Vale? 00:08:44
Entonces, terminada esta primera parte 00:08:48
Efectivamente ya uno podría pensar 00:08:50
La verdad es que el n mayúscula 00:08:52
Perdón, la verdad es que la variable 00:08:54
Este número generado, pues me sobra 00:08:56
Podría reutilizar n 00:08:58
Y ya está, ¿no? 00:09:00
Puedo reutilizar n e irla cambiando de valor aquí dentro 00:09:01
Porque como no la vuelvo a usar 00:09:05
Como no la vuelvo a usar 00:09:06
Podría reutilizar esta propia variable n 00:09:07
¿Vale? 00:09:10
Pero bueno, hemos empezado desde 0 00:09:11
Pues así nos ha quedado por ahora 00:09:15
¿Vale? Entonces esta parte está clara 00:09:17
Un bucle que va generando números 00:09:19
Ese número lo tengo que guardar 00:09:21
En algún sitio 00:09:23
Pues me hago una variable para él 00:09:24
¿Por qué valor empieza? 00:09:26
Por el inicial 00:09:29
Y ahora, ¿cómo los voy generando? 00:09:30
¿Cómo me van saliendo del grifo? 00:09:32
Pues me van saliendo del grifo esos números 00:09:34
De esta manera, con esta fórmula 00:09:37
O con esta otra 00:09:39
Dependiendo de cómo sea 00:09:40
El número, el anterior 00:09:42
Apoyándome en el anterior 00:09:44
Pues apoyándome en el anterior 00:09:46
Según esta fórmula, genero el siguiente 00:09:48
¿Vale? Pues este es el grifo de números generados 00:09:50
Inicialmente el N mayúscula 00:09:53
¿Cuándo acaba ese grifo de números generados? 00:09:55
Cuando hayamos llegado a 1 00:09:57
Podríamos hacer la primera prueba 00:09:58
A ver si esto nos sale alguna cosa rara 00:10:00
O no nos sale algo raro 00:10:03
Vale, introduzca número 00:10:07
Entonces, si yo le pongo el menos 3 00:10:15
Pues me sigue pidiendo 00:10:17
Si le pongo el 1, me sigue pidiendo 00:10:18
le tengo que poner uno mayor que uno, vale, pues la parte 00:10:20
de la validación funciona 00:10:22
45, pues sí que tarda 00:10:23
¿no? es que está repitiendo el mismo 00:10:34
patrón una y otra vez 00:10:39
sí, ya, ya, ya voy, ya voy, que os está dando 00:10:40
talk, vale 00:10:44
vale 00:10:46
si el número generado 00:10:49
es par, se divide 00:10:53
por dos, si es impar 00:10:55
se multiplica por tres y se suma uno 00:10:56
yo he hecho lo que 00:10:58
me está diciendo, ¿no? 00:11:01
NUM generado va a ser 00:11:03
el generado entre 2 si es par 00:11:20
el generado por 3 más 1 si es impar 00:11:22
a ver 00:11:24
esto tiene una, que no nos importa 00:11:29
o sea que hay números para los que no termina nunca 00:11:32
nos da igual, o sea yo he hecho lo que hace 00:11:34
el ejercicio, solamente voy a revisar que he hecho 00:11:36
lo que está en el ejercicio 00:11:38
si es impar se multiplica por 3 00:11:39
y se suma 1 00:11:42
he hecho lo que me está diciendo 00:11:43
voy a volver a 00:11:45
si voy a probarlo 00:11:47
con otro 00:11:50
bueno pues interesante que hemos hecho mal 00:11:50
vamos a encontrarlo 00:11:59
mientras el número 00:12:00
sea mayor o igual que 00:12:05
uno, ¿no? Está bien, ¿no? 00:12:07
No un generado. 00:12:09
Ah, efectivamente. Muy bien 00:12:12
visto. Claro, porque si yo 00:12:17
me meto para el uno, es cuando ya 00:12:19
la lío otra vez. 00:12:21
Vale, vale, vale, vale, vale. Muy, muy, muy 00:12:23
bien visto. Vale. 00:12:25
Vale. Pues de ahí la importancia 00:12:27
de hacer unas pruebas intermedias. 00:12:29
Muy bien visto. Estaba yo obsesionada con el uno. 00:12:31
Vale. Ahora 00:12:34
ya... Sí. 00:12:35
Vale, pues entonces ya nos hemos dado cuenta de este errorcillo 00:12:37
Haciendo las pruebas, ¿hemos sacado el ejercicio? 00:12:42
No, nos falta mostrar aquí 00:12:44
Nos falta mostrar aquí 00:12:47
Cuántas veces, cuántos números se han generado 00:12:50
Y cuál ha sido el mayor 00:12:55
Eso es meter el algoritmo que ya sabemos de cuenta y de máximo 00:12:56
Venga, pues vamos a contar 00:13:00
Pues si vamos a contar un contador que se inicializa cero 00:13:02
Y lo incremento 00:13:06
Para cada número generado 00:13:09
Esa parte ya está 00:13:12
Es contar, no tenemos mayor problema 00:13:13
Se han generado 00:13:16
Dime 00:13:20
A ver 00:13:25
Lo puedes hacer, todo lo que esté bien hecho 00:13:41
Está bien hecho 00:13:43
Si tú dices usar un for y así no usas una variable 00:13:44
Aparte, por ejemplo 00:13:47
Bueno, es otra forma de escribirlo 00:13:48
Lo que pasa es que como el for suele tener 00:13:58
se asume o se asocia a usos muy específicos 00:14:00
que es recorrido de colecciones 00:14:03
recorrido de arrays, de colecciones de datos 00:14:07
con índices que indican posiciones 00:14:10
pues normalmente uno espera de un for que se use para hacer esas cosas 00:14:11
pero no es que esté mal 00:14:15
no es que esté mal ni bien 00:14:18
sino que se asocia sobre todo a ese tipo de códigos 00:14:21
entonces uno ve un for 00:14:24
y se espera una colección de datos que va recogiendo, recorriendo. 00:14:28
Aquí en realidad no hay una colección de datos, va generando un número, 00:14:32
pero bueno, que tampoco es que haya un criterio, está bien o está mal. 00:14:34
Vale, se ha generado con números. 00:14:38
Y ahora el máximo, el máximo. 00:14:40
Pues, ¿cómo hacemos algoritmo de máximo? 00:14:42
Pues ya lo hemos hecho muchas veces. 00:14:45
El máximo se hace. 00:14:48
Yo inicialmente asumo como máximo el primero de todos 00:14:50
o el menor valor posible 00:14:55
para que el primero se convierta 00:14:57
en el primer máximo. 00:14:59
Y para el máximo siempre hay un bucle 00:15:01
que me va soltando números. 00:15:02
Siempre hay un bucle que me va soltando números. 00:15:04
El bucle que aquí en este caso es este. 00:15:06
Y ahora, para cada número que me suelta, 00:15:08
cada número que me suelta, 00:15:11
¿es mayor que el máximo hasta ese momento? 00:15:12
Tengo nuevo máximo. 00:15:14
El máximo siempre implica que hay un bucle 00:15:16
que me va soltando las cosas. 00:15:19
Y yo cada cosa que me suelta 00:15:20
la comparo con el máximo hasta ese momento. 00:15:22
para ver si me toca reutilizar o no. 00:15:25
Aquí la clave es con qué valor inicializo máximo 00:15:28
para asegurarme de que el primer número 00:15:31
siempre se va a convertir en el máximo. 00:15:34
Esa es la clave. 00:15:36
Me tengo que asegurar inicializando el máximo actual 00:15:37
que el primer número siempre se va a convertir en el máximo. 00:15:40
Entonces, aquí los números van a ser todos mayor que 1, siempre. 00:15:43
Entonces, con que inicialice a 0, es suficiente. 00:15:47
Joder, ¿qué estoy haciendo? 00:15:52
Ahí, ya está 00:15:53
¿Vale? Con que lo inicialice a 0 00:15:59
El máximo actual 00:16:01
Ya tengo la garantía 00:16:02
De que la operación de máximo 00:16:04
Que la voy a hacer ahora 00:16:07
Si mi número generado 00:16:08
Es mayor 00:16:11
¿Vale? 00:16:15
Si mi número generado es mayor 00:16:21
Que el máximo 00:16:27
Hasta ese momento 00:16:29
Tengo nuevo máximo 00:16:30
Y ahora ya me falta mostrarlo 00:16:33
Y hemos terminado 00:16:41
el valor pico ha sido 00:16:42
más 00:16:48
actual 00:16:52
vale, bueno pues ahora ya si que 00:16:53
lo tengo completo 00:16:56
a falta de hacer alguna prueba 00:16:57
porque se me puede haber escapado 00:17:00
otro detalle 00:17:01
como el que 00:17:04
se me ha escapado antes del mayor o igual 00:17:05
vale, entonces 00:17:08
este ejercicio 00:17:10
pues nada, combinaba 00:17:11
cuatro cosas básicas 00:17:14
validar un número, un bucle 00:17:16
que está validando el número 00:17:19
ahora ya otro bucle 00:17:20
que va generando 00:17:22
numeritos, según una secuencia 00:17:24
los va generando 00:17:26
y tiene una condición 00:17:27
de finalización, la que sea 00:17:29
entonces yo a priori no sé cuántas 00:17:33
veces se va a ejecutar, pues 00:17:35
me pega más un for 00:17:36
¿vale? 00:17:37
y ahora, ¿qué tengo que 00:17:43
incorporar? una cuenta 00:17:44
que está ahí incorporada y una operación de máximo 00:17:46
que la operación de máximo siempre es así 00:17:49
cada valor que me va llegando comparo con el máximo actual 00:17:52
si lo supera tengo nuevo máximo y actualizo 00:17:56
y luego tengo que pensar bien el valor inicial del máximo 00:17:59
para asegurarme de que el primer valor 00:18:03
de la secuencia se va a convertir en el máximo 00:18:06
primero, vale, aquí con el 00:18:10
Bueno, pues esto más o menos 00:18:13
Estaría hecho 00:18:15
Introduzca número 7 00:18:18
El valor pico ha sido 52 00:18:21
Esta prueba sí que la ha hecho bien por lo menos 00:18:25
Y se han generado 16 00:18:27
Podríamos seguir haciendo pruebas, pero bueno 00:18:28
Es de esperar que no hayamos cometido ningún error 00:18:30
Si he acertado en este 00:18:33
Vale, pues este ya estaba 00:18:35
Este era 00:18:41
En principio 00:18:43
el sencillo, o sea, esto 00:18:45
ya eran 00:18:48
tres puntos 00:18:50
si hacíais este ejercicio 00:18:52
y este ejercicio, pues sí que era 00:18:53
sota, caballo y rey, lo de clases 00:18:56
calcado, no tenía nada muy 00:18:58
extraño, ni muy de pensar, este era 00:19:00
entonces había que rascar dos puntos 00:19:02
en los otros siete, entonces yo creo que 00:19:04
hombre, que lo ha probado, creo que no era complicado 00:19:06
había que rascar dos puntos de los otros 00:19:08
siete para tener ya un aprobado 00:19:10
bueno, pues este, vale 00:19:11
Nos vamos con el segundo, que era un poquito más, podía ser más retorcido, en función de cómo lo planteara uno, podía ser más retorcido. 00:19:16
vale, pues este enunciado 00:19:23
leer una cadena 00:19:44
que dijimos que iba a tener siempre 00:19:50
el patrón de 00:19:53
unas cuantas letras 00:19:54
o caracteres, otros cuantos caracteres 00:19:56
otros cuantos caracteres, entre uno y varios 00:19:58
cada uno, pero que nunca se iban 00:20:01
a repetir, si yo ya había tenido 00:20:03
un pack de caracteres 00:20:04
ese carácter ya no iba a aparecer 00:20:06
en ningún otro pack, porque si no se podía complicar 00:20:08
más el ejercicio y no había necesidad 00:20:11
vale, pues entonces 00:20:13
entendiendo que 00:20:15
la cadena 00:20:16
de partida iba a ser esa 00:20:19
que no había ni que validarla ni que nada 00:20:20
asumimos que el usuario la introduce bien 00:20:23
en realidad cualquier cosa que introduce 00:20:24
bueno, sí, que la introduce bien 00:20:28
la convertimos en esto de aquí 00:20:30
y luego ya mostramos la convertida 00:20:32
a la original en función 00:20:35
de si la original es más corta 00:20:37
o más larga que la convertida 00:20:39
vale, pues entonces 00:20:41
vamos a arrancarlo 00:20:43
como leemos del teclado 00:20:45
pues 00:20:48
y ahora pedimos el dato 00:20:49
el único dato que hay 00:20:58
que es la cadena a convertir 00:21:00
vale, y ahora ya sí que 00:21:02
bueno, empezamos 00:21:21
uno ya antes de empezar a escribir 00:21:23
pues piensa más o menos cómo lo va a hacer 00:21:25
se hace una primera idea 00:21:27
lo que está claro es que el resultante del ejercicio, el resultante es otra cadena. 00:21:28
Entonces, pues yo me haría ahí mi cadena y tiene sentido pensar que la cadena resultante la vamos a obtener concatenando lo que vayamos obteniendo de contar de la original. 00:21:34
De la original vamos a ir contando y vamos a ir concatenando sobre la resultante el carácter que hayamos contado con su contador, vamos a ir concatenando. 00:21:48
con lo cual mi cadena resultado 00:21:57
como yo ya preveo que la voy a construir 00:21:59
concatenando sobre ella 00:22:02
concatenando y concatenando sobre ella 00:22:03
los patrones que voy encontrando 00:22:05
pues la inicializo con el vacío 00:22:08
para poder ir haciendo una concatenación 00:22:10
esto es como la suma acumulativa 00:22:12
que inicializamos con cero 00:22:14
para que lo primero que sumamos al acumulador 00:22:15
se le sume al cero 00:22:18
pues esta es la cadena acumulativa 00:22:19
la inicializo al vacío 00:22:22
para que lo primero que concatenemos 00:22:23
se concatene sobre la cadena vacía 00:22:26
y ahora 00:22:28
pues que es lo más sencillo 00:22:30
que se nos puede ocurrir 00:22:34
pues voy a recorrer la cadena 00:22:35
y voy a ir contando 00:22:37
para cada carácter 00:22:39
si es igual que la anterior 00:22:42
cada vez que encuentre 00:22:44
que es igual que el siguiente 00:22:45
que es igual que el siguiente 00:22:46
que es igual que el siguiente 00:22:48
incremento un contador 00:22:48
cuando ya no es igual que el siguiente 00:22:50
ahí ya puedo hacer una primera concatenación 00:22:55
y reinicio el contador 00:22:57
¿vale? es lo primero 00:22:59
que a mí se me ocurriría y me parece 00:23:01
que lleva lo más fácil 00:23:03
pero bueno, lo habéis hecho de formas muy 00:23:04
distintas, ¿vale? lo primero que a mí 00:23:07
se me ocurriría, repito, es 00:23:09
arranco con la cadena 00:23:10
y voy contando 00:23:12
para cada carácter si es igual que el siguiente 00:23:15
si es igual que el siguiente, si es igual que el siguiente 00:23:17
y así voy contando 00:23:19
en cuanto llegue a uno que no es 00:23:21
igual que el siguiente, paro el contador 00:23:23
y ya puedo hacer la primera 00:23:25
concatenación al resultado. 00:23:27
Y como ya he parado 00:23:30
al contador, 00:23:30
la siguiente 00:23:34
iteración del while ya va a ir 00:23:36
contando con el siguiente carácter. 00:23:37
Es decir, algo así, por ejemplo. 00:23:40
Como vamos a recorrer una cadena, 00:23:43
ahora ya una cadena 00:23:46
tiene sus posiciones desde la primera a la última, 00:23:47
unas posiciones concretas. 00:23:49
Una cadena la recorro como un for, 00:23:51
Desde su primera posición a la última 00:23:53
Entonces, como una raíz, perdón 00:23:54
Con lo cual aquí, pues un for 00:23:57
Es lo más cómodo 00:23:59
Desde igual a cero, siendo y la posición de la cadena 00:24:00
Mientras y sea menor 00:24:03
Que mi cadena 00:24:06
Length 00:24:07
Incrementando y 00:24:10
¿Vale? Yo hago una primera 00:24:12
Un primer prototipo 00:24:14
Y luego ya vamos arreglando 00:24:16
Ya vamos arreglando, ¿no? 00:24:17
Pero hago un primer prototipo 00:24:20
y luego ya vamos arreglando cositas, detalles, etc. 00:24:22
Entonces, yo he dicho, lo primero que voy a hacer, 00:24:25
voy a recorrer mi cadena para iniciar un bucle 00:24:27
y mientras mi carácter sea igual al siguiente, lo cuento. 00:24:31
Entonces, pues aquí, mi contador, ¿vale? 00:24:35
Y ahora, si el carácter en la posición en la que estoy 00:24:45
resulta que es igual 00:25:00
al carácter 00:25:03
en la posición siguiente 00:25:07
aquí en cuanto 00:25:09
pongo un i más uno 00:25:11
ya se me despiertan las alarmas 00:25:13
sobre este límite superior 00:25:15
del for, ya se me despiertan 00:25:17
las alarmas, pero bueno, eso ya 00:25:19
lo retocamos ahora 00:25:21
primero yo me hago mi primer prototipo 00:25:23
donde más o menos planteo mi idea 00:25:25
esbozo mi idea 00:25:27
y luego ya la voy afinando 00:25:29
¿vale? pero está bien que yo te digo 00:25:31
uy cuidado, estás comparando cada carácter 00:25:33
con el siguiente 00:25:35
cuidadín, que entonces 00:25:36
no te vas a poder parar en el último 00:25:39
te vas a tener que parar en el anterior 00:25:41
siempre, ahí ya se me despierta 00:25:43
la primera alarma, ¿vale? 00:25:45
bueno, pues si 00:25:47
el carácter en el que estoy es igual al siguiente 00:25:48
incremento el contador 00:25:51
contador que he inicializado a 1 00:25:53
¿por qué? porque el 00:26:00
Carácter charad y ya es uno 00:26:01
Ya es un carácter, ya es uno 00:26:04
Por eso he inicializado a uno 00:26:05
Vale, entonces, así voy 00:26:06
Carácter en la posición y es igual al siguiente 00:26:10
Incrementando, vale 00:26:12
El bucle volverá 00:26:14
Sigue siendo igual al siguiente 00:26:16
Muy bien, incremento contador 00:26:17
El bucle for volverá 00:26:20
Sigue siendo tú igual a tu siguiente 00:26:21
Incremento contador, el bucle volverá 00:26:24
Sigue siendo tú igual a tu siguiente 00:26:26
Incremento contador 00:26:28
llegará un momento en el cual 00:26:29
me pare yo en una posición, ya he acabado 00:26:31
todas las as, por ejemplo 00:26:33
llegará el momento en el que me pare en una posición 00:26:35
en la que ya no soy igual 00:26:37
que mi siguiente, llegará un 00:26:39
momento en que ya estoy parada en una posición 00:26:41
en la que ya no soy igual a mi siguiente 00:26:44
pues entonces ahí me toca 00:26:45
construir resultado 00:26:47
pues venga, resultado 00:26:49
más igual 00:26:52
el carácter concreto en el que estoy 00:26:53
que ya no es igual 00:26:55
al siguiente 00:26:59
que ya no es igual al siguiente 00:27:00
concatenado 00:27:03
con 00:27:05
el contador 00:27:07
aquí de nuevo 00:27:10
se me despierta una pequeña 00:27:15
alarma de si este más 00:27:17
va a hacer la suma o la concatenación 00:27:18
yo quiero que haga la concatenación 00:27:21
vale, pero lo voy a dejar 00:27:23
así para luego ir arreglando los errores 00:27:25
si uno no se da cuenta y le sale 00:27:27
y ahora que me falta 00:27:29
volver a poner el contador a 1 00:27:31
para reiniciar la cuenta 00:27:33
¿vale? este sería el esbozo de la idea 00:27:34
que he planteado 00:27:40
ahora ya hay que retocar a ver si esto funciona o no 00:27:43
¿vale? entonces el esbozo de la idea pues consiste en esto 00:27:46
el esbozo de la idea 00:27:50
consiste en esto, yo tengo por ejemplo esto 00:28:06
a, a, c, c, d, d, d, era 00:28:09
Voy a recorrer la cadena para cada posición y ¿eres igual que tu siguiente? Incremento contador. Ahora voy a esta. ¿Eres igual que tu siguiente? Incremento contador. Ya llevaría 3 porque como el contador ha empezado en 1. Ahora estoy en esta. ¿Eres igual a tu siguiente? No, no eres igual. 00:28:13
pues entonces me voy al else 00:28:30
el else lo que hace ya es concatenar 00:28:31
a resultado 00:28:34
la parte que toca, que es el carácter 00:28:35
en esta posición, el a, con su cuenta 00:28:38
y reiniciar contador a 1 00:28:40
ahora, el bucle 00:28:42
vuelve, c, tú, ¿eres igual a tu siguiente? 00:28:44
sí, c igual a 2 00:28:46
ahora estoy aquí, ¿tú eres igual a tu siguiente? 00:28:47
no, pues toca el else 00:28:50
que concatenará el resultado 00:28:52
el c con su contador 00:28:54
y ya está, y reiniciará 00:28:55
contador a 1 y pasamos al siguiente tú eres igual a tu siguiente si el contador 2 paramos aquí tú 00:28:58
eres igual a tu siguiente si contador 3 vale entonces aquí quedan varias cosas por definir 00:29:05
que es cuidadín con esto y a ver si esto me está haciendo con concatenación o me está sumando 00:29:15
y ¿qué pasa en el último pack? 00:29:22
¿Qué pasa en el último pack? 00:29:29
Porque si yo tengo 3Ds, 00:29:31
cuando he parado en este, 00:29:34
¿tú eres igual a tu siguiente? 00:29:37
Sí, contador igual a 2. 00:29:39
¿Tú eres igual a tu siguiente? 00:29:40
Ah, no, me paro en el penúltimo. 00:29:41
¿Tú eres igual a tu siguiente? 00:29:43
Entonces, contador igual a 3, ¿vale? 00:29:45
pero como el bucle se para aquí 00:29:49
me faltaría 00:29:52
por concatenar lo último 00:29:54
entonces tendríamos que añadirlo al final 00:29:56
y ya está, pero vamos a 00:29:58
hacer las primeras pruebas 00:30:00
de esto para ver cómo iríamos 00:30:02
arreglando lo que va fallando 00:30:04
pero bueno, la idea de lo que estoy haciendo está entendida 00:30:05
ahora hay que pulirla 00:30:08
la idea de lo que estoy haciendo está entendida 00:30:10
entonces, si uno ejecuta esto sin más 00:30:11
lo primero que le va a salir 00:30:14
bueno, voy a mostrar el resultado 00:30:15
Si eso resulta 00:30:18
Hacemos el primer arreglo 00:30:23
Y paramos un momento 00:30:25
Si uno ejecuta esto sin más 00:30:26
Cadena 00:30:29
Vale, pues le sale esto 00:30:34
Y dice, uh, que ha pasado 00:30:40
Pero no pasa nada 00:30:42
Ah, me he salido del 00:30:43
String 00:30:45
Me he metido en el index 12, cuidado 00:30:47
Ah, claro, es que estoy comparando 00:30:50
Cada carácter con su siguiente 00:30:52
Con lo cual tengo que 00:30:54
Pararme en el penúltimo 00:30:56
No en el último 00:30:57
Tengo que pararme en el penúltimo 00:30:58
Primera cosa que uno se da cuenta 00:31:01
Si no ha atendido a su alarma 00:31:05
Cuando ha visto aquí al I más uno 00:31:08
Le ha salido la alarma mental de cuidado 00:31:09
Que en cada iteración del FOR 00:31:12
Estoy mirando el siguiente 00:31:15
Cuidado, pues me tengo que quedar en el penúltimo 00:31:17
No en el último 00:31:20
Pues si no ha atendido a esa alarma 00:31:21
No se le ha despertado en ese momento 00:31:23
Al ver aquí el I más uno 00:31:24
Se le despierta aquí 00:31:26
Uy, me he salido del array 00:31:28
Perdón, del stream 00:31:30
Me vengo por aquí, porque esto hay que hacerle caso 00:31:32
Hay que leer lo que te dice 00:31:35
Me vengo por aquí 00:31:36
Hasta llegar a la primera línea 00:31:38
Que ya es código mío 00:31:41
Porque todo esto son clases de Java 00:31:42
Uy, me he salido aquí 00:31:44
Ah, claro, jolín, es que estoy llegando 00:31:47
Hay más uno, con lo cual tengo que 00:31:49
Pararme antes, vale, es error arreglado 00:31:51
Siguientes comprobaciones 00:31:53
Las paramos un momentito y las hacemos 00:31:54
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:
3 de diciembre de 2025 - 11:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
126.60 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid