Saltar navegación

20241104 ProgrEstruct-Arrays-ejercicios_8 - 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.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues el ejercicio 28 va a ser el primero en el que ya sea una pequeña aplicación para gestionar cosas. Dentro de las cosas que podemos hacer, pues con consola y poco más. 00:00:00
un sistema para gestionar 00:00:10
notas de alumnos. 00:00:19
La primera versión es 00:00:21
nombres de alumnos en un array. 00:00:23
El sistema tiene que poder insertar alumnos, 00:00:25
eliminarlos, buscarlos, 00:00:27
es decir, devolver la posición, 00:00:30
pero esa versión la vamos a 00:00:31
directamente ya modificar 00:00:32
para que además 00:00:34
vamos a hacer una aplicación que trabaje 00:00:36
con alumnos y sus notas. 00:00:38
Entonces, 00:00:41
los alumnos van a estar en un array 00:00:42
y las notas en otro 00:00:45
el array de los alumnos 00:00:46
será de string 00:00:49
no, porque 00:00:50
no podemos hacerlo bidimensional 00:00:53
porque las notas son enteras 00:00:55
y los nombres 00:00:57
son cadenas, entonces no puede ir 00:00:59
en un mismo array, son tipos de datos distintos 00:01:01
vale 00:01:03
entonces 00:01:05
tenemos un array de nombres 00:01:05
y un array de, y aparte bidimensional 00:01:09
se complicaría. Bueno, y una raíz de notas. Y ya está. 00:01:11
Entonces, primero, la aplicación es de gestión de notas y de alumnos. 00:01:15
Bueno, funcionalidades de la aplicación. Puedes insertar un alumno 00:01:20
con su nota, eliminar un alumno con su nota, 00:01:23
devolvamos a hacer, dado el nombre de alumno que te diga qué nota tiene, 00:01:27
una serie de funcionalidades. Buscar 00:01:31
alumnos que tengan menos de una nota, 00:01:35
mostrar la nota media de alumnos 00:01:38
vamos a hacer una aplicación 00:01:41
de alguna manera 00:01:42
una aplicación que gestione alumnos y notas 00:01:44
entonces 00:01:46
vamos a fijar primero los datos 00:01:47
ya lo hemos dicho, los datos 00:01:51
colección de alumnos, colección de notas 00:01:52
¿vale? siempre 00:01:55
una primera fase es 00:01:56
¿dónde vamos a guardar esos datos? 00:01:58
pues si tengo un montón de alumnos 00:02:01
y tengo un montón de notas 00:02:02
pues el montón de alumnos en un array 00:02:03
y el montón de notas en otro array 00:02:06
donde para una posición 00:02:08
ese alumno se corresponde con su nota. 00:02:10
Alumnos de una posición 00:02:13
tienen su nota en la posición 00:02:14
equivalente del otro array. 00:02:16
Entonces podemos decidir que esa sea 00:02:19
la forma de guardar los datos. 00:02:20
Nuestro listado de notas. 00:02:22
Y ahora, funcionalidades que vamos a hacer. 00:02:24
Vamos a incorporar varias. Insertar nota, 00:02:26
calcular nota media, el alumno que tenga 00:02:28
la nota más alta, cuántos han suspendido. 00:02:30
Vamos a meter diferentes funcionalidades. 00:02:32
Meter un alumno nuevo, sacar alumnos. 00:02:34
Bueno, como si fuera un sistema de gestión de notas y alumnos. 00:02:36
Vale. 00:02:41
Entonces, como la aplicación va a tener varias funcionalidades 00:02:42
para que se comunique con el usuario, 00:02:44
lo mejor es que tenga un menú. 00:02:47
Claro, un menú. 00:02:49
Los menús, ¿cómo funcionan? 00:02:50
Te muestra este. 00:02:52
¿Qué quiere hacer? 00:02:53
Insertar alumno, eliminar, mostrar nota media, 00:02:54
calcular alumnos suspensos, etcétera. 00:02:57
Te muestra una serie de opciones. 00:02:59
Te lee la opción. 00:03:02
Y luego ya en función de la opción, 00:03:04
hace lo que tenga que hacer y vuelve a mostrar 00:03:05
el menú, claro, pues justo 00:03:07
lo que yo he dicho ya nos suena a dos cosas 00:03:09
a do while y a switch case 00:03:11
un do while que te 00:03:13
hace, do, muestra menú 00:03:15
¿por qué do while? porque 00:03:17
la primera vez entras seguro para mostrar menú 00:03:19
claro, do 00:03:21
while, dentro del do, muestras 00:03:23
menú, les opción y un switch 00:03:25
case que en función de la opción hace una cosa u otra 00:03:27
mientras la opción diferente de 00:03:29
salir y para arriba otra vez 00:03:31
luego esa es la estructura de una aplicación 00:03:33
con menú, pues vamos a hacer primero 00:03:35
nuestro menú con las opciones 00:03:37
y luego ya nos ponemos a programar cada opción 00:03:39
claro, y nos quedará un programa pues muy largote 00:03:41
venga 00:03:44
ejercicio 28 00:03:45
hemos quedado 00:03:48
vale, pues venga 00:04:08
los datos 00:04:08
los datos hemos dicho que van a estar 00:04:09
dos arrays 00:04:12
un array con los nombres 00:04:15
de los alumnos 00:04:18
vale 00:04:19
entonces 00:04:26
de cuantas posiciones 00:04:27
pues como tenemos 00:04:32
que decidirlo desde ya 00:04:35
tenemos que decidirlo 00:04:36
nosotros no sabemos cuantos alumnos hay 00:04:37
de hecho se van a estar insertando 00:04:40
eliminando, no sabemos 00:04:42
entonces una opción que tenemos 00:04:44
una opción que tenemos, luego ya modificaremos 00:04:46
para hacer una 00:04:48
mejor, pero una opción que tenemos 00:04:49
fácil es 00:04:52
me declaro una caja de alumnos muy grandota 00:04:54
por ejemplo hasta 100 00:04:56
y como mucho 00:04:58
me van a caber 100 00:05:00
entonces yo pues ahí 00:05:01
tendré en cada momento los alumnos que tenga 00:05:04
a lo mejor tengo relleno solo 5 00:05:06
que me dicen insertar 1 00:05:08
pues ya tengo 1 más 6 00:05:10
que me dicen eliminar 1 00:05:11
pues me quedo con 1 menos 00:05:13
Pero en mi caja como caben hasta 100 00:05:15
Pues no hay problema 00:05:18
Entonces nos podemos quedar ahí con 100 00:05:19
Venga 00:05:21
Y ahora las notas pues lo mismo 00:05:22
Cada posición tiene 00:05:25
La nota del alumno que está en esa misma posición 00:05:34
Vale 00:05:37
Como vamos a tener que leer por teclado 00:05:41
En algún momento 00:05:43
Ahora vamos a ponerlo 00:05:46
Cuando hagamos el menú las vamos escribiendo. 00:05:53
Cuando escribamos las... 00:05:55
Vale, entonces. 00:05:57
Ahora, ¿el programa en qué va a constar? 00:05:59
Pues en un menú que se muestra menú. 00:06:01
Le opción... 00:06:04
Pues venga, esto es un do while. 00:06:05
Un do while. 00:06:10
Aquí vamos a hacer un do while. 00:06:11
¿El bucle cuándo va a terminar? 00:06:13
Cuando la opción metida sea la diferente de salir. 00:06:15
Esto ya lo comprobaremos, esa condición. 00:06:19
Ya lo comprobaremos, esa condición. 00:06:21
Por el dual, ¿qué va a hacer? ¿Mostrar menú? 00:06:23
Pues mostrar menú es 00:06:25
un rollo 00:06:27
porque tenemos que escribir todas las opciones. 00:06:30
¡Joder! 00:06:33
Se me ha ido. 00:06:35
Vale, pues a ver opciones. 00:06:42
Vamos a poner 00:06:44
insertar alumno. 00:06:45
Vamos a inventarnos unas cuantas 00:06:48
interesantes. 00:06:50
He puesto 28 00:06:53
pero va a ser una cosa tuneada 00:06:54
a nuestros intereses. 00:06:56
Eliminar alumno. 00:07:02
Vale. 00:07:04
Poner nota a un alumno. 00:07:06
Porque cuando insertamos un alumno, 00:07:19
inicialmente lo insertamos sin nota. 00:07:21
Nota cero podemos poner. 00:07:22
Y luego ya, cuando ese alumno está, 00:07:24
le vamos poniendo sus notas. 00:07:25
Poner nota a un alumno. 00:07:27
Vale. 00:07:29
¿Qué más funcionalidades nos pueden interesar? 00:07:29
Pues, por ejemplo, sacar listado. 00:07:32
porque si sacamos un listado será la forma 00:07:35
que comprobemos si estamos insertando bien o mal 00:07:37
claro 00:07:39
sacar listado de notas 00:07:39
y así será la forma de comprobar que lo estamos haciendo 00:07:45
bien, bueno, no estoy poniendo el número 00:07:47
de la opción, entonces el tío no va a saber 00:07:49
claro 00:07:51
2, 3, o podéis poner 00:07:52
A, B, C, la que os dé la gana 00:07:55
2, 3, 4 00:07:56
sacar listado de notas 00:07:59
vale, por ejemplo 00:08:00
vamos a hacer una opción que sea 00:08:03
ratio 00:08:05
de suspensos 00:08:08
para ver si tienen que expulsar 00:08:09
al profe o no 00:08:11
vale 00:08:12
ni de coña 00:08:14
así que no os hagáis ilusiones 00:08:17
digo porque nos ponemos a suspender a propósito 00:08:19
no, no, no 00:08:21
pero te pagan menos algo 00:08:22
¿qué va? te van a pagar menos 00:08:24
te pagan lo mismo, ¿que para qué sigan 00:08:27
todos suspensos? pues para información 00:08:29
para ti decir, ostras, suspenden muchos 00:08:31
¿qué hacemos? 00:08:33
hombre, a ver 00:08:37
pues sirve para cosas, en mi caso 00:08:38
para que grabe las clases 00:08:40
para que repita las cosas 00:08:41
200.000 veces 00:08:45
para todo, que sigue sin funcionar 00:08:47
pues ya no se me ocurre nada más 00:08:49
no se me ocurre más 00:08:50
relájate 00:08:52
ratio de suspensos 00:08:56
¿qué más funcionalidades pueden ser interesantes? 00:08:58
nota media 00:09:02
Nota media del curso 00:09:03
Enviar un mail 00:09:05
Al alumno con menos nota 00:09:07
Para reírnos de él 00:09:09
Pues mira, eso se haría en cuatro líneas 00:09:10
Se coge una librería, pim, y se envía el email 00:09:12
Y llega tu email a tu bandeja de entrada 00:09:14
Pero eso más adelante 00:09:16
¿Vale? 00:09:17
Mojarnos de alumnos 00:09:20
Vale, no, y la de salir 00:09:21
Mojarnos de Pedro 00:09:23
Mi madre está bien 00:09:25
Venga, y salir 00:09:29
Ahora 00:09:32
una vez que hemos mostrado el menú 00:09:33
hay que leer la opción 00:09:36
pues por ejemplo la opción 00:09:37
la podemos leer así 00:09:40
bueno 00:09:42
opción como queráis 00:09:45
llamar a esa variable 00:09:48
entonces ahora ya en función 00:09:49
de si la opción es 1, 2, 3, 4, 5, 6 00:09:52
y 7 pues se hace una cosa u otra 00:09:54
entonces ahora ya 00:09:56
si que tiene sentido hacer esto 00:09:57
en el caso 00:10:00
de que la opción sea 00:10:02
Case 1 00:10:03
Pues bla bla bla 00:10:05
Tendremos que hacer lo que toque 00:10:07
Y así con las 7 00:10:08
Siguientes 00:10:14
Vale, no sé cuántas llevo 00:10:17
Case 1 lo que sea, case 2 lo que sea 00:10:37
Case 3 lo que sea 00:10:39
6, 7 00:10:46
En el caso 7 00:10:49
Pues ya sabemos que lo que vamos a hacer va a ser un mensajito 00:10:50
Vale, adiós 00:10:53
Para que el tío sepa que se va. 00:10:54
Cerrando aplicación, por ejemplo. 00:10:58
Ala, en el caso 7 cerramos aplicación. 00:11:02
No, porque es que ya el programa va a terminar. 00:11:08
Va a terminar el bucle. 00:11:10
Y podemos poner un default. 00:11:13
Porque imaginaos que el tío la mete mal, la opción. 00:11:15
Entonces, pues le decimos. 00:11:18
Opción incorrecta. 00:11:22
Para que se vaya a mostrar el menú. 00:11:23
¿Qué ocurre? 00:11:26
Voy, voy, voy 00:11:27
Pero no hay nada arriba 00:11:29
Vale, entonces ahora ya 00:11:33
Sí que podemos marcar la condición 00:11:36
Este bucle se va a estar ejecutando 00:11:39
Muestra menú, lee opción, procesa 00:11:41
Muestra menú, lee opción, procesa 00:11:43
Se va a estar ejecutando todo el rato 00:11:45
Mientras la opción 00:11:48
Sea diferente de la 7 00:11:49
Que es la de salir 00:11:51
¿Verdad? 00:11:52
Mientras la opción sea diferente de la de salir 00:11:54
Va a estar 00:11:57
entonces cuando el tío dé la opción de salir 00:11:58
este do while termina y el programa 00:12:00
ya no hace nada más 00:12:02
con lo cual habrá salido 00:12:03
bueno, como quieras 00:12:05
entonces, pero aquí que ocurre 00:12:08
que el compilador me dice 00:12:10
eh, opción, no tengo ni idea de cuál es opción 00:12:12
claro que no tiene ni idea, porque la he declarado 00:12:14
dentro de este bloque 00:12:17
por eso yo había hecho un boolean salir 00:12:18
y luego en la opción 7 le meto un 00:12:20
igual a 3 00:12:22
claro, la he declarado dentro de este bloque 00:12:23
pues claro, no pasa nada 00:12:26
es que lo que tienes es que declararla fuera 00:12:27
entonces la declaramos fuera 00:12:29
y ahora ya soluciona el problema 00:12:31
¿vale? la opción se declara 00:12:33
fuera y se lee dentro 00:12:35
es que se usa 00:12:37
en esta condición y esto está fuera 00:12:41
de estas llaves 00:12:43
entonces la declaras fuera 00:12:44
pero la lees aquí 00:12:46
entonces este es un dual que está todo el rato 00:12:48
muestra menú, lee opción 00:12:50
y haz lo que toque 00:12:53
muestra menú, lee opción y haz lo que toque 00:12:54
si la opción es la 7 00:12:56
lo que tocará será cerrando aplicación 00:12:58
y cuando nos vayamos a 00:13:01
la condición 00:13:03
dirá, uy es la 7, pues ya está 00:13:05
ya no hará más, vale 00:13:06
ya está, ahora nos falta rellenar las opciones 00:13:08
entonces si ejecutamos 00:13:17
esto, pues ahora mismo 00:13:19
las opciones del menú no harán nada 00:13:21
pero al menos ya funcionará esto como 00:13:23
insertar al 1, 1, ya está 00:13:24
no me hace nada, pero 00:13:27
me muevo, me muestra el menú 00:13:29
Venga, ahora voy a poner nota a un alumno 00:13:30
No hace nada porque no tengo nada puesto 00:13:33
Pero me vuelvo a mostrar el menú 00:13:35
6, vale, no hace nada 00:13:36
Me vuelvo a mostrar el menú 00:13:38
7, ala, cerrando aplicación y se acabó el programa 00:13:39
Bueno, pues la estructura del menú funciona 00:13:42
Pero claro 00:13:46
Ahora viene 00:13:48
Lo conflictivo 00:13:49
Que se acerca a una de las opciones 00:13:52
¿Vale? 00:13:54
Vale 00:13:58
Yo creo que me he dejado el teléfono en el baño 00:13:58
No está mi teléfono por ahí, ¿verdad? 00:14:02
A ver, que creo que me lo deja en el baño 00:14:16
Porque se ha ido el internet este 00:14:18
Seguimos 00:14:20
Venga, vamos con las 00:14:21
Funcionalidades 00:14:29
Este programa se nos va a alargar 00:14:30
se nos va a alargar en líneas 00:14:34
un montón. 00:14:37
¿Vale? Silencio. 00:14:40
Claro, ¿por qué? Porque no sabemos 00:14:42
todavía hacer métodos de librería. 00:14:43
No sabemos. 00:14:46
Cuando sepamos hacer métodos de librería, en lugar 00:14:48
de tener un programa enorme, 00:14:49
dividiremos esas porciones que yo he 00:14:51
dicho. Pues la de ver si algo está o no está. 00:14:54
A ver si no sé qué. Lo dividiremos en funciones distintas. 00:14:55
Entonces, mi programa será llamar 00:14:58
a esas funciones, pero como ahora mismo no sabemos 00:14:59
hacerlo, se nos va a quedar un programa 00:15:01
enormísimo, ¿vale? 00:15:03
Venga, pues vamos al caso 1 00:15:06
No, no es difícil hacerlo, pero vamos 00:15:07
a ver primero esta parte 00:15:12
Eso, eso 00:15:13
Vale, insertar 00:15:16
alumno, insertar alumno 00:15:18
Pues venga 00:15:20
Para insertar alumno habrá que decirle 00:15:20
al usuario, introduzca 00:15:24
el nombre del alumno, ¿verdad? 00:15:26
veis que aplicación más bonita nos queda 00:15:27
introduzca nombre del alumno 00:15:33
vale, leemos el nombre del alumno 00:15:37
vale 00:15:39
y ahora, este nombre donde se coloca 00:15:48
en la primera 00:15:50
posición libre de este array 00:15:52
este array es la 00:15:54
caja que hemos hecho para guardar 00:15:56
los alumnos 00:15:58
claro, está al principio 00:15:58
vale, es que 00:16:01
de la barrita 00:16:03
vale 00:16:05
Entonces, este array de aquí inicialmente tiene nul, nul, nul, nul, nul en la primera posición que esté libre. 00:16:13
¿Cuál es la primera posición que esté libre? 00:16:20
No lo sabemos, pues necesitamos una variable adicional que lleve un registro de la primera posición libre. 00:16:22
Entonces, a variable adicional, pues una variable posiciono como sea que inicialmente es cero. 00:16:31
Cero, la declaro aquí. 00:16:37
entonces ahora ya, este alumno 00:16:39
le podemos guardar ya en 00:16:42
alumnos de post 00:16:46
y dejamos este incrementado 00:16:48
para el siguiente que creemos 00:16:50
nombre 00:16:51
vale, y la nota hemos dicho que cuando a un alumno 00:16:53
se le crea por primera vez 00:16:58
se le pone nota 0 00:17:00
pues venga, vamos a ponerle 00:17:01
notas 00:17:04
este igual a 0 00:17:06
hemos insertado ya un alumno 00:17:10
ah, perdón, no, no, no, cuidado 00:17:12
notas, no lo puedo incrementar aquí 00:17:14
porque notas tiene que ir al mismo sitio 00:17:17
es decir 00:17:18
pos es la posición 00:17:23
hasta la que hay rellenos, tanto alumnos 00:17:25
como notas, porque van en paralelo 00:17:27
si hay un alumno está su nota, si hay un alumno está su nota 00:17:29
vale, pues inicialmente 00:17:31
pos es cero 00:17:33
entonces, cuando yo inserto un alumno 00:17:34
lo guardo en esa posición 00:17:37
pongo su nota correspondiente 00:17:38
que está en esa misma posición, pongo su nota 00:17:41
a cero y dejo esto 00:17:43
incrementado para que el siguiente 00:17:45
alumno que se introduzca 00:17:47
se quede en la siguiente posición. 00:17:49
He quitado esto que había puesto yo así 00:17:51
muy rápidamente, porque si ponía 00:17:53
esto, las notas se ponían en la siguiente, 00:17:55
en la que no era. No, se tiene que poner 00:17:57
en la misma. 00:17:59
Vale, pues el alumno 00:18:03
ya está metido. 00:18:04
El alumno ya está. 00:18:08
Vale, ¿qué vamos a hacer después? 00:18:12
¿Puedes repetir un poco? 00:18:13
Espera, me acuerdo del 1 del 2. 00:18:14
Yo también me he rayado. 00:18:16
A ver, yo tengo un array pensado para meter alumnos y sus notas en posiciones idénticas que inicialmente no tiene nada. 00:18:18
Entonces voy a usar esta variable adicional para indicar cuál es la posición en la que me toca meter un alumno nuevo. 00:18:27
La primera vacía, la primera vacía. 00:18:34
Inicialmente la primera vacía es la cero, la primera vacía. 00:18:37
Entonces cuando yo inserto un alumno, lo insertaré en la primera vacía. 00:18:40
y dejo post incrementado 00:18:44
para que la primera vacía se quede incrementada 00:18:46
en una unidad. 00:18:48
Bueno, cada uno 00:18:53
lleva su nota. Entonces, los requisitos 00:18:54
de la aplicación me dicen, cuando insertes 00:18:56
un alumno, ponle nota cero. Luego ya hay una funcionalidad 00:18:58
después que es ponerle una nota a ese. 00:19:00
¿Vale? 00:19:03
Bueno, pues entonces, vamos a 00:19:08
saltarnos la de eliminar. 00:19:09
Vamos a saltarnos la de eliminar. 00:19:11
Vamos a hacer la de ponerle nota a un 00:19:14
alumno. Ahora ya sí. 00:19:15
la de eliminar, por ahora nos la saltamos, 00:19:17
vamos a poner la funcionalidad de poner nota 00:19:20
a un alumno. Vale, pues esta es 00:19:22
la opción 3. Habrá que 00:19:24
preguntarle primero 00:19:26
nombre del alumno 00:19:27
al que vamos a poner nota. 00:19:30
Nombre de alumno. 00:19:34
Vale, estamos en la funcionalidad 00:19:36
de poner nota a un alumno. Nombre 00:19:37
de alumno. Leemos la nota 00:19:39
de ese alumno. Perdón, el nombre de ese alumno 00:19:41
al que hay que ponerle nota. 00:19:43
Vale, nombre como ya está declarado 00:19:45
No hace falta que lo redeclare 00:19:56
Ahora, ¿qué tengo que hacer con ese alumno 00:19:57
Al que le tengo que poner nota? 00:20:00
Voy a tener que buscar en el array de alumnos 00:20:01
Y cuando encuentre en qué posición está 00:20:03
En esa misma posición 00:20:06
De notas, le pongo la nota 00:20:08
Que me den 00:20:10
Nombre de alumno y qué nota quiere poner 00:20:10
Vamos a pedirle 00:20:13
Nota que quiere poner al alumno 00:20:14
el mensajito para que quede claro 00:20:22
lo que queremos hacer 00:20:24
y leemos pues eso 00:20:25
una nota cualquiera 00:20:30
vale, pues ahora, ahora ya sí que 00:20:32
hay que recorrer el array 00:20:37
hasta encontrar la 00:20:39
posición en la que está ese alumno 00:20:41
y cuando la encontremos 00:20:44
en esa misma posición del array notas 00:20:45
ir a esa nota 00:20:47
pues venga, vamos a recorrer el array de alumnos 00:20:48
mientras si sea menor 00:20:51
Porque alumnos.lens, voy a dejarlo así a ver si alguno se pone nervioso. 00:20:55
A ver, recorro la raíz de alumnos. 00:21:05
Ahora, para cada alumno, si ese alumno resulta que es igual al que me han pasado que busque, 00:21:08
si es igual, ¿qué ocurre? 00:21:19
Que en esta posición y es en la que está ese alumno. 00:21:21
es en esta posicioni 00:21:24
pues entonces será en esta 00:21:26
posicioni en la que yo tenga 00:21:29
que poner dentro de la array notas 00:21:31
la nota que me han dado 00:21:33
¿verdad? 00:21:34
no, en mi cabeza no piensa así 00:21:39
si hombre, que si, que si, ¿cómo no va a pensar así? 00:21:41
claro que piensa así 00:21:43
a ver, estamos recorriendo 00:21:44
el array de alumnos 00:21:47
para cada alumno 00:21:48
en cuanto encontramos el alumno 00:21:52
¿Cuyo nombre es el que me han dado? 00:21:55
Pues es el que está en esa posición. 00:21:56
Vale, pero ¿por qué la de nota sí? 00:21:58
Vale, porque si este alumno es igual al nombre que me han dado, 00:22:00
es que el alumno de posición i es igual al nombre que me han dado. 00:22:05
Pues el alumno de posición i tiene que tener su nota 00:22:09
en la posición i del otro array. 00:22:12
Pues entonces en la posición i del otro array le pongo su nota. 00:22:15
En la posición i del otro array. 00:22:19
Ah, vale. 00:22:21
¿Vale? 00:22:23
Ok. 00:22:23
Vale, ahora sí, pero no. 00:22:26
Casi, pero no. 00:22:30
Aquí hay un problema. 00:22:32
Que estoy recorriendo el array de alumnos entero. 00:22:34
Y tengo que recorrer el array de alumnos ancianos. 00:22:37
Tengo que recorrer solo los que hay rellenos de verdad. 00:22:40
¿Y cuántos hay rellenos de verdad? 00:22:44
Pos. 00:22:46
Estos son los que hay rellenos de verdad. 00:22:48
Cuando he rellenado uno, pos vale uno. 00:22:50
Cuando he rellenado dos, pos vale dos. 00:22:52
luego aquí nada de alumnos.le 00:22:54
aquí post, que son los que realmente 00:22:57
están rellenos, claro 00:22:59
los que realmente están rellenos 00:23:01
vale, pues ya le hemos puesto 00:23:03
la nota al alumno 00:23:08
vamos a 00:23:09
vamos a hacer este programa profesional 00:23:15
de forma que si yo le he metido un alumno que no está 00:23:18
que el programa me diga, uy no he encontrado 00:23:20
el alumno, vamos a hacer una variable 00:23:22
boolean, para que quede esto 00:23:24
mucho más bonito y profesional 00:23:26
encontrado 00:23:27
que inicialmente 00:23:29
está a falso. 00:23:32
Y si yo ya he encontrado el alumno, 00:23:33
es decir, si entro en este if alguna vez, 00:23:35
si yo ya lo he encontrado, 00:23:39
ahora ya ponemos 00:23:41
encontrado a true. 00:23:41
Entonces, ¿para qué nos sirve esta variable que hemos puesto aquí? 00:23:46
La hemos añadido. 00:23:49
Esta, a la hora de meter la nota, 00:23:51
no hace falta, ¿no? 00:23:52
Pero la hemos añadido para que cuando hemos 00:23:54
acabado este for, sepamos 00:23:56
si hemos encontrado alumno o no lo hemos encontrado. 00:23:58
De forma que si no lo hemos encontrado 00:24:00
la aplicación sea un poco más amigable 00:24:02
y nos diga, uy, no encontré a ese alumno. 00:24:04
Mucho mejor, ¿verdad? Porque si no se va a quedar callada. 00:24:05
Si no has encontrado 00:24:10
al alumno, pues dices 00:24:12
no existe el alumno. 00:24:13
Punto pelota. 00:24:15
Vale. 00:24:20
Ya tenéis que iros acostumbrando a aplicaciones 00:24:21
ya más grandes. Más grandes, aplicaciones 00:24:23
que hacen cosas. 00:24:25
Esto y más. 00:24:29
Mucho más, no hay límites 00:24:30
Para la imaginación 00:24:33
Este cuesta un punto 00:24:36
Vale 00:24:38
Y para qué nos vale el encontrado 00:24:40
Uy, nos vale el encontrado 00:24:45
Para ya usarlo y salimos de este for también 00:24:47
Ya que hemos puesto el encontrado 00:24:49
Para avisar al usuario 00:24:51
Si no había ninguno con ese nombre 00:24:53
Ya de paso, vamos a usarlo en este for 00:24:55
Para que una vez encontrado 00:24:58
no siga haciendo iteraciones hasta el infinito 00:24:59
entonces, mientras recorras el array 00:25:01
y además no me hayas 00:25:03
encontrado 00:25:05
porque una vez que lo hayas encontrado ya no sigas mirando 00:25:06
alumnos, pues nos sirve 00:25:12
tiene un uso doble este boolean 00:25:13
tiene un uso doble 00:25:15
el parar el for cuando ya lo hemos encontrado 00:25:16
y además darle un aviso 00:25:20
al usuario 00:25:21
además darle un aviso 00:25:22
¿en español? 00:25:25
en español estás jodido 00:25:28
Que no, que es broma 00:25:29
Sí, vamos a hacer el listado de notas 00:25:35
Para poder usar la aplicación 00:25:41
Y ver si realmente funciona 00:25:43
Porque si no tenemos una opción para que nos muestre el resultado 00:25:44
No sabemos si ha metido notas o no ha metido 00:25:47
Claro, no, no, lo vais a completar esta tarde 00:25:48
Vamos a hacer la opción 4 00:25:53
A ver, sois perfectísimamente capaces 00:25:56
Si sois unos vagos, eso ya es otro tema 00:26:00
Pero capaces sois 00:26:02
Vale, hemos listado 00:26:04
Vamos a recorrer el for y ya está 00:26:06
Tú solito 00:26:08
De esto y mucho más 00:26:10
Vamos a 00:26:11
La opción de listado 00:26:15
Es simplemente 00:26:17
Recorrer los for y ya está 00:26:19
Desde igual a cero, mientras si sea menor a post 00:26:22
Venga, que no vamos a tener que ir 00:26:24
Esta es la opción de listado 00:26:27
Vamos a mostrar 00:26:30
Vamos a mostrar 00:26:31
Alumnos 00:26:38
Espera, es todo seguidito 00:26:41
Con un guión 00:26:43
Alumnos, que es 00:26:44
Alumnos de I 00:26:47
Y separado 00:26:48
Con 00:26:50
Un guioncito o dos 00:26:52
Su nota 00:26:55
Notas de I 00:26:56
Pues mira, a mí me han entrado los calores 00:27:01
A ver 00:27:03
La opción del listado ya está 00:27:04
Es este for 00:27:08
El for que recorre a raíz de alumnos 00:27:09
Y sus notas, pero solo hasta el relleno 00:27:12
Vale, pues vamos a hacer 00:27:14
Nos falta la funcionalidad de 00:27:16
Eliminar alumnos, la ratio de suspensos 00:27:18
Y la nota media, que es fácil 00:27:20
Lo podéis hacer perfectamente 00:27:22
Pero vamos a ejecutar 00:27:23
¿Me repites el caso 4, por favor? 00:27:25
¿Cómo que te lo repita el caso 4? 00:27:28
El caso 4 es el listado. 00:27:30
Sacar un listado. 00:27:31
Estos son dos líneas. 00:27:34
Este for es... 00:27:37
Pero fue una cosa. 00:27:39
He visto en el caso 3 00:27:41
en donde 00:27:42
lo de... 00:27:44
Ay, perdón, perdón. 00:27:47
Pero si es un for número de corriente. 00:27:49
Dime. 00:27:51
Ah, sí, sí. 00:27:54
Tienes razón. 00:27:55
Hay que tener cuidado porque después de un next int 00:27:56
Que aquí tenemos un next in 00:27:59
Luego ya tenemos un next line 00:28:00
Para el nombre 00:28:03
Entonces aquí después de este next in 00:28:04
Un next line 00:28:05
Porque si no esto se va a la porra 00:28:06
A ver con el escáner 00:28:09
Si cuando hay espacios 00:28:15
Con el buffer reader que es otro objeto no 00:28:17
Es que lo estamos haciendo todo muy muy muy a mano 00:28:19
Pero mejor 00:28:23
Es como hay que empezar 00:28:25
Porque luego si no 00:28:26
vale 00:28:27
pero vamos, con el escáner es que es así 00:28:29
te puedes cambiar el token 00:28:32
a ver, que el escáner 00:28:35
tiene muchas cosas para configurarlo, pero bueno 00:28:36
estamos, como no conocemos objetos, estamos dando lo básico 00:28:38
vale, después de este next 00:28:40
int, ya no hay problema porque después de 00:28:42
este next int leemos la opción 00:28:44
entonces después de este next int ya iremos al menú 00:28:46
que vuelve a hacer un next int, luego esa combinación no es 00:28:48
problemática, entonces vamos a probarlo 00:28:50
venga, paramos esto 00:28:52
y ahora vamos a volver a ejecutarlo 00:28:54
Entonces, si ponéis el pasado 00:28:56
Y te enfrentas a una persona 00:28:58
De la edad media 00:29:00
Le dirías, ¿qué sabes hacer? 00:29:01
¿Cómo? 00:29:04
Vamos a 00:29:06
Insertar un alumno 00:29:11
Venga, Pepe 00:29:14
Hemos insertado a Pepe 00:29:16
Vamos a insertar a otro más 00:29:19
A Juan 00:29:20
Ya tenemos a dos 00:29:23
Vamos a poner 00:29:24
Nota 00:29:25
Vamos a poner nota 00:29:26
A Juan 00:29:30
¿A quién le quieres poner a Juan? ¿Qué le vamos a poner? 00:29:32
Un 10 00:29:34
Venga 00:29:34
Vamos a poner nota al Pepe este 00:29:36
¿Qué nota le ponemos? 00:29:40
Un 0 00:29:42
Venga, vamos a ver el listado de notas 00:29:42
Que llevamos puestas 00:29:46
Pues llevamos... Uy, que si este notprint 00:29:47
Me ha faltado ahí, pero vamos, está bien 00:29:49
Un Pepe tiene un 0 00:29:51
Y Juan tiene un 10 00:29:55
Y luego el menú 00:29:56
Claro, es que luego esto es del menú 00:29:57
Es que me ha faltado un pedazo System.out 00:29:59
Println 00:30:01
Me falta un 00:30:02
Joder, me ha puesto un 10 a mí 00:30:07
Toma ya, di que sí 00:30:09
Voy Pedro 00:30:10
Voy a poner un menos 10 00:30:13
Me falta aquí 00:30:14
Un System.out 00:30:18
Println 00:30:20
Y ahora ya sí quedaría bonito 00:30:21
Pero vale, ya está, funciona 00:30:23
A ver, pues intentad 00:30:25
Eliminar 00:30:28
Con eliminar el problema que tenemos es 00:30:30
Que el alumno que queremos quitar 00:30:32
Los de abajo, hay que subirlos 00:30:34
Una posición hacia arriba, pero eso ya lo hemos hecho 00:30:36
No, a ver, es un bucle 00:30:38
Que pi, pi, pi, ya está 00:30:40
Es un bucle, eliminar 00:30:41
Ratio de suspenso 00:30:43
Contar suspensos, dividir entre el total 00:30:45
Dividir entre pos 00:30:48
Como el de moverlo 00:30:49
Como el del circular 00:30:51
Claro, te mueves desde pos 00:30:52
Hasta el que la posición a eliminar 00:30:56
Y ya está, o sea, es muy cortito 00:30:58
Ratio de suspensos 00:31:00
Cuentas los suspensos y divides entre pos 00:31:01
Pues ya está, nota media 00:31:03
La media de la RAI 00:31:05
O sea, lo que queda se hace en nada, en realidad 00:31:06
Pues venga, intentad hacerlo 00:31:09
¿Vale? 00:31:11
¿Cómo que no? 00:31:13
Bueno, sí, sí, sí 00:31:13
Ah, hombre, por Dios 00:31:15
Vale 00:31:19
Uff 00:31:20
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:
5
Fecha:
11 de noviembre de 2024 - 12:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
142.36 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid