Saltar navegación

20251117 EjerArrays_5_incluyeFOREACH - 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.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues venga, 14. 00:00:00
Aquí ya tengo la primera parte. 00:00:01
A ver, lo he hecho para que en lugar de 10 00:00:04
sea una cantidad de tamaño genérica. 00:00:06
Para que no sea exactamente 10, 00:00:09
pero da igual, no cambia nada. 00:00:11
Pide al usuario tamaño del array 00:00:12
con el que va a trabajar. 00:00:14
N, que se mete aquí. 00:00:16
Y lo que hago es reservar un array 00:00:18
con una posición más. 00:00:22
Porque lo que va a hacer el programa 00:00:24
es insertar uno nuevo. 00:00:25
Entonces, al insertar uno nuevo 00:00:27
y desplazar los otros necesita un espacio más 00:00:29
por eso he reservado 00:00:31
un espacio más 00:00:33
que los números que realmente va a meter el usuario 00:00:35
al principio 00:00:37
vale, pues primero rellenamos las 00:00:38
n primeras posiciones 00:00:41
con números aleatorios 00:00:43
para no andar con teclado 00:00:45
aquí simplemente 00:00:46
estoy mostrando el array para ver 00:00:49
lo que ha 00:00:51
lo que ha generado, mostramos el array 00:00:52
y ahora ya 00:00:55
Posición en la que quieres insertar 00:00:57
Y nuevo número a insertar 00:00:59
Vale, a partir de aquí es donde ya empieza 00:01:01
El problema 00:01:03
¿Vale? 00:01:04
Entonces, esto de nuevo 00:01:07
Pues esto de nuevo 00:01:09
Lo podemos plantear 00:01:24
A ver 00:01:29
Vale, pues yo tengo aquí 00:01:30
Perdido la práctica con esto 00:01:44
Rápida que era el año pasado 00:01:49
Vale 00:01:52
Vale, tenemos nuestro array 00:01:53
De n posiciones 00:01:56
Y esta última 00:01:57
Vale, esta última de aquí 00:01:59
Es una adicional 00:02:02
Porque como todos se van a mover 00:02:05
Hacia, vale 00:02:06
Aquí tengo mi array 00:02:08
Vale, entonces luego me dicen 00:02:10
Posición en la que vas a 00:02:12
A meter el dato 00:02:14
Pues por ejemplo aquí 00:02:17
Ahí voy a meter el dato 00:02:18
Vale, el nuevo dato que me den 00:02:20
El 3, el 4, el numerito que sea 00:02:22
Lo voy a insertar ahí 00:02:24
Bueno, pues entonces, ¿cuál es mi problema? 00:02:25
La asignación de este nuevo número 00:02:28
A esta posición, está clara 00:02:30
A la posición en la que me han dado 00:02:32
Llamémosla pos 00:02:34
O llamémosla como sea 00:02:36
A la posición en la que me han dado 00:02:37
Esta pos 00:02:40
Pues nada, yo le asigno el 3 00:02:41
Pero claro, antes tengo que haberme preocupado 00:02:44
De mover estos 00:02:46
todos una posición hacia arriba 00:02:48
tengo que haber preocupado de esto 00:02:51
entonces una vez que los he movido todos 00:02:53
una posición hacia arriba, ya puedo asignar 00:02:55
a la posición pos 00:02:57
ya podré asignar 00:02:59
a esta posición ya podré asignar este numerito 00:03:01
entonces 00:03:03
¿cómo los voy moviendo hacia arriba? 00:03:05
no puedo hacer directamente 00:03:07
a la posición i más 1 00:03:08
asígnale i, y así todo el rato 00:03:11
porque entonces borramos 00:03:13
la i más 1 y cuando haya que copiar 00:03:15
Esta en esta ya la hemos perdido 00:03:17
Entonces tenemos que ir de arriba hacia abajo 00:03:18
Que es 00:03:21
Oye, a esta posición 00:03:22
Copia lo que hay aquí 00:03:24
Ala, muy bien 00:03:26
Este ya se ha movido aquí 00:03:28
Aquí queda el que estaba 00:03:30
Pero ahora ya a esta posición 00:03:32
Copia el que hay aquí 00:03:34
Se queda este duplicado, muy bien 00:03:36
Y ahora, a esta posición 00:03:38
Copia el que hay aquí 00:03:40
Se queda este duplicado, así hasta que lleguemos 00:03:41
A esta posición, copia el que hay aquí 00:03:44
se queda este duplicado, cuando ya hemos terminado 00:03:46
asignamos a esta posición el número 00:03:49
y se acabó 00:03:51
entonces tenemos que hacer un bucle 00:03:52
que va desde la última 00:03:54
hasta la que 00:03:57
tengo que insertar 00:03:59
y en cada una de ellas asigno 00:04:00
a esa posición su anterior 00:04:03
cuando ya he hecho eso 00:04:04
a esta de aquí que se me ha quedado duplicada 00:04:06
le copio el nuevo número y ya está 00:04:08
vale, pues entonces 00:04:11
esto, un for 00:04:15
mientras si 00:04:18
empezando en la última 00:04:22
vale, empezando en la última 00:04:24
mientras si sea 00:04:27
mayor o igual 00:04:28
que la posición en la que tengo que insertarlo 00:04:29
porque voy desde arriba 00:04:33
hacia abajo 00:04:35
y decrementando 00:04:35
n es 00:04:37
el tamaño 00:04:43
del array 00:04:46
los números que hay en el array 00:04:47
este es mi array 00:04:49
que tiene 00:04:50
n mayúscula números más 1 00:04:52
que he reservado yo aquí 00:04:55
entonces la posición n es esta 00:04:56
¿cómo se llama la raíz? 00:04:59
la raíz se llama números 00:05:04
y lo he declarado 00:05:05
de n más 1 00:05:08
posiciones 00:05:09
has puesto el tamaño 00:05:10
claro, para que no sea 10 00:05:12
que sea el tamaño que él me diga 00:05:14
entonces, él me va a decir 00:05:17
voy a meter 7 números 00:05:19
Pues yo lo declaro con una posición más extra 00:05:21
Una más extra 00:05:24
Vale, y ahora ya 00:05:25
Pues desde arriba hacia abajo 00:05:28
¿Qué voy a hacer? Pues en números 00:05:30
De i 00:05:31
Asignale 00:05:33
La que tiene antes 00:05:35
Asignale la que tiene antes 00:05:37
Y ya está, con este primer for 00:05:44
Con este primer for de aquí 00:05:48
A ver si esto se abre 00:05:51
vale, pues que estamos haciendo aquí 00:05:53
tenemos 00:06:01
este es el array 00:06:07
que yo le he reservado 00:06:10
n más una posiciones 00:06:12
vale, le he reservado 00:06:14
n más una 00:06:16
para que tenga aquí una extra 00:06:18
ya que tiene que hacer el desplazamiento 00:06:22
y esta es la posición 0 00:06:24
la 1, la 2, la 3 00:06:27
así hasta la posición 00:06:28
vale 00:06:31
hasta la posición n, perdón, no, esta no es 00:06:33
la posición n 00:06:36
que es esta, ¿vale? 00:06:40
es decir, tiene n más una posiciones 00:06:45
desde la 0 hasta la n 00:06:47
están rellenas estas de aquí 00:06:49
estas son las que están rellenas 00:06:51
esta no la hemos rellenado porque está 00:06:52
extra reservada 00:06:55
simplemente para que se muevan a la derecha 00:06:56
tantos como sean 00:06:59
necesarios hasta dejar uno 00:07:01
bueno, pues entonces imaginamos que queremos meter en esta 00:07:03
posición de aquí 00:07:05
esa es la posición que me han dado 00:07:06
la posición que me han dado es igual a 3 00:07:08
y quiero meter el número que sea 00:07:11
me da lo mismo, el nuevo número que he leído yo por ahí 00:07:13
este nuevo número 00:07:15
vale, pues entonces, ¿qué es lo que estoy haciendo 00:07:16
con este bucle? 00:07:19
pues partiendo desde n 00:07:20
hasta 00:07:22
posición 00:07:24
desde n hasta posición 00:07:25
a esta posición 00:07:28
le asigno el numerito que hay aquí 00:07:30
por ejemplo, si esto tiene 1, 3 00:07:33
5, 4, 0 00:07:34
1, 7 y aquí este 00:07:37
estaría indefinido, pues a esta 00:07:39
posición le asigno lo que hay aquí 00:07:41
a la posición i le asigno 00:07:42
la i-1, el 7 se queda duplicado, muy bien 00:07:45
el 7 ya ha avanzado 00:07:47
ahora, mi bucle 00:07:48
avanza hacia abajo, ahora estoy aquí 00:07:51
a esta quien le asigno lo que tiene la anterior 00:07:52
luego el 7 se ve pisado por el 1 00:07:55
el 1 se ha quedado duplicado 00:07:57
muy bien, ahora sigo bajando 00:07:59
al 1 que le asigno lo que tiene mi anterior 00:08:01
la 0, el 1 desaparece 00:08:03
y se convierte en el 0 00:08:05
no hay problema, el 1 es que ya había viajado 00:08:06
hacia allí, ahora en esta 00:08:08
¿qué tengo que hacer en esta? pues en esta 00:08:10
le asigno lo que hay en la anterior, que es el 4 00:08:12
el 0 desaparece y se me queda en 4 00:08:15
entonces todos 00:08:17
se van moviendo hacia allá, a cada uno le asigno 00:08:18
la anterior, a este 00:08:20
le asigno su anterior, a este su anterior 00:08:22
cada vez que hago una asignación 00:08:24
piso el que había, pero no hay problema porque lo pise 00:08:26
porque ya previamente lo había llevado arriba 00:08:29
ya previamente lo había llevado aquí 00:08:31
entonces cuando ya he terminado este bucle 00:08:32
todos se han ido hacia allá 00:08:34
al 4 le asigno el anterior 00:08:36
3 y ya ha terminado 00:08:39
entonces 00:08:41
ahora ya en la posición 00:08:42
en la que hay que insertar, este ya se ha quedado 00:08:44
duplicado porque todos han pasado hacia arriba 00:08:47
se ha quedado duplicado, pues a este ya me falta 00:08:49
asignar a esa posición el nuevo 00:08:51
y ya está 00:08:53
entonces el copiar 00:08:54
en cada uno su anterior 00:08:57
lo estoy haciendo de izquierda a derecha 00:08:58
porque si lo hiciera 00:09:01
de derecha a izquierda, estaría borrando 00:09:03
todos los números 00:09:05
si estos fueran mis números, por ejemplo 00:09:05
vale, si yo primero voy a copiar 00:09:16
este 00:09:22
aquí, vale, pues entonces 00:09:23
el 4 se asigna aquí 00:09:26
muy bien, el 4 ya lo he movido 00:09:27
pero es que ahora, aquí tendría que copiar 00:09:29
el que había antes, lo acabo de perder 00:09:31
lo acabo de perder, no puedo mover aquí 00:09:33
el 5 que había antes, porque lo acabo de perder 00:09:36
entonces no puedo hacer las copias 00:09:38
de izquierda a derecha, sino al revés 00:09:39
sale abajo arriba 00:09:42
sino así, vale, voy sacando 00:09:44
este lo copio aquí 00:09:46
se queda duplicado, no hay problema 00:09:47
ahora, este 9 lo llevo aquí 00:09:50
muy bien, se quedan 00:09:51
los dos 9, ahora este se lo he pisado 00:09:54
por el 7, vale 00:09:56
hasta que ya se me quedan duplicados 00:09:58
estos dos, pero es que este es el que ya 00:10:00
se pisa con el nuevo 00:10:02
vale 00:10:03
Bueno, a ver si 00:10:14
Si cambias los índices 00:10:20
Y pones el I más 1 aquí 00:10:23
Pero vamos, que siempre tienes que copiar 00:10:25
Que ir llevándote 00:10:28
En este sentido 00:10:30
Porque si no, si tú lo haces 00:10:31
En el otro sentido 00:10:34
Pisas el siguiente a copiar 00:10:35
Y no puedes pisar el siguiente 00:10:38
A copiar, porque lo has perdido 00:10:40
Claro, lo puse en general 00:10:41
para que no tuviera que ser 10 00:10:49
estrictamente 00:10:51
Es que es un plan complicado 00:10:53
A ver, primero voy a terminar 00:11:05
Lo que todavía me falta, asignar 00:11:18
A la posición nueva 00:11:19
A números de pos 00:11:21
Me falta asignarle la nueva 00:11:23
Nuevo num 00:11:26
Vale, me falta asignarle la nueva 00:11:27
Entonces, con esto 00:11:29
A la n 00:11:30
le asigno lo anterior y así hasta que 00:11:34
llegue a la posición 00:11:36
¿vale? entonces aquí 00:11:36
mayor que pos 00:11:41
creo que sería mayor 00:11:42
estrictamente ¿no? porque 00:11:46
a que duplico es pos 00:11:48
sería ¿verdad? 00:11:49
sea mayor 00:11:52
vamos a probar así con este 00:11:53
con el límite como lo tenía antes 00:11:57
porque si es un error lo cambiamos y ya está 00:11:59
vale entonces esta sería la idea 00:12:01
ahora vamos a probarlo a ver si en algún 00:12:04
momento del límite hemos copiado 00:12:06
una de más, tenemos que parar antes 00:12:08
ya veremos, pero bueno 00:12:10
voy a mostrar el array 00:12:11
voy a mostrar el array antes y después 00:12:13
a ver si se ha insertado 00:12:18
vale, pues venga 00:12:21
ejecutamos 00:12:24
venga, 10 posiciones 00:12:25
el array 00:12:30
que me ha generado es este 00:12:32
de 10 posiciones, aunque tiene una más 00:12:34
libre, que no he mostrado ahí 00:12:36
ahí no la he mostrado, porque el for 00:12:38
de arriba que muestra 00:12:40
Este primer for que he usado para mostrar 00:12:41
Muestra las n primeras 00:12:44
O sea, la siguiente que he generado 00:12:46
Como está todavía sin rellenar, ni la muestro 00:12:48
Tendría un 0 porque se lo ha dado por defecto 00:12:50
Vale 00:12:52
¿Dónde estamos? 00:12:54
Aquí 00:12:56
Ahora, introduzca posición insertar 00:12:57
Venga, vamos a insertar en la 2 00:12:59
¿Qué nuevo número quiere insertar? 00:13:01
El 11 00:13:05
Que no está 00:13:07
Vale 00:13:07
el array es 23, 17 00:13:08
y efectivamente en la 00:13:12
posición 2, 0, 1, 2 00:13:13
en la 2 00:13:16
ha insertado 00:13:17
el 11, 9, 22, 18 00:13:19
y los dos las ha desplazado 00:13:21
pero me falta uno por mostrar 00:13:23
pero eso es un error 00:13:25
de que cuando 00:13:26
he mostrado el último array 00:13:29
el último array 00:13:31
me interesan las n más 1 posiciones 00:13:33
No, tiene N más una 00:13:34
Le he rellenado una más 00:13:39
Porque como se desplazan todas 00:13:40
Necesito un hueco más 00:13:42
Estos son los números que él ha metido 00:13:43
Un 3, ¿dónde? 00:13:47
Estos son los que el usuario va a meter 00:13:55
Pero yo reservo una más 00:13:57
Porque como los voy a desplazar una 00:13:59
¿Vale? 00:14:01
Entonces vamos 00:14:02
No sé qué he hecho 00:14:03
Vale, pues por ejemplo 00:14:04
8 posiciones 00:14:05
Vamos a insertar el 99 00:14:07
Uy, no, no, esto no 00:14:10
La posición 99 no está 00:14:12
Así que esto fallaría 00:14:14
Lo paro directamente 00:14:16
Vale 00:14:17
Me he equivocado 00:14:18
8, posición, en la posición 3 00:14:20
¿Qué vamos a insertar? 00:14:24
El 99 00:14:25
Pues ahora ya sí 00:14:26
En la posición 3, que es donde estaba 00:14:28
El 24, 0, 1, 2 y 3 00:14:31
En la posición 3 00:14:33
Ha metido el 99, lo ha colado 00:14:34
Y el 24, 15, 1, 3, 8 00:14:37
Se han ido todos 00:14:39
Hacia allá 00:14:40
¿Vale? 00:14:41
¿N? 00:14:45
¿N es el tamaño de la array? 00:14:45
¿N es el tamaño de la array? 00:14:52
Que yo le pido al usuario 00:14:54
Entonces, él va a decir 00:14:55
Él va a meter 7 números 00:14:58
Por ejemplo, entonces yo reservo 00:14:59
Una posición más, porque sé que luego 00:15:01
Voy a insertar otro después 00:15:03
Entonces como voy a insertar otro y se van a tener que mover 00:15:05
¿Vale? 00:15:07
Vale 00:15:17
Vamos a aprovechar 00:15:17
Este código 00:15:20
¿Qué? 00:15:22
¿Vale? 00:15:31
Después de leer los datos, lo que es el programa en sí 00:15:32
El que hace la inserción 00:15:34
Es esto, esas líneas de ahí 00:15:36
¿Vale? 00:15:38
Esas líneas son las que lo mueven todo 00:15:40
Uno a la derecha 00:15:42
Y luego mete en el nuevo 00:15:44
¿Y está igualico? 00:15:46
¿Perdón? 00:16:10
¿Se podría poner ahí otra array? 00:16:11
¿Aquí? No hombre, aquí no puedes poner otra array 00:16:13
Porque en esta variable cae 00:16:15
Cada una de las posiciones de la array 00:16:16
A ver, si tuvieras una array de arrays 00:16:19
Sí, pero es otra cosa la que nos hemos metido 00:16:20
Es decir, esta variable 00:16:23
Se va cargando con lo que tiene 00:16:24
Cada... a ver 00:16:27
Es decir, sí 00:16:29
la primera diferencia es esa 00:16:31
pero claro, es importante porque luego tiene otra gorda 00:16:38
este bucle 00:16:40
si mi array es este 00:16:46
se ejecuta una vez por iteración 00:16:48
ahí no hay alternativa, ¿vale? 00:16:53
una vez por iteración 00:16:55
y ahora, declaro una variable n local 00:16:56
esta variable es local a este bucle 00:16:59
desaparece 00:17:02
cuando yo llego a este punto 00:17:03
la variable n ya ha desaparecido 00:17:04
la variable n solo tiene uso aquí dentro de este for 00:17:06
solo tiene uso ahí 00:17:09
cuando yo he salido del for ya ha desaparecido esa variable 00:17:10
y ahora esta variable que le va pasando 00:17:13
pues imaginaos 00:17:15
que ahora tengo yo que sé esto 00:17:17
pues en la primera vuelta en la variable n 00:17:18
cae el 3 00:17:21
y ya está y en esa vuelta yo hago lo que sea 00:17:22
en este caso ha sido mostrar 00:17:25
en la siguiente vuelta del for 00:17:26
en la variable n ya desaparece el 3 00:17:29
y cae el 4 00:17:31
y ya hago lo que sea con el 4 00:17:32
en la siguiente vuelta de ese for 00:17:34
en la variable n 00:17:37
desaparece lo que hubiera y cae el 3 00:17:38
luego esta es una variable temporal 00:17:41
que va recogiendo en cada 00:17:43
vuelta o en cada iteración 00:17:45
todos y cada uno de los valores 00:17:47
para que yo haga con ellos 00:17:49
lo que quiero, entonces lo que yo voy a hacer 00:17:51
es consultar, sumar 00:17:53
pues me da igual trabajar con una copia 00:17:54
con el propio valor 00:17:56
pero ojo 00:17:57
cuidado porque si estamos rellenando 00:18:00
una array y yo por ahorrarme tiempo 00:18:04
digo, oye, voy a rellenarlo con un for it 00:18:06
porque como lo voy a recorrer entero 00:18:08
pues ahí ya he liado, por ejemplo 00:18:09
imaginaos que pretendemos rellenar este array 00:18:12
de nuevo con unos 00:18:14
por ejemplo 00:18:16
y yo digo, venga, voy a recorrerlo así 00:18:17
que es más cómodo 00:18:19
imaginaos que uno dice, oye 00:18:20
voy a rellenar 00:18:28
mi array con unos 00:18:30
pues de esta manera 00:18:33
porque es más cómodo de recorrer 00:18:35
que poner ahí el it, vale 00:18:36
pues que estamos haciendo aquí, pues una cagada 00:18:37
¿qué estaríamos haciendo aquí? 00:18:41
yo tengo mi array números 00:18:45
mi array números 00:18:47
con todas sus posiciones 00:18:48
y tengo mi variable n 00:18:51
que es una variable auxiliar 00:18:53
que está aquí para quedarse con una copia 00:18:54
de cada cosa que yo vaya pasando 00:18:58
entonces ¿qué es lo que hacemos en la primera iteración? 00:19:00
mi variable 00:19:03
imaginaos que el array originalmente 00:19:03
tiene lo que tuviera 00:19:05
esto, yo que sé 00:19:06
primera vuelta del for 00:19:08
lo primero que hace el for each 00:19:11
a mi variable n 00:19:13
le copia el 3 00:19:15
eso es lo primero que hace 00:19:17
y ahora ya que hago yo 00:19:20
asigna n igual a 1 00:19:22
vale muy bien n igual a 1 00:19:23
y ahí se queda el 1, el 1 no está aquí 00:19:25
no he usado el 1 para rellenar el array 00:19:27
no, el 1 se ha quedado 00:19:30
en la variable n que es la copia 00:19:32
se ha quedado aquí el 1 00:19:34
con lo cual no estoy rellenando el array haciendo esto 00:19:35
estoy dando valores a la copia 00:19:38
solamente 00:19:40
cuando la iteración vuelve otra vez 00:19:40
ahora es el 7 00:19:43
el que se copia en la variable 00:19:45
esta temporal, se copia el 7 00:19:47
y ahora yo le vuelvo a dar un 1 00:19:49
vale, le vuelvo a dar un 1 00:19:51
es decir, estoy dando unos todo el rato 00:19:52
a esta variable copia 00:19:55
el array 00:19:56
no se está rellenando de unos 00:19:59
no se está rellenando de unos 00:20:01
luego, este bucle for 00:20:02
con esta sintaxis 00:20:05
este for each, tiene sentido 00:20:07
cuando yo lo único que quiero hacer es 00:20:08
operar con estos números 00:20:10
pero sin cambiarles el valor 00:20:12
para hacer cosas, porque me da igual operar con ellos 00:20:14
que con la copia, ¿vale? 00:20:16
porque con esta sintaxis 00:20:18
es con la copia 00:20:20
con la que opero, pero me da igual 00:20:22
operar con una copia que con el valor original 00:20:24
si voy a operar para obtener 00:20:26
resultados, pero si lo que quiero 00:20:28
es modificar lo que hay aquí, modificarlo 00:20:30
no puedo hacerlo con esto 00:20:33
porque estaré modificando esta 00:20:35
si quiero modificar 00:20:36
para la posición 3 darle 00:20:38
un valor a la posición 4 darle otro si quiero modificar esto y así que tengo 00:20:40
que ir con el for normal que a través del y me lleva ya al valor 00:20:45
vale pues venga vamos a pararlo aquí 00:20:51
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:
17 de noviembre de 2025 - 18:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
20′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
433.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid