Saltar navegación

20241105 ProgrEstruct-Arrays-ejercicios_10 - 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 11 de noviembre de 2024 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

La ratio de suspensos 00:00:00
Pues habréis hecho un contador 00:00:03
Ya está, punto pelota, un contador 00:00:04
Un contador que empieza valiendo 0 00:00:06
Como todos los contadores 00:00:09
Y ahora, ese contador que va a contar 00:00:10
Posiciones del array 00:00:13
Luego desde 0 hasta pos solamente 00:00:15
Que son las que nos cuentan 00:00:17
Posiciones del array que sean menores que 5 00:00:18
Ya está, es lo único que va a contar 00:00:21
Y ahora una vez que las tiene contadas 00:00:22
La ratio de suspensos 00:00:25
Será ese número entre el total 00:00:27
y listo, una vez que se acabó la cuenta 00:00:28
el número dentro del total y se acabó 00:00:31
y la media 00:00:33
pues lo mismo pero en lugar de 00:00:35
contar notas menores que 5 00:00:37
en lugar de contar 00:00:39
sumarlas, una suma acumulativa 00:00:40
empezamos siendo 0, vamos sumando 00:00:43
lo sumando son todas las notas 00:00:45
para todo el array y la nota media 00:00:48
la suma 00:00:52
que nos ha salido 00:00:54
entre el total de alumnos 00:00:55
y ya está 00:00:57
Bueno, pues esta aplicación 00:00:58
Ya estaría en su versión 1 00:01:10
Vamos a hacer la versión más bonita 00:01:12
Puedo poner el 6 00:01:15
Esto 00:01:17
Vale 00:01:18
Bueno, está claro 00:01:32
Hemos hecho lo de siempre, contar y sumar 00:01:43
Lo que pasa es que ahora lo que estamos contando 00:01:45
y sumando, nos va llegando 00:01:48
de posiciones de un array, nos va llegando 00:01:49
de ahí, en lugar de llegarnos pues del teclado 00:01:52
donde sea, nos va llegando de ahí, pero son los ejercicios 00:01:54
del principio 00:01:56
vale 00:01:57
bueno, pues esta aplicación nos gusta 00:01:59
está muy bien, mete las notas 00:02:02
hace las medias, podemos poner una nota 00:02:04
eliminar un alumno, mostrar un listado, etc 00:02:05
pero 00:02:08
pero 00:02:10
es un poco 00:02:11
feilla, por lo que ya hemos 00:02:14
dicho antes, que hemos tenido 00:02:16
que decir, mira, vamos a asumir 00:02:18
que como mucho hay 100 00:02:20
entonces ya hemos tenido 00:02:22
que hacer ya esa restricción de partida 00:02:24
y al igual 00:02:26
que hemos dicho antes, si me dicen, oye, cuidado 00:02:28
que a lo mejor esta misma aplicación la voy a 00:02:29
reutilizar en lugar de en mi academia, la voy a 00:02:32
reutilizar ahí en mi instituto de no sé 00:02:34
qué, y ahí puedo tener hasta mil alumnos 00:02:36
pues hay que entrar en el código 00:02:38
cambiar el código 00:02:40
y volver a ejecutarla 00:02:41
no es la idea, esta aplicación entonces 00:02:44
no es reutilizable de forma 00:02:47
sencilla, tengo que cambiar el código 00:02:49
si la quiero reutilizar en un escenario 00:02:51
distinto de muchos más alumnos 00:02:53
eso por un lado, primera pega que la hace fea 00:02:54
segunda 00:02:57
pega, quejolines 00:02:59
yo tengo ahí un array de mil 00:03:01
o de diez mil o de los que quiera, porque 00:03:03
podría decir, oye, para que sea reutilizable 00:03:05
incluso ahí en los confines del 00:03:07
universo, no pasa nada 00:03:09
yo me voy a hacer un array que quepan hasta 00:03:11
200.000 y luego tú ya 00:03:13
no, funciona 00:03:15
pero tengo ahí 00:03:17
200.000 espacios en memoria 00:03:18
habilitados ocupando la memoria RAM 00:03:21
cuando la mayoría 00:03:23
de las veces a lo mejor solo estoy usando 10 00:03:25
o 12, no es una solución 00:03:27
tampoco, entonces 00:03:29
¿cuál sería la solución bonita? 00:03:31
es decir, pues vamos a hacernos 00:03:33
un array en principio 00:03:35
de 0 posiciones 00:03:37
y según vayan llegando y saliendo 00:03:39
lo voy estirando y lo voy encogiendo 00:03:41
Efectivamente 00:03:43
Entonces vamos a hacer la versión 2 00:03:45
Que será una pequeña modificación de esta 00:03:48
Pero un poquito más bonita 00:03:50
A ver 00:03:51
Ejera raíz, donde está 00:03:53
Este ejercicio 00:03:55
Lo hemos llamado ejercicio 28 00:03:57
Pero ejercicio 28 tuneado 00:03:59
Porque no es exactamente el ejercicio 28 00:04:00
Entonces vamos a cambiarle de nombre 00:04:02
Eso, voy a poner ejercicio 28 00:04:05
Con un poco de tuning 00:04:08
tuning en mi época 00:04:11
era cuando sintonizabas la radio 00:04:15
ahora ya no, ¿verdad? 00:04:16
ya no se sintonizan 00:04:18
ya pasan radios 00:04:21
con una tele y un palillo 00:04:22
¿con una tele y un palillo? 00:04:24
eso no me lo sé 00:04:27
cuando se jodía la tele 00:04:28
las ruedas 00:04:32
ah, las ruedas de las teles viejas 00:04:34
esas teles no las conozco 00:04:36
Son teles del 60 para abajo 00:04:40
No hombre, pero entonces él no las conocería 00:04:43
Con una tele y un palillo 00:04:44
En mi casa debían estar muy modernizados 00:04:49
Ya que hemos juntado las batallitas 00:04:53
De ancianos 00:05:01
A ver, venga 00:05:02
Bueno, pues este es el tuneado 00:05:07
Ahora vamos a hacer 00:05:11
El 28 tuneado 00:05:13
Pero una versión más bonita 00:05:14
En que la RAI no tiene necesariamente 00:05:16
100, 200 00:05:18
Sino que se adapta a los alumnos que yo tengo en cada momento 00:05:19
Pues venga, ejercicio 28 00:05:22
Se quedaba el pelo así 00:05:25
Ah, y en las de ahora no pasa 00:05:36
Ah, claro, porque no tiene el tubo de rayos catódicos 00:05:37
Este, si no se pega el pelo 00:05:40
Ah, pues mira, eso no lo había comprobado nunca 00:05:41
Tiene sentido 00:05:42
Es verdad 00:05:44
Qué tiempos más bonitos 00:05:47
Sí 00:05:51
Claro, el otro día 00:05:56
Bueno, me llegan 200.000 chorradas 00:05:57
Por Instagram 00:06:02
Claro 00:06:04
Vale, versión 2 00:06:04
y me llegó 00:06:09
algunas cosas 00:06:12
venga, versión 2 00:06:14
vale 00:06:15
vale, he copiado 00:06:16
venga, a ver 00:06:20
he copiado 00:06:25
este ejercicio tal cual 00:06:27
en otra clase 00:06:30
lo he copiado tal cual en otra clase 00:06:31
y ahora vamos a hacer una modificación 00:06:34
para poder hacer lo siguiente 00:06:35
oye, vamos a cambiar 00:06:38
mi array de partida 00:06:39
no voy a asumir 00:06:41
un tamaño, no voy a asumir un tamaño porque 00:06:42
si yo asumo ahí un tamaño, ese array ya se 00:06:45
queda así siempre y es una pena 00:06:47
que a lo mejor a veces esté usando 3 00:06:49
a veces 4 y siempre va a tener 100 00:06:51
lleno de nada, de nul, de nul, de nul 00:06:53
vale, pues de partida así 00:06:55
de 0, dirijo un array 00:06:56
de 0 posiciones, ¿se puede declararlo? 00:06:59
si se puede 00:07:01
es decir, yo puedo hacer esto 00:07:02
¿cuál es la diferencia entre un array de 0 00:07:05
posiciones y no haberlo 00:07:07
declarado, es decir, 00:07:09
me podríais decir, bueno, ¿qué diferencia hay 00:07:11
entre 00:07:13
hacerlo 00:07:15
de arriba y hacerlo de abajo? 00:07:17
Sí que hay. 00:07:22
En este caso, 00:07:23
el objeto array, este es un 00:07:24
objeto... 00:07:26
¿Qué pasa? 00:07:27
Ah, 00:07:31
pensaba que no había bajado eso. 00:07:32
Vale, o sea, 00:07:37
me diréis, ¿y qué diferencia hay 00:07:38
entre hacer lo de arriba y lo de abajo 00:07:40
pues hay una diferencia enorme 00:07:42
en lo de arriba yo he declarado 00:07:44
el objeto alumnos, recordéis que 00:07:46
los arrays son un objeto, pero todavía 00:07:48
no he creado 00:07:50
el objeto en sí, lo único que estoy 00:07:51
diciendo es alumnos es la dirección de 00:07:54
memoria que apuntará al array 00:07:56
pero todavía no está creado 00:07:58
con lo cual aquí alumnos es un null que no 00:08:00
veas, y si yo aquí hiciera 00:08:02
por ejemplo esto, si yo 00:08:04
hago esto, alumnos 00:08:08
punto length 00:08:13
si yo hiciera esto de arriba 00:08:14
string alumnos y alumnos.length 00:08:16
si yo lo intento ejecutar 00:08:19
me va a decir aquí null pointer exception 00:08:20
¿vale? 00:08:23
me va a decir null pointer exception 00:08:25
porque alumnos 00:08:26
efectivamente no está 00:08:28
creada, bueno de hecho es que 00:08:30
ni siquiera me deja ahora mismo sacar 00:08:32
la esta porque ya 00:08:34
tiene justo arriba ¿vale? 00:08:36
no puedo, entonces 00:08:38
sin embargo esto de aquí 00:08:40
abajo es otra cosa distinta 00:08:45
aquí sí he creado 00:08:47
el objeto, aquí sí lo he creado 00:08:49
el objeto array, pero tiene cero 00:08:50
es decir, no cabe ningún 00:08:53
elemento, entonces yo aquí sí que podría hacer esto 00:08:55
aquí sí que podríamos 00:08:57
hacer si quisiéramos 00:08:59
alumnos.length 00:09:00
podría, y me devolvería 00:09:04
cero, tienes cero posiciones 00:09:07
en ese array, pero el objeto existe 00:09:09
lo que pasa es que sin posiciones 00:09:11
vale, pues entonces 00:09:13
ya teniendo claro que hay una diferencia 00:09:15
entre declararlo sin crearlo 00:09:17
y crearlo con cero posiciones 00:09:19
pues ahora ya vamos a hacer 00:09:21
esta versión nuestra 00:09:23
en el que decimos 00:09:25
oye, vamos a ver 00:09:26
mi array de alumnos 00:09:27
inicialmente tiene cero 00:09:30
con lo cual me voy a olvidar de post 00:09:31
y me voy a olvidar de todo 00:09:34
y ahora cada vez que me tallo un alumno 00:09:35
pues me crearé un array 00:09:38
con una posición más que el que tenía 00:09:40
copio el original 00:09:42
en el nuevo 00:09:44
y en la posición extra 00:09:46
copio el alumno adicional 00:09:48
y luego sustituyo 00:09:49
¿vale? esa sería la situación 00:09:52
ideal, pues venga, vamos a modificar 00:09:54
esas opciones, ¿vale? entonces repito 00:09:56
de partida mi array tiene cero posiciones 00:09:58
tiene cero, y ahora, vámonos a la opción 00:10:00
insertar alumno 00:10:02
opción insertar alumno, la vamos a borrar 00:10:03
enterita, bueno, lo de 00:10:06
introduzca nombre y poner el nombre lo dejamos 00:10:08
por eso lo vamos a utilizar 00:10:10
vale, lo que vamos a borrar es esto 00:10:11
¿vale? 00:10:13
Venga, ¿ahora qué tenemos que hacer para insertar el alumno? 00:10:16
Vamos a crear una array auxiliar con una posición más 00:10:18
que el que tiene en ese momento en la array alumnos, 00:10:22
la que tenga. 00:10:24
Pues venga, vamos a crearnos, claro, 00:10:25
una array de string aux, por ejemplo, aux alumnos, 00:10:28
con una posición más, 00:10:34
una posición más que el que tenga el de alumnos en ese momento. 00:10:39
justo que tiene 00:10:44
alumnos en ese momento, alumnos.led 00:10:46
pues este es el primer paso 00:10:49
un auxiliar con una 00:10:50
posición más para albergar ese extra 00:10:52
ahora, siguiente paso 00:10:54
copiamos alumnos 00:10:56
en aux alumnos 00:10:58
vale, un for que recorre 00:11:00
todo el array alumnos para 00:11:03
copiar ese en el otro 00:11:04
y luego la posición adicional 00:11:05
extra del aux con el nombre 00:11:08
nuevo y luego ya 00:11:10
sustituimos uno en el otro 00:11:12
entonces, ahora 00:11:13
vamos a recorrer 00:11:15
alumnos 00:11:18
vamos a recorrer alumnos 00:11:19
vale, ¿qué hacemos con alumnos? 00:11:25
copiarlo en auxalumnos 00:11:28
auxalumnos de i 00:11:29
igual a 00:11:33
alumnos de i 00:11:35
ala, ya están 00:11:37
copiadas, auxalumnos 00:11:39
todavía le sobra uno, porque le hemos hecho 00:11:41
con una posición más, todavía le sobra uno 00:11:43
vale, ahora ya que están copiados 00:11:44
la posición que le sobra 00:11:46
a auxalumnos, porque tiene una más 00:11:48
tiene una más 00:11:51
porque lo hemos creado de tamaño 00:11:53
una más que alumnos 00:11:54
pues la última que le sobra 00:11:56
la última que le sobra, claro 00:11:58
que esa será la última posición 00:12:00
de una raíz cualquiera, ¿cuál es? 00:12:03
siempre es la última posición de una raíz cualquiera 00:12:04
es su tamaño menos uno, ¿verdad? 00:12:07
esta es la última posición de una raíz cualquiera 00:12:10
bueno, pues su última posición 00:12:12
con nombre. 00:12:16
¿Vale? Entonces ya 00:12:21
auxalumnos ya es el array definitivo. 00:12:22
Claro. 00:12:25
Donde tiene los nombres 00:12:26
de alumnos que estaban alumnos copiados en él 00:12:28
y en la posición extra 00:12:30
que le hemos creado, el nuevo. 00:12:32
La posición extra es la última, que siempre 00:12:34
es el tamaño del array menos uno. 00:12:36
Y ahora, una vez que ya hemos 00:12:39
hecho esto, decimos, oye, el array original 00:12:40
sustituyelo 00:12:42
por auxalumnos. 00:12:44
Sustituido. 00:12:48
Y auxalumnos, como es local al switch, 00:12:51
pues este array auxalumnos ya va a desaparecer. 00:12:53
No nos importa, es un array local que está ahí, 00:12:57
que lo estamos usando cada vez que entramos en case 1. 00:13:00
Cada vez que entramos aquí, lo creamos y lo eliminamos. 00:13:04
En cada iteración, se crea, se elimina, se crea, se elimina. 00:13:09
Vale, un segundito. 00:13:14
Pero claro, con las notas lo mismo. 00:13:16
Recordad que alumnos y notas van en paralelo 00:13:18
Luego con notas 00:13:21
¿Qué tendremos que hacer? 00:13:23
Lo mismo, crear un array con una posición más 00:13:25
Copiar el original de notas 00:13:28
En el auxiliar de notas 00:13:29
Y ahora en la extra 00:13:31
En este caso ponerle un cero 00:13:33
Porque hemos dicho que cuando insertamos un alumno 00:13:34
Le ponemos nota cero 00:13:36
Entonces vamos a hacer lo mismo pero con notas 00:13:37
Pues lo mismo con array de notas 00:13:40
Sería un array de 00:13:46
Enteros 00:13:49
auxnotas que va a tener 00:13:50
cuánto 00:13:58
cuántas posiciones 00:14:02
pues las mismas de notas más uno 00:14:04
vale 00:14:06
aquí en notas lo mismo, perdón 00:14:09
que cuando he hecho, vale 00:14:12
cuando he creado el array de notas aquí 00:14:14
de cero posiciones también, como el de string 00:14:15
vale 00:14:18
pues volvemos aquí abajo 00:14:19
un auxiliar con una 00:14:22
posición más 00:14:28
Que el que tiene actualmente la raíz de notas 00:14:29
Ahora lo mismo 00:14:32
Copiamos 00:14:34
El original 00:14:35
Copiamos el original 00:14:37
En el nuevo 00:14:45
Aux de notas 00:14:47
De i 00:14:51
Igual a notas de i 00:14:52
Cuando este fuera terminado 00:14:55
Que es en ese punto 00:14:58
En el auxiliar tenemos las mismas notas 00:14:58
Que teníamos en el original 00:15:02
Y hay una posición libre 00:15:03
Que es la última 00:15:05
En esa posición libre 00:15:06
Que viene dada por aux de notas 00:15:08
Punto len 00:15:11
Menos uno, esa es la última 00:15:13
Pues le ponemos cero 00:15:15
Que es la nota que ponemos al que insertamos siempre 00:15:17
Y ahora sustituimos 00:15:19
Notas que se quede pisado 00:15:21
Con este auxiliar que es el definitivo 00:15:23
¿Vale? 00:15:25
¿Qué más cambia de esta aplicación? 00:15:36
En el caso dos 00:15:38
Lo que cambia ahora se nos queda todo más fácil 00:15:38
porque ya de pos pasamos 00:15:41
el caso 2 que es 00:15:43
bueno, que es el de eliminar 00:15:45
vale, vamos a el de eliminar 00:15:47
vamos a borrarlo enterito menos el nombre 00:15:48
de la... 00:15:51
claro, en el caso 00:15:52
de eliminar va a quedar más sencillo porque 00:15:55
tú creas uno con una posición menos 00:15:57
y copias el original en el nuevo 00:15:59
saltándote la que 00:16:01
hay que eliminar, se queda más sencillo en este caso 00:16:03
entonces el caso 2 que es eliminar 00:16:05
vamos a borrarlo todo 00:16:07
salvo el nombre del alumno a eliminar. 00:16:09
¿Vale? 00:16:16
El caso 2 era el nombre del alumno a eliminar. 00:16:16
A ver, ¿qué te desespera? 00:16:19
¿De aquí? 00:16:25
¿Estas? 00:16:26
Bueno, porque cuando insertas 00:16:31
un alumno hemos dicho que la nota que le ponemos 00:16:32
es cero en el momento de insertarle. 00:16:34
Vale, venga, eliminar alumno. 00:16:38
Esto es muy fácil. Eliminar alumno va a resultar 00:16:40
en un array de una posición menos. 00:16:42
¿Vale? 00:16:45
Luego eliminar alumno 00:16:47
Vamos a hacer el array auxiliar de alumnos 00:16:50
El array auxiliar ahora va a ser 00:16:56
El ausalumnos va a ser 00:17:02
Del tamaño de alumnos 00:17:05
Menos una posición 00:17:07
El array auxiliar ahora va a tener 00:17:08
Una posición menos que el original 00:17:11
¿Vale? 00:17:13
Porque vamos a sacar uno 00:17:14
Va a tener una posición menos 00:17:15
¿Y ahora qué tenemos que hacer? 00:17:17
Pues más fácil, copiar el alumnos original en el nuevo, en el auxiliar, saltándonos el alumno cuyo nombre coincide con este. 00:17:20
Pero ¿por qué suspiras tanto? 00:17:36
Ya, pero es todo el rato lo mismo en realidad, es todo el rato lo mismo. 00:17:41
Es poner en práctica todo el rato lo mismo. 00:17:44
Vale, vamos a recorrer alumnos. 00:17:46
Alumnos.led. 00:17:49
Recorremos alumnos. 00:17:50
Y ahora, mientras i menor que alumnos.le, vale, ya hemos creado el array auxiliar con una posición menos, vale, ahora vamos a recorrer nuestro array alumnos que hay que mover al otro, ¿qué hacemos con ese array alumnos?, bueno, pues si alumnos de i resulta que no es igual al que hay que eliminar, que el que hay que eliminar se llama nombre, 00:17:51
si no es igual 00:18:21
es decir, si no es igual 00:18:24
no es igual, entonces 00:18:26
alumnos de i lo tendré que asignar 00:18:29
a algún sitio 00:18:31
¿vale? es decir, si alumnos 00:18:33
de i, estoy recorriendo la raíz de alumnos 00:18:37
si alumnos de i 00:18:39
no es igual al nombre que 00:18:42
tengo que eliminar, pues alumnos 00:18:44
de i se va a la posición 00:18:46
de auxalumnos 00:18:48
pero ¿a cuál? 00:18:50
a la que te cree 00:18:52
tienes que crear otro contador 00:18:53
Claro, ¿a cuál? 00:18:55
Bueno, pues aquí tengo que crear efectivamente un contador para ese array que inicialmente es cero. 00:18:58
Y cada vez que le asignemos uno, se incrementa. 00:19:04
Esto ya lo hemos hecho también en otro ejercicio. 00:19:06
Vale, pues nos creamos aquí. 00:19:10
Vamos a poner un nombre largo para que se entienda. 00:19:16
Inicialmente es cero. 00:19:18
Entonces, el primero que copiamos, lo copiamos en post, aux, alumnos. 00:19:19
Y aprovechamos y lo dejamos incrementar. 00:19:26
Y ya está. 00:19:29
Y se acabó la copia. 00:19:30
¿Vale? 00:19:32
Entonces recorremos alumnos. 00:19:33
Si no coincide con el nombre, 00:19:35
si no coincide, 00:19:38
lo copiamos, pero ¿dónde? 00:19:39
En la que toque. 00:19:41
Inicialmente tocará en la cero 00:19:43
y lo dejamos incrementado en la que toque. 00:19:44
Cada vez que hacemos una copia, 00:19:46
cada vez que hacemos una copia 00:19:48
lo dejamos incrementado ahí. 00:19:49
¿Vale? 00:19:52
Ahora, cuando este for ya ha terminado, 00:19:54
que habrá terminado aquí, 00:19:56
Porque he hecho una llave 00:19:58
Cuando ese for ya ha terminado 00:19:59
Esta llave 00:20:03
Aquí está un poco de sobra 00:20:05
Sí, esta llave creo que está de sobra 00:20:07
Cuando ese for ya ha terminado, sustituyo 00:20:09
Alumnos 00:20:12
Se queda pisado 00:20:13
Por aux alumnos 00:20:15
Ahí se queda pisado 00:20:17
Claro, es que 00:20:19
Es la idea 00:20:32
El array aux alumnos se ha quedado ahí en esa dirección 00:20:33
Y este otro saca en esta dirección 00:20:36
Lo que tienes que hacer es a este puntero 00:20:38
Que empiece a apuntar a este 00:20:40
O sea, le cambias la dirección para que empiece a apuntar al otro 00:20:42
Este se ha quedado sin nadie que le apunte 00:20:44
Lo tirará a la basura, al recolector de basura 00:20:47
Entonces, efectivamente 00:20:49
Estas variables 00:20:50
Que estamos creando 00:20:52
Son variables para guardar direcciones 00:20:53
Que lo que hacemos es estarlas cambiando 00:20:55
Ahora apunta aquí, ahora apunta allí 00:20:57
Claro, cada vez que hacemos esto, lo que hacemos es cambiar 00:20:58
Una dirección que lleve de un lado a otro 00:21:01
Efectivamente 00:21:03
Sí, de hecho en C 00:21:05
hay una sentencia específica 00:21:14
para eliminar 00:21:16
tienes la 00:21:17
tienes una asignación de memoria 00:21:19
tienes que crear, con más yo creo que era 00:21:22
crear el espacio 00:21:24
y asociarlo al puntero 00:21:26
y luego tienes una específica para eliminar ese espacio 00:21:27
claro, ¿cuál es la ventaja? 00:21:30
que tienes mucho más control 00:21:32
a bajo nivel, con C 00:21:34
Obviamente tienes muchísimo más control a bajo nivel 00:21:36
Que tienes con un lenguaje de estos 00:21:38
Pero hacer una aplicación con C es una locura 00:21:39
Haces un sistema operativo, haces esas cosas 00:21:41
Pero no una aplicación de usuario 00:21:43
Vale, pero esto mismo 00:21:45
Que hemos hecho de los alumnos 00:21:47
Que hemos eliminado al alumno 00:21:49
Hay que eliminar su nota también 00:21:50
O sea, lo mismo con notas 00:21:52
Notas igual 00:21:54
Un array notas auxiliar 00:21:55
Se copia el original saltándote 00:21:57
Pues venga, haces lo mismo con notas 00:22:00
Aquí debajo 00:22:03
Y así os aseguráis 00:22:04
De que lo que hemos hecho 00:22:08
En esta funcionalidad 2 00:22:10
De eliminar está claro 00:22:11
¿Vale? 00:22:12
Eliminamos 00:22:18
Su nota 00:22:18
A ver, sí 00:22:20
Sí, sí, sí, no tienes razón 00:22:25
Claro, sí 00:22:27
Eliminar su nota 00:22:29
Tienes 00:22:32
Tenemos que marcar 00:22:33
¿Cuál es esta posición? Vamos a tener que marcarla 00:22:35
Claro, vale 00:22:38
A ver, para eliminar la nota 00:22:40
No es un for idéntico, porque claro 00:22:42
¿Qué nota tenemos que eliminar? 00:22:44
No, aquí teníamos claro 00:22:47
¿Qué nombre teníamos que eliminar? 00:22:49
El alumno, pero nota 00:22:51
Entonces aquí lo que tenemos es que usar 00:22:52
Este for para quedarnos con 00:22:55
La posición a eliminar 00:22:57
Y ahora ya esa posición en la array de notas 00:22:58
Entonces ya podemos poner aquí 00:23:01
Por ejemplo 00:23:03
poseliminar 00:23:04
igual a menos uno por ejemplo 00:23:10
y ahora, si en cuanto lo encontremos 00:23:12
en cuanto lo encontremos 00:23:15
no, un else no, en cuanto lo encontremos 00:23:16
aprovechamos 00:23:20
y esa posición y 00:23:21
que se pase a la posición 00:23:24
a eliminar 00:23:27
ahí 00:23:28
uy, perdón 00:23:31
Y ya está, ya la tendremos 00:23:34
Ah, perdón, perdón, perdón 00:23:38
Sí, sí, se me está 00:23:41
Se me está yendo la pinza 00:23:42
Entonces 00:23:44
Sí, si no es el nombre 00:23:45
Esa es la que toca eliminar 00:23:54
Efectivamente, que sí, que sí, que se me está yendo la cabeza 00:23:55
Vale 00:23:58
Efectivamente 00:24:05
vale, entonces este array 00:24:07
lo estamos aprovechando, aparte 00:24:12
de para ir haciendo 00:24:15
copia, este no es el de eliminar 00:24:15
lo copio, este no es el de eliminar, lo copio 00:24:18
este no es el de eliminar, lo copio, uy, este es el de eliminar 00:24:20
pues me quedo con su posición 00:24:22
para luego cuando 00:24:24
haga el recorrido 00:24:26
del array de notas, saber que posición 00:24:28
no tengo que copiar, pues venga 00:24:30
ahora sí, ya teniendo esta variable 00:24:32
que ya sabemos, esta variable 00:24:35
que va a tener la posición de la raíz de notas 00:24:36
a eliminar 00:24:39
pues ahora os hacéis un auxiliar con una posición menos 00:24:40
y vais copiando 00:24:43
original en auxiliar, original en auxiliar 00:24:45
salvo la posición a eliminar 00:24:47
salvo la posición, esa no 00:24:48
pues venga 00:24:50
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:
11 de noviembre de 2024 - 12:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
110.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid