Saltar navegación

20241105 ProgrEstruct-Arrays-ejercicios_9 - 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.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, habíamos hecho la funcionalidad 1 de insertar, para lo cual habíamos puesto esta variable adicional, 00:00:00
que era una variable que tenía un uso muy concreto, que es saber en cada momento cuántos alumnos había. 00:00:13
Entonces, inicialmente hay cero, pero cuando ya se inserta el primer alumno, POS se queda incrementado. 00:00:21
entonces pos es un contador de alumnos 00:00:28
pero ya no solo un contador de alumnos 00:00:30
sino el que cada vez que insertamos uno 00:00:32
nos permite acceder 00:00:35
a la posición en la que 00:00:37
toca insertar el nuevo 00:00:39
inicialmente cuando la aplicación arranca 00:00:40
pos es cero, cero alumnos 00:00:42
y efectivamente es en cero 00:00:44
donde insertaremos ese nuevo 00:00:46
pero sin embargo 00:00:48
cuando insertemos el 00:00:50
segundo alumno, pos habrá quedado 00:00:52
valiendo uno, hay uno alumnos 00:00:54
y efectivamente será en uno 00:00:56
donde tengo que insertar el siguiente 00:00:58
será en 1 00:01:00
entonces POS tiene ese doble uso 00:01:01
contador de cuántos alumnos hay en un momento dado 00:01:03
realmente en este array 00:01:06
que tiene 100 huecos 00:01:08
y también indicar 00:01:09
cuál es la primera posición libre 00:01:12
la primera posición libre 00:01:13
cuando la aplicación arranca la primera posición libre es la 0 00:01:15
pero cuando tenemos un alumno 00:01:18
la primera posición libre es la 1 00:01:19
porque está ocupada la 0 00:01:21
¿No deberíamos hacer también aquí para dejar 00:01:23
el array de alumnos valiendo 00:01:24
¿Cómo? 00:01:26
Para dejar el array de alumnos valiendo la posición total 00:01:31
de los alumnos, no deberíamos hacer en el bucle 00:01:33
meter lo del ejercicio anterior 00:01:35
de una array auxiliar 00:01:37
que los copie y luego los devuelva a un array 00:01:39
de tamaño total. Vale, a ver, o sea 00:01:41
lo que pasa es, si queremos no tener 00:01:43
ese array ahí, pero en principio esta sería 00:01:45
una solución, ¿no? Yo tengo hasta un máximo de 00:01:47
100, y luego ese 100 00:01:49
a veces está ocupado hasta aquí, a veces hasta aquí, a veces 00:01:51
hasta aquí. Es una posibilidad, ¿vale? 00:01:53
Luego vamos a hacer una versión 2. 00:01:55
¿Vale? Pero esta es una opción sencilla. 00:01:57
Yo digo, como mucho voy a tener 100. 00:01:59
Como mucho. 00:02:01
Que luego la aplicación cambia y te dicen, 00:02:03
oye, que a lo mejor tienes hasta 1000. 00:02:05
Pues no te queda más remedio que entrar 00:02:07
y poner aquí un 0 más. 00:02:09
¿Vale? Entonces es una versión 00:02:11
bueno, regularcilla, 00:02:13
porque si me cambian las condiciones 00:02:15
y me dicen, oye, no, que puede 00:02:17
que tengas 150. Pues tienes que venir al 00:02:19
código, cambiarlo 00:02:21
volverlo a compilar para volverlo 00:02:23
ya a ejecutar, luego habría 00:02:25
la versión 2 en la cual efectivamente 00:02:27
vamos a que este programa 00:02:29
estire y encoge la 00:02:31
raíz según van llegando, con lo cual si llegan 00:02:33
150, estira hasta 150, no hay problema 00:02:35
vale, pero esta versión es la más 00:02:37
sencilla y esta versión necesita 00:02:39
esta variable adicional con esa 00:02:41
función que hemos dicho 00:02:43
contador de alumnos en un 00:02:44
momento dado y también 00:02:47
sirve como indicador 00:02:49
de primera posición libre en la que no hay alumnos. 00:02:51
Primera en la que no hay alumnos. 00:02:53
Vale, pues con eso 00:02:55
insertar era eso. Leíamos el 00:02:57
nombre, lo guardábamos en la posición 00:02:59
que tocaba, la nota 00:03:01
la poníamos a cero cuando insertábamos un alumno, 00:03:03
la guardamos en la posición 00:03:06
que toca y esta se queda incrementada. El caso dos 00:03:07
es el que nos saltamos. 00:03:09
El caso tres, poner la nota a un alumno 00:03:11
pues era 00:03:13
sencillo también 00:03:15
porque nos daban 00:03:17
nombre del alumno al que le quieres poner la nota. 00:03:19
Esta nota que quieres poner, esta otra. 00:03:21
Recorríamos el array 00:03:24
hasta las 00:03:25
posiciones ocupadas solo. 00:03:27
Recorríamos el array solo hasta 00:03:30
las posiciones ocupadas. 00:03:31
Y para cada alumno 00:03:34
si coincidía con este nombre 00:03:35
le asignábamos la nota 00:03:37
a ese alumno en esa posición y que habíamos 00:03:39
encontrado que coincidía con el nombre a buscar. 00:03:41
Nombre es el nombre de búsqueda. 00:03:44
En cuanto 00:03:47
encontrábamos la posición y 00:03:47
dentro del for, la posición y 00:03:49
en la que teníamos un alumno con ese 00:03:51
nombre, pues en esa misma 00:03:53
posición pero del array paralelo notas 00:03:55
le poníamos la nota 00:03:58
y ya está, y además avisábamos de que lo habíamos 00:03:59
encontrado, avisábamos 00:04:01
y esto nos permitía 00:04:03
que si no lo encontrábamos 00:04:06
la aplicación nos avisara y así queda 00:04:07
más bonita 00:04:09
claro, porque si ejecutamos 00:04:11
esto y le decimos 00:04:14
venga, vamos a insertar un alumno 00:04:16
Puesala 00:04:17
Pepito 00:04:19
Y ahora ya está insertado 00:04:21
Vamos a poner nota a un alumno 00:04:23
Nombre de alumno 00:04:25
Juanito 00:04:27
Nota que quiere poner alumno, 5 00:04:28
Pues ese alumno no existe 00:04:30
¿Cómo? 00:04:33
¿Vale? 00:04:36
¿Pero por qué hacéis ruido todo el rato? 00:04:39
Están llamando a alguien 00:04:46
Venga, a ver, entonces 00:04:47
Y luego habíamos hecho la funcionalidad del listado de notas 00:04:55
Para comprobar que lo que hacíamos funcionaba 00:04:58
¿Vale? 00:05:00
Un for para recorrer el array de alumnos 00:05:01
Y el array de notas 00:05:04
Un for y este for pues nada 00:05:05
Nos muestra el alumno de posición y 00:05:07
La nota de posición y para todos los alumnos 00:05:10
Dentro del for 00:05:12
Y ya no habíamos hecho más 00:05:14
funcionalidades de estas. 00:05:16
Venga, vamos a 00:05:19
eliminar a un alumno 00:05:20
dado su nombre. Claro, eliminar 00:05:22
a un alumno dado su nombre. 00:05:25
¿Alguien ha hecho esta de eliminar? Que levante 00:05:27
la mano. ¿Alguien ha hecho 00:05:29
esta de eliminar y le funciona? 00:05:31
Que levante la mano. 00:05:33
Ahí hay una 00:05:36
gran diferencia. 00:05:37
William, ¿tú tampoco la has 00:05:39
hecho? 00:05:41
Nadie la ha hecho 00:05:41
John 00:05:47
John me ha dicho que le elimina todo 00:05:49
Así que no me vale 00:05:51
No me has dicho eso que no te funciona 00:05:52
Bueno, me lo tomaré como un no funciona 00:05:54
Sí, pero la funcionalidad no era eliminar todo 00:06:01
Era eliminar un alumno 00:06:06
Sí, esa es la que es 00:06:07
Examen, cárgate todo 00:06:11
Hace un programa que no funcione 00:06:13
Y que cuelgue el equipo 00:06:15
Veréis como aprobáis todos 00:06:16
Bueno, no es tan fácil 00:06:18
No es tan fácil 00:06:19
Sí, bueno 00:06:21
A ver, pues nada 00:06:23
Para eliminar un nombre 00:06:25
Primero vamos a leer, vamos a decirle 00:06:27
A ver, ¿a qué alumno quiere usted eliminar? 00:06:29
Nombre alumno 00:06:38
Pues nada, leemos el nombre del alumno que tenemos que eliminar. 00:06:39
Y ahora, ahora ya viene que pensemos qué algoritmo usar. 00:06:52
Vale, pues entonces, tendremos, a ver si más o menos lo vemos. 00:06:58
Este es nuestro array de alumnos, con todas sus posiciones. 00:07:10
Entonces, a lo mejor en un momento dado, solamente, a ver, ¿vale? Las que tenemos rellenas en un momento dado son igual, por ejemplo, son estas tres primeras, pues son pos, ¿vale? Estas de aquí, por ejemplo, ¿vale? Tenemos rellenas las tres primeras, por ejemplo, solo. 00:07:16
con lo cual tenemos rellenas la 0, la 1 00:07:41
y la 2 00:07:44
hasta la pos menos 1 00:07:46
vale, entonces vamos a suponer que 00:07:47
me dan un nombre 00:07:50
y yo cuando busque en el array 00:07:51
quiero 00:07:53
he comprobado que es este 00:07:54
vale, pues esto ya lo hemos hecho 00:07:57
lo que tenemos es que todos los que están 00:08:02
a partir de este 00:08:04
subirlos a una posición más arriba 00:08:05
pero esto lo hicimos en otro ejercicio 00:08:08
si empezábamos a subir desde justo 00:08:10
el siguiente 00:08:12
Entonces, al 00:08:13
Ah, bueno, no, en este caso 00:08:15
Sí que subimos este aquí 00:08:17
¿Vale? Y este se elimina, perfecto 00:08:19
Y este se queda duplicado 00:08:21
Pero no pasa nada porque luego vamos a subir 00:08:22
Este aquí 00:08:24
Y luego vamos a subir este ahí 00:08:25
¿Vale? Entonces 00:08:28
Desde una posición siguiente 00:08:30
A la que tenemos que eliminar 00:08:33
Desde una posición siguiente, desde esta 00:08:35
Tenemos que empezar con un for 00:08:37
Que vaya desde esta hasta la última 00:08:38
De las rellenas 00:08:41
sea la que sea 00:08:42
hasta pos-1 00:08:43
que es la última que tenemos rellena 00:08:46
tenemos rellena desde 0 hasta pos-1 00:08:48
pues desde la siguiente 00:08:50
a la que tenemos que eliminar, tendremos que hacer 00:08:52
a esta le copias esta 00:08:54
con lo cual este alumno ya desapareció 00:08:56
y este ha subido arriba 00:08:58
y aquí se queda duplicado, claro 00:09:00
porque he asignado este alumno aquí arriba 00:09:02
pero ahora, a este copiaremos el siguiente 00:09:04
hasta pos-1 00:09:06
bueno, hasta pos-1 00:09:08
Ese lo copiarás en el de arriba 00:09:11
Y ya pues menos uno te sobra 00:09:12
Con lo cual 00:09:14
Sí, sí tenemos 00:09:14
A ver 00:09:17
Es que 00:09:18
Sí, a ver 00:09:19
Es que la pizarra es más fácil 00:09:20
Uy, Rosa 00:09:21
La que me habrá echado esta mañana 00:09:24
Cuando ha visto esto 00:09:27
Ya lo dijo 00:09:28
Ya lo ha visto 00:09:28
Ya lo ha visto 00:09:29
Uy, qué suerte 00:09:30
Solo vio la de Paul y ya 00:09:31
Pero ha dado una pertenencia más 00:09:33
Y es que 00:09:34
Me he librado por los pelos 00:09:35
A ver 00:09:37
Ha visto lo de Paul 00:09:38
Madre mía 00:09:40
Ahí ya ha colapsado y ya no ha querido ver más 00:09:41
Prácticamente 00:09:43
Bueno, a ver, entonces 00:09:44
A ver 00:09:48
Este es nuestro array 00:09:50
Tenemos a lo mejor 00:09:51
Rellenas, estas de aquí 00:09:54
Por ejemplo, estas de aquí 00:09:56
Que van de 0 00:09:57
A pos-1 00:09:59
¿Verdad? 00:10:01
Entonces, por ejemplo, queremos eliminar esta 00:10:03
¿Pero por qué pos-1? 00:10:06
Hombre, porque tienes posposiciones rellenas 00:10:07
Pues van desde la 0 hasta pos-1 00:10:10
Si pos es 7 00:10:11
Tienes de la 0 a la 6 00:10:16
Pues ya está 00:10:17
Claro, la primera es la 0 00:10:19
Claro, 7 posiciones 00:10:21
Un total de 7 posiciones 00:10:24
Se enumeran desde 0 hasta 6 00:10:26
Un total de 9 posiciones 00:10:27
Se enumeran desde 0 hasta 8 00:10:29
Un total de pos-posiciones 00:10:31
Se enumeran desde 0 hasta pos-1 00:10:33
vale, pues entonces, ese es el que queremos eliminar 00:10:35
pues nuestro objetivo es 00:10:38
que este que está aquí 00:10:40
asignárselo a este 00:10:41
con lo cual 00:10:44
aquí se quedará el PP 00:10:46
este 00:10:48
¿vale? 00:10:49
y este ya se habrá quedado sobrescrito 00:10:52
aquí se queda duplicado, claro, pero no pasa nada 00:10:54
porque el siguiente 00:10:56
ahora se asignará aquí 00:10:57
con lo cual este se quedará sobrescrito 00:10:59
este PP, pero no pasa nada porque ya antes había 00:11:02
pasado arriba 00:11:04
y así con todos 00:11:05
hasta el pos-1 00:11:06
que es el último que tendremos que asignar 00:11:08
al pos-2 00:11:11
y este se va a quedar duplicado 00:11:12
pero no pasa nada porque lo que 00:11:15
hacemos es, como este ya no nos importa 00:11:17
esta parte de la raya nos importa 00:11:19
cuando ya hemos terminado de hacer esto 00:11:21
a la variable pos, que es el indicador de posiciones 00:11:22
válidas, la decrementamos 00:11:25
de forma que lo que 00:11:26
haya de aquí hacia abajo ya no nos importe 00:11:29
claro, esa información no nos 00:11:32
importa, está ahí hacia abajo 00:11:33
solo nos importa esta 00:11:35
entonces solo tenemos que hacer eso 00:11:37
un for que vaya desde la 00:11:39
que tenemos que eliminar hasta 00:11:41
la penúltima copiando el siguiente 00:11:43
en el anterior, el siguiente en el anterior 00:11:45
y luego decrementar pos al final 00:11:47
ya está, entonces 00:11:49
eso 00:11:51
ahora ya buscamos 00:11:55
Vale, pues entonces ahora ya vamos a buscar, 00:12:06
primero tenemos que buscar en qué posición está el alumno a eliminar, 00:12:11
porque siempre tenemos que pensarlo por partes. 00:12:15
Otra cosa es una vez que ya tenemos las partes hechas, 00:12:18
pues veamos que podemos a lo mejor hacerlo todo en un código más compacto 00:12:21
o aprovechar un mismo bucle para hacer dos cosas a la vez, 00:12:25
pero siempre de partida, sobre todo si estamos orientándonos, 00:12:29
pensémoslo todo por partes. 00:12:33
Entonces ya hemos leído el nombre del alumno. 00:12:35
Muy bien, ¿qué nos falta ahora? 00:12:36
Localizar la posición donde está ese alumno. 00:12:38
Y luego ya hacer eso que hemos dicho ahí. 00:12:41
Pero primero hay que localizar la posición donde está el alumno. 00:12:43
Venga, pues vamos a localizarla. 00:12:45
Claro, vamos a localizar la posición donde está el alumno. 00:12:48
Venga, pues entonces vamos a buscar en este for 00:12:52
que recorre todas las posiciones válidas. 00:12:55
Ahora ya hacemos 00:12:59
Si alumnos de i 00:13:12
Resulta que es igual 00:13:14
Que es igual al nombre que me han eliminado 00:13:16
Ya está 00:13:24
Esa posición i es la que estoy buscando 00:13:24
Esta es la que estoy buscando 00:13:28
Pues la guardo aquí 00:13:29
Ya la habría encontrado 00:13:31
Entonces, esa primera parte 00:13:35
Ese trocito de código 00:13:37
Cuyo uso es exclusivamente 00:13:38
encontrar la posición 00:13:40
donde está el alumno a eliminar 00:13:42
sería esto 00:13:43
recorro el array 00:13:45
en todas las posiciones que tienen algo real 00:13:48
en cuanto encuentre un alumno 00:13:50
en alguna de esas posiciones 00:13:54
cuyo nombre coincide 00:13:56
pues justo esa posición es la que estoy buscando 00:13:57
no, la almaceno en inu 00:13:59
la almaceno en la variable pos 00:14:03
que es la que he preparado 00:14:04
para guardar esa posición 00:14:07
entonces cuando este for 00:14:08
ha terminado 00:14:12
ya en i estará la posición 00:14:13
del alumno 00:14:16
cuyo nombre es el que yo he leído 00:14:17
o no 00:14:20
porque si no hay ningún alumno 00:14:24
con esa posición 00:14:26
si no hay ninguno 00:14:28
entonces nunca jamás 00:14:29
habré entrado en el if 00:14:32
entonces pos alumno se habrá quedado 00:14:33
claro 00:14:36
a ver 00:14:37
físicamente valdrá 0 00:14:39
pero para el compilador estará indefinido 00:14:41
entonces aquí sería bonito 00:14:43
por ejemplo, si le llamamos menos 1 00:14:45
porque entonces ya, cuando salgamos 00:14:47
de este for 00:14:49
la forma de saber si el alumno 00:14:50
apareció o no, es viendo la posición 00:14:53
si es menos 1 00:14:56
es que jamás hemos entrado aquí 00:14:57
luego si es menos 1, es que no hemos 00:14:59
encontrado un alumno que se llame así 00:15:01
porque 00:15:03
y parte desde 0 00:15:04
entonces aquí podríamos 00:15:07
hacer, por ejemplo, 00:15:09
si posalumno 00:15:11
es igual a menos uno, 00:15:12
no hemos entrado 00:15:18
nunca en este if. 00:15:19
¿Vale? Ves que este if está 00:15:22
ya fuera del for, no he puesto aquí llaves. 00:15:23
Además he puesto ya a propósito para no ser 00:15:25
tan pesado con las llaves. Entonces, al no 00:15:27
haber puesto llaves, este for solo tiene 00:15:29
esta sentencia dentro y no tiene más. 00:15:31
Solo tiene esa sentencia. Este for 00:15:33
es solo para ir comprobando 00:15:35
todos y cada uno de los alumnos de i 00:15:37
a ver cuál de ellos 00:15:39
su nombre es el que me han dado 00:15:41
y si alguno es 00:15:43
su posición 00:15:45
es la que estoy buscando 00:15:47
claro, si es menos uno es imposible 00:15:48
haber entrado en ese i porque las posiciones 00:15:52
no pueden ser menos uno, serán cero o uno 00:15:53
o dos o tres, las que sean 00:15:55
entonces si está en menos uno yo ya le puedo decir 00:15:56
perdona pero ese 00:15:59
alumno que quieres eliminar 00:16:01
es que no existe 00:16:03
entonces si pos es menos uno el alumno no existe 00:16:04
no hace falta que hagamos más 00:16:16
pero si no es menos uno 00:16:18
es que sí lo hemos encontrado 00:16:20
bueno, pues aquí ya sí que es donde habrá que hacer 00:16:21
eso que hemos dicho antes 00:16:24
de ir 00:16:27
desde pos, perdón, desde pos no 00:16:28
desde la posición alumno copiando 00:16:30
el siguiente en el de arriba, el siguiente en el de arriba 00:16:32
el siguiente en el de arriba 00:16:34
entonces esto lo podríamos hacer 00:16:35
pues venga 00:16:37
desde igual a cero, perdón, no 00:16:40
desde la posición del alumno eliminar 00:16:46
¿vale? 00:16:48
mientras sí sea menor que pos-1. 00:16:51
Porque lo que voy a hacer, 00:16:57
en cada posición copio el siguiente en esa. 00:16:58
En cada posición copio el siguiente en esa. 00:17:02
Luego me quedo en la penúltima, 00:17:05
porque ya en la penúltima copiaré la siguiente, 00:17:07
que es la última, en esa. 00:17:09
Pues, ¿qué hacemos? 00:17:18
Pues lo que hacemos es 00:17:18
alumnos 00:17:21
le asignamos 00:17:26
alumnos de i 00:17:29
más 1 00:17:31
no, a cada una 00:17:32
le asigno la que tiene por debajo 00:17:40
i más 1 00:17:42
porque estamos subiendo los de abajo 00:17:43
hacia arriba 00:17:48
a ver, no es que esté recorriendo al revés 00:17:49
estoy recorriendo desde aquí 00:17:55
esta es posalumno 00:17:55
empiezo en esta, ¿qué hago? 00:17:57
a esta, le asigno esta 00:17:59
que es i más uno 00:18:01
luego, cuando pase hasta de aquí, a esta 00:18:02
le asigno esta, que es i más uno 00:18:05
o sea, mi i va variando 00:18:07
desde posalumno, posalumno más uno 00:18:09
va variando, y en cada i 00:18:11
le asigno la que tiene debajo, que la que tiene debajo 00:18:12
es i más uno, ¿vale? 00:18:15
pero vamos, si algo 00:18:18
hemos hecho mal, va ahora cuando 00:18:19
lo ejecutemos 00:18:21
cantará 00:18:23
vale, pero cuidadín 00:18:24
Porque igual que subo los nombres de alumnos 00:18:27
Tengo que subir las notas 00:18:30
Que van en paralelo los dos a raíz 00:18:31
Van en paralelo 00:18:33
Entonces que no se nos olvide 00:18:34
Notas de i 00:18:36
Me he dado cuenta yo solita 00:18:47
Vale 00:18:49
Fíjate, notas de i más 1 00:18:53
¿Vale? 00:18:56
Entonces, fijaos que nos quedamos en el penúltimo 00:19:05
Porque cuando estamos en el penúltimo 00:19:07
A ese le asignamos su siguiente 00:19:09
que ya es el post 00:19:11
para que se quede el post 00:19:12
claro 00:19:14
entonces una vez que hemos hecho ya todas las subidas 00:19:15
el último se ha quedado 00:19:19
ahí duplicado 00:19:21
pero es que esa última posición ya no nos interesa para nada 00:19:21
ahora tenemos un alumno menos 00:19:24
entonces una vez que este foro ha terminado 00:19:26
tenemos ya un alumno menos 00:19:28
que nos interese 00:19:31
la cuenta de alumnos 00:19:33
se tiene que decrementar en uno 00:19:34
pero dentro de la edad 00:19:36
claro, claro 00:19:37
claro 00:19:38
y ya estaría, entonces hombre, mucho mejor 00:19:41
si le ponemos 00:19:47
alumno 00:19:49
eliminado 00:19:51
alumno 00:19:54
y lo concatenamos y todo con su nombrecito 00:19:56
el alumno 00:19:58
de ese nombre eliminado 00:20:05
vale 00:20:07
entonces dentro de este case ya es un código 00:20:18
pues un poco largo, lo ideal sería 00:20:21
que si ya pudiéramos hacer métodos auxiliares 00:20:23
funciones auxiliares, algunas cosas 00:20:26
las metiéramos en métodos auxiliares, pero todavía no podemos. 00:20:28
¿Cómo auxiliares? 00:20:31
Que si pudiéramos 00:20:33
ya hacer alguna función auxiliar no nos quedaría 00:20:34
un case tan largo, porque podríamos hacer una 00:20:36
pero ahora todavía no podemos. 00:20:38
Vale, bueno, pues lo que hemos hecho 00:20:40
a que podríais haberlo hecho 00:20:41
vosotros en casa por la tarde, si os hubierais puesto. 00:20:44
Sí, todo eso. 00:20:47
Porque esto ya lo hemos visto. 00:20:48
Sí, claro que podríais, lo que pasa es que tenéis que 00:20:50
poneros y concentraros y dedicar 00:20:52
un rato, en el cual 00:20:54
ni miro el móvil, ni miro nada 00:20:56
Ni chateo 00:20:57
Con nadie 00:20:59
Solo me concentro 00:21:01
Vale, pues venga, vamos a probarlo 00:21:02
Porque, a ver 00:21:05
Yo tiro sobre la marcha 00:21:07
Pero puedo estar haciendo burradas 00:21:09
Algunas de las burradas que hago 00:21:11
Son voluntarias para que luego salgan 00:21:13
Y las solucionemos 00:21:15
Pero hay burradas que no son voluntarias 00:21:16
Que me salen solas 00:21:19
Entonces vamos a 00:21:19
Venga, vamos a insertar a un alumno 00:21:22
Ala 00:21:27
Venga, ya está insertado un alumno 00:21:27
Vamos a insertar a otro 00:21:33
¿Cómo que el alumno no existe? 00:21:35
Ah, es que lo he eliminado 00:21:44
Le he dado a dos 00:21:45
Ah, le he dado a la opción dos, claro, mira, me ha funcionado 00:21:47
El alumno no existe, vale 00:21:50
Vamos a insertar a Jaimito, otra vez 00:21:51
La verdad es que hubiera sido más bonito si hubiera puesto yo aquí 00:21:54
Un alumno insertado, que ni he puesto nada de eso 00:22:00
Vale, vamos a ponerles 00:22:03
nota. A Luisito 00:22:04
le vamos a poner 00:22:07
un 6. 00:22:09
Que también debería haber puesto nota puesta 00:22:10
correctamente, pero no, porque soy una vaga. 00:22:12
Vamos, 00:22:16
hombre, es un sistema. Vamos a poner nota 00:22:16
a Jaimito 00:22:18
que tiene un 10. 00:22:21
Y vamos a ver el listado. 00:22:23
Ahí están, el listado 00:22:25
de notas. Venga, 00:22:26
vamos a eliminar al primero 00:22:28
de ellos. Luisito. 00:22:30
Vale. 00:22:38
alumno eliminado, vamos a ver 00:22:39
si está eliminado, sacar listado 00:22:41
de notas, pues sí 00:22:43
vale 00:22:44
aquí las pruebas, uno debería 00:22:46
hacerlas siempre pensando en los casos 00:22:54
extremos, hemos hecho un caso 00:22:56
para este caso no ha funcionado 00:22:57
pero uno tiene que pensar siempre en lo que se llaman 00:22:59
los casos límite 00:23:02
cuando hace pruebas, los casos límite son las situaciones 00:23:03
que normalmente se refieren 00:23:06
cuando hablo de números, números muy pequeños 00:23:08
o números muy grandes 00:23:10
cuando hablo de cadenas, cadenas vacías 00:23:10
entonces aquí 00:23:13
como estoy hablando de eliminar 00:23:15
si solo tengo un elemento y elimino ese 00:23:17
ese sí se podría entender como un caso límite 00:23:19
porque implicaría dejar el array vacío 00:23:21
ese a lo mejor 00:23:23
en ese caso particular 00:23:24
no funciona 00:23:26
como el general 00:23:29
vamos a probar, vamos a eliminar 00:23:30
a Jaimito 00:23:33
vale, pues se entra 00:23:34
dentro del general, este caso límite 00:23:39
cuando a mí se me queda sin Arrays, vamos a poner un listado 00:23:41
de notas, el listado de notas 00:23:43
vacío, bueno 00:23:45
pues parece que todo funciona 00:23:48
a ver, ratio de suspenso y nota media del curso 00:23:50
me lo vais a hacer ahora mismo, porque esto claro 00:23:52
que sabéis hacerlo y mostrarlo 00:23:54
así que venga 00:23:56
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:
4
Fecha:
11 de noviembre de 2024 - 12:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
95.21 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid