Saltar navegación

20241022 ProgrEstruct-Bucles-ejercicios_6 - 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 22 de octubre de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

y los demás se han subido al carro 00:00:00
así porque les da la gana 00:00:03
I have sex daily 00:00:04
quiero decir mis lex 00:00:07
eso 00:00:08
bueno, ahora está de moda 00:00:09
todo está de moda 00:00:12
venga 00:00:14
venga, a ver 00:00:16
vale, aquí ya 00:00:24
hacemos otra cosa nueva 00:00:26
sumar y contar 00:00:28
ya nos lo sabemos todo de memoria 00:00:31
aquí nos dicen 00:00:32
calcular máximo y mínimo 00:00:34
eso no es ni sumar ni contar 00:00:37
eso no lo hemos hecho hasta ahora 00:00:39
la media sí 00:00:40
la media será lo mismo que he dicho anterior 00:00:42
una lista de números 00:00:45
o sea, ir pidiendo números 00:00:47
entonces para hacer la media lo mismo que hemos hecho 00:00:48
un bucle, pide número 00:00:51
hace la suma 00:00:53
y cuenta el número 00:00:54
pide número, lo suma y lo cuenta 00:00:57
y luego cuando hayamos acabado el bucle 00:01:00
la suma entre la cuenta, la media 00:01:02
lo que hemos hecho antes 00:01:04
vale, aquí un for no 00:01:05
porque aquí me dicen, no vas a pedir 10 números 00:01:07
o 20 00:01:10
aquí vas a estar pidiendo números mientras metas un 0 00:01:11
luego aquí 00:01:14
yo no sé exactamente cuántas veces 00:01:16
se va a hacer el bucle 00:01:18
es más que infinito 00:01:19
es infinito indefinido 00:01:23
yo no sé cuántas veces se va a ejecutar 00:01:23
si la primera vez el tío mete el 0 00:01:26
la segunda vez, pues se va a hacer dos veces 00:01:28
pero si en la siguiente ejecución mete el 0 00:01:30
la vez 15, se va a ejecutar 15 veces 00:01:32
entonces no sé cuántas veces se va a ejecutar 00:01:34
de partida, luego aquí el for no pega 00:01:36
aquí pegará un while 00:01:38
porque la condición es 00:01:40
mientras el número sea 00:01:42
mayor o igual que 0 00:01:43
porque va a terminar cuando sea negativo 00:01:45
entonces aquí será un while 00:01:48
porque aquí no es la cantidad 00:01:50
de veces que se va a hacer 00:01:52
sino hasta cuándo se va a hacer 00:01:53
se va a hacer mientras sea positivo 00:01:55
luego aquí va a ser un while 00:01:58
vale, pues un while y hacer la media 00:01:59
eso ya lo sabemos hacer 00:02:01
pero aparte nos piden 00:02:02
un máximo y un mínimo 00:02:04
entonces el máximo y el mínimo 00:02:06
eso no lo hemos programado, no sabemos hacerlo 00:02:08
se nos tiene que ocurrir, tenemos que pensarlo 00:02:11
¿cómo lo haríamos? 00:02:13
en el mundo real para ahora programarlo 00:02:15
¿vale? 00:02:18
bueno, pues cuando uno tiene un máximo 00:02:20
Tiene que hacer el máximo 00:02:22
De un conjunto de cosas 00:02:25
El máximo siempre es el máximo de un conjunto de cosas 00:02:26
Claro, el máximo de un conjunto 00:02:28
Pues a ver 00:02:30
¿Cómo hago yo para ponerle? 00:02:39
Es que como me han quitado el boli 00:02:42
¿Cómo hago yo para ponerle un...? 00:02:43
¿Quién tenía eso? 00:02:44
No, pero serían suyos 00:02:51
Serían suyos, se los habría comprado él 00:02:53
Oye, ¿y no podéis cogerle uno así sin que se entere? 00:02:55
Ahora también te veo con más rotuladores de ese hombre. 00:03:02
Ah, pues ahora entiendo por qué no desaparecen a los demás. 00:03:06
Es que no os ha dicho es coleccionista. 00:03:09
Se la lleva de por. 00:03:11
Pues igual se lo va llevando. 00:03:13
Vale, a ver, ¿cómo hago para un pincel más gordo? 00:03:14
No, porque así es siempre el mismo. 00:03:18
Bueno, da igual. 00:03:24
Se ve más o menos, ¿no? 00:03:25
vale, entonces 00:03:27
vamos a hacer el máximo de varias cosas 00:03:29
por ejemplo, de un conjunto de cosas 00:03:31
esta, esta 00:03:33
esta, esta y esta 00:03:35
que pueden ser números 00:03:37
puede ser cualquier cosa, entonces 00:03:39
el máximo es el máximo en algo 00:03:41
si es números está claro, el máximo en valor 00:03:43
el máximo en valor, pero podría 00:03:45
ser el máximo 00:03:47
de alumnos, pero el máximo de alumnos 00:03:48
¿en qué? en edad, vale, pues el que tiene 00:03:51
la edad máxima, o sea, el concepto de máximo 00:03:53
en general, es el máximo 00:03:56
de lo que sea, ¿vale? 00:03:58
Pues, ¿cómo hacemos en realidad 00:04:00
el máximo? Pues 00:04:02
vamos a ver, nosotros 00:04:04
en condiciones normales, miramos 00:04:05
y decimos, este, y lo cogemos 00:04:08
pero al ordenador 00:04:10
no le podemos decir, míralos todos a mogollón 00:04:12
y coge, no le podemos decir eso 00:04:14
al ordenador hay que darle una secuencia 00:04:16
de pasos muy masticada 00:04:18
para que lo haga, lo que nosotros 00:04:20
hacemos de mirar de golpe y coger 00:04:22
nos parece que hemos mirado de golpe 00:04:23
y hemos cogido. Pero en realidad 00:04:26
hemos seguido una secuencia, aunque 00:04:28
no nos dé tiempo a identificarla. 00:04:30
Pues esa secuencia que hemos seguido 00:04:32
se la tenemos que pasar al ordenador, porque 00:04:34
él es siquiera darle pasito por pasito. 00:04:36
Pues esa secuencia que en realidad seguimos, aunque 00:04:38
no nos demos cuenta, para ver cuál es 00:04:40
el mayor de algo, 00:04:42
el mayor de lo que sea, en caso de números, 00:04:44
de valor. En caso de 00:04:45
mesas, de tamaño, la que sea. 00:04:48
Pues ¿cómo lo hacemos? 00:04:50
En realidad vamos uno por uno. 00:04:52
uno no puede mirar todo a la vez 00:04:53
aunque no lo parezca va haciendo un barrido 00:04:55
miramos este 00:04:57
como ahora mismo solo he mirado uno 00:04:59
este es el mayor sí o sí 00:05:02
no tengo nada que decidir 00:05:03
ahora paso a mirar el siguiente 00:05:05
tengo dos opciones 00:05:07
que este supere al anterior 00:05:09
si lo supera 00:05:11
tengo un nuevo mayor 00:05:12
un nuevo máximo, que es este 00:05:14
ahora paso a ver el siguiente 00:05:16
oye, este es mayor que el 00:05:19
Es decir, tenemos mentalmente un espacio aquí, un espacio aquí en el que tenemos en cada momento el que hasta ese instante es el máximo para nosotros, ¿vale? Entonces, yo he mirado el primero, en ese instante el máximo es el primero porque es el único que hay, no me ha dado tiempo a mirar más, luego el máximo es el primero, ¿vale? 00:05:21
inmediatamente después miro el segundo 00:05:42
repito, puede haber ocurrido dos cosas 00:05:45
que este segundo supere a este o no 00:05:47
si no lo supera 00:05:49
mi mente no ha cambiado y aquí sigue 00:05:51
estando el primero 00:05:53
pero si este supera a este 00:05:54
aquí en mi mente, en mi visión de cuál 00:05:56
es el mayor, pasa a estar este 00:05:59
ahora, miro el siguiente 00:06:01
puede de nuevo ocurrir dos cosas 00:06:03
que este siguiente supere 00:06:05
al que en mi mente era el mayor 00:06:07
o que no lo supere 00:06:09
si no lo ha superado, en mi mente el mayor sigue siendo este 00:06:10
pero si lo ha superado, automáticamente 00:06:13
este pasa a ser el que era el mayor 00:06:15
y así hasta que hago todos 00:06:16
entonces, esa es la secuencia 00:06:19
que realmente seguimos cuando queremos ver 00:06:21
de un conjunto de valores, cuál es el mayor 00:06:23
en algo, en lo que sea 00:06:25
en el caso de números, en valor 00:06:26
pero podría ser, pues ya digo, en el caso de 00:06:28
ventanas en tamaño, en lo que fuera 00:06:31
vale, pues estos pasitos 00:06:33
se los tenemos que decir al ordenador 00:06:35
nada más, entonces decirle 00:06:37
esto al ordenador es muy fácil 00:06:39
prepárate una cajita, una variable 00:06:41
para guardar el que sea el máximo 00:06:43
en cada instante 00:06:46
y ahora empiezo con un bucle 00:06:46
a recorrerlos 00:06:50
uno tras otro 00:06:52
luego para hacer el máximo 00:06:53
un bucle va a ser imprescindible 00:06:55
un bucle que vaya uno tras otro 00:06:57
inicialmente 00:06:59
en el máximo guardo el primero 00:07:01
el primero 00:07:03
y ahora ya en ese bucle voy uno por uno 00:07:05
este es mayor que este 00:07:07
sustituye. Y ya está. 00:07:09
Voy a este. ¿Este es mayor que este? 00:07:12
Lo sustituye. 00:07:14
Y voy al siguiente. ¿Este es mayor 00:07:16
que este? No, pues no lo sustituye. 00:07:18
Y voy al siguiente. ¿Este es 00:07:20
mayor que este? Pues lo sustituye. 00:07:22
Luego, para hacer el máximo, ya está. 00:07:24
Una variable para 00:07:26
guardar el que sea máximo en cada momento 00:07:28
que inicialmente, cuando 00:07:30
arranque el recorrido, será el primero. 00:07:32
Y luego ya arranca un recorrido 00:07:34
en el cual voy uno por uno. 00:07:36
y con cada uno me hago una pregunta 00:07:38
oye tú, ¿superas al que era el mayor para mí? 00:07:40
no lo superas, no tengo nada que hacer 00:07:43
paso al siguiente, lo superas 00:07:44
te sustituyo y ya está 00:07:47
pues todo eso es lo que tenemos que decirle 00:07:48
que lo haga él 00:07:51
y ya está, sabemos hacerlo 00:07:52
es hacer if, hacer bucles 00:07:53
claro, es hacer un bucle 00:07:56
con un if dentro y una variable 00:07:59
que es la que va recibiendo 00:08:00
el valor si procede 00:08:02
pues ya está, nada más que eso es lo que tenemos que hacer 00:08:04
Y el mínimo será lo mismo, pero en el if será menor en vez de mayor. 00:08:07
Pero bueno, ahora lo hacemos. 00:08:10
Vale, pues entonces, ejercicio 15. 00:08:12
Ejercicio 15, vale. 00:08:33
Consiste en leer valores por teclado. 00:08:35
Pues venga, como vamos a leer valores por teclado, 00:08:38
pues esto va a tener que estar sí o sí. 00:08:41
Vale, una variable para guardar el valor máximo en cada momento 00:08:58
tiene que haber, ¿no? 00:09:03
es esta de aquí 00:09:05
es esta 00:09:06
esta de aquí, la que tiene que ahorrar el valor máximo 00:09:08
en cada momento 00:09:11
y ahora ya empieza mi recorrido de valores 00:09:12
estos valores de donde me llegan 00:09:14
los voy pidiendo por teclado 00:09:17
luego voy a tener que hacer un bucle para 00:09:18
irlos leyendo y así poder pararme en cada uno 00:09:21
de ellos 00:09:23
vale, pues entonces vamos a ir 00:09:23
a ver como nos va quedando 00:09:28
vamos a hacer un bucle 00:09:30
en el cual vamos a ir pidiendo los valores 00:09:32
Luego ya completamos con la condición 00:09:34
Lo que sea 00:09:42
Introduzca el numerito 00:09:43
Y lo leemos 00:09:47
Me falta la variable para el numerito 00:09:50
Pues venga, número 00:09:52
Número igual al número que he leído 00:09:54
Vale, entonces lo que yo he dicho tal cual 00:10:03
Que nos faltarán cosas ahora por completar 00:10:07
Claro es, vale, si ese número 00:10:09
Es mayor 00:10:11
Que el que es el máximo hasta ese momento 00:10:13
Lo tiene que sustituir 00:10:16
luego lo que yo he dicho trasladado 00:10:18
es así 00:10:21
si este número 00:10:22
es mayor 00:10:25
que el que es el máximo 00:10:27
hasta ese momento, sea el que sea 00:10:29
entonces 00:10:31
tengo nuevo valor máximo 00:10:33
¿vale? entonces esta es la idea 00:10:35
que he expresado yo antes 00:10:42
vamos haciendo 00:10:44
el recorrido por los números, en este caso 00:10:46
el recorrido implica leerlos 00:10:48
¿vale? pues voy cogiendo 00:10:49
cada número, que es lo que decía, voy cogiendo cada 00:10:52
número, voy cogiendo cada número 00:10:54
con cada número, ¿es 00:10:55
mayor que el que está aquí colocado? 00:10:58
si es mayor, pues 00:11:00
pisa el que estuviera ahí colocado 00:11:02
que es justo lo que he hecho 00:11:03
aquí, ¿es mayor que el que está 00:11:06
colocado en esa variable? 00:11:08
pues pisa el que está ahí colocado 00:11:10
lo pisa, num se convierte 00:11:11
en el nuevo máximo y paso 00:11:14
al siguiente 00:11:16
y paso al siguiente, vale 00:11:16
entonces, por ahora vamos a dejarlo así 00:11:22
vamos a terminar 00:11:25
con este bucle que me dice aquí, oye 00:11:27
¿y la condición cuál es? me han dicho 00:11:28
haz esto mientras 00:11:30
no metas un número negativo 00:11:32
¿no? 00:11:34
la lista finalizará 00:11:38
cuando se introduzca un número negativo 00:11:40
vale, pues entonces 00:11:41
mientras num sea 00:11:43
mayor o igual que cero, haz esto 00:11:46
vale, esto empieza ya a aproximarse 00:11:48
al código, pero claro 00:11:52
hay que irle arreglando cosas 00:11:53
vale, mientras el número que yo leo 00:11:55
aquí dentro sea positivo 00:11:57
compara, a ver si supera 00:11:59
el que es máximo hasta ese momento 00:12:01
y actualizas 00:12:03
vale 00:12:04
primera cosa que me dice el compilador 00:12:06
oye, que num 00:12:09
la primera vez que entras al 00:12:11
while, num no está 00:12:13
inicializado, num no tiene nada, no puedo 00:12:15
evaluar la condición 00:12:17
vale, lo que pasa es que nosotros sabemos que 00:12:18
una primera vez 00:12:21
tenemos que entrar sí o sí 00:12:22
esa primera vez hay que entrar sí o sí 00:12:24
para leer el primero y luego ya las siguientes 00:12:26
depende, por eso ya lo hemos 00:12:28
dicho antes, hombre pues voy a 00:12:30
meter uno cualquiera que 00:12:32
haga que la condición sea cierta 00:12:34
y ya está 00:12:35
vale, esto ya está solucionado 00:12:37
entraremos una primera vez en el while 00:12:40
leemos número 00:12:42
que ese número cumple la condición de superar 00:12:46
el máximo hasta ese momento 00:12:48
se convierte en el nuevo máximo 00:12:50
es decir, pasa a esta cajita 00:12:52
y me voy al siguiente 00:12:55
vale, pero aún así el compilador 00:12:56
se sigue quejando como la de esperar 00:12:59
me dice, oye, cuidado 00:13:00
pero el máximo, ¿con qué lo inicializo? 00:13:01
nosotros hemos dicho antes 00:13:08
a ver, hay una opción que siempre 00:13:10
nos funcionaría, porque la que dices tú 00:13:12
de cero, y si metes 00:13:14
números negativos, imagínate 00:13:16
que todos los números, ah bueno, perdón, en este caso 00:13:18
no, porque lo negativo finaliza, vale, vale 00:13:20
pero vamos a imaginarnos un caso que queremos hacer 00:13:21
el máximo de un montón de números 00:13:25
que pueden ser negativos o positivos 00:13:27
de 20, por ejemplo, que pueden ser negativos 00:13:29
y positivos, entonces el máximo 00:13:31
lo tendríamos que inicializar 00:13:33
al más bajo 00:13:34
posible, y ese es menos 00:13:36
infinito, no existe 00:13:38
no, no, no, no, no se puede inicializar 00:13:40
a nul porque es una variable primitiva 00:13:43
no, entonces, a ver, la idea es que 00:13:44
nuestro objetivo es que se inicialice 00:13:46
con el primero de todos 00:13:49
con el primero de la lista 00:13:50
que se inicialice con el primero 00:13:51
¿verdad? 00:13:53
es decir, que si estamos en la primera iteración 00:13:55
si estamos en la primera iteración 00:13:57
es que ni hacemos esto 00:14:00
máximo es igual al primero 00:14:01
¿vale? 00:14:03
es decir, estas iteraciones 00:14:05
de aquí yo con el primero 00:14:08
he dicho el primero directamente a la variable 00:14:09
máximo, el primero directamente a máximo 00:14:12
y ya con los siguientes 00:14:14
es donde hago la comparación ¿verdad? 00:14:16
porque con el primero no tengo nada 00:14:18
con lo que comparar, el primero ya es el primer 00:14:20
máximo de todos 00:14:22
entonces podríamos hacer una primera modificación 00:14:23
una primera versión a ver si nos gusta 00:14:26
y sería 00:14:28
a ver si estamos en la primera 00:14:30
o no, por ejemplo 00:14:32
¿se podría usar un 00:14:34
for dentro del while? ¿para qué? 00:14:36
en este caso 00:14:40
no lo necesitamos, a un bucle anidado 00:14:42
dentro de otro bucle si es imprescindible 00:14:44
sí, pero para qué queremos 00:14:46
en este caso no nos hace falta, lo único que queremos 00:14:48
aquí es que 00:14:50
si estamos en la primera 00:14:52
de las iteraciones, es decir 00:14:54
estamos leyendo el primero, si estamos en la primera 00:14:56
en ese caso no hacer esto 00:14:58
es decir, si estamos en la 00:15:00
primera, queremos 00:15:02
directamente hacer esto, máximo igual al número 00:15:09
que he leído, si estamos en la 00:15:11
primera, máximo igual al número que he leído 00:15:13
es decir, si estamos aquí 00:15:14
aquí, yo con este 00:15:16
no lo quiero comparar con nada, lo que quiero 00:15:19
es llevarlo a máximo directamente. 00:15:21
Ya está. Porque en ese momento es el 00:15:23
máximo, el único que hay. 00:15:25
Con las siguientes ya sí. Con las siguientes 00:15:27
tengo que... Compara con 00:15:29
el que es máximo. Lo supera, 00:15:31
sustituye. No lo supera, no haces 00:15:33
nada. Entonces, ¿qué es lo que puedo 00:15:35
hacer en este código? 00:15:37
Vale, pues detectar si estamos en la primera. 00:15:39
Porque si estamos en la primera, máximo es 00:15:41
igual a null. Y si no estamos en 00:15:43
la primera, entonces 00:15:45
hago esto. 00:15:47
Luego esto es un if else, ¿verdad? 00:15:49
¿Estoy en la primera? 00:15:51
Pues entonces 00:15:54
máximo igual a none. 00:15:56
¿No estás en la primera? 00:15:58
Pues entonces 00:16:01
ya haces esto. 00:16:02
Entonces me falta aquí 00:16:05
meter algo para detectar si estoy en la primera o no. 00:16:06
Hombre, pues lo tengo muy fácil. 00:16:09
Me pongo un contador cualquiera por aquí 00:16:10
que empieza haciendo cero 00:16:12
y lo incremento aquí. 00:16:13
¿Vale? 00:16:16
Claro, pero lo puede incrementar 00:16:19
dentro de leaf. 00:16:20
para que se los incremente la primera vez 00:16:21
vale, entonces esta sería una 00:16:23
primera versión 00:16:26
que lo que me importa es que la entendáis 00:16:28
ahora vemos si podemos a lo mejor usar otro truco 00:16:29
vale, entonces ahora aquí 00:16:32
si estoy en la primera vez 00:16:37
vale, entonces 00:16:38
con esto que yo he hecho aquí 00:16:47
vale 00:16:50
entonces, aquí 00:16:57
ya, si estamos 00:16:59
en la primera iteración 00:17:02
si estamos en la primera 00:17:04
ya sabemos, o sea, la primera vez 00:17:05
que entra, que va a entrar seguro 00:17:08
máximo se va a inicializar con 00:17:10
num, estupendo, y cont se va a quedar incrementado 00:17:12
para que ya la siguiente vez 00:17:14
no entre en el if, ya más nunca, ya no va a entrar en el if 00:17:16
más nunca, entonces ya las siguientes veces 00:17:18
un segundo, las siguientes veces 00:17:20
ya va a entrar por aquí siempre, ya va a entrar 00:17:22
por aquí, ¿verdad? siempre, que es justo lo que queremos 00:17:24
¿vale? 00:17:26
sí, un cont 00:17:29
que empieza valiendo cero 00:17:30
¿vale? entonces si estamos en la primera 00:17:31
ya está 00:17:33
y si no estamos en la primera 00:17:34
ya me toca hacer todo esto 00:17:37
¿vale? 00:17:38
en la primera porque máximo 00:17:40
es igual a 5 00:17:43
porque es el único que tienes 00:17:44
claro, en la primera vez que entras tienes el primer número 00:17:45
ahí no tienes nada con lo que comparar 00:17:49
de antes 00:17:51
ahí sabes, ese es el máximo 00:17:52
sí o sí, porque es el único que tengo 00:17:55
ese es el máximo, sí o sí 00:17:56
vale, aun así el compilador 00:17:58
se nos pone tonto 00:18:01
pero porque el compilador no entiende lo que está pasando 00:18:03
entonces nosotros sabemos 00:18:06
que aquí va a entrar 00:18:07
seguro 00:18:09
porque count empieza valiendo 0 00:18:11
y este while es 00:18:14
mientras num sea mayor o igual que 0 y num es 0 00:18:15
entonces nosotros sabemos que va a entrar 00:18:18
una primera vez 00:18:20
y que esa primera vez va a ser 0 00:18:20
con lo cual sabemos que máximo se va a 00:18:24
inicializar seguro con el primero 00:18:25
lo sabemos seguro por la combinación 00:18:27
de valores que hemos dado 00:18:29
pero el compilador no mira 00:18:30
los valores, mira la estructura 00:18:34
y él mira, estoy en un while 00:18:35
que puede entrar o no 00:18:37
y aquí estás en un if que puedes entrar o no 00:18:39
con lo cual no tengo la seguridad 00:18:42
de que máximo tenga algo 00:18:43
no tengo la seguridad porque si no entras nunca en ese if 00:18:45
nosotros sabemos que va a entrar 00:18:48
que va a entrar la primera, lo sabemos 00:18:49
pero el compilador solo mira estructuras 00:18:51
dice esto es un if, un if puede que sí 00:18:53
puede que no, con lo cual puede 00:18:55
que llegues aquí y máximo no tenga nada 00:18:57
entonces se te queja, pero esto ya sí que lo arreglamos 00:18:59
y decimos, bueno, te doy aquí cualquier cosa 00:19:01
la que me dé la gana 00:19:03
inicializa lo que quieras, a cero, me da igual 00:19:04
entonces el compilador ya se calla 00:19:07
pero este valor que te hayas puesto aquí no vale para nada 00:19:09
ese valor que hayas puesto ahí no vale para nada 00:19:12
porque tú sabes 00:19:13
que se va a inicializar 00:19:15
máximo la primera vez con el primer 00:19:17
número, pisando el que tú hayas puesto 00:19:19
arriba, pisando el que hayas puesto arriba 00:19:21
te da igual el que hayas puesto arriba 00:19:23
vale, pues este programa vamos a comprobar que nos hace 00:19:24
el máximo y sobre el máximo de unos números metidos 00:19:30
y luego buscamos 00:19:32
alguna traversión 00:19:36
con un contador que empieza 00:19:36
valiendo 0 00:19:40
si es 0 y ya lo dejas incrementado 00:19:40
para que la siguiente 00:19:43
ah, inicializando num a 0 00:19:44
porque como num es mayor o igual que 0 00:19:47
el máximo es 00:19:49
máximo 00:19:59
vale, pues vamos a 00:20:01
ejecutar este a ver si 00:20:10
introduzca número 87 00:20:12
introduzca número 100 00:20:14
introduzca número 34 00:20:16
introduzca número 0 00:20:18
introduzca número 00:20:20
y voy a meter un negativo para que acabe 00:20:21
menos 7 00:20:23
con el menos 7 00:20:26
acaba, el máximo es 100 00:20:28
vale, es una sola 00:20:30
prueba, la que he hecho 00:20:32
pero bueno, está bien 00:20:34
no hace falta que hagamos más, el máximo es 100 00:20:36
vale 00:20:38
Ya, como estamos muy sueltos 00:20:39
Para seguir moviendo la cabeza 00:20:43
Vamos a hacer alguna variante 00:20:44
Que no tenga este if dentro 00:20:47
Que se hace un poco engorroso, todo el rollo 00:20:48
Vamos a ver si nos ocurre alguna variante 00:20:51
Vale, va por lo de 00:20:52
Inicializar al cero, justo que has dicho tú 00:20:55
¿Vale? Es, a ver 00:20:57
El objetivo de poner 00:20:58
Este contador a cero 00:21:00
Y hacer aquí un if, si es igual a cero 00:21:03
Es simplemente 00:21:05
Para asegurarnos de que la variable 00:21:06
máximo se inicializa con el primero. 00:21:09
¿Vale? Se inicializa con el 00:21:12
primero. Bueno, pues entonces 00:21:13
si yo pongo 00:21:15
la variable máximo al menor 00:21:17
valor posible 00:21:19
de todos los que se pueden meter, 00:21:20
lo pongo al menor valor posible, 00:21:23
¿vale? 00:21:26
Sé seguro que el primero 00:21:27
va a ser mayor que ese menor valor 00:21:29
posible. Entonces sé seguro 00:21:31
que el primer valor va a inicializar 00:21:33
máximo. ¿Vale? 00:21:35
y repito, si inicializáramos 00:21:37
esta variable 00:21:39
máximo, con el menor valor 00:21:41
que existe, imaginémonos que es 00:21:43
menos infinito, 00:21:45
cuando llega el 00:21:46
primero, si yo hago el, este número 00:21:49
supera menos infinito, es que 00:21:51
lo va a superar seguro. 00:21:53
Lo va a superar seguro. 00:21:55
Entonces, como lo va a superar seguro, 00:21:56
pues sé que el efecto 00:21:59
que voy a lograr es que este primer número 00:22:01
inicialice máximo la primera vez. 00:22:02
Pero a mí se me va a dar un problema para mí, 00:22:04
que si tú le metes el mínimo 00:22:06
un negativo 00:22:09
te va a poner el negativo como el mínimo 00:22:10
y lo que tienes es para el probante 00:22:13
no, a ver, si yo le pongo un negativo 00:22:14
entonces mi lista ha acabado y me va a decir 00:22:17
el máximo es ese número, porque es el mayor de todos 00:22:19
si mides también los mínimos 00:22:20
estamos ahora con los máximos 00:22:21
para ver como si ese truco 00:22:25
de poner un contador que entra 00:22:27
para detectar la primera vez, no lo podemos ahorrar 00:22:29
bueno, ese truco era 00:22:31
para conseguir que en esta 00:22:33
variable, que esta variable 00:22:35
se inicialice la primera vez 00:22:37
con este valor sí o sí 00:22:39
bueno, pues con el truco de poner 00:22:40
este al menor valor posible del mundo 00:22:43
a menos infinito 00:22:45
la primera vez que entre 00:22:47
cuando yo haga la comparación 00:22:49
¿este valor es mayor que este? 00:22:50
va a ser que sí, porque lo he inicializado 00:22:53
a menos infinito, con lo cual 00:22:55
lo que vamos a conseguir es que la primera vez 00:22:57
esta variable se inicialice con el primero 00:22:59
que es lo que quería, y luego ya 00:23:01
las siguientes dependen 00:23:03
luego, versión 2 00:23:04
que podríamos hacer 00:23:06
ahora vemos como se inicializa 00:23:07
menos infinito 00:23:10
la versión 2, vamos a poner 00:23:11
una versión 2, aquí 00:23:16
vale, voy a copiar y pegar 00:23:19
y la retoco sobre esta 00:23:31
vale, lo que pasa es que como 00:23:32
el inloquito, porque ya están 00:23:44
declaradas, pero vamos, es el mismo 00:23:46
programa, vale, entonces 00:23:48
Vale 00:23:51
Es que esta llave de aquí 00:23:55
Me sobra y me falta 00:24:01
Vale 00:24:03
Pero es esta, ¿no? 00:24:06
Es esta 00:24:11
Con lo cual esto me dice 00:24:12
Duple 00:24:15
Máximo, sí, pero están sin declarar 00:24:16
Entonces, ¿por qué? 00:24:21
Ah, vale, vale, porque no estoy declarando 00:24:23
Estoy ahora ya inicializando 00:24:25
Entonces, así, vale 00:24:26
Vale, versión 2 00:24:28
Está igual que la de arriba 00:24:33
Vale, pues entonces 00:24:35
Si consiguiéramos inicializar 00:24:36
Esto a menos infinito, repito 00:24:39
Ya veremos cómo 00:24:40
Ahora ya podríamos ahorrarnos todo esto de aquí que hemos hecho 00:24:41
Y dejarlo así 00:24:44
Si num 00:24:47
Es mayor que el máximo 00:24:49
Máximo igual a num 00:24:50
Con lo cual, la primera vez que entramos 00:24:51
la primera de todas 00:24:54
como máximo es menos infinito 00:24:56
la condición se va a cumplir 00:24:58
sí o sí y conseguimos lo que queríamos 00:25:00
que el número sea el primer 00:25:02
máximo de todos, conseguíamos lo que queríamos 00:25:04
con lo cual nos queda 00:25:06
un bucle más pequeñito y más sencillo 00:25:08
pero que nos falta de aquí, inicializar esto 00:25:10
a menos infinito 00:25:12
menos infinito, obviamente 00:25:13
no se puede codificar en una 00:25:16
variable entera de 32 bits 00:25:18
pero la equivalente a menos infinito 00:25:20
una variable entera de 32 bits 00:25:23
es el número negativo más bajo posible 00:25:24
que se puede codificar en 32 bits 00:25:27
que es el que a mí me interesa 00:25:28
yo tengo 32, mi recta real 00:25:30
en programación, mi recta real 00:25:32
no es entre menos infinito y más infinito 00:25:35
no es 00:25:37
si yo estoy trabajando con números enteros de 32 00:25:37
mi recta la he acotado 00:25:40
la he acotado entre lo más bajo 00:25:42
que puedo codificar en 32 bits 00:25:45
menos 2 elevado a 31 00:25:46
y lo más alto que puedo codificar en 32 bits 00:25:48
2 elevado a 31 00:25:50
luego lo tengo acotado, mi menos infinito 00:25:51
en programación es el número 00:25:54
más bajo que puedo codificar 00:25:56
con los 32 bits del entero 00:25:58
¿y ese cuál es? o se lo pongo 00:25:59
a capón, menos 2 elevado a 31 00:26:02
o ya cuando vimos los dos enteros 00:26:04
dijimos 00:26:06
que había una forma de sacarlo 00:26:06
que era este 00:26:09
¿os acordáis de esto? 00:26:11
¿os suena? 00:26:14
sí, sí, lo pusiste 00:26:14
vale, dijimos, por curiosidad 00:26:15
este es el valor más 00:26:18
pequeñito, ¿está 00:26:20
grabado? Sí, sí, sí, cuando hablábamos 00:26:22
de tipos de variables, enteras, double. 00:26:25
Entonces, este es, y lo mostramos por pantalla 00:26:28
a ver cuál era. Entonces, este es 00:26:32
el valor más pequeño que 00:26:34
se puede codificar con una variable int 00:26:38
que se corresponderá a menos 2 elevado a 00:26:40
31, en realidad. Porque con 00:26:43
32 bits, 1 de signo, para el valor absoluto 00:26:46
tengo 31, le he salvado 31 por el menos. 00:26:49
Bueno, pues ese valor es ese. 00:26:52
Entonces, 00:26:55
este es el menos infinito nuestro, 00:26:55
el más pequeño posible, porque es que 00:26:58
por debajo de ese no puedo codificar ninguno. 00:26:59
¿Y si el cliente quisiera 00:27:01
el infinito actual? 00:27:03
Pues que vaya a pedírselo 00:27:05
a otro universo, 00:27:08
porque en este no se puede 00:27:10
almacenar el menos infinito 00:27:12
en ningún sitio. 00:27:14
¿De momento? 00:27:16
no sé, y de momento 00:27:17
y del futuro 00:27:18
no existe 00:27:20
tú tienes 00:27:23
una capacidad de almacenamiento limitada 00:27:25
no puedes 00:27:27
para almacenar menos infinito 00:27:29
necesitas infinitos bits 00:27:31
no tienes infinitos bits 00:27:32
¿vale? entonces 00:27:34
vale, a ver, que trabajamos 00:27:37
con double, yo aquí estoy trabajando con enteros 00:27:43
todo el rato, perdón, con long 00:27:44
Con todo el rato 00:27:46
Que trabajamos con long 00:27:47
En long nos cambia 64 00:27:49
Podemos más bajito todavía 00:27:50
Bueno, pues con long 00:27:53
Uno puede sacar el menor valor posible 00:27:54
En long con esto 00:27:57
¿Vale? 00:27:59
A ver, me dice 00:28:00
Como esta estaba así 00:28:01
¿Vale? Es decir, si trabajáramos con variables long 00:28:05
Son 64 bits 00:28:08
El menor valor posible 00:28:10
Los traigo de aquí 00:28:11
Pero bueno, estamos con int 00:28:12
con 32, tampoco va a meter 00:28:14
números tan grandes 00:28:16
vale, pues este programa 00:28:17
esta versión es idéntica 00:28:21
a la de arriba, pero 00:28:23
gracias a ese truco, no tengo 00:28:25
que distinguir cuál es la primera iteración 00:28:28
para en la primera inicializar 00:28:29
máximo a num, y luego ya en la siguiente 00:28:31
es hacer esto, ahora 00:28:34
en todas hago esto, en todas 00:28:36
y ya sé que en la 00:28:37
primera sí o sí voy a entrar aquí 00:28:40
sí o sí 00:28:41
¿vale? entonces como en la primera 00:28:43
sé que sí o sí voy a entrar aquí porque 00:28:46
num no sé cuál va a ser 00:28:48
num va a ser cuál va a ser, no sé cuál va a ser 00:28:49
pero va a ser 00:28:52
mayor que este fijo 00:28:53
entonces en la primera 00:28:55
iteración ya inicializaré 00:28:58
máximo a num 00:29:00
claro, claro, tú lo inicializas 00:29:01
claro, siempre 00:29:10
lo inicializas al menor valor posible 00:29:10
Sí, lo que importa es 00:29:13
Pues tener los recursos para resolver los problemas 00:29:18
Sea de una manera, sea de otra 00:29:21
Tenerlos, conocerlos y entenderlos 00:29:22
Vale 00:29:24
Bueno, pues la misma idea sería 00:29:25
El mínimo 00:29:29
Pero, claro 00:29:30
Pero lo resolvemos ahora 00:29:32
Vale, paramos un momento 00:29:35
Pero el problema es igual, cambia 00:29:36
El while es el mismo 00:29:39
Todo es el mismo, cambia 00:29:41
Esto 00:29:42
Sí, porque tú metes números 00:29:43
Mientras sean positivos 00:29:46
Para ver cuál es el menor 00:29:47
Cambia este signo y cambia esto 00:29:48
Claro, lo demás es idéntico 00:29:51
Luego en la media hacer la suma 00:29:53
Pero eso ya sí que es lo de 00:29:55
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
22 de octubre de 2024 - 18:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
114.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid