Saltar navegación

20251117 EjerArrays_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 17 de noviembre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues ahora sí, vamos a corregirlo. 00:00:01
Vale, el problema parte de dos arrays con números que ya rellenaremos. 00:00:18
Este array de aquí lo inicializo a la vez que lo declaro, no pasa nada. 00:00:30
Este otro array de aquí que lo inicializo a la vez que lo declaro, no pasa nada. 00:00:38
y este array de aquí, que como este array tiene que tener 00:00:42
los elementos de los otros dos, tendrá que tener el doble de posiciones 00:00:46
lógicamente, entonces este ejercicio está hecho para 5, 5 y 10 00:00:50
pero podría estar hecho para un array con N mayúscula 00:00:55
siendo N lo que sea, que yo he leído por teclado 00:00:59
otro array con N mayúscula siendo N lo que sea, y entonces este tendría que ser 00:01:02
2 por N, ¿vale? lo podríamos generalizar así 00:01:06
leyendo n por teclado y ya está 00:01:11
nos da lo mismo 00:01:13
vale, pues entonces 00:01:15
una vez rellenos los dos arrays 00:01:17
números 1 y números 2 00:01:21
que tienen las posiciones 00:01:23
que sean cada uno 00:01:30
5 en este caso 00:01:31
hay que construir el que tiene el doble de posiciones 00:01:33
pero claro 00:01:36
a la posición 0 00:01:41
¿cuál va? 00:01:43
la 0 de esta 00:01:45
pero a la 1 va a la 0 de esta otra. 00:01:46
A la posición 1, la posición 1 de esta va a la 2 00:01:51
y la posición 1 de esta va a la 3. 00:01:55
Entonces, primero tenemos que entender dónde va cada una, ¿no? 00:02:00
Se van a intercalar. 00:02:02
Entonces, ahora ya que entendemos lo que va pasando, pues lo vamos pensando. 00:02:03
Bueno, pues aquí yo de nuevo veo, así a simple vista, 00:02:07
estoy viendo de nuevo 00:02:12
una sucesión de pares y de impares 00:02:13
es decir 00:02:17
el array de arriba 00:02:18
sus elementos 00:02:20
van cayendo 00:02:22
en la 0 00:02:23
en la 0, en la 2 00:02:25
en la 4 00:02:31
en la 6, en la 0, 2 00:02:32
4 y 6 van cayendo 00:02:35
los elementos de la de arriba 00:02:37
y sin embargo 00:02:39
los elementos de la de abajo 00:02:41
Van cayendo 00:02:43
En la 1 00:02:45
En la 3 00:02:46
En la 5 00:02:48
¿Vale? Eso es lo que voy observando 00:02:50
Según voy analizando el problema 00:02:53
Entonces yo analizo el problema 00:02:55
Lo describo 00:02:57
Voy viendo un poquito cómo funciona 00:02:58
Y ya empiezo a ver a partir de ahí 00:03:00
Patrones, referencias 00:03:02
A cosas que ya sé, que ya he manejado 00:03:04
Empiezo a ver esas pequeñas 00:03:06
Referencias 00:03:09
A situaciones en las que ya 00:03:10
he lidio alguna vez 00:03:12
hombre, pues aquí estoy viendo que 00:03:13
las posiciones a donde van a caer 00:03:16
los números de la 00:03:19
de la raya de arriba 00:03:20
son una sucesión de pares 00:03:22
0, 2, 4, 6 00:03:23
sin embargo, las posiciones 00:03:25
a donde van a caer los números de abajo 00:03:28
es una sucesión de impares 00:03:30
1, 3, 5, 7 00:03:32
entonces ya sabemos como generar 00:03:33
una sucesión de pares 00:03:36
y una sucesión de impares 00:03:38
en particular la de impares ya la hemos generado a veces 00:03:39
Si yo quiero generar la sucesión de números impares, pues 2 por el generador que sea más 1. 00:03:41
Cuando x es igual a 0, ¿qué más se ve el azul? 00:03:50
Si yo tengo 2 por y o por x, me da igual más 1. 00:03:56
Entonces ya sabemos que esta función matemática, esta expresión matemática me va generando todos los impares para igual a 0, 1, 2, 3, ¿verdad? 00:04:07
Cuando y es igual a 0 me genera el 1, pero cuando y es igual a 1 me genera el 3, ¿verdad? Esto ya lo hemos manejado otras veces, me genera el 1. 00:04:19
pero cuando i es igual a 1 me genera el 3 00:04:28
y cuando i es igual a 2 me genera el 5 00:04:30
entonces esta función ya la hemos usado a veces 00:04:33
cuando necesitábamos generar una sucesión de impares 00:04:36
¿vale? 00:04:40
pues la sucesión de pares ¿cómo será? 00:04:41
pues en lugar de 2 por i más 1 00:04:44
2 por i 00:04:45
2 por i será la sucesión de pares 00:04:46
cuando i es igual a 0 me genera el 0 00:04:49
pero cuando i es igual a 1 me genera el 2 00:04:52
y cuando y es igual a 2 me genera el 4 00:04:56
entonces 00:04:59
estas dos expresiones 00:05:00
pues las tenemos ya 00:05:03
archivadas en nuestra cabeza, como tantas 00:05:05
cosas tenemos ya archivadas 00:05:06
con las que hemos trabajado 00:05:08
para yo identificarlas rápidamente cuando veo un problema 00:05:10
ya voy identificando y digo, ah vale 00:05:13
pues yo voy recorriendo 00:05:14
puedo hacerlo como 00:05:17
voy recorriendo estos arrays 00:05:18
para la posición 0, para la 1 00:05:20
para la 2, para la 3 00:05:23
y voy generando para cada posición 00:05:24
la 0, la 1, la 2, la 3 00:05:28
pues para cada una de ellas 00:05:30
voy generando el par y el impar 00:05:32
los dos 00:05:35
en el impar colocaré en la raíz de arriba 00:05:36
y en el par colocaré el de abajo 00:05:40
entonces se tratará de 00:05:42
a partir de las posiciones que hay aquí 00:05:44
la 0, la 1, la 2, la 3, la 4 00:05:46
a partir de estas posiciones 00:05:48
generar la sucesión de los pares 00:05:50
y la sucesión de los impares 00:05:53
esas sucesiones 00:05:56
me van a decir donde voy colocando 00:05:58
cada elemento 00:06:00
y ya está 00:06:01
más o menos con eso ya puedo tener una primera idea 00:06:03
de por donde tirar, como arrancar 00:06:06
entonces ahora ya pues 00:06:08
empiezo a dar forma, la empiezo a programar 00:06:09
y empiezo a afinar, a ver si lo completo 00:06:11
vale 00:06:14
pero identificar siempre pues todos los 00:06:15
cuando uno analiza un problema 00:06:18
va analizando patrones 00:06:19
que ya le recuerdan 00:06:22
le hacen traer 00:06:23
cosas con las que ya ha trabajado 00:06:25
¿vale? tenemos que apoyarnos siempre 00:06:29
en lo que ya sabemos, por eso es tan importante 00:06:31
la memoria para programar 00:06:33
¿vale? la memoria 00:06:35
lo más importante 00:06:37
lo segundo más importante 00:06:39
pegadito justo detrás de la memoria 00:06:42
el razonamiento lógico 00:06:43
claro, lo tercero 00:06:45
muy pegadito a lo anterior 00:06:48
la práctica, la práctica, la práctica 00:06:49
en la práctica, ¿vale? 00:06:51
Bueno, pues entonces, si ahora ya 00:06:54
con esta idea 00:06:56
intentamos hacerlo 00:06:56
pues 00:06:59
nos queda 00:07:01
esto, ¿vale? 00:07:03
Pues vamos a ir recorriendo 00:07:11
los arrays 00:07:12
números.length 00:07:15
números1, perdón, .length 00:07:25
vale, pues a ver 00:07:28
Y va variando entre 0, 1, 2, 3 y 4 00:07:31
Porque es 5, si fuera otro número, lo que fuera, y va variando 00:07:37
Pues con 2 por i, yo voy generando 00:07:40
Con 2 por i sé que voy generando los pares 00:07:44
Con esta expresión, 2 por i, iré generando 00:07:46
0, 2, 4, 6, que es justo 00:07:49
A la posición de mi array resultado que tengo arriba 00:07:53
A esta posición, que es justo 00:07:57
Donde quiero que vaya 00:08:00
Este 00:08:02
Es justo donde quiero que vaya este 00:08:03
¿Vale? 00:08:08
Cada 00:08:11
Todos y cada uno de las posiciones 00:08:12
Del primer array 00:08:14
Del de arriba 00:08:16
Van a ir ¿Dónde? A la 0 00:08:17
A la 2, a la 4 00:08:20
Si, no se lo asigno, ahora se lo 00:08:21
No lo relleno, ahora lo relleno, ¿Vale? 00:08:26
Si, estaba pensando en esto 00:08:27
Y ahora, 2 por i más 1 00:08:28
2 por i más 1 00:08:31
¿Qué me va generando? 00:08:35
Me va generando 00:08:37
1, 3, 5, 7 00:08:38
Que son justo las posiciones del array resultado 00:08:41
A donde van a ir 00:08:43
Las posiciones del segundo array 00:08:44
Son justo 00:08:47
Pues entonces son justo 00:08:48
Las posiciones 00:08:51
A donde van a ir los del otro array 00:08:52
¿Vale? 00:09:03
Entonces 00:09:05
La 0, 1, 2, 3 de cada uno de ellos 00:09:05
va a ir a la sucesión 00:09:09
de posiciones pares 00:09:10
y a la sucesión 00:09:12
de posición impares 00:09:15
a las de pares irá número 1 00:09:16
y a las de impares irá número 2 00:09:19
efectivamente no lo he rellenado 00:09:20
voy a rellenarlo 00:09:23
para no tener que meterlo por teclado 00:09:25
con números aleatorios 00:09:27
y así no tengo que cuando lo ejecute meterlo por teclado 00:09:29
todo el rato 00:09:31
entonces vamos a recorrer 00:09:32
y ahora 00:09:34
ah uy 00:09:43
Números 1 de i 00:09:45
Lo vamos a rellenar con 00:09:55
El resultado de generar un número aleatorio 00:09:57
Entre 0 y 100 00:10:01
Pero como esto me lo da en decimal 00:10:05
Me lo da en decimal 00:10:09
Pues le voy a hacer el casting entero 00:10:10
Y el otro array, números de 2 también 00:10:13
Números aleatorios para no andar ahí 00:10:21
Números 2 00:10:24
Vale 00:10:28
antes de hacer la mezcla 00:10:32
vamos a mostrarlos 00:10:34
para luego poder comprobar que realmente 00:10:36
se han intercalado bien 00:10:39
pues vamos a mostrar 00:10:40
otro array para mostrar 00:10:44
y luego introducimos 00:10:46
aquí vamos a mostrar 00:10:51
números 00:11:04
uno de i 00:11:10
y luego voy a mostrar el segundo 00:11:11
bueno voy a mostrar las posiciones 00:11:17
así 00:11:20
Números 2 de i 00:11:20
Vale, esto es solamente para mostrar 00:11:27
Todas y cada una de las posiciones de los dos arrays 00:11:29
La primera posición del primero 00:11:31
La primera posición del segundo 00:11:34
La segunda del primero 00:11:36
La segunda del segundo 00:11:37
Para luego comprobar si realmente se ha intercalado bien 00:11:38
Y ahora vamos a mostrar 00:11:41
El resultado 00:11:43
Vamos a mostrar el resultado 00:11:45
A ver si lo he intercalado correctamente 00:11:58
Vale 00:12:05
Pues esta sería nuestra primera versión del código 00:12:06
Una vez revisado 00:12:09
Vale, no tiene errores de compilación 00:12:12
Le veo sentido 00:12:14
Empezamos a hacer pruebas 00:12:15
Empezamos a hacer pruebas 00:12:17
A ver si esto funciona 00:12:19
Tiene errores 00:12:22
Vale, pues estos son los dos arrays 00:12:23
Y efectivamente 00:12:29
Los ha ido intercalando 00:12:32
36, 44 00:12:33
88, 12 00:12:36
39, 37 00:12:38
Pues sí, ha rellenado dos arrays con números aleatorios y luego ha generado uno con diez posiciones, que es este, donde he ido intercalando los demás, ¿vale? 00:12:40
Subir es esto, ¿vale? Pues esta sería la primera aproximación de esa otra manera, recorriendo la array grande. 00:13:07
Si estoy en posición par, lo relleno con el de arriba y si estoy en posición impar, lo relleno con el de abajo. 00:13:22
primera aproximación 00:13:28
pero claro, no, ya se ponía a pensar 00:13:30
y si hiciera las pruebas 00:13:33
ya vería que no me funciona 00:13:35
pero si se ponía a pensar lo diría, claro 00:13:36
en la posición 0 00:13:39
cuando ires la 0 yo quiero la 0 00:13:41
cuando i avanzado 00:13:42
y estoy en la 1 00:13:45
genial, estaré poniendo la 1 00:13:46
ahora i a vuelto a avanzar, estoy en la 2 00:13:48
¿qué números no tengo que poner? 00:13:51
según esto estaré poniendo la posición 2 00:13:55
de número 1, no, no, no 00:13:57
No, la posición 2 no, te está saltando 1, ¿vale? 00:13:58
Es decir, con esto que estamos haciendo aquí, estaríamos haciendo lo siguiente. 00:14:01
Con esto que estamos haciendo aquí, tengo el array de arriba, números 1. 00:14:15
El array de abajo, números 2. 00:14:23
Y luego tengo el resultado, con el doble de posiciones. 00:14:28
Resultado 00:14:32
Para la posición 0 00:14:37
Esto no cambia de colorcito solo 00:14:39
Para la posición 0 00:14:45
Como es par 00:14:49
Estupendo 00:14:50
En la posición 0 irá este 00:14:51
El 1, muy bien va el 1 00:14:54
Ahora salto a la posición 1 00:14:56
Que es esta, muy bien 00:14:58
La 0, la 1, la 0, la 1 00:14:59
Salto a la 1 00:15:01
En la 1, como es impar 00:15:02
Oye, dame la posición 1 de este 00:15:05
Primer problema 00:15:08
Imaginaos que aquí hay un 2 y un 3 00:15:09
Primer problema, no, es que en la 1 no quiero la posición 1 de este 00:15:12
No quiero la misma, quiero la primera 00:15:17
El problema es que en este for yo voy recorriendo la 0, la 1, la 2 y la 3 00:15:19
Pero las tengo que ir rellenando con las posiciones equivalentes del otro 00:15:26
Es decir, la 1 no va con la 1 de este, sino con la 0 00:15:30
Y la 3, 0, 1, la 3 no va con la 3 de este, sino con la 1, ¿vale? 00:15:34
O sea, el problema está claro, porque no nos funcionaría. 00:15:42
Otra cosa es cómo lo arreglamos, ¿vale? 00:15:44
Pero entendéis que este haría a la 0 de este, la 0, muy bien. 00:15:47
A la 1, la 1, fatal, quiero la 0. 00:15:51
A la 2, la 2 de este, no, no, no, perdona, te ha saltado esta. 00:15:55
A la 3, la 3 de este, no, no, perdón, quiero esta. 00:15:59
¿vale? entendéis que los índices 00:16:02
no van a la par 00:16:04
en el recorrido del de abajo 00:16:06
no van a la par con los de arriba 00:16:08
entonces el problema está claro 00:16:10
¿no? 00:16:12
¿por qué no funcionaría? 00:16:16
¿está más o menos claro? 00:16:19
porque esta asignación 00:16:20
esta posición 00:16:21
y esta posición no son la misma 00:16:23
a la cero 00:16:26
sí que va a la cero, pero a la uno 00:16:27
no va a la uno de estas, sino a la cero 00:16:30
de estas 00:16:32
y a la 1 de esta 00:16:32
no va la 00:16:35
y a la 2 00:16:35
no va la 2 de esta, sino la 1 00:16:37
y a la 3 de aquí 00:16:40
no va la 3 de esta, sino la 1 00:16:42
es decir, van por 00:16:44
van por libre 00:16:46
entonces estas posiciones 00:16:47
nos las tenemos que ir ingeniando 00:16:49
para que no sigan la secuencia 00:16:52
de las de arriba, estas posiciones en la 00:16:54
primera iteración 00:16:56
¿vale? esta posición tiene que ser 00:16:57
cero, y en la siguiente 00:17:00
iteración no tiene que 00:17:02
haber cambiado, y ya en la 00:17:04
siguiente tiene que haber cambiado, entonces este 00:17:06
índice tiene que ser otro 00:17:08
este índice tiene que ser otro, que vaya por libre 00:17:09
llamémosle x 00:17:12
y este tiene que ser otro 00:17:13
llamémosle y, que empiezan valiendo 00:17:15
cero, y se incrementan 00:17:18
solo cuando usamos 00:17:20
su valor, solo, pero 00:17:22
son dos índices que van por libre, empiezan valiendo 00:17:24
cero, eso sí, y se incrementan 00:17:26
solo cuando usamos su valor 00:17:28
Entonces, esto pues lo podríamos hacer así 00:17:30
Por ejemplo, pues, ¿vale? 00:17:38
Aquí, por ejemplo 00:17:48
Yo aquí he aprovechado ya, he metido tres variables 00:17:49
¿Vale? 00:17:58
He metido tres variables 00:18:01
He metido tres 00:18:02
Este va a ser el indicador de la posición en la que estoy 00:18:07
del array grande, el indicador de la posición del array 00:18:12
números 1 y el indicador de la posición del array números 2, entonces 00:18:16
para la primera posición del array que es par 00:18:20
pues le asigno la primera de x y ya x 00:18:24
lo dejo incrementado, ya x lo dejo incrementado 00:18:28
para que la siguiente vez que asigne una posición de números 1 sea 00:18:31
la siguiente y aquí no le asigno 00:18:36
la i, le asigno su posicionador 00:18:41
que es el i, y lo dejo incrementado 00:18:42
para que la siguiente vez que lo use 00:18:45
asigne la siguiente 00:18:47
entonces estas posiciones empiezan en 0 00:18:48
también las dos empiezan en 0 00:18:51
pero se van incrementando 00:18:52
solo cuando se usan 00:18:56
no en cada iteración del bucle, no en cada iteración 00:18:58
solo cuando se usan 00:19:00
cuando i es igual a 0 00:19:02
como es par, estoy usando la posición 0 00:19:04
y se queda incrementado a 1 00:19:06
cuando i es igual a 1 00:19:07
vengo por aquí 00:19:10
asigno y que es igual a 0 y la dejo 00:19:12
incrementada a 1, pero la x sigue 00:19:14
siendo 1, la de antes 00:19:16
vale, o sea estas son 00:19:18
las posiciones que yo voy cogiendo 00:19:20
de esos dos a raíz, las voy 00:19:23
cogiendo según las necesito 00:19:24
para la 0, cojo la 0 00:19:26
y la dejo incrementada 00:19:28
para la 1, cojo la 0 00:19:30
y la dejo incrementada 00:19:32
para la 2, cojo la 1, que era como se había 00:19:33
quedado antes y la dejo incrementada 00:19:36
para la 3, cojo 00:19:39
la 1, que era como si había que la 2, perdón 00:19:41
cojo la 1 y la dejo incrementada 00:19:43
este es el indicador 00:19:44
de la posición de números 00:19:47
1 y números 2 en el que estoy 00:19:49
entonces no tendría sentido que 00:19:50
aquí yo dijera 00:19:56
ah bueno, lo voy a poner aquí 00:19:58
los incrementos los voy a poner ahí 00:19:59
no, no hay no, porque entonces se incrementaría 00:20:02
en cada vuelta, no, en cada vuelta 00:20:04
no, este se incrementa solo 00:20:06
cuando lo uso, solo cuando lo uso 00:20:08
cuando he entrado en el else, ese 00:20:10
no se incrementa, ese no se toca 00:20:12
y este se incrementa solo cuando lo uso 00:20:14
para apuntar al siguiente 00:20:17
para apuntar al siguiente, no en cada vuelta 00:20:18
en el if no 00:20:20
se incrementan solo en la iteración en la que 00:20:21
entramos, cuando se usa 00:20:25
no siempre, por eso no lo pondría aquí 00:20:26
esto 00:20:28
no lo pondría ahí, vale 00:20:29
pues vamos a ver si se han 00:20:35
intercalado bien de esta otra manera 00:20:40
a ver si lo hemos hecho bien 00:20:43
vale 00:20:49
a ver 00:20:55
15, 1, 51, 45 00:20:57
15, 1, 51, 45, sí 00:20:59
Se han intercalado exactamente igual 00:21:01
Que de la otra manera 00:21:04
Se ha hecho bien 00:21:05
¿Vale? 00:21:07
Bueno, otra forma de hacerlo 00:21:16
Que entiendo que es por la que tú 00:21:17
Querías hacerlo, ¿no? 00:21:19
¿Y cuál era tu problema? 00:21:22
Pues a lo último 00:21:23
Que en vez de ponerlo 00:21:24
El x más más 00:21:26
En el y 00:21:28
Lo hacía en cien 00:21:30
Claro, entonces te ibas saltando 00:21:32
Posiciones que no se llegaban a asignar 00:21:35
Nunca porque te las estabas saltando 00:21:37
Vale 00:21:39
Y de hecho te saldría en algún momento 00:21:41
Una rain desbound exception 00:21:44
Porque llegaría el momento en que la X se sale del 5 00:21:46
Claro 00:21:49
Llega hasta 10 de hecho 00:21:50
Bueno, más o menos, ¿entendido? 00:21:52
Más o menos 00:21:57
Vale, pues 00:21:58
Siguiente 00:22:02
¿Qué vais y vamos a hacer? 00:22:07
¿Tenéis alguna petición o elijo? 00:22:10
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:
2
Fecha:
17 de noviembre de 2025 - 18:26
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
22′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
600.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid