Saltar navegación

20251119 EjerArrays_7 - 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 21 de noviembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues, dime, en el 19, partimos de esa premisa, asumimos que lo va a hacer así, vale, luego lo hacemos si queréis, venga, pues vamos al 9, vale, venga, el 9, que nos dice el 9, nos dice, dos arrays de 12, 00:00:00
A ver, vamos a hacerlo para que en lugar de 12 sean del tamaño que me diga el usuario. 00:00:30
¿De qué tamaño quieres el array? 00:00:36
De este. 00:00:38
¿Vale? Y así no es siempre 12. 00:00:39
Bueno, pues dos arrays del tamaño que me diga el usuario. 00:00:41
Vamos a hacer un tercero que vaya intercalándolos, pero de 3 en 3. 00:00:44
¿Vale? 00:00:49
Sería la versión más complicada del 8. 00:00:50
El 8 los va intercalando de 1 en 1. 00:00:52
El 9 los va intercalando de 3 en 3. 00:00:55
Pues venga, como vamos a pedirle al usuario datos por teclado, pues esto lo necesitamos 00:00:58
Ahora, lo primero que le pedimos 00:01:08
Lo primero que le pedimos es tamaño del array 00:01:16
Para que el ejercicio tenga sentido, como es coger 3 de uno, 3 de otro, 3 de uno, 3 de otro 00:01:21
Para que tenga sentido vamos a decirle que sea múltiplo de 3 00:01:35
porque aquí en el enunciado original 00:01:39
me daban ya un número 12 que es múltiplo de 3 00:01:41
vamos a pedirle que sea múltiplo de 3 00:01:44
¿vale? para que tenga sentido 00:01:46
tamaño del array múltiplo de 3 00:01:48
y ya que estamos tuneando 00:01:51
vamos a hacer una validación 00:01:57
para asegurarnos de que realmente 00:02:00
mete uno múltiplo de 3 00:02:02
bueno, de hecho, aunque es una complejidad 00:02:04
pues bueno, para seguir practicando sobre lo mismo 00:02:08
vamos a validarlo de tal manera 00:02:11
Que no solo validemos que es múltiplo de 3 00:02:13
Sino que además me meta realmente una cifra 00:02:16
Es decir, no me meta hola, ¿qué tal? 00:02:19
Porque entonces me daría un error, ¿verdad? 00:02:22
Entonces vamos a validar la entrada 00:02:24
Validamos la entrada 00:02:26
Para que sea número 00:02:31
Y múltiplo de 3 00:02:35
¿Vale? 00:02:38
Pues entonces, ¿qué significa eso? 00:02:43
Este es el numerito n 00:02:45
que va a ser el tamaño del array que le hemos pedido 00:02:47
este es el numerito n 00:02:51
y lo vamos a estar leyendo todo el rato 00:02:52
mientras 00:02:54
no cumpla la condición de 00:02:55
ser número y múltiplo de 3 00:02:59
entonces esta validación 00:03:03
la podríamos hacer 00:03:05
mientras n 00:03:06
mientras n no sea número 00:03:09
¿cómo ponemos la condición de no ser número? 00:03:13
No es tan fácil 00:03:16
¿Vale? 00:03:18
Entonces vamos a poner aquí un boolean 00:03:19
O sea, no es como múltiplo de 3 00:03:21
Que la podemos poner aquí un boolean 00:03:22
Es número 00:03:23
¿Vale? 00:03:25
Es número 00:03:26
Entonces 00:03:27
Mientras n 00:03:28
Mientras 00:03:30
No sea número 00:03:34
Además de no ser número 00:03:39
Espera, vamos a hacer en otro sentido 00:03:42
Es que complico yo mucho la vida con esto 00:03:44
Mientras n 00:03:47
Siendo n 00:03:49
el resultado de haber hecho la lectura 00:03:50
mientras n mayúscula 00:03:52
perdón 00:03:55
siendo n el resultado de haber leído del teclado 00:03:55
scan.nextint 00:03:59
sea 00:04:01
múltiplo 00:04:02
no múltiplo de 3 00:04:04
vale 00:04:06
vale, vale, no es que lo estoy 00:04:07
no, porque para validar que sea número 00:04:12
tengo que leer con nextline 00:04:13
vale, no, no lo puedo hacer en el mismo bucle 00:04:15
vale, porque si lo leo con nextint 00:04:17
y no es número 00:04:20
me va a dar una excepción y separa el programa 00:04:21
que no es lo que quiero, entonces 00:04:23
vamos a leer el numerito, vale 00:04:25
lo tenemos que leer con next line 00:04:28
vale, n igual 00:04:30
a scan punto 00:04:33
next line, vale 00:04:34
lo tenemos que leer así, porque 00:04:37
si él me introduce hola 00:04:39
por las buenas, y yo lo he leído 00:04:40
con next in, el programa 00:04:42
pararía y se detendría, y yo no quiero 00:04:44
que pare y se detenga, yo quiero que 00:04:46
él me pueda introducir cualquier cosa 00:04:48
yo verificar si realmente me ha introducido un número 00:04:50
múltiplo de 3, si me lo ha introducido 00:04:53
sigo haciendo cosas y si no me lo ha introducido 00:04:57
le vuelvo a pedir, vale, pues entonces lo tengo que leer con next line 00:04:59
para que no se detenga, con lo cual esta 00:05:03
declaración es string 00:05:05
el dato leído 00:05:08
vale, entonces 00:05:11
vale, pues ahora 00:05:14
vamos a ver si es número o no es número 00:05:17
Para ver si es número o no es número 00:05:19
Tengo que ir cifra por cifra 00:05:22
Viendo si cada una 00:05:24
De las cifras 00:05:26
Cumple la condición de ser un número 00:05:27
De la tablasti 00:05:29
Entonces eso de nuevo es ver si algo ocurre o no ocurre 00:05:30
Pues boolean 00:05:34
Es número 00:05:35
Yo parto de partida que es igual a true 00:05:36
Que todas son cifras 00:05:39
Y voy a ver ahora si encuentro un contraejemplo 00:05:41
Pues me voy a ir 00:05:43
Por todas las 00:05:45
Posiciones 00:05:47
del string, desde i igual a 0 00:05:49
mientras i sea menor que dato 00:05:51
leído 00:05:53
punto leed 00:05:54
incrementando i 00:05:57
vale, para todos y cada una 00:06:01
si alguno de los 00:06:03
char en esa posición 00:06:06
si alguno de los char 00:06:07
en la posición i 00:06:09
resulta que no cumple 00:06:13
la condición de ser cifra 00:06:16
ya es número y lo puedo poner a falso 00:06:17
y esa condición cual será 00:06:19
la de, tendremos que abrir la tabla ASTI 00:06:20
vale, aquí es 48 y 57 00:06:24
entre 48 y 57, vale, pues la condición sería 00:06:28
si es menor que 48 00:06:32
o es mayor 00:06:37
que 57 00:06:42
o es mayor que 00:06:44
pues entonces ya sé que automáticamente 00:07:00
la cifra 00:07:03
en esa posición no es un 00:07:05
número realmente, o sea el carácter 00:07:07
perdón, el carácter de esa posición no es una cifra 00:07:09
con lo cual ya puedo concluir 00:07:11
que es 00:07:13
número 00:07:15
perdón, que es número aquí 00:07:16
vale, que es número 00:07:18
es igual a falso 00:07:23
vale 00:07:25
pero no es lo único que tengo que validar 00:07:26
tengo que validar 00:07:29
que además sea múltiplo de 3 00:07:31
entonces ahora ya sí que puedo arrancar el bucle 00:07:33
entonces, mientras 00:07:35
esto 00:07:37
no sea número 00:07:39
o siendo número 00:07:45
¿vale? 00:07:48
o siendo número 00:07:53
no sea múltiplo de 3 00:07:54
¿vale? ¿cómo puedo comprobar si es 00:07:57
múltiplo de 3? 00:07:58
¿vale? pues el dato leído 00:08:00
¿cómo lo puedo convertir a entero? 00:08:03
con el integer parse in, ¿verdad? 00:08:04
Con el par 0. 00:08:07
Pues si el par 0, si no es número, 00:08:09
o siendo número, 00:08:12
aquí pongo el doble or, 00:08:15
para que entre aquí solo si este es true, 00:08:17
o siendo número, 00:08:20
si yo hago el resto de dividirlo entre 3, 00:08:22
resulta que es diferente de 0, 00:08:25
pues entonces, 00:08:29
si esto no ocurre, 00:08:30
Tengo que volver a pedir el número otra vez 00:08:32
Voy aquí 00:08:34
Este mensajito 00:08:36
No, no, no 00:08:37
Esto ha sido por introducir 00:08:42
Una validación por practicar con más cosas 00:08:44
Porque el programa era 00:08:46
Yo aquí le voy a pedir el número para que el tamaño 00:08:49
De la raíz sea un número personalizado 00:08:52
Pero voy a validar 00:08:54
Que sea realmente un número 00:08:56
Y múltiplo de 3 00:08:58
Para introducirle eso y así podemos hacer 00:09:00
Hacemos más cosas 00:09:02
Vale, pues entonces 00:09:03
Introduzca número, vale, pues 00:09:05
He entrado en el while 00:09:08
Es porque necesito pedir el número 00:09:10
Otra vez 00:09:14
Pues entonces vuelvo a pedir el número 00:09:14
Y me vuelvo a hacer 00:09:17
La condición 00:09:20
Aquí para 00:09:21
Si es número o no 00:09:23
Entonces todo esto otra vez 00:09:25
Me lo tengo que copiar y pegar 00:09:27
Entonces 00:09:28
Un rollo porque 00:09:30
no sabemos hacer métodos 00:09:34
auxiliares, cuando sepamos hacerlo 00:09:37
estos códigos van a ser infinitamente 00:09:38
más claros 00:09:40
entonces, fijaos, todo lo que he hecho 00:09:42
solo para validar que 00:09:47
esta cadena que 00:09:48
he metido 00:09:50
sea una sucesión 00:09:51
de cifras y además múltiplo de 3 00:09:54
entonces lo primero es 00:09:56
he verificado a ver si es una sucesión de cifras 00:09:59
con este código 00:10:02
este es más fácil de entender 00:10:04
de partida asumo que sí, que es una sucesión 00:10:05
de cifras, ahora voy 00:10:08
una por una, en cuanto alguna de ellas 00:10:10
se convierta en contraejemplo 00:10:12
asumo que esto es falso 00:10:14
y ahora 00:10:15
me meto en el bucle, mientras no sea 00:10:17
número o 00:10:20
siendo número 00:10:21
al convertirlo a entero me de múltiplo de 3 00:10:23
diferente de 0, entras otra vez 00:10:26
y al entrar, ¿qué vas a hacer? 00:10:28
volver a pedir el número 00:10:30
y volver a mirarme 00:10:31
si es número o no 00:10:33
entonces, este código 00:10:34
solo para validar, cuando salga del while 00:10:42
es porque ambas son falsas 00:10:44
es decir 00:10:47
porque 00:10:48
lo que yo acabo de leer aquí en dato leído 00:10:49
ha cumplido que esto es true 00:10:52
luego es un número 00:10:54
y además es múltiplo de 3 00:10:55
cuando las dos sean falsas 00:10:58
es cuando va a salir del while 00:11:00
cuando las dos sean falsas 00:11:02
entonces esto es 00:11:03
un buen ejemplo 00:11:08
de la importancia 00:11:11
de usar 00:11:13
el doble AND 00:11:15
o el simple AND 00:11:17
este es un buen ejemplo estupendo 00:11:18
si yo aquí pongo un simple AND 00:11:20
pongo una simple barrita 00:11:23
él va a evaluar 00:11:26
las dos siempre 00:11:27
entonces imaginaos que esta le ha dado 00:11:28
true, si le ha dado true 00:11:30
significa que eso no es 00:11:33
una sucesión de cifras 00:11:35
porque no es 00:11:37
número, legado a true no es una sucesión 00:11:39
de cifras, entonces como aquí 00:11:40
hay solo una barrita, aunque el or 00:11:42
ya sé que va a ser true sí o sí 00:11:45
porque true, or, lo que sea 00:11:46
es true, ya lo sé, pues al haber 00:11:48
solo una barrita, evalúa la segunda 00:11:51
cláusula igualmente, porque hay solo una 00:11:53
pues al evaluar la segunda cláusula 00:11:55
resulta que el integer 00:11:57
cuando tú le das una cadena 00:11:58
que no es una sucesión de cifras, pum 00:12:00
te peta y te para la aplicación 00:12:02
porque te dice no puedo convertir eso entero 00:12:05
porque me has pasado hola que tal 00:12:06
y eso no puedo 00:12:08
entonces aquí fundamental 00:12:09
aquí si tiene una trascendencia 00:12:13
crítica, poner las dos 00:12:15
barras, porque cuando no es 00:12:17
un número, es decir, cuando esto ya es true 00:12:19
yo no quiero que haga esto jamás 00:12:20
porque si lo hiciera el programa pararía 00:12:22
porque habría una excepción 00:12:24
entonces aquí tengo que poner las dos 00:12:25
para que en el caso de que 00:12:29
esto no sea un número, esto ya ni lo 00:12:31
mire, esto ya ni lo mires 00:12:33
Porque si tratas de mirar 00:12:34
Si hola es múltiplo de 3 00:12:36
Es imposible, te voy a parar el programa 00:12:38
Entonces, si esto es true 00:12:39
Esto ni lo mires 00:12:42
¿Vale? 00:12:43
Luego aquí no tenemos elección 00:12:45
Tenemos que poner doble barra, no hay elección 00:12:46
Esto no es 00:12:48
Esto no es 00:12:50
Mientras no sea múltiplo de 3 00:12:56
No, porque tú sigues pidiéndolo 00:12:58
Mientras no sea número 00:13:04
mientras no sea número 00:13:05
mira si es múltiplo de 3 00:13:07
no, no, no, mientras no sea número 00:13:08
o siendo número 00:13:11
no sea múltiplo de 3, vuelves a entrar 00:13:13
entonces, cuando no sea 00:13:15
número, esto entero 00:13:17
ya es true, entonces al ser 00:13:19
true, la segunda parte ni te la evalúa 00:13:21
porque true or 00:13:23
lo que sea es true, me da 00:13:25
igual que la segunda parte sea falso o true 00:13:27
el or final va a ser true 00:13:29
con lo cual, si esto es true 00:13:31
y esto es el negado 00:13:33
de ser número, es decir, cuando no lo sea 00:13:35
ya no va a entrar 00:13:37
en la segunda parte de Lord 00:13:39
que es lo que queremos, que no entre si no es número 00:13:40
porque cómo va a convertir a entero 00:13:43
algo que no es número, no podría 00:13:45
¿vale? 00:13:46
entonces cuando cualquiera de las dos 00:13:49
se da, cualquiera de las dos 00:13:51
porque podría ser número, con lo cual 00:13:53
esto es falso, porque es un numerito 00:13:55
entonces sí que entraría aquí 00:13:57
porque esta es falsa, luego Lord depende ya de la segunda 00:13:58
parte 00:14:01
convertiría y no habría problema 00:14:02
porque ha sido número, porque de hecho 00:14:05
esto ha sido falso, convertiría 00:14:07
y al no ser múltiplo de 3 00:14:08
pues seguiría siendo falso 00:14:11
la agregada, entraría en el while 00:14:13
a pedir el siguiente, etc 00:14:15
bueno, pues todo esto solo 00:14:16
es para hacer la validación 00:14:19
si esto que yo he leído 00:14:20
es una sucesión de cifras que además 00:14:22
compone un número entero o no 00:14:25
vale, cuando yo 00:14:26
he salido ya del while 00:14:30
Ahora ya sí que sí 00:14:31
Me hago mi tamaño del array 00:14:33
Con el parseador ese maravilloso 00:14:37
¿Cómo lo llamáis? 00:14:40
Con el parsero 00:14:43
Pues ya el parsero 00:14:45
Nos ha convertido 00:14:52
La cadena leída a entero 00:14:54
Y ahora yo ya 00:14:56
Como aquí ya hay un código medio raro 00:14:58
Ya largo, tendría sentido 00:15:01
Hacer unas primeras pruebas 00:15:02
Porque aquí podemos haberla cagado 00:15:04
Vamos a hacer unas primeras pruebas 00:15:06
A ver si realmente el programa 00:15:09
Me está todo el rato pidiendo el número 00:15:10
Mientras no sea 00:15:12
Y no se llega a parar nunca 00:15:13
Vamos a probarlo porque no las tengo todas conmigo 00:15:16
Que no hayamos escrito aquí algo mal 00:15:19
Más, me voy a dar mal 00:15:20
Jolín 00:15:22
A ver 00:15:23
Vamos a ponerle aquí 00:15:24
El tamaño de la raíz 00:15:27
Será 00:15:31
El numerito este 00:15:32
que me han pedido que será múltiplo de 3 00:15:34
venga 00:15:37
lo ejecutamos 00:15:39
tamaño de la raíz, introduzca número 4 00:15:40
me sigue pidiendo 00:15:49
pero no es múltiplo de 3 00:15:51
y me sigue pidiendo 00:15:52
efectivamente yo le he metido algo que es una cadena 00:15:54
y tampoco le gusta 00:15:57
introduzca número 00:15:59
pues 87 es múltiplo de 3 00:16:02
vale, con lo cual 00:16:05
ya si que se ha quedado con el 87 00:16:07
Vale, pues esta primera validación parece que funciona 00:16:09
Está así todo el rato mientras yo le meta algo 00:16:12
Que es o cadena o número diferente de múltiplo de 3 00:16:14
Vale, pues ahora ya sí que hacemos el ejercicio sí o sí 00:16:19
Vamos a declararnos los arrays 00:16:23
Los arrays originales de partida 00:16:25
Array 1 00:16:28
Que será new int 00:16:31
De N mayúscula 00:16:33
Array 2 00:16:36
que será 00:16:40
un new int 00:16:43
de n mayúscula 00:16:46
y el resultado 00:16:48
lo pongo aquí abajo 00:16:50
que será 00:16:52
un array 00:16:54
de el doble 00:16:55
vamos cogiendo 00:16:58
3 de cada uno 00:17:00
tendrá el agregado de todos 00:17:02
pues el resultado va a ser 00:17:03
de 2 por n 00:17:06
uy que tontería hago aquí 00:17:08
resultado igual a 00:17:10
new int 00:17:12
de 2 por n 00:17:13
vale 00:17:16
y ahora ya es cuando 00:17:18
podemos pensar 00:17:26
como hacemos esto 00:17:27
vale pues 00:17:29
a ver 00:17:33
vale pues como lo habéis 00:17:40
pensado vosotros 00:17:50
imagino que muchos lo habéis hecho ya 00:17:51
Claro, pues 00:17:53
Hay muchas posibilidades 00:17:58
Supongo 00:18:02
3, 4, 5, 6 00:18:03
Aquí tenemos el otro 00:18:08
¿Vale? 00:18:09
Y el 00:18:15
Resultante 00:18:16
Bueno, espera, vamos a poner 00:18:19
La pizarra 00:18:20
Normal 00:18:23
Que ahí no se ve muy bien 00:18:24
Vale, la pizarrita 00:18:26
Bueno 00:18:32
Así más bonito 00:18:32
1, 2, 3, 4, 5, 6 00:18:35
Esta 00:18:39
Y ahora 00:18:44
El resultante que tiene el doble 00:18:48
Bueno, pues como lo habéis 00:18:50
Planteado, que es lo que habéis hecho 00:18:58
Los que lo habéis hecho 00:19:00
Primero 00:19:01
Hay que ir 00:19:03
Haciendo tres posiciones en cada 00:19:04
Claro 00:19:06
A ver 00:19:07
Podríamos, el tema es en el for que hagáis 00:19:17
El for que hagamos 00:19:22
El i del for 00:19:23
Que va a ir recorriendo 00:19:24
Si las posiciones del de abajo 00:19:27
O las posiciones de los de arriba 00:19:29
Y se van generando las de abajo multiplicando 00:19:31
Si va recorriendo las de arriba 00:19:33
Para i igual a 0 tendrá que generar la 0, la 1 y la 2 del de arriba, de la raíz primero 00:19:35
Y para i igual a 1 tiene que generar la 0, la 1 y la 2 de la raíz segunda 00:19:53
para i igual a 0 00:20:05
copia esta y esta 00:20:12
entonces seguimos en i igual a 0 00:20:15
para i igual a 0 00:20:16
tiene que generar 00:20:19
la 0, la 1 y la 2 de la raíz 00:20:20
segunda, copiarlo donde 00:20:23
si, perdón 00:20:25
0, 1 y 2 00:20:26
a la 0, 1 y 2 00:20:29
y la 0, 1 y 2 00:20:31
a la 3, 4 00:20:33
y 5 00:20:35
la 0, 1 y 2 00:20:35
de la raíz de arriba 00:20:39
la 0, 1 y 2 de este 00:20:40
y la 0, 1 y 2 de este 00:20:41
que estos van en paralelo 00:20:44
te generas este multiplicado por 3 00:20:45
y a sus consecutivas 00:20:48
entonces es una posibilidad 00:20:50
ir recorriendo 00:20:52
los a raíz de arriba de 3 en 3 00:20:53
esta 00:20:57
luego ya salta 0, 1, 2 00:20:58
saltas a la 3 00:21:00
luego ya saltas, ahora vas recorriendo de 3 en 3 00:21:01
3, 4, 5, saltas a las 6 00:21:04
vas recorriendo de 3 en 3 00:21:06
vas recorriendo los arrays de arriba 00:21:07
de 3 en 3 00:21:10
y ahora ya, para cada posición en la que te paras 00:21:11
haces 3 copias 00:21:14
y lo que tienes es que 00:21:17
generar donde lo vas copiando 00:21:18
pues vas copiando 00:21:20
en la que es del 00:21:22
de array de arriba 00:21:24
la que estás y del de array de abajo 00:21:25
en el que 00:21:28
estás, pero el de 00:21:30
la raíz de abajo, le sumas 3 00:21:32
más 00:21:35
me he explicado fatal, pero bueno 00:21:35
sabéis a lo que me refiero, aunque me he explicado 00:21:37
de pena, entonces 00:21:41
vamos a intentar hacerlo 00:21:42
más o menos con la idea esa, ir recorriendo 00:21:43
de 3 en 3 00:21:46
y en cada parada 00:21:48
pues tengo que decidir 00:21:49
donde me toca del de abajo 00:21:52
hacer las 6 copias 00:21:54
que tengo que hacer 00:21:56
a ver 00:21:57
Las 6 copias, 3 de cada uno 00:21:59
Bueno 00:22:03
Pues entonces 00:22:09
Mientras i sea menor que n 00:22:12
Que es el tamaño de los de arriba 00:22:18
Ay, perdón 00:22:20
i más igual 3 00:22:21
Vale 00:22:38
Dime 00:22:39
¿De dónde vas a sacar los números? 00:22:43
Los voy a sacar de array 1 y array 2 00:22:48
Y voy a ir copiando el resultado 00:22:50
Ah, vale, vale, que no los he rellenado 00:22:52
Sí, sí, sí, tienes toda la razón 00:22:57
Sí, sí, no los he rellenado, vale 00:22:59
Pues 00:23:01
Los voy a rellenar 00:23:02
En aleatorio para no meterlos 00:23:09
Vale, y aquí sería 00:23:10
Array 00:23:13
Uno de i 00:23:15
Igual a 00:23:17
Vamos a convertir a int 00:23:19
Un número aleatorio 00:23:21
Multiplicado 00:23:24
por 100 00:23:28
por ejemplo 00:23:30
y array 2 00:23:31
lo mismo 00:23:34
array 2, vale, luego 00:23:35
este es el posicionador 00:23:50
de arriba 00:23:53
vale, el posicionador 00:23:55
de arriba, y ahora el posicionador de abajo 00:23:57
o sea, y es el índice de los dos 00:24:00
arrays de arriba, que va para 00:24:03
del 0, 3, 6 00:24:04
pero luego necesito otro índice 00:24:06
para indicar donde voy copiando abajo 00:24:08
¿Vale? Entonces ese índice 00:24:10
¿Cómo le podemos llamar? 00:24:13
Pues j, ¿verdad? 00:24:15
j empieza valiendo 0 00:24:16
Entonces 00:24:17
Aquí 00:24:19
Resultado de j 00:24:25
De j más 1 y de j más 2 00:24:27
Sería 00:24:30
Array 1 de 00:24:32
i y más 1 00:24:33
Y más 2, ¿verdad? 00:24:36
Sí, es que es un poco lioso 00:24:41
Ya, ya, ya 00:24:42
Es que es un poco lioso 00:24:44
Vamos a intentar tenerlo claro en la pizarra 00:24:46
Lo que vamos a escribir 00:24:48
Porque si no se queda un poquito lioso 00:24:49
Porque uno se puede poner aquí a escribir 00:24:51
Y el que lo escribe, bueno, sí 00:24:52
En el mejor de los casos lo ve 00:24:54
Pero el otro, pues no lo ve 00:24:56
Vale 00:24:57
A ver 00:24:58
Vamos a intentar 00:25:02
Verlo en la pizarra 00:25:06
Que es como vosotros 00:25:10
En un caso similar tendréis que hacerlo en un examen 00:25:12
Pues, hombre, si no le sale de cabeza fenomenal 00:25:15
Pero normalmente 00:25:17
pues uno tiene que hacerse primero 00:25:18
su composición de lugar en el papel 00:25:21
vale 00:25:23
para 00:25:24
entonces 00:25:25
vale, los arrays originales 00:25:27
estos 00:25:41
el i se va a referir 00:25:45
a la posición que estoy en el 00:25:47
array de arriba y luego tengo 00:25:49
mi array resultado 00:25:51
y con el j me voy a referir 00:25:52
a donde escribo de mi array resultado 00:26:03
con el i me refiero 00:26:06
la posición en la que estoy arriba 00:26:08
y con el J me refiero 00:26:09
a la posición en la que estoy en el de abajo 00:26:12
¿no? vale 00:26:14
entonces en cada iteración 00:26:15
el I de arriba 00:26:18
va de 3 en 3, es una posibilidad 00:26:19
que estamos en sobre la marcha, entonces en la primera 00:26:22
iteración el I se para en la 0 00:26:24
para trabajar con 00:26:26
estos 3 primeros, para trabajar con estos 3 00:26:27
en la siguiente 00:26:30
iteración el I se para 00:26:32
en el 3 00:26:33
para trabajar con y trabajará 00:26:34
con estos tres siguientes, en la siguiente iteración 00:26:38
el i está aquí colocado, en el seis 00:26:43
para trabajar con estos tres siguientes, entonces las iteraciones 00:26:46
del bucle van a ir, primera iteración 00:26:51
tengo estos tres, siguiente iteración tengo estos, siguiente iteración tengo estos 00:26:54
vale, entonces en cada iteración lo que ocurrirá 00:26:59
es que yo estaré escribiendo seis de golpe 00:27:03
Entonces en cada iteración estoy escribiendo 6 de golpe 00:27:06
Luego J, para empezar, en cada vuelta de ese for 00:27:11
Se quedará incrementado 6 posiciones 00:27:17
Porque en cada iteración yo lo estoy escribiendo en 6 sitios 00:27:20
Luego J se va a quedar incrementado en 6 posiciones 00:27:25
Vale, ahora lo que tenemos que ver es que escribimos cada vez 00:27:29
Bueno, pues de cada bloque de cada pack 00:27:32
Puedo hacer mi posición I en la posición J que me toque 00:27:37
La I más 1 en la J más 1 00:27:44
Y la I más 2 en la J más 2 00:27:46
Y luego del otro bloque 00:27:49
La I en la J más 3 00:27:52
La I más 1 del segundo bloque en la J más 4 00:27:55
y la I más 2 00:27:58
del segundo bloque es la J más 5 00:28:02
esa es una posibilidad fácil 00:28:03
entonces cada vuelta del bucle 00:28:07
for de arriba trabaja 00:28:09
con dos packs de 3 00:28:11
cada vuelta trabaja con dos packs de 3 00:28:13
y cada vuelta 00:28:16
me va escribiendo esos packs 00:28:17
en estas posiciones 00:28:18
con lo cual J se va a quedar incrementado 00:28:20
en 6 efectivamente cada vez 00:28:22
entonces bueno 00:28:24
lo podemos plantear así 00:28:27
igual lo habéis hecho de otra manera 00:28:28
yo voy dando vueltas 00:28:29
cada vuelta coge, va de 3 en 3 00:28:31
en cada vuelta 00:28:33
cojo los que están a continuación de ese i 00:28:35
y los escribo donde toquen 00:28:37
el i en el j, el i más 1 en el j más 1 00:28:39
el i más 2 en el j más 2 00:28:42
y el i del otro en el j más 3 00:28:44
este i 00:28:46
este i más 1 del otro en el j más 4 00:28:47
y este i más 2 del otro en el j más 5 00:28:50
por ejemplo 00:28:52
por ejemplo 00:28:54
vale, vamos a intentar ahora 00:28:55
reproducir esto 00:28:58
a ver 00:28:59
a ver si nos acordamos de lo que hemos dicho 00:29:07
mi jota tiene que empezar valiendo 0 00:29:13
si o si, por eso lo he metido aquí 00:29:21
mi jota va valiendo 0 00:29:23
y ahora 00:29:26
resultado de jota 00:29:27
pues el primero 00:29:30
de el array de arriba 00:29:33
array de i 00:29:36
Y J se tiene que quedar incrementado 00:29:38
¿Vale? 00:29:42
J lo dejo incrementado 00:29:44
Porque la siguiente copia 00:29:46
El siguiente elemento lo voy a copiar 00:29:48
En el siguiente de J 00:29:49
Resultado de J 00:29:52
Y se sigue quedando incrementado para la siguiente copia 00:29:53
Array1 de I más 1 00:29:56
Ahora 00:29:59
Array1 de I más 1 00:29:59
Resultado de 00:30:10
J más más 00:30:15
este 00:30:17
y sigo asignándole a la J 00:30:19
pero ahora me toca el array 2 00:30:22
entonces esto mismo 00:30:24
lo pongo aquí 00:30:29
y array 2 00:30:33
vale, entonces lo que hemos 00:30:34
dicho en la pizarra sería esto 00:30:42
voy sucesivamente 00:30:44
al J dejándolo incrementado 00:30:46
con lo cual en total se va a incrementar 6 veces 00:30:48
justo se le hacen 6 copias 00:30:50
en las primeras 00:30:52
3 posiciones copio las 3 00:30:54
que toquen de raíz 00:30:56
y en las siguientes tres posiciones 00:30:57
toco las otras tres que tocan 00:31:00
del otro 00:31:03
e i va de tres en tres 00:31:03
vale 00:31:08
entonces primero vamos a ver si esto funciona 00:31:10
esto lo que pasa es que así queda muy feo 00:31:17
porque claro, yo observo esto, aquí veo un patrón 00:31:20
entonces esto lo podría 00:31:22
meter a su vez en un bucle 00:31:24
lo podría, vale, porque aquí estoy viendo un patrón 00:31:25
pero bueno, vamos a ver si esto funciona 00:31:28
Vale, y ahora vamos a ver el resultado final 00:31:31
Antes que nada 00:31:34
Vamos a mostrar los Arrays 00:31:35
A ver si realmente los ha intercalado 00:31:38
Vamos a mostrar aquí primero el Array 1 00:31:39
Array 1 00:31:42
El Array 1 sería 00:31:46
Para cada numerito en Array 1 00:31:49
Muéstrame el numerito 00:31:53
Salto de línea 00:32:05
Y ahora voy a mostrar el Array 2 00:32:13
y el array dos 00:32:15
lo muestro aquí 00:32:28
vale, aquí estoy mostrando los dos 00:32:29
arrays con los valores que me ha generado aleatoriamente 00:32:34
los que sean, y ahora voy a mostrar 00:32:36
el resultante 00:32:38
a ver el resultante, a ver 00:32:39
que hemos hecho aquí 00:32:42
para cada numerito n en mi 00:32:43
resultado 00:32:48
muéstrame 00:32:48
resultado 00:32:52
muéstrame 00:33:03
ala, vamos a ver esta primera 00:33:06
versión, a ver si nos hemos salido 00:33:11
de la RAI en algún sitio o hemos hecho 00:33:13
algo raro, venga 00:33:15
pues vamos a decirle 00:33:22
que 12 00:33:24
vale 00:33:25
si, lo ha hecho bien 00:33:27
primero ha metido este pack 00:33:35
luego ha metido este 00:33:38
otro 00:33:40
luego este otro 00:33:41
luego este otro 00:33:44
bueno 00:33:46
pues si ha funcionado 00:33:48
vale 00:33:49
¿dónde podría incrementarla si no? 00:33:52
es que la incremento 00:34:25
cada vez que hago una asignación 00:34:26
entonces hago 00:34:27
aquí hago una asignación, la tengo que dejar 00:34:30
incrementada porque inmediatamente 00:34:32
después viene otra 00:34:34
entonces hombre, a ver, tendrías esta alternativa 00:34:35
si no la incrementas aquí, es que solo hay una alternativa 00:34:38
que es aquí 00:34:40
no hay otra, tienes que incrementarla 00:34:42
en cualquier caso antes de la siguiente 00:34:44
asignación, antes de la siguiente tienes que hacerlo 00:34:46
Porque si no estás pisando esa 00:34:48
Entonces si no la pones aquí 00:34:49
La tienes que poner aquí abajo 00:34:51
Y bueno, ponerla aquí abajo en cada una 00:34:53
Se me complica mucho el código 00:34:56
Mucho más cómodo si la meto ahí, ¿no? 00:34:57
Más cómodo si la meto ahí 00:35:01
Pero si no la pones ahí 00:35:02
Es que no hay otra, ¿qué es ponerla ahí? 00:35:04
Entonces queda más cómodo, más bonito 00:35:08
Si lo metemos así 00:35:10
Vale, entonces 00:35:11
Bueno, pues es una posibilidad 00:35:17
a lo mejor lo habéis dicho de otra manera 00:35:27
o lo que sea, pero siempre tratad de 00:35:30
primero haceros una idea clara 00:35:32
de lo que queréis hacer 00:35:34
y luego ya plantáis ese código 00:35:35
y ya está 00:35:38
no hace falta que sean revesados 00:35:39
ni nada 00:35:44
¿alguien ha dicho Raquel? 00:35:45
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:
3
Fecha:
21 de noviembre de 2025 - 13:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
453.52 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid