Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 3-11-23 - 1 - 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 3 de noviembre de 2023 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, repito, aparte de poco a poco irnos familiarizando con la sintaxis, 00:00:00
los operadores, la construcción de programas sencillos, 00:00:10
tenéis que ir identificando las destrezas concretas que vamos incorporando 00:00:15
para tenerlas siempre ahí y tirar de ellas y no empezar de cero cada vez, 00:00:21
lo que repito mil veces hasta la saciedad. 00:00:24
¿Cómo se hace una suma acumulativa? 00:00:27
Uno tiene que identificar cuando un programa implica en algún punto de él, 00:00:29
en alguna parte, porque un programa al final es en muchas partes que se van combinando, 00:00:34
pues uno tiene que identificar cuando en alguna parte tiene que hacer la suma de muchas cosas 00:00:37
y si lo ha identificado pues ya sabe, lo hemos hecho muchas veces, 00:00:42
cómo tiene que hacerlo un bucle que va acumulando la suma, 00:00:45
si es la media pues luego dividir entre el total, 00:00:48
uno tiene que identificar cuándo va a necesitar contar, 00:00:51
si uno ya ha identificado que en un trozo de programa tiene que contar, 00:00:54
pues pone un contador que ya sabemos, una variable que empieza a cero y se va incrementando, 00:00:58
¿qué más cosas hemos incorporado? 00:01:03
Pues esto último que hemos dicho hoy, 00:01:06
si un trozo de programa me tiene que decir si algo ocurre o no ocurre, 00:01:08
pues mi forma de plantearlo es, asumo de partida una de las dos cosas, 00:01:11
que ocurre o no, la que me interese en función de lo que estoy haciendo 00:01:15
y ahora en un bucle busco algo que me haga cambiar de idea, 00:01:18
si encuentro algo que me hace cambiar de idea lo que se llama el contraejemplo lo cambio 00:01:22
y si no pues nada, mi idea sigue la original, 00:01:25
cuando ya he terminado el bucle ya sé si eso se cumple o no se cumple, 00:01:28
ese tipo de cosas son las que vamos incorporando 00:01:32
y son formas de pensar que ya las podéis usar ahí 00:01:35
para cualquier situación en la que tengáis que hacer algo como eso. 00:01:38
Pues aquí tenemos otro ejemplo, 00:01:43
hacer el mínimo de un conjunto de valores, 00:01:46
María cállate, el mínimo de un conjunto de valores o el máximo de un conjunto de valores, 00:01:49
no es un problema trivial, yo tengo un montón de datos como calculo el máximo, 00:01:54
no es trivial, vale, hay que seguir un mecanismo 00:01:58
que una vez que uno ya lo ha seguido y lo ha hecho una vez, 00:02:02
pues es que es lo mismo todo el rato, 00:02:05
vale, vamos a hacerlo con este ejercicio, 00:02:07
vale, la idea sería, antes de ponernos a programar, 00:02:10
vamos a ver cuál es la idea que seguiríamos, 00:02:16
cómo lo pensaríamos en la cabeza, lo del máximo o el mínimo. 00:02:19
Vale, pues otro problema que nos ocupa en relación a ese ejercicio, 00:03:16
por ejemplo, el máximo de un conjunto de valores, 00:03:20
cuando se habla de máximo y mínimo, 00:03:24
tiene que ser de un conjunto de valores, claro, ¿no? 00:03:27
¿Vale? Adrián, de un conjunto de valores. 00:03:35
Bueno, pues, ¿cuál es el procedimiento mental 00:03:39
que uno seguiría y que podemos trasladar luego ya directamente a código? 00:03:43
Bueno, pues podríamos ir, por ejemplo, 00:03:48
tenemos que ir uno por uno, 00:03:51
porque los programas siempre van una cosa detrás del otro, 00:03:54
nosotros mentalmente podemos mirar eso y en paralelo decir, 00:03:58
ah, el máximo es 14, 00:04:02
hemos hecho un vistazo y nos da la sensación de que hemos operado en paralelo, 00:04:05
y nos da la sensación de que hemos operado en paralelo, 00:04:09
en realidad no es que hayamos operado así, 00:04:12
pero bueno, estamos acostumbrados a un pensamiento que nos hace pensar que, 00:04:14
hecha un vistazo, sé que el máximo es el 14, 00:04:17
porque hemos procesado muy rápido, 00:04:20
¿vale? Pero hemos procesado muy rápido una secuencia de acciones, 00:04:23
aunque no nos hayamos dado cuenta, 00:04:27
no nos hemos dado cuenta, pero muy rápidamente hemos procesado una secuencia de acciones. 00:04:29
Al ordenador hay que darle esa secuencia de acciones, 00:04:33
hay que dársela, al ordenador no le puede poner los números y que lo mire, 00:04:36
como hacemos nosotros, no, 00:04:40
al ordenador hay que detallarle la secuencia de acciones 00:04:42
para llegar a esa conclusión rápida que hemos llegado nosotros viendo ahí el 14, 00:04:45
a él hay que detallarse. 00:04:49
¿Vale? Pues ¿qué secuencia de acciones le podemos detallar? 00:04:51
Es la que nosotros hemos seguido, aunque no nos hayamos dado cuenta, 00:04:54
aunque no nos hayamos dado cuenta y nos parece que las hemos visto todos a la vez, 00:04:57
hemos dedicado un nanosegundo a mirar cada uno de ellos, 00:05:01
y cuando hemos encontrado uno que superaba a otro, 00:05:05
decíamos, ah, es este. 00:05:09
Y si luego en el nanosegundo posterior hemos visto otro que era superior a este, 00:05:11
hemos dicho, ah, no, no, no, es este. 00:05:16
Entonces, aunque no nos hayamos dado cuenta, los hemos ido mirando en secuencia. 00:05:18
Y según mirábamos uno que superaba al que era máximo hasta ese momento, 00:05:22
teníamos un máximo nuevo. 00:05:27
Eso es lo que hemos hecho, lo que pasa es que los hemos mirado tan rápido 00:05:29
que nos parece que los hemos visto de golpe 00:05:32
y que nos hemos dado cuenta de que es el 14. 00:05:34
Pero no lo hemos hecho así. 00:05:36
Bueno, pues al ordenador hay que decirle lo que tiene que hacer 00:05:38
y tiene que ser exactamente eso. 00:05:40
Entonces al ordenador le vamos dando los números uno por uno. 00:05:42
Cuando le damos el primero, él asume que ese es el máximo de todos. 00:05:46
Ese único que tiene es el máximo. 00:05:50
Ahora le damos el siguiente y se hace la pregunta, 00:05:53
oye, ese siguiente que me han dado, 00:05:56
¿es mayor que el que es el máximo hasta ese momento? 00:05:58
Que yo lo he puesto aquí en mi casillita de máximo, 00:06:01
que era el 3, ¿es mayor? 00:06:04
Ah, pues sí que lo es, sí que lo es. 00:06:06
Pues tengo nuevo máximo. 00:06:08
El 3 ya no es el máximo actual, sino que es el 7. 00:06:09
Fenomenal. Vale. 00:06:12
Ahora, le damos el siguiente número, 00:06:14
el que hemos visto nosotros y inmediatamente después 00:06:18
aunque no nos hayamos dado cuenta. 00:06:20
El 5. 00:06:22
Y él se vuelve a hacer la pregunta, 00:06:23
oye, ¿el 5 es mayor que el que yo tenía como valor máximo hasta ese momento? 00:06:25
No, el que yo tenía como valor máximo hasta ese momento es el 7, 00:06:29
el 5 no es mayor, pues no lo sustituyen. 00:06:32
Lo dejo así. Vale. 00:06:34
Le damos el siguiente valor, 00:06:36
menos 12. 00:06:38
Y se vuelve a hacer la pregunta, 00:06:40
oye, ¿el menos 12 es mayor que el que era máximo hasta ese momento, 00:06:42
que es el 7? 00:06:46
No, no es mayor, pues el máximo sigue siendo 7. 00:06:47
Vale, le damos el siguiente, 00:06:50
el 14. 00:06:52
El ordenador se vuelve a preguntar, 00:06:54
oye, ¿el 14 es mayor que el que era máximo hasta ese momento, que era el 7? 00:06:56
Ah, pues sí, el 14 es mayor que el que era máximo hasta ese momento. 00:07:00
Pues pisa el 7 y se queda con el 14. 00:07:03
¿Hay más números que darle? 00:07:07
No, no hay más números, pues ya está, ya ha terminado. 00:07:09
Entonces el procesamiento es lo que hemos hecho nosotros en realidad. 00:07:11
Los hemos mirado en secuencia 00:07:15
y hemos ido sustituyendo uno por otro 00:07:17
en función de si encontramos uno que era el máximo hasta ese momento. 00:07:19
Por eso tenemos que ir dando a él. 00:07:22
Le vamos dando los números uno por uno, 00:07:24
o los valores que sea. 00:07:26
Él parte de la base de que el primero de todos es el máximo. 00:07:28
Parte de esa base. 00:07:32
Y ahora ya va aceptando los demás en un bucle. 00:07:34
Si alguno de ellos supera al que es el máximo, 00:07:37
fenomenal, tiene nuevo máximo. 00:07:40
Que no, lo deja como estaba. 00:07:42
Y así los va recibiendo todos. 00:07:44
Cuando ya los ha recibido todos, 00:07:46
lo que haya en esta cajita es el que era máximo. 00:07:48
Por ese procedimiento, 00:07:52
que es el que seguimos nosotros, 00:07:54
aunque lo hagamos tan rápido que nos damos cuenta, 00:07:56
es el que hay que detallarle. 00:07:58
Se lo detallamos para calcular el máximo 00:08:00
de un conjunto de números, por ejemplo. 00:08:02
Y nos quedaría 00:08:05
algo así. 00:08:11
Vale. 00:08:15
Ay, perdona. 00:08:17
Vale. 00:08:21
Vale, pues quince. 00:08:37
Quince. 00:08:51
Vale. 00:09:22
Pues vamos a centrarnos. 00:09:24
Luego ya ampliamos con las otras dos funcionalidades, 00:09:26
el mínimo y la media. 00:09:28
Pero bueno, va a ser... 00:09:30
Vamos a centrarnos primero en la parte de hacer el máximo. 00:09:32
Entonces este programa dice, 00:09:35
esto es un bucle que va pidiendo números. 00:09:37
Finaliza cuando se introduzca un número negativo. 00:09:40
Entonces aquí efectivamente este bucle 00:09:43
no tiene sentido hacerlo con un FOR. 00:09:45
Porque yo de partida no sé cuántas veces se va a hacer. 00:09:47
Depende. 00:09:50
Porque como cada vez se mete en el número nuevo, 00:09:52
pues cuando sea negativo. 00:09:54
No sé cuántas veces se va a hacer, no lo sé. 00:09:55
Entonces si esto no tiene sentido hacerlo con un bucle FOR, 00:09:57
pues bueno, 00:09:59
podemos 00:10:01
¿vale? 00:10:05
Hacerlo con un do while para que entre una primera vez 00:10:07
y pida el primer número. 00:10:09
Y mientras ese número 00:10:15
sea mayor o igual que cero, 00:10:17
o lo que es lo mismo no sea negativo, 00:10:19
yo sigo con el bucle. 00:10:21
¿Vale? 00:10:23
Entonces este número 00:10:24
lo declaro aquí fuera. 00:10:26
Vamos a poner el escáner porque vamos a leer 00:10:29
números del teclado. 00:10:31
¿Vale? 00:10:39
Pues este bucle ¿qué va a hacer? 00:10:40
Introduce numerito. 00:10:42
Para olvidarme de la tilde pongo valor. 00:10:50
Lo leo. 00:10:55
Lo leo. 00:11:04
Y ahora 00:11:06
¿qué tiene que hacer este programa? 00:11:08
Pues justo lo que hemos hecho. 00:11:10
¿Vale? 00:11:12
Justo lo que hemos hecho. 00:11:13
Entonces 00:11:14
en una variable 00:11:16
esto lo hemos hecho aquí 00:11:19
en una variable aparte 00:11:21
pues se irá guardando el que es máximo 00:11:23
en cada momento, una variable aparte. 00:11:25
En esta variable. 00:11:27
Entonces según le van llegando los números 00:11:29
según le van llegando los números 00:11:31
pues va comprobando a ver si el número 00:11:33
que le ha llegado es mayor que el máximo hasta ese momento. 00:11:35
Si es mayor que el máximo hasta ese momento 00:11:37
tiene nuevo máximo. 00:11:39
Esa es la idea. 00:11:40
Luego entonces necesito 00:11:41
una variable adicional para guardar ese máximo. 00:11:43
¿Vale? 00:11:45
Pues la ponemos. 00:11:46
¿Vale? Vamos construyendo el programa 00:11:49
según lo vamos pensando 00:11:51
y vamos necesitando las cosas. 00:11:53
Hasta que construimos un primer 00:11:55
prototipo de programa sobre el que ya revisamos 00:11:57
miramos a ver si lo puedo arreglar, etc. 00:11:59
Bueno, entonces el programa 00:12:01
según he dicho yo sería 00:12:03
si este numerito 00:12:05
que yo he leído 00:12:07
resulta que es mayor 00:12:09
que el que 00:12:11
es el máximo hasta ese momento 00:12:13
pues 00:12:15
queda actualizado el máximo 00:12:17
con ese numerito. 00:12:19
Esta es la idea que yo he planteado, ¿verdad? 00:12:21
Esta es la idea que yo he planteado. 00:12:25
Lo mismo que yo he dicho en la pizarra. 00:12:27
Me van llegando números. 00:12:29
Si el número que me va llegando 00:12:31
es mayor que el que es máximo 00:12:33
hasta ese momento 00:12:35
que aquí viene la duda de 00:12:37
bueno, es la primera vez 00:12:39
pues entonces queda actualizado. 00:12:41
¿Vale? 00:12:43
Y todo esto lo haré mientras el número 00:12:45
no sea negativo. 00:12:47
Bueno, esta sería la idea. 00:12:49
Ahora tenemos que refinarla. 00:12:51
Claro, sería la idea. 00:12:53
¿Vale? Pero la idea está clara 00:12:55
del procedimiento, ¿no? 00:12:57
La idea está clara. En una cajita va a ir el máximo. 00:12:59
Me van llegando los números. 00:13:01
Cada número puede ser 00:13:03
nuevo máximo 00:13:05
porque es mayor que el que era máximo hasta entonces 00:13:07
entonces pisa el que era máximo hasta entonces 00:13:09
y me sigue llegando número. 00:13:11
¿Es mayor que el que era máximo hasta entonces? 00:13:13
No. Ignorado. Me llega número. 00:13:15
¿Es mayor que el que era máximo hasta entonces? 00:13:17
No. Ignorado. Me llega número. ¿Es mayor que el que era máximo hasta entonces? 00:13:19
Sí. ¡Hala! Pisa el máximo. 00:13:21
Lo pisa. Tengo nuevo máximo. 00:13:23
La idea que estoy diciendo es esa, ¿verdad? 00:13:25
¿Vale? 00:13:27
Claro, hay que depurar. 00:13:29
La primera cuestión es 00:13:31
¿con el primer número 00:13:33
cuál es el máximo inicial? 00:13:35
¿Cuál es el máximo inicial? 00:13:37
Ahí el compilador, no se mete en venejeras 00:13:39
y me dice, perdona, máximo 00:13:41
lo tienes que inicializar a algo. 00:13:43
Dice, lo tienes que inicializar. 00:13:45
Lo tienes que inicializar. 00:13:47
Porque la primera vez, con el primer número 00:13:49
yo no sé con qué 00:13:51
compararlo. 00:13:53
¿Vale? 00:13:55
Entonces, antes hemos dicho 00:13:59
antes hemos dicho 00:14:01
que el funcionamiento ideal 00:14:03
es que 00:14:05
es que el máximo inicial 00:14:07
sea el primer número. 00:14:09
¿Verdad? Que el máximo inicial 00:14:11
sea el primer número, ¿no? 00:14:13
¿Me llega el primer número? 00:14:15
Es mi máximo inicial. 00:14:17
¿Con el siguiente número? 00:14:19
Pisa el máximo si lo supera o no. 00:14:21
¿Con el siguiente? Pisa el máximo si lo supera o no. 00:14:23
¿Verdad? Sería. 00:14:25
Pero claro, aquí tengo un problema y es 00:14:27
cuando yo he declarado la variable máximo 00:14:29
la tengo que declarar 00:14:31
todavía no tengo ni el primer número. 00:14:33
¿Qué truco puedo hacer 00:14:37
para darle un valor 00:14:39
de tal manera que ya con el primer número 00:14:41
que llegue se cumpla esta condición? 00:14:43
¿Qué truco puedo hacer? 00:14:45
Yo quiero que ya con 00:14:47
el primer número que me llegue de partida 00:14:49
ya sea seguro 00:14:51
mayor que este 00:14:53
con el que yo lo he inicializado. 00:14:55
¿Qué truco puedo poner? 00:14:57
¿Vale? Esa es una opción. Perfecto. 00:14:59
Por eso digo que esa es una opción estupenda 00:15:09
y solo trabajamos con positivos. 00:15:11
Perfecto. En este caso, como solo vamos a tener 00:15:13
en cuenta positivos, estaría 00:15:15
bien. 00:15:17
Pero el caso más general es que 00:15:19
si yo inicializo al menor 00:15:21
entero posible, al menor 00:15:23
de todos los posibles enteros, al más 00:15:25
pequeñito. Si lo inicializo al más 00:15:27
pequeñito de todos 00:15:29
el primer número que me llega va a ser 00:15:31
mayor que este seguro. 00:15:33
Luego el máximo se va a inicializar 00:15:35
con el primero. 00:15:37
Y luego ya los siguientes. Entonces la pregunta que nos queda 00:15:39
es ¿cuál es el entero más pequeñito de todos? 00:15:41
¿menos infinito? 00:15:43
No lo puedo inicializar ya, pero es que 00:15:45
un ordenador no entiende de más infinitos 00:15:47
y menos infinitos. Entiende de que los enteros 00:15:49
van entre 32 bits y lo más pequeñito 00:15:51
que se pueda almacenar 00:15:53
tiene un límite, que eso 00:15:55
en su momento ya lo vimos 00:15:57
y dijimos que podíamos acceder a ese valor 00:15:59
de esta manera, ¿verdad? 00:16:01
¿Recordáis esto? 00:16:03
Pues lo tenéis 00:16:05
por ahí, en algún ejercicio, en alguna grabación. 00:16:07
¿Vale? 00:16:09
Entonces, esto es 00:16:11
el menor entero posible 00:16:13
que 00:16:15
Java permite codificar en 32 bits. 00:16:17
Bueno, Java el ordenador. 00:16:19
El menor entero posible. 00:16:21
Pues con ese truco ya lo tengo todo solucionado. 00:16:23
Inicializo mi máximo 00:16:25
al más pequeño posible. 00:16:27
¿Vale? Al más pequeñito posible. 00:16:29
Y ahora ya, según voy leyendo 00:16:31
números, ¿vale? 00:16:33
¿El mayor supera 00:16:35
al más pequeñito posible? 00:16:37
O lo supera o es igual que él. 00:16:39
No hay otra. Pues entonces 00:16:41
tengo nuevo máximo. 00:16:43
Leo el siguiente. ¿El que me llega 00:16:45
supera al nuevo máximo que yo tengo? 00:16:47
No. Pues el máximo se queda como está. 00:16:49
Leo el siguiente. 00:16:51
¿El que me llega supera 00:16:53
al que era máximo? Sí. Pues lo actualizo. 00:16:55
¿Vale? 00:16:57
Entonces ahora ya, con este 00:16:59
truco, 00:17:01
este programa ya sí que funciona. 00:17:03
¿Vale? Con este truco 00:17:05
este programa ya sí funciona. 00:17:07
No es un truco. Sabéis cómo hay que hacerlo. 00:17:09
Obviamente. 00:17:11
¿Vale? Entonces, ¿entendéis este funcionamiento? 00:17:13
Sin importar entenderlo bien, 00:17:15
porque es la manera de hacer un máximo. 00:17:17
Es, voy recorriendo, 00:17:20
si alguno supera 00:17:22
al que era máximo, que está en esta variable aparte, 00:17:24
lo sustituye. 00:17:26
¿Vale? 00:17:28
Entonces aquí lo único, 00:17:30
uno podría hacerse preguntas, 00:17:32
como lo tengo hecho, como un do while, 00:17:34
primero leo el número, entonces la finalización 00:17:36
es que sea negativo, 00:17:38
pues está teniendo en cuenta también 00:17:40
ese negativo que es para finalizar 00:17:42
para hacer el máximo. 00:17:44
Entonces, bueno, aquí habría que aclarar un poco 00:17:46
y decir, a ver, el último número 00:17:48
que te entra, que va a ser negativo seguro, 00:17:50
porque cuando es negativo ya no repites. 00:17:52
El último que te entra, 00:17:54
¿lo quieres tener en cuenta 00:17:56
para el máximo, lo quieres tener en cuenta? 00:17:58
Pues en función de eso, tendríamos 00:18:00
que meter esto en un if, si el número es 00:18:02
diferente de negativo, 00:18:04
¿vale? Pero bueno, vamos a 00:18:06
a no liarlo. 00:18:10
¿Esto está entendido, lo del máximo? 00:18:14
¿Sí? 00:18:16
Vamos a ejecutarlo a ver si algo 00:18:18
se nos ha escapado. 00:18:20
Bueno, me faltaría aquí mostrar 00:18:22
el máximo 00:18:26
lo que tenga la variable 00:18:38
max. 00:18:40
Vamos a ver. 00:18:42
Pues venga, 00:18:46
87, 00:18:48
45, 00:18:50
23, 00:18:52
777, 23 00:18:54
y menos 1. 00:18:56
El máximo es 777. 00:18:58
Pues sí, 00:19:00
lo ha hecho bien. 00:19:02
Si yo meto de partida 00:19:04
ya un negativo, 00:19:06
si meto de partida un negativo, 00:19:08
ese negativo 00:19:10
es el único número que he metido, 00:19:12
es el propio máximo. 00:19:14
Si meto de partida un negativo, 00:19:16
entonces uno puede hacer todas las pruebas que quiera, 00:19:20
pues el no sé cuántos, 00:19:22
este, este 00:19:24
y este, y el máximo es este. 00:19:26
Bueno, pues funciona. 00:19:28
¿Vale? 00:19:32
¿Cómo cambiaríais este código? 00:19:38
O sea, esto sería para 00:19:40
calcular máximo. 00:19:44
Lo voy a poner separado. 00:19:46
¿Cómo cambiaríais 00:19:52
este código ahora si lo que queremos es 00:19:54
algo muy parecido 00:19:56
en realidad, que es calcular el mínimo? 00:19:58
¿Cómo cambiaríais este código 00:20:04
para que en lugar de calcular el máximo 00:20:06
de todos los num que le van llegando, 00:20:08
calcule el mínimo 00:20:10
en otra variable aparte, que sea de min o como sea? 00:20:12
Efectivamente, es la misma idea. 00:20:22
Yo voy recibiendo números. 00:20:24
Si alguno supera el mínimo 00:20:26
hasta ese momento, 00:20:28
lo supera, perdón, por debajo, 00:20:30
pues lo cambia. 00:20:32
¿Vale? Pues vamos a hacer una variable 00:20:34
min aquí. 00:20:36
Esta variable min 00:20:38
la voy a inicializar 00:20:40
con el mayor valor posible 00:20:42
que me permite codificar java, 00:20:44
que es este, con el mayor valor posible. 00:20:46
Con el mayor. 00:20:48
De tal manera que el primer número que me lleve 00:20:50
ya va a ser menor o igual que ese número, 00:20:52
con lo cual se va a actualizar 00:20:54
el mínimo con ese primer valor que me llega. 00:20:56
Se va a actualizar con ese primer valor. 00:20:58
Porque va a ser menor o igual que este. 00:21:02
Si es igual, es que ya está actualizado 00:21:04
a ese valor, al primero. 00:21:06
Y si es menor, se va a actualizar 00:21:08
con ese valor nuevo que me llega. 00:21:10
Bueno, pues sí. 00:21:12
Ponemos el código este mismo abajo. 00:21:14
Introduzca valor, leemos, y sería 00:21:20
si el número es menor 00:21:22
que el mínimo 00:21:24
hasta ese momento, 00:21:26
pues entonces ya tenemos nuevo mínimo. 00:21:28
¿Vale? 00:21:30
Sería un hipocambio. 00:21:32
Introducimos valor, que ese número es menor 00:21:34
que el mínimo hasta ese momento. 00:21:36
Tengo nuevo mínimo. 00:21:38
Y ahora ya 00:21:40
lo mostraría. 00:21:44
El mínimo es 00:21:48
min. 00:21:52
¿Vale? 00:21:56
¿Vale? 00:21:58
Aquí sí que va a ocurrir 00:22:02
que como el número negativo 00:22:04
que yo meto para finalizar 00:22:06
lo está teniendo en cuenta, 00:22:08
va a ser siempre el mínimo el número negativo final. 00:22:10
Va a ser siempre el número negativo final 00:22:12
el número. Vale, pero podemos cambiar aquí 00:22:14
el i poniendo. Si el número que me han metido 00:22:16
es mayor o igual que 0, 00:22:18
para no tener en cuenta el negativo, 00:22:20
y siendo mayor o igual 00:22:22
que 0, 00:22:24
además es menor que el mínimo, 00:22:26
aquí ya sí que lo meto. 00:22:28
Para sólo tener en cuenta, 00:22:30
sólo tener en cuenta 00:22:32
el positivo. 00:22:34
O sea, no tener en cuenta el último negativo 00:22:36
de finalizar. Vale, ahí ya sí que 00:22:38
tiene importancia. 00:22:40
Vamos a probarlo. 00:22:42
Si le meto yo de partida un negativo, 00:22:56
¿qué me va a mostrar? 00:22:58
Bueno, espera, ahora está haciendo 00:23:04
la primera parte del bucle. 00:23:06
Esta. 00:23:08
El máximo es menos 2. 00:23:10
Y ahora vamos a hacer el mínimo. 00:23:12
Si le meto de partida un negativo, 00:23:14
la parte del mínimo, ¿qué me va a mostrar? 00:23:16
Si le meto de partida 00:23:18
un negativo, aquí no entra, 00:23:20
¿verdad? Si le meto de partida 00:23:22
un negativo, lo que me va a mostrar 00:23:24
es lo que tuviera min. 00:23:26
¿Y qué tiene min? Esto. 00:23:28
Que yo he inicializado aquí. Entonces, si de partida 00:23:30
le meto un negativo aquí, 00:23:32
pues me muestra el mayor valor 00:23:36
entero, como esperábamos. Porque es que 00:23:38
no ha llegado ningún número 00:23:40
sobre el que calcular el mínimo. 00:23:42
No ha llegado ninguno. 00:23:44
Vamos a... 00:23:46
Vamos a esta parte. 00:23:52
Ahora vamos a... 00:23:54
El mínimo, 8, 67, 00:23:56
0 y menos 3. 00:24:00
El mínimo es 0. Vale, pues lo ha hecho 00:24:02
bien. El mínimo de todos los que he metido es 0. 00:24:04
Lo ha hecho bien. 00:24:06
¿Vale? 00:24:08
Vamos a dejar también aquí la condición. 00:24:10
Aunque aquí no afecte, 00:24:12
para que sean iguales. 00:24:14
¿Vale? Entonces, esto 00:24:22
de máximo y mínimo 00:24:24
os tiene que quedar en la cabeza que 00:24:26
la idea 00:24:28
es que sea máximo, sea mínimo. 00:24:30
Se inicializa con el primer valor 00:24:32
y los demás sirven para, según van llegando, 00:24:34
decidir si actualizo el que es máximo 00:24:36
o el que es mínimo. 00:24:38
Entonces, 00:24:40
aquí realmente es una tontería 00:24:42
hacer los dos códigos por separado. 00:24:44
Puedo llevarlo en paralelo. 00:24:46
Puedo llevarlo en paralelo. 00:24:48
¿Vale? Este código 00:24:50
para el máximo, y ahora voy a copiar 00:24:52
aquí esto para el mínimo. 00:24:54
Que tontería 00:24:56
llevarlos en dos bucles separados. 00:24:58
Y ahora aquí ya. 00:25:00
Vale, lo pongo en el mismo bucle. 00:25:14
Y ahora ya sí. 00:25:16
Se introduce valor. 00:25:18
Si el número supera el máximo, 00:25:20
actualizo máximo. 00:25:22
Y ahora ya aparte. 00:25:24
Otro if aparte. Esto no es un else. 00:25:26
Siempre las dos cosas. 00:25:28
Si supera el máximo, tengo 00:25:30
un nuevo máximo. 00:25:32
Si baja por debajo del mínimo, tengo un nuevo mínimo. 00:25:34
Dos if separados. Son dos tareas 00:25:36
que se hacen en paralelo. Por un lado compruebo 00:25:38
a ver si supera el máximo 00:25:40
y por otro lado compruebo a ver si está por debajo del mínimo. 00:25:42
Para hacer en paralelo las dos cosas. 00:25:44
En paralelo voy actualizando 00:25:46
esta variable, luego esta 00:25:48
y así mientras no 00:25:50
introduzcamos uno negativo. 00:25:52
Y ya está. 00:25:54
Como hacemos aquí, pues venga. 00:25:56
9, 43, 2, 65, 3. 00:26:02
Y este para acabar. 00:26:06
Ah, es que cuando he hecho el copia y pega. 00:26:12
No, el máximo es más 00:26:14
y el mínimo es min. 00:26:16
Que he hecho mal. 00:26:18
Ah, la condición. 00:26:20
Si número es 00:26:22
mayor que máximo. 00:26:24
Ah, vale, que cuando he copiado 00:26:26
la condición enterita, del copia y pega 00:26:28
de abajo. Vale, vale. 00:26:30
Ahí, si número es mayor 00:26:32
que máximo. 00:26:34
Ahí. 00:26:36
Vale. 00:26:38
Vale, ahora ya. 00:26:42
Sí. 00:26:44
4, 6, 2, 00:26:46
8 y menos 2. 00:26:48
El máximo 8 y el mínimo 2. 00:26:50
Vale. 00:26:52
¿Cómo ya lo tengo abajo? 00:27:02
Sí, a ver, en esta condición 00:27:06
aquí no hace falta, a ver, aquí hay una 00:27:08
implicación y es 00:27:10
lo que pasa es que lo he puesto por homogeneidad de condiciones. 00:27:12
Aquí 00:27:14
el no ponerlo, lo que significa 00:27:16
es que te procesa el negativo, entonces 00:27:18
si tú de partida le pones un negativo 00:27:20
te dice que el máximo es el número negativo. 00:27:22
En lugar de decirte que el máximo es este. 00:27:24
Entonces, es la única diferencia. 00:27:26
Pero para que funcione el de arriba 00:27:28
igual que el de abajo y sólo entre 00:27:30
en él, si no es negativo 00:27:32
para que sean las dos situaciones iguales, 00:27:34
pues por eso lo he puesto. 00:27:36
¿Vale? 00:27:40
Y en este mismo código ya 00:27:42
podemos incluir que haga la media. 00:27:44
Está haciendo la operación para el máximo. 00:27:46
Este es la operación para el mínimo. 00:27:48
Y podemos incluir que haga la media. 00:27:50
¿Qué tengo que incluir para que haga la media además? 00:27:52
¿Qué más meto aquí dentro de ese 00:27:56
bucle? 00:27:58
¿Un cont, por ejemplo? 00:28:04
A ver, ya tengo el bucle, no hace falta. 00:28:10
Aquí una variable que me va sumando ese número. 00:28:12
¿Vale? 00:28:14
Con hacer esto, 00:28:16
suma más igual 00:28:18
número. 00:28:20
Suma más igual número. 00:28:22
Declarando la suma. 00:28:24
Igual que cero. 00:28:28
¿Vale? Suma más igual número. 00:28:34
Y para luego hacer la media tengo que 00:28:36
saber cuántos números hay. 00:28:38
Con lo cual necesito un contador también. 00:28:40
¿Vale? 00:28:46
Entonces, con... 00:28:50
Vale, pues esta parte de aquí es para la media. 00:28:54
Voy sumando en la variable suma 00:28:58
como siempre los números que me van llegando, 00:29:00
voy sumando los números que me van llegando 00:29:02
y los voy contando. Esto es lo de siempre. 00:29:04
Cuando ya he salido del bucle 00:29:06
ya puedo mostrar la media. 00:29:08
Aquí lo único, cuidado, que estoy 00:29:10
contando el número negativo también para la media. 00:29:12
Si no lo quiero contar para la media 00:29:14
lo tendría que sacar en un if, ¿verdad? 00:29:18
Entonces, para que sea una misma línea 00:29:20
y así recordamos cosas, podemos hacer 00:29:22
suma igual a 00:29:24
y evaluamos 00:29:26
la condición. El número 00:29:28
es mayor o igual que cero. 00:29:30
Pues entonces sí lo quiero sumar 00:29:32
a la suma. 00:29:34
Suma más 00:29:36
número. 00:29:38
¿Que no? 00:29:40
Pues suma, se queda como está. 00:29:42
¿Vale? 00:29:44
Esta línea es 00:29:46
para sumar el numerito que me ha 00:29:48
llegado a la suma, para hacer la suma acumulativa. 00:29:50
Pero solo si es positivo. 00:29:52
Si es negativo ya es el último de finalizar 00:29:54
no quiero incorporarlo en la media. 00:29:56
¿Vale? 00:29:58
Una sola línea y contamos. 00:30:00
Y ahora ya aquí, una vez que hemos 00:30:02
salido fuera podemos hacer la media 00:30:04
que ya hemos hecho, suma entre con. 00:30:06
Entonces vamos a 00:30:36
probar. 00:30:38
Pues metemos 00:30:40
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
3 de noviembre de 2023 - 14:05
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
743.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid