Saltar navegación

20241015 ProgrEstruct-Bucles_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 16 de octubre de 2024 por Raquel G.

25 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, ¿en qué se basaba la programación estructurada? 00:00:02
La programación estructurada es una manera de programar que se sustenta en la idea de que nosotros podemos elaborar una solución para cualquier tipo de problema sin más que combinar, recordad, ¿verdad? 00:00:09
Pues lectura de datos, bueno lo voy a llamar asignaciones porque es como estábamos acostumbrados, entonces todo lo relacionado con lectura de datos, asignaciones de datos a variables, todo eso ya lo hemos visto. 00:00:30
¿Qué otro tipo de sentencia hemos visto? 00:00:51
Tomar decisiones 00:00:54
Es decir, que mi programa 00:00:55
En función de una condición 00:01:01
Haga una cosa o haga otra 00:01:02
Y eso, según lo vamos anidando 00:01:04
Pues permite que un programa 00:01:06
Tenga un montón de ramas de posibilidades distintas 00:01:08
Según yo voy anidando 00:01:10
Decisiones una dentro de otra 00:01:12
¿Vale? 00:01:13
Pero nos falta 00:01:16
Una posibilidad más 00:01:17
Para ahora ya sí tener todas las herramientas 00:01:20
Que necesitamos para poder hacer 00:01:22
cualquier cosa, solo nos falta 00:01:24
una herramienta más 00:01:27
que son los bucles 00:01:28
bueno, pues 00:01:30
solamente con esto 00:01:33
ya se puede elaborar cualquier algoritmo 00:01:34
para resolver cualquier cosa que pueda hacer el ordenador 00:01:37
no hace falta nada más 00:01:39
¿vale? entonces la programación 00:01:40
que usa esto 00:01:43
es la programación estructurada 00:01:45
esas sentencias 00:01:47
claro, se ponen en secuencia, una tras otra 00:01:49
y así podemos resolver cualquier problema 00:01:50
la dificultad efectivamente es 00:01:53
elaborar el algoritmo, es decir 00:01:56
decidir esas sentencias 00:01:58
cuáles son y en qué orden 00:02:00
¿vale? elaborar el algoritmo 00:02:02
que permite realmente llegar a esa solución 00:02:04
lo que llamamos 00:02:07
normalmente hacer el diseño de mi programa 00:02:08
eso es lo difícil, ¿cómo las combino yo? 00:02:10
¿cómo combino yo mis sentencias para conseguir 00:02:13
lo que yo quiero? 00:02:14
bueno, más o menos ya hemos visto que cuando yo 00:02:16
veo, vislumbro que un programa 00:02:18
puede tener varias posibilidades 00:02:20
ahí ya sabemos que 00:02:22
pues voy a tener que coger una decisión 00:02:24
entonces cuando ya nos damos cuenta 00:02:26
de que tenemos que coger una decisión, ya empezamos a perfilarlo 00:02:28
vale, hay una condición involucrada 00:02:31
¿esa condición cuál es? 00:02:33
pues ya empiezo a elaborar esa condición 00:02:34
¿tengo más de una rama? pues entonces tendré 00:02:36
if con otro 00:02:39
if anidado dentro 00:02:40
¿que lo puedo poner en un if el save para que sea más bonito? 00:02:42
lo pongo, en un switch case porque es el caso 00:02:44
concreto de que la decisión es salvar de una variable 00:02:46
pues lo pongo, todo eso 00:02:48
que no dejan de ser 00:02:50
pautas para permitirnos 00:02:51
diseñar a nosotros los programas 00:02:54
todo eso 00:02:56
se nos queda todavía corto porque hay cosas 00:02:57
que no podemos hacer con eso 00:03:00
hay cosas que no podemos hacer 00:03:01
entonces para eso tenemos las sentencias 00:03:03
de repetición o los bucles 00:03:06
esto es como 00:03:08
por ejemplo 00:03:17
imaginaos 00:03:18
que me piden 00:03:21
en un programa que sea 00:03:22
el típico menú 00:03:25
Por ejemplo, un menú donde se tiene que mostrar, 00:03:27
bueno, ya se me ha acabado la tinta, 00:03:32
pues un menú donde se muestran mensajitos, 00:03:36
opción 1, pues sumar, 00:03:39
imaginaos que fuera una calculadora, 00:03:43
opción 2, restar, 00:03:49
¿no? Me están pidiendo que haga una calculadora. 00:03:57
Y esa calculadora no me tiene que valer solo para una operación, 00:03:59
sino para varias. 00:04:03
Pero claro, yo tengo que poder salir de ese programa cuando quiera, 00:04:06
pues podría tener otra opción que fuera salir. 00:04:09
Vale, me dicen, y que este menú se vaya mostrando 00:04:17
mientras tú no le des a la opción esta. 00:04:20
Entonces, ahora ya sí que estamos haciendo una calculadora 00:04:24
de sumas y restas normal y corriente. 00:04:27
Se muestra el mensajito. 00:04:29
Se lee esto, 1. 00:04:31
Ah, me has dado la opción 1. 00:04:34
Pues entonces tengo que sumar. 00:04:36
pido los datos y los subo 00:04:37
¿vale? ¿y ahora qué tiene que ocurrir? 00:04:39
pues que se tiene que volver a mostrar el menú otra vez 00:04:41
no vale que mi programa acabe 00:04:43
¿que ahora me has dado la opción 2? 00:04:45
le pido los números y hago la resta 00:04:48
¿y qué tiene que ocurrir? que se tenga que volver a mostrar 00:04:50
el programa otra vez, no vale que el programa acabe 00:04:52
vale, y así me puedo estar un montón de veces 00:04:53
¿que ahora 00:04:56
me han dado la opción 3? termino 00:04:58
esto podría ser un programa que funciona como 00:04:59
una calculadora, que está todo el rato, muestra 00:05:02
menú, leo opción, hace 00:05:04
operación, con un switch efectivamente 00:05:05
y sale, pero claro, con lo que nosotros 00:05:07
hemos hecho, no podemos hacer 00:05:10
eso, es imposible, nosotros solo 00:05:12
sabemos 00:05:13
hacer esto una vez 00:05:14
le pedimos la opción 00:05:17
y en función de 00:05:19
la opción que me hayan dado, ahora ya 00:05:20
hago la suma o la resta, o no hago nada 00:05:23
pero claro 00:05:26
esto tiene que ocurrir otra vez más 00:05:27
y otra vez más, y otra vez más, y así varias 00:05:29
todo el rato 00:05:32
¿se podría hacer sin un bucle pero con un 00:05:32
go to dentro de un if? 00:05:34
no, no, primero porque 00:05:38
go to no existe en la programación estructurada 00:05:40
de hecho, si la programación estructurada 00:05:42
se diseñó precisamente 00:05:44
su primera pauta fue eliminar 00:05:46
los go to 00:05:48
es que ni tienes esa sentencia 00:05:49
no puedes, no puedes usarla 00:05:52
claro, y si la tuvieras 00:05:53
un go to, es que estarías haciéndome un bucle 00:05:56
al que le estás llamando go to 00:05:58
entonces me estarías haciendo un bucle, estarías usando go to 00:05:59
como bucle, claro 00:06:02
con lo que tenemos 00:06:03
seríamos incapaces de hacer este programa 00:06:06
o sea, ¿qué necesitamos? 00:06:07
necesitamos, cuando uno se da cuenta 00:06:10
de cómo quiere que funcione, dice 00:06:11
ojo, es que yo lo que necesito es 00:06:13
que esto 00:06:15
que incluye 00:06:16
leer la opción 00:06:18
y luego ya operar 00:06:21
con las sentencias que fueran 00:06:23
lo que necesitamos es 00:06:26
todo esto hacerlo 00:06:27
muchas veces 00:06:29
¿Vale? Entonces, cuando ya hemos 00:06:30
entendido lo que tiene que hacer una aplicación 00:06:33
pues nos podemos haber dado cuenta 00:06:35
que una parte de esa aplicación 00:06:36
o toda ella, depende 00:06:39
necesitamos que se haga 00:06:41
varias veces 00:06:43
¿Un número de veces cuáles? No lo sé 00:06:44
ahora nos metemos en ella, pero identificamos que tiene que hacer 00:06:47
varias. Entonces 00:06:49
con lo que nosotros hemos visto hasta ahora no podemos 00:06:51
hacerlo. Otra cosa es que me dijeran 00:06:53
espera, tu calculadora tiene 00:06:55
que hacer esto siete 00:06:57
veces, entonces sí 00:06:59
podríamos hacerlo con lo que hemos hecho hasta ahora 00:07:01
copiaríamos y pegaríamos el código 00:07:03
siete veces, una debajo de la otra 00:07:05
quedaría el programa horroroso 00:07:06
pero efectivamente hasta siete 00:07:08
veces podríamos hacer operaciones 00:07:11
podríamos hacer siete operaciones 00:07:13
pero normal no es funcionar así, normal es decir 00:07:14
no, no, esto que se repita 00:07:17
hasta que 00:07:19
no se dé una condición 00:07:21
¿vale? pues eso es justo la definición 00:07:22
de BUP 00:07:25
conjunto de sentencias que se repiten 00:07:25
mientras no se cumpla 00:07:28
una condición de fin 00:07:30
bueno, pues justo eso 00:07:32
es lo que veríamos que pasa 00:07:34
en un programa como este 00:07:37
oye, ojo, esto lo tengo claro como programarlo 00:07:38
muy bien, pero es que además 00:07:41
necesito que esto se repita un montón de veces 00:07:42
vale, pues tengo ahí 00:07:45
un bucle, eso tendré que meterlo 00:07:47
dentro de un bucle 00:07:49
vale, pero una vez que ya he identificado 00:07:49
que tengo un bucle y que tengo que meter 00:07:52
algo dentro de ese bucle 00:07:54
tenemos que ponerle ya el colofón 00:07:56
que es decir, muy bien, pero 00:07:58
¿hasta cuándo se va a repetir eso? 00:08:00
¿Hasta cuándo? Pues depende 00:08:02
de la aplicación que estemos haciendo. En este caso 00:08:04
sería mientras la opción 00:08:06
no sea 3. Cuando la opción 00:08:09
sea 3, se acabó. 00:08:11
Entonces un bucle se caracteriza 00:08:13
por dos cosas. 00:08:14
El conjunto de acciones que se va a repetir 00:08:16
y forma 00:08:19
parte ya de mi diseño, 00:08:21
de mi elaboración del programa, 00:08:22
de mis ideas, decidir qué parte 00:08:24
es la que se tiene que repetir. 00:08:26
Y luego, una vez que hemos decidido 00:08:28
qué parte es la que se va a repetir, 00:08:30
lo que necesitamos saber siempre, 00:08:32
obligatoriamente, es una condición 00:08:34
que es la que fija cuando va a dejar 00:08:36
eso de repetirse. 00:08:38
No hay bucle que no se caracterice 00:08:40
por una condición de finalización. 00:08:42
No lo hay. Un bucle tiene que tener 00:08:44
una condición de finalización asociada. 00:08:46
Bueno, pues en este caso, 00:08:48
para este ejemplo concreto, 00:08:50
sería esto, por ejemplo. 00:08:52
y así pues en los 00:08:54
creo que cientos ejemplos 00:09:01
que veremos de ejercicios de estos 00:09:03
en ese caso también habría que 00:09:05
encorsetarlo entre que las opciones 00:09:07
son 1, 2 y 3 00:09:09
si las opciones son 1, 2 y 3 00:09:10
entra este bucle 00:09:13
bueno luego habría que ver 00:09:14
si no pues tú le podías poner 00:09:17
un mensaje opción incorrecta pero te tendría que 00:09:19
volver a mostrar otra vez 00:09:21
iría todo dentro del bucle 00:09:22
vale vamos a ver como es la sintaxis 00:09:24
la sintaxis para expresar esa idea 00:09:26
que es repetir un montón de cosas 00:09:28
varias veces hasta que 00:09:30
una condición deje de cumplirse 00:09:32
¿vale? 00:09:34
bueno, pues entonces la sintaxis es esta 00:09:36
la palabra while 00:09:38
entre paréntesis 00:09:42
una condición 00:09:44
una condición 00:09:45
porque la condición tenemos 00:09:48
que tenerla, no hay bucle sin condición 00:09:50
no existe 00:09:52
y ahora ya, entre llaves 00:09:53
las sentencias que se repiten 00:09:56
que he decidido yo que son las que tienen que repetir 00:09:58
¿vale? esta es la sintaxis 00:10:04
entonces necesito las dos cosas 00:10:16
tener claro que es lo que quiero 00:10:18
que se repita, que eso repito 00:10:20
lo habré hecho después de haber analizado mi programa 00:10:23
haber visto de que va, como funciona 00:10:25
que tiene que ver el usuario 00:10:26
pues las sentencias que se tienen que repetir 00:10:28
y imprescindible 00:10:30
identificar 00:10:32
qué condición va aquí. 00:10:34
Y ahora, ¿esto cómo funciona 00:10:37
una vez que la máquina virtual se lo ha encontrado? 00:10:39
Pues esto es una sentencia más. 00:10:41
La máquina virtual viene por aquí, 00:10:42
va haciendo lo que va haciendo y de repente llega al while. 00:10:44
¿Qué es lo que hace? 00:10:47
Lo primero que hace, evalúa condición, 00:10:48
que se cumple, 00:10:51
ejecuta esto, como si fuera un if. 00:10:53
Pero la diferencia con un if es que cuando aquí 00:10:55
teníamos un if, evalúa condición, 00:10:56
que se cumple, ejecuta esto y luego sigue. 00:10:58
Ya está, no hace nada más. 00:11:00
pues el while 00:11:01
añade algo al if 00:11:03
evaluamos condición 00:11:05
como si fuera un if, que se cumple 00:11:08
entramos y 00:11:09
volvemos arriba otra vez y la volvemos 00:11:11
a evaluar, se sigue cumpliendo 00:11:14
entramos 00:11:16
y volvemos arriba otra vez a evaluarla 00:11:17
se sigue cumpliendo, entramos 00:11:19
y volvemos arriba otra vez 00:11:21
y así se está indefinidamente 00:11:23
hasta que llegue un momento en que esta condición 00:11:25
deja de cumplirse 00:11:27
claro, si el bucle está bien diseñado y hace 00:11:28
algo con sentido, las sentencias 00:11:31
que hay aquí, las sentencias 00:11:33
que hay aquí 00:11:35
van modificando las variables 00:11:36
de las que depende esta condición 00:11:39
porque si estas sentencias no 00:11:40
tocan ninguna de las variables 00:11:43
de las que depende la condición, el bucle no acabaría 00:11:45
jamás, ¿no? 00:11:47
o sea, si es true desde el principio, seguiría siendo true 00:11:49
pero claro, no es la idea 00:11:51
no queremos bucles 00:11:54
infinitos, no valen para nada, un programa 00:11:55
con un bucle infinito se quedaría trazcado para siempre 00:11:57
entonces esto responderá a 00:11:59
ahora lo veremos en ejemplos 00:12:02
yo tengo aquí unas variables 00:12:03
si esas variables cumplen una condición 00:12:04
entro aquí 00:12:07
como consecuencia de haber operado 00:12:08
puede que esta condición 00:12:11
ya haya dejado de ser true 00:12:14
porque aquí han cambiado los valores de sus variables 00:12:15
y si es falso 00:12:17
se acabó, es salido 00:12:19
entonces esto en el diagrama de flujo 00:12:20
que ya mencionamos cuando hablábamos de los if 00:12:23
pues si el if era esto 00:12:25
esto era LIF 00:12:27
evalúo condición, que se cumple hago esto 00:12:29
que no se cumple hago esto 00:12:33
y termino 00:12:34
esto era LIF 00:12:35
pues el WHILE no es eso 00:12:37
el WHILE es 00:12:41
evalúo condición 00:12:49
hasta ahí estamos igual 00:12:52
evalúo condición 00:12:53
que se cumple 00:12:55
hago lo que tengo que hacer 00:12:59
vale 00:13:03
vamos a poner aquí como si hubiera cosas 00:13:05
Que se cumple 00:13:06
Hago lo que tengo que hacer 00:13:12
¿Y qué hago? 00:13:14
Y vuelvo arriba otra vez 00:13:16
Vuelvo arriba 00:13:18
Entonces en el if 00:13:20
Si se cumplía, hago lo que tengo que hacer y se acabó 00:13:22
Se acabó 00:13:25
En el while, que se cumple, hago lo que tengo que hacer 00:13:25
Y vuelvo arriba otra vez 00:13:28
¿Y en la rama del no, qué pasa? 00:13:30
En la rama del no, sigue, se ha acabado 00:13:32
Y seguimos por aquí 00:13:34
Luego este es el if y este es el while 00:13:35
¿vale? porque a veces 00:13:38
a la hora de escribir el código 00:13:40
los mezcláis 00:13:43
y dices, ah, si pasa esto, tengo que hacer esto 00:13:43
y ponéis un while directamente 00:13:46
pero es claro, el while 00:13:48
si pasa eso, efectivamente lo hace 00:13:49
pero es que luego se vuelve arriba otra vez 00:13:52
si sigue pasando, lo va a volver a hacer 00:13:54
y vuelve arriba, si sigue pasando, lo va a volver a hacer 00:13:56
sin embargo el if 00:13:58
lo hace una vez y solo una, y se acabó 00:14:00
me da igual que la condición siga siendo cierta 00:14:02
o no sea cierta, solo lo va a ejecutar una vez 00:14:04
solo una, y continúa 00:14:06
Sin embargo, el while lo va a estar ejecutando 00:14:08
Un montonaco de veces 00:14:11
Hasta que esto sea falso 00:14:13
Y cuando esto sea falso 00:14:14
Pues ya se va por aquí 00:14:16
¿Vale? 00:14:18
Entonces, esta estructura la necesitamos 00:14:20
Para hacer muchísimas cosas 00:14:22
Muchísimas 00:14:24
¿Cómo? 00:14:25
¿Cómo un bucle en falso? 00:14:32
Es que no entiendo 00:14:33
Bueno, a ver, el no es que ya se acabó 00:14:33
la sentencia, a partir de aquí yo le pongo 00:14:38
la sentencia que quiera, que toca ahí hacer otro while 00:14:40
porque toca hacer otro bucle 00:14:42
ya veremos, depende de lo que toque 00:14:43
pero esta estructura es una estructura 00:14:45
que funciona así 00:14:48
y yo decido en qué momento 00:14:49
me es útil, en qué momento me es útil 00:14:52
o la necesito y entonces la pongo ahí 00:14:54
y cuando decidiré que me sea útil, cuando me doy 00:14:55
cuenta que hay algo que tengo que hacer varias veces 00:14:58
entonces ahí la identifico 00:15:00
y cuando ya me he dado cuenta de eso 00:15:02
lo siguiente que tengo que pensar es, vale, ¿y de qué condición 00:15:04
Depende que esto se siga haciendo o no 00:15:06
¿Vale? 00:15:08
Si es falso 00:15:11
Y os apunto, es falso 00:15:12
Y si muestra un mensaje no válido 00:15:14
No se puede repetir el bucle de nuevo 00:15:15
Para que la persona 00:15:17
No, no, no, o sea, si la condición es falsa 00:15:18
Ya no hace nada, o sea, si tú quieres que se meta 00:15:21
El bucle de nuevo 00:15:23
Es que 00:15:24
Es que entonces, ¿para qué haces un bucle? 00:15:25
O sea, quieres que lo repita 00:15:29
Tanto si es falsa como si no, entonces no sería 00:15:31
Tendrías un bucle infinito 00:15:33
Es que no acabo de entenderte 00:15:35
Por ejemplo, necesitamos los datos 00:15:36
Y necesita que los datos sean 00:15:39
El número del 0 al 4 00:15:40
Si es el 0 al 4, va a decir que sí 00:15:42
Va a ingresar los datos y se va a repetir 00:15:45
Pero si es falso 00:15:47
O sea, que si el número es 5 00:15:49
Que diga, el número no es válido 00:15:50
Y que se vuelva a repetir 00:15:52
Claro, pero es que entonces 00:15:53
La condición no será 00:15:54
Que el número sea de una hasta cuatro 00:15:57
Aquí pondrás la condición 00:15:59
Que el número sea 1, 2, 3, 4 y 5 00:16:00
Y aquí ya dentro distinguirás 00:16:02
que es los cuatro primeros, hago lo que sea 00:16:05
que es el cinco, pongo no válido 00:16:07
y vuelves, pero en la condición 00:16:10
va a figurar como válido todos los números 00:16:12
vale 00:16:14
y ya, si no se mete 00:16:15
ninguno de ellos, en algún momento tendrás que 00:16:18
decidir salir, habrá alguna opción que sea 00:16:20
salir, la que sea 00:16:21
porque si tú haces un programa que una condición 00:16:22
sea imposible, que se haga falsa 00:16:26
solo tiene una opción para ser apagado 00:16:27
que es que mates el proceso 00:16:30
directamente y nunca deberíamos tener una aplicación 00:16:32
cuya única salida es matar el proceso 00:16:34
en el sistema operativo, me refiero 00:16:35
siempre debería haber una salida por código 00:16:38
entonces siempre tendrías que poner 00:16:40
una condición 00:16:42
que alguna vez se haga falsa 00:16:44
en el ejemplo que tú me dices 00:16:46
cuando metas 6, por ejemplo 00:16:47
el 6, la que sea 00:16:49
o salir, o lo que sea 00:16:50
vale, pues esto de 00:16:53
identificar que un bug nos vendría muy bien 00:16:56
ya nos ha pasado 00:16:58
en algunos ejercicios 00:16:59
en realidad 00:17:02
no, bueno, pero ahí no nos hacía falta un bucle 00:17:02
la fecha del día siguiente, dices 00:17:14
no, porque eso era una fecha, pues la del siguiente 00:17:17
y ya está 00:17:19
no, es que no sé a la misma a cuál te refieres 00:17:20
pero bueno, si te acuerdas o lo que sea 00:17:26
pero por ejemplo 00:17:28
vamos a hacer primero el uso de un bucle 00:17:30
solamente para ver su sintaxis 00:17:33
es un ejemplo más sencillo 00:17:35
y luego podemos ya plantear ejercicios 00:17:37
más retorcidos 00:17:39
vale, ¿qué pasa? 00:17:41
vale, venga, vamos a hacer 00:17:52
un nuevo proyecto solamente ya de 00:17:53
bucle 00:17:55
perdón, sí, sí, sí 00:17:56
vale, a ver ya esto 00:18:01
¿cómo funciona? 00:18:02
a ver, a ver 00:18:03
Venga, un nuevo proyecto 00:18:04
Ejemplos 00:18:30
Proyecto Ejemplo Buclis 00:18:33
Vamos a ver. 00:18:40
Vamos a suponer 00:19:33
Un ejercicio que me piden simplemente 00:19:36
Vamos a meter un número 00:19:39
Cuatro cifras 00:19:44
Leer entero 00:19:48
De cuatro cifras 00:19:52
No vamos a verificar que sean 00:19:54
Y contar 00:19:56
Cuántas son pares 00:20:00
Vale, no he puesto el 00:20:02
se puede hacer algo así como 00:20:12
charat 0++ 00:20:25
para que sube 00:20:27
para que luego la posición sea la 1 00:20:29
y luego la posición sea la 2 00:20:33
no, porque creo que es que cambian la tabla 00:20:35
no, no, no, si tú pones charat 0 00:20:36
más más 00:20:39
no, no, no, en todo caso 00:20:41
el 0 se convertiría en 1 00:20:43
en el almacenamiento temporal, pero da igual 00:20:45
vale, a ver 00:20:47
es una 00:20:49
es un enunciado 00:20:50
un poco absurdo y estúpido 00:20:52
pero es porque vamos a ir incrementando poco a poco 00:20:53
vale, esto en cualquier caso 00:20:55
si me apuráis 00:20:57
esta versión así 00:21:00
uno la podría hacer 00:21:01
en realidad sin bucles, ¿verdad? 00:21:04
porque podríamos hacer 00:21:06
si la primera 00:21:07
sacando las cifras, unidades decenas 00:21:08
si la primera es par y la segunda no 00:21:11
y la tercera no y la cuarta no 00:21:13
o si la primera es impar 00:21:15
y la segunda no y la tercera no y la cuarta no 00:21:17
O sea, podríamos así deducir si hay solo una, o si hay dos, o si hay tres, o si hay cuatro. 00:21:19
Pero bueno, sería una condición muy larga y muy retorcida. 00:21:25
Vale, entonces lo que yo quería poner con este ejemplo es una situación que se nos puede dar mucho. 00:21:28
Un ejercicio, una aplicación en la que tenemos que contar cuántas veces ocurre algo, ¿vale? 00:21:33
Entonces esta es la primera cosa que la palabra contar, cuando nos damos cuenta de que tenemos que contar, 00:21:40
aquí ya se nos enciende la bombilla 00:21:45
de que voy a necesitar un book 00:21:49
yo veo un enunciado y digo 00:21:51
ya traducido a mi idioma 00:21:54
tengo que contar cuantas veces pasa algo 00:21:56
contar implicará 00:21:59
ir yo recorriendo 00:22:04
algún espacio de situaciones 00:22:07
seguir en una variable 00:22:13
en una variable llevando una cuenta, ¿verdad? 00:22:16
Entonces, cuando yo identifico que tengo que contar algo, automáticamente 00:22:19
ya digo, vale, aquí voy a tener que hacer varias 00:22:22
veces, mirar si algo ocurre y si 00:22:25
eso ocurre, incrementar una cuenta, incrementar 00:22:28
una cuenta. Entonces, primero, yo me he dado cuenta 00:22:31
de que tengo que contar y no me he dado cuenta de 00:22:34
nada más, ¿vale? 00:22:37
Entonces, pues si yo 00:22:40
Me he dado cuenta que tengo que contar 00:22:44
Vamos a poner un contador 00:22:46
Que es el que va a llevar la cuenta 00:22:47
Lo inicializo a 0 00:22:49
Y ahora este contador lo tendré que ir 00:22:51
Sumando 1 00:22:54
1, 1 más, 1 más, 1 más 00:22:55
¿Vale? Entonces ahí ya está el bucle 00:22:58
Ahí ya está el bucle, vale 00:23:00
Entonces, ahora ya 00:23:01
He identificado que hay que contar, vale, contador 00:23:04
Venga, vamos a leer 00:23:06
El numerito 00:23:07
Importamos 00:23:09
Vale 00:23:30
Bueno, pues ahora 00:23:33
Tendré que 00:23:36
Ir recorriendo 00:23:37
Vale, espera 00:23:39
Voy a cambiar de enunciado porque 00:23:44
No quiero, vamos a 00:23:46
Olvidarnos de los string que no gustan mucho 00:23:47
Este primero que sea sin string 00:23:50
Vale, vamos a cambiar 00:23:52
No, no, no, no, no, no 00:23:54
Pero es verdad que con este iba a mezclar 00:23:56
String y no hay necesidad 00:23:58
Vamos a partir más sencillo 00:23:59
Vale, solicitar números enteros y contar los pares. 00:24:01
Vale, el programa tiene que funcionar. 00:24:20
Introduzca número 7, introduzca número 25, introduzca número menos 4, introduzca número menos 8, números tal cual. 00:24:22
Vale, pues el resultado final del programa tiene que ser, has metido 7 pares, has metido 5 pares. 00:24:30
Es decir, contar los pares. 00:24:36
vale, pues entonces 00:24:38
automáticamente sabemos que tenemos que contar 00:24:40
muy bien, bueno, ahora ya 00:24:41
¿qué es lo que tenemos que hacer varias veces aquí? 00:24:44
tratando, cuando seguimos entendiendo 00:24:46
el ejercicio, hombre pues con lo que 00:24:48
me han dicho que tiene que funcionar 00:24:50
introduzca número, meter número 00:24:51
y operarlo, introduzca 00:24:54
número, meter número, lo que tenemos que hacer 00:24:56
varias veces es pedir 00:24:58
un número, leerlo 00:25:00
y ver si es par o no es par, entonces eso 00:25:01
lo tenemos que hacer varias veces 00:25:03
pues entonces, yo aquí voy a tener 00:25:05
un bucle en el que 00:25:07
varias veces tendré que hacer 00:25:11
introduzca 00:25:13
número 00:25:19
leemos el numerito 00:25:20
y ahora 00:25:31
pues operar con él para ir 00:25:35
obteniendo mi cuenta final 00:25:39
entonces mi programa empieza a ser algo así 00:25:40
nos hemos dado cuenta de que lo que va a hacer varias veces 00:25:42
es introducir número 00:25:44
leerlo 00:25:46
y ver como hacer para 00:25:48
llevar yo una cuenta 00:25:50
de si es par o no es impar 00:25:52
pero eso lo tendremos que hacer varias veces 00:25:53
si tiene porcentaje 2, contador más más 00:25:55
claro, entonces, ¿qué ocurre? 00:25:57
el bucle está todavía indefinido 00:26:00
aparte de que hay falta 00:26:02
completar esto, el bucle tiene que tener 00:26:03
obligatoriamente una condición 00:26:05
vale, pues entonces, claro 00:26:07
la pregunta es, ¿cuándo salgo yo de aquí? 00:26:09
¿cuándo salgo yo de aquí? 00:26:12
me lo tendrán que definir enunciado 00:26:13
estoy pidiéndole números indefinidamente 00:26:15
estoy pidiéndole números 00:26:17
bueno, te dirán, mira, hasta que introduzcas uno negativo 00:26:18
por ejemplo, yo ya he pedido 00:26:22
ese dato añadido 00:26:25
y digo, el programa 00:26:27
finaliza 00:26:29
cuando 00:26:32
se introduzca 00:26:35
número negativo 00:26:39
vale, ya tengo los datos 00:26:43
entonces, todo esto 00:26:47
de aquí, introducir número 00:26:49
leerlo y operar 00:26:51
con él, introducir número, leerlo y operar 00:26:53
con él, se tiene que 00:26:55
ocurrir mientras el numerito 00:26:56
leído sea positivo 00:26:59
esa condición ya la tengo, mientras n 00:27:00
sea mayor o igual que 0 00:27:03
mientras n sea mayor o igual 00:27:04
que 0, el numerito n 00:27:09
esto se tendrá 00:27:11
que realizar 00:27:13
vamos a seguir 00:27:14
haciendo el código hasta encontrar 00:27:17
ya la solución final, bueno yo lo sigo 00:27:19
perfilando 00:27:21
ya he leído este numerito n 00:27:21
¿qué tengo que hacer con él? 00:27:25
Me han dicho que si es positivo 00:27:26
Si es par se incrementa mi cuenta 00:27:29
Y si no, no 00:27:32
Pues entonces ahora aquí ya puedo hacer 00:27:32
Si en es par 00:27:35
Entonces incremento mi cuenta 00:27:36
Y si no, pues nada 00:27:41
Si en es par 00:27:45
Contador 00:27:47
Bueno, esto ya empieza a tener un aspecto 00:27:48
Ya más de programa 00:27:54
Aunque le faltan cosas por definir 00:27:55
Vale, ¿qué hemos hecho? 00:27:58
Primero, identificar 00:27:59
Vale, entonces, ¿qué pasos hemos seguido? 00:28:01
Primero, identificar qué tenemos que hacer varias veces 00:28:26
Pues mostrar el mensaje 00:28:28
Leer numerito 00:28:30
Y contarlo 00:28:31
Al principio hemos dejado contado abierto 00:28:33
Pero ahora ya hemos perfilado un poco más 00:28:35
Y contar siempre lo vamos a hacer así 00:28:38
Contar siempre lo vamos a hacer 00:28:40
Si yo tengo que contar una variable 00:28:41
Que empieza siendo cero 00:28:44
Claro, por eso, lo estamos definiendo 00:28:45
Claro, estamos aproximándonos a la solución final 00:28:58
¿Vale? 00:29:00
Hemos identificado que esto es lo que tengo que hacer varias veces 00:29:01
Vale 00:29:04
Ahora ya nos hemos dado cuenta 00:29:05
Y ya lo vamos a tener claro para siempre 00:29:08
Que cuando tenemos que hacer una cuenta 00:29:10
Eso siempre va a implicar 00:29:12
una variable que empieza siendo 0 00:29:15
y un bucle 00:29:17
en el cual yo la voy incrementando 00:29:19
si ocurre algo. 00:29:22
Pues entonces ya automáticamente 00:29:24
interiorizamos, asociamos 00:29:25
que una operación natural en programación 00:29:27
es contar. Y esa operación 00:29:29
natural va a implicar 00:29:31
declarar un contador, inicializarlo a 0 00:29:33
y tendrá que haber un bucle 00:29:35
dentro del cual 00:29:37
se vaya incrementando la cuenta si 00:29:39
procede. Esa es la estructura de 00:29:41
contador. ¿Vale? Pues en este caso 00:29:43
efectivamente tengo un bucle 00:29:45
y la cuenta se va 00:29:47
incrementando si procede 00:29:48
y en este caso, ¿cuándo va a proceder? 00:29:51
Cuando el número sea par. ¿Vale? Pues ya tengo 00:29:53
bastante hecho. Aquí efectivamente 00:29:55
me salen errores de compilación. 00:29:57
Claro, ya al verlo 00:29:59
pues ya es que nos hacía daño a la vista. 00:30:01
¡Ojo! Hemos declarado N dentro 00:30:03
de este bloque. 00:30:05
Claro, ya hemos dicho, dijimos 00:30:07
en su momento cuando el IF. 00:30:09
Cuidado cuando yo abro un bloque 00:30:11
que es un código entre llaves 00:30:13
cuando abro un bloque que es un código entre llaves 00:30:14
todas las variables 00:30:17
que se declaren dentro 00:30:19
solamente son visibles 00:30:20
y se pueden usar ahí dentro 00:30:23
cuando el bucle termina han desaparecido 00:30:24
entonces aquí 00:30:26
estoy dentro del bloque 00:30:28
estoy fuera, perdón, del bloque 00:30:30
estoy fuera, entonces el compilador me dice 00:30:32
¿y en quién es? 00:30:35
claro, es que lo tengo que declarar fuera de este bloque 00:30:36
para poder usarla aquí 00:30:39
vale, pues la tengo que declarar aquí 00:30:40
con lo cual aquí ya no la declaro 00:30:44
solo la leo 00:30:46
solo la leo 00:30:48
vale, aun así 00:30:50
aun así 00:30:53
el compilador sigue dándonos un error 00:30:56
¿qué nos va a estar diciendo? 00:30:58
nos va a decir, ojo, la primera vez que entras 00:31:01
n no tiene 00:31:04
ningún valor todavía 00:31:06
la primera vez que entras n está sin definir 00:31:07
con lo cual la primera vez yo no puedo evaluar 00:31:10
esta condición 00:31:12
¿Cómo voy a entrar aquí si n todavía está por definir? 00:31:13
Eso es lo que nos está diciendo 00:31:17
Cuidado que n está sin inicializar 00:31:18
No puedo entrar 00:31:20
Bueno, démosle cualquier variable 00:31:21
Que haga que esta condición 00:31:24
Sea cierta 00:31:26
¿Vale? Y entonces ya podamos entrar 00:31:27
¿Vale? Pues ya tenemos 00:31:30
Nuestro programa bastante terminado 00:31:34
Y ahora le decimos 00:31:36
Los números pares 00:31:38
Han sido 00:31:44
Y mostramos 00:31:47
El resultado de contador 00:31:54
Bueno, pues este programa sin un bucle 00:31:55
Habría sido imposible 00:31:59
Porque esto lo teníamos que hacer varias veces 00:32:00
Y no vale 00:32:03
Copiar y pegar 00:32:05
Uno debajo del otro porque no sabemos cuántas 00:32:07
Depende de cuándo 00:32:09
Tarde en llegar el número 0 00:32:11
Depende de cuánto tarde 00:32:13
El negativo, perdón, depende de cuánto tarde 00:32:14
Llega el negativo 00:32:17
Porque si no está inicializada 00:32:17
La máquina virtual llega por aquí 00:32:25
Y te dice 00:32:27
Uy, para la primera evaluación no tengo nada 00:32:28
Entonces le das un primer valor para que entre 00:32:31
O puedes leer el primero fuera también 00:32:33
O también puedes leer el primero fuera 00:32:34
Claro 00:32:37
Podemos leer el primer valor 00:32:39
Fuera también, si queremos 00:32:41
A ver 00:32:42
Ahora el tema ya 00:32:47
Es que las dudas 00:32:53
matemáticas, pues uno se tiene que ir 00:32:54
al que le ha planteado el ejercicio y decirle 00:32:56
oye, ¿tú qué estás considerando? ¿Cero par o impar? 00:32:58
Cero, yo creo 00:33:01
que no es ni par ni impar 00:33:03
al menos en la 00:33:05
matemática axiomática. 00:33:07
¿Y el porcentaje 2 de 0 00:33:08
es igual a 0? 00:33:10
Ya, sí, pero 00:33:13
que matemáticamente las cosas no se definen 00:33:15
así, como el resultado de operaciones, 00:33:17
porque estaría siendo del final al principio. 00:33:19
Las operaciones se definen en función de axiomas 00:33:21
Y hay un axioma 00:33:23
Sobre el que se sustenta todo, varios 00:33:25
Y creo que para que encaje 00:33:27
Todo el edificio del álgebra 00:33:29
El cero no es ni par ni impar 00:33:30
¿Vale? Pero claro, esto ya son cuestiones 00:33:33
Que uno aclara con el edificio 00:33:35
Oye, ¿quieres contarlo o no quieres contarlo? 00:33:36
Porque si no lo quieres contar, pues lo sacas de aquí 00:33:38
Si es igual a cero y n distinto de cero 00:33:41
Lo pones en la condición o no 00:33:43
Pero ya sería una cuestión de cambiar la condición 00:33:44
¿Vale? Nosotros ahora mismo estamos 00:33:46
Asumimos que el cero nos vale como par 00:33:48
pero claro, pero si lo haremos 00:33:52
ya te suma uno aunque no pongas nada 00:33:53
pero como te lo lees fuera al cero, como la inicialista es al cero 00:33:55
ya entra dentro y te está sumando uno 00:33:58
sí, bueno, que podríamos efectivamente 00:33:59
sí, pero luego el contador 00:34:02
no cuenta, no cuenta 00:34:06
lo estoy haciendo, lo estoy ejecutando 00:34:07
no cuenta 00:34:09
a ver, el primer 00:34:10
solo te contarían los ceros que tú has metido 00:34:13
el primero no 00:34:15
o sea, este cero no, porque este no está contado 00:34:16
Este no lo cuenta porque solo incrementas el contador 00:34:19
Después de haberlo introducido 00:34:22
Claro, solo se incrementa después de haberlo introducido 00:34:23
Este está ignorado para la cuenta 00:34:28
Este solamente es para meter el número 00:34:30
Lo que sí que está ocurriendo es que el negativo del final 00:34:33
Si lo cuenta, porque tú metes el negativo 00:34:38
Ese lo mete en la cuenta 00:34:40
Y luego ya se da cuenta después de que tiene que salir 00:34:42
De nuevo son detalles que habría que hablar con el que lo ha planteado 00:34:45
y decirle, concrétame 00:34:48
bien estos casos extremos como quieres 00:34:51
que funcione, pero ahora mismo 00:34:53
no nos vamos a perder con eso 00:34:55
entonces, lo único que queremos decir 00:34:57
es, en este programa 00:34:59
hemos identificado, una vez que lo hemos analizado 00:35:00
lo hemos visto, que hay algo que tiene que repetir varias veces 00:35:02
pues ese algo 00:35:04
dentro del bucle, vale 00:35:06
se va a repetir varias veces 00:35:08
pedir número, leerlo 00:35:10
y si ocurre una condición 00:35:13
incrementar la cuenta 00:35:15
todo esto varias veces 00:35:16
pues a un while, no hay otro 00:35:18
y ahora hay que decir, el while no se puede 00:35:19
quedar indefinido, hay que decir 00:35:22
vale, pero esto hasta cuándo, hasta cuándo 00:35:24
pues ahí de nuevo te lo habrán tenido que indicar 00:35:27
oye, eso mientras no 00:35:29
metas un negativo, en cuanto metas un negativo 00:35:30
ya no tiene que seguir el programa 00:35:32
pues eso ya te permite definir la 00:35:34
condición, ¿vale? 00:35:36
bueno, pues 00:35:39
este es un ejemplo que no podríamos 00:35:40
haber hecho sin bucles, claro, no nos queda más remedio 00:35:42
entonces ahora ya si ejecutamos esto con la 00:35:44
salvedad de que el negativo 00:35:46
lo va a tener en cuenta en la cuenta 00:35:48
que podríamos quitarlo para que no 00:35:50
lo tenga en cuenta, pues simplemente 00:35:52
así, claro ponemos 00:35:54
aquí si n es 00:35:56
mayor o igual que 0 00:35:57
y siendo n mayor o igual que 0 00:35:59
es par, si no quisiéramos contar el negativo 00:36:02
pero eso ya son detalles que tendríamos que hablar con 00:36:04
y si no quisiéramos que contara 00:36:06
los ceros como pares 00:36:10
lo ponemos así, depende de lo que queramos 00:36:11
si n es mayor que 0 y es 00:36:14
par, eso ya depende de lo que nos haya dicho 00:36:16
el que nos planteó el enunciado 00:36:18
así contaría 00:36:20
solamente como pares los positivos 00:36:22
diferentes de cero 00:36:24
bueno, cero es que no es positivo 00:36:26
vale, entonces 00:36:27
si ejecutamos esto, pues claro, los cuenta 00:36:33
el 8, el 3, el 4 00:36:36
el 7 y el menos 2 00:36:39
pues he metido 00:36:41
dos 00:36:42
dos pares 00:36:43
vale 00:36:47
Vale, vamos a hacer otro anunciado 00:36:53
A lo mejor más 00:36:58
A ver 00:36:59
¿Perdón? 00:37:00
¿Cómo que no? 00:37:15
¿En cuanto metas un negativo? 00:37:16
Si a mí me ha salido 00:37:18
¿Por qué no va a salir? 00:37:18
Meto 76 00:37:22
Menos 4 00:37:23
Ya está, ya ha salido 00:37:25
¿Qué? 00:37:26
una condición de final 00:37:30
a ver, pero ¿cómo que meta 4? 00:37:32
o sea, a ver si el programa te dice 00:37:40
y si tú quieres meter 700 00:37:41
a ver, que depende de lo que te pida el ejercicio 00:37:43
este es, cuenta los pares 00:37:49
hasta que te introduzca yo un negativo 00:37:51
en una ejecución puedes haber metido 2, en otra puedes haber metido 1.500 00:37:52
no lo limitas 00:37:55
de partida 00:37:57
No, con el 0 no 00:37:58
Porque n mayor o igual que 0 00:38:02
Es la condición 00:38:04
Si yo lo pongo así, sí 00:38:05
Con el 0 lo pararía también 00:38:06
Entonces, claro 00:38:08
Otra versión, lo paramos así 00:38:11
Entonces este te pararía con el 0 00:38:14
Lo que pasa es que 00:38:17
Cuando tú has metido el 0, como aquí 00:38:19
Entra, aquí lo tengo que mantener 00:38:21
Para, si no quiero contarlo 00:38:23
Si no quiero contarlo, el 0 00:38:25
claro, pero 00:38:27
a la condición no llega hasta después de hacer esto 00:38:34
me refiero, si yo el 0 no quiero que lo cuente 00:38:37
este no lo puedo quitar 00:38:39
porque me lo va a contar también 00:38:40
o el negativo 00:38:41
vale, es un ejemplo, este programa 00:38:43
una vez se ejecutará 3 veces, otra vez 00:38:46
se ejecutará 27, depende, lo que tarde esto 00:38:48
es meter el negativo, depende 00:38:50
y es así como tiene que funcionar, claro 00:38:51
que no limites tú de partida las veces que 00:38:54
vale, pues a ver 00:38:56
otro ejemplito 00:38:58
vale 00:39:00
venga, ahora ya sí vamos a poner 00:39:09
string y char que os gustan tanto 00:39:15
venga, vamos a 00:39:17
a ver, bueno, venga 00:39:21
espera, vamos a 00:39:29
vale 00:39:31
venga, vamos a hacer uno 00:39:37
Enunciado 00:39:48
No tiene este al final 00:39:51
Enunciado, venga 00:39:54
Programa que solicite 00:39:56
Dos números enteros 00:40:02
N1 y N2 00:40:06
¿Vale? 00:40:13
De nuevo vamos a hacer una cuenta 00:40:17
El programa tiene que mostrar 00:40:18
Cuantos 00:40:21
Números entre 1 y N1 son múltiplos de N2 00:40:26
Venga, datos de entrada, dos números 00:40:42
Entonces, por ejemplo, si N1 fuera 100 00:40:55
El programa tiene que mostrar cuántos números entre 1 y 100 00:41:00
Son múltiplos del segundo que he metido 00:41:04
Si meto 100 y 3 00:41:07
Tengo que mostrar cuantos múltiplos 00:41:10
Entre 1 y n1 00:41:12
Son múltiplos de 3 00:41:14
Entre 1 y 100 son múltiplos de 3 00:41:15
¿Cuánto sabe contar? 00:41:17
¿Cuánto sabe contar? 00:41:26
Pues hasta que se le acabe la pila de memoria 00:41:27
Y te haga un 00:41:29
Stack overflow error 00:41:31
¿Te da mucho? 00:41:34
Bueno, el stackoverflow error te lo va a dar 00:41:38
Si lo haces recursivamente 00:41:41
No, pero un bucle infinito nunca jamás va a parar 00:41:43
Es decir 00:41:46
Tú puedes hacer esto si te da la gana 00:41:47
Si lo que ha hecho ha sido el contador más más 00:41:49
Y la condición del contador sea más cero 00:41:50
No, lo que va a pasar es que te va a desbordar la variable 00:41:52
Imagínate que yo hago esto 00:41:54
A ver 00:41:56
Int 00:41:57
Cont igual a cero 00:41:59
Y ahora hago esto 00:42:02
Este programa 00:42:03
Nunca jamás va a petar 00:42:06
Cuando cont salga de lo que caiga en un int 00:42:08
Como desborda 00:42:12
Por fuera 00:42:14
Pues el numerito 00:42:14
Vuelve a reiniciarse 00:42:16
Ya te empiezan a salir cosas sin sentido 00:42:18
Pero este programa nunca jamás va a parar 00:42:20
Pero no te va a romper el ordenador 00:42:22
No te va a romper la memoria 00:42:24
Esto nunca 00:42:25
Ahí lo tenemos, ya está 00:42:28
No va a parar nunca jamás 00:42:29
Aquí me puedo estar hasta el infinito 00:42:32
Voy a tener que parar con esta 00:42:35
claro, si le haces 00:42:38
que además me lo muestre 00:42:41
si fuéramos 00:42:44
tuviéramos la vista tan hábil 00:42:47
claro, claro, si es lo que ha hecho 00:42:51
muy bien, muy rápido 00:42:52
claro, entonces vas a ver un montón 00:42:55
y si fueras capaz de verlo 00:42:56
llegarías a ver un momento que cuando ha llegado 00:42:58
al número int más alto 00:43:00
pues ya empiezas a irte cosas sin sentido 00:43:02
pero porque está cortando, nada más 00:43:03
Esto nunca te va 00:43:05
Vale, contar múltiplos 00:43:09
Bueno, pues leer los dos numeritos 00:43:13
Eso lo sabemos hacer sin problemas 00:43:15
Ni mensaje ni nada 00:43:17
Lo leemos así directamente para 00:43:32
Next int 00:43:34
Y n2 00:43:36
Bueno, pues aquí ya empiezan nuestros problemas 00:43:38
Que es, a ver, ¿cómo hacemos esto? 00:43:52
Tenemos que contar 00:43:54
Cuántos números 00:43:56
Entre 1 y n1 cumplen 00:43:57
una condición. La condición 00:43:59
de ser múltiplos de n2. 00:44:02
Bueno, algo hemos 00:44:04
llegado y es a que tenemos que contar. 00:44:06
Contar cuántos de algo, 00:44:08
en este caso, cuántos números cumplen la condición. 00:44:10
Algo hemos llegado, que tenemos que contar. 00:44:12
Pues un contador vamos a necesitar 00:44:14
sí o sí. Pues no pasa nada, 00:44:15
nos ponemos ahí un contador 00:44:18
que empieza siendo cero. 00:44:19
Ahora, si tenemos que contar, 00:44:22
va a tener que haber algún 00:44:25
bucle en algún sitio 00:44:26
que si se cumple una condición 00:44:27
inclemente mi contador. 00:44:30
Algo así va a tener que haber en algún sitio. 00:44:34
Algo así va a tener que ser mi programa. 00:44:41
Algo así, ¿no? 00:44:48
En un bucle mi contador será incrementando 00:44:49
si ocurre algo. 00:44:51
Y así hasta que este bucle termine. 00:44:53
Algo así. 00:44:55
Vale, pero esto todavía se queda muy corto. 00:44:56
Ahora vamos a seguir pensando. 00:44:58
vale, ¿qué tengo yo que recorrer? 00:44:59
¿qué tengo yo que recorrer? 00:45:03
los números entre n1 y n2 00:45:05
claro, para hacer las comprobaciones 00:45:06
bueno, pues tenemos que recorrer 00:45:08
los números entre n1 00:45:10
entre 1 y n1 00:45:12
es decir, tenemos que recorrer 00:45:13
1, luego 2, luego 3 00:45:16
y con cada uno de ellos 00:45:18
ver si es múltiplo de n2 00:45:19
con lo cual, si yo ese numerito 00:45:22
ese numerito que empieza siendo 00:45:24
1, luego es 2, luego es 3 00:45:26
lo tuviera guardado en algún sitio 00:45:28
la condición esta ya me sería 00:45:30
muy cómoda, ¿vale? 00:45:31
imaginamos que se llama num 00:45:34
pues porque yo pondría 00:45:35
el resto de 00:45:37
dir num entre n2 00:45:39
es igual a 0, pues le cuento 00:45:41
entonces lo que me falta es 00:45:43
que este número 00:45:45
en cada iteración del bucle 00:45:47
la primera vez tiene que ser 1 00:45:49
pero la segunda tiene que ser 2 00:45:51
y la tercera tiene que ser 3 00:45:53
y la cuarta tiene que ser 4 00:45:55
vale, pues entonces ya puedo decir 00:45:57
ah, vale, pues me voy a hacer una variable 00:46:00
que empiece siendo 1 00:46:02
y yo en cada 00:46:04
iteración del bucle 00:46:06
la vaya incrementando 00:46:08
vale, vale, venga 00:46:10
pues entonces, esta variable 00:46:12
que empiece siendo 1 00:46:14
y ahora 00:46:15
me hago esto de aquí 00:46:17
y ya me estoy aproximando cada vez más 00:46:20
entonces, ¿qué se hace un montón de veces? 00:46:22
primero 00:46:25
para num igual a 1 00:46:26
si es múltiplo de n2 lo cuento 00:46:27
y lo dejo incrementado 00:46:30
para la siguiente vuelta 00:46:32
volvemos a la siguiente vuelta 00:46:33
si ha quedado incrementado, ahora será 2 00:46:35
¿2 es múltiplo de n2? 00:46:37
sí, lo cuento 00:46:39
y lo dejo incrementado 00:46:40
para la siguiente cuenta 00:46:43
entonces para hacer esto 00:46:44
me he tenido por tanto que inventar una variable nueva 00:46:45
una variable nueva 00:46:49
que representa mi recorrido 00:46:50
todo lo que tenemos que ir recorriendo 00:46:52
el 1, el 2, el 3, el 4 00:46:53
Entonces ya tenemos mucho hecho 00:46:55
Vale, ¿qué nos falta? 00:46:57
¿Cuándo termino yo de hacer 00:46:59
Estas iteraciones? 00:47:01
Claro, me han dicho que compruebe 00:47:03
Cuántos números desde 1 00:47:05
Hasta n1 00:47:07
¿Cuántos entre 1 y n1? 00:47:09
Entonces tendré que parar esto 00:47:12
Cuando num 00:47:13
Ya me haya, yo he pasado 00:47:14
Y sea mayor que n1 00:47:17
Perdón 00:47:19
Mientras no me haya pasado, perdón 00:47:21
Que estoy viendo al revés 00:47:23
y ahora ya sé que lo he terminado 00:47:23
bueno, sí, porque 00:47:26
si dice entre 1 y n1 00:47:32
pues entonces este bucle 00:47:33
entrará cuando no me es igual a 1 00:47:35
mirará si es múltiplo de 0 00:47:37
de n2 y lo contará 00:47:39
y lo deja incrementado 00:47:41
para la siguiente 00:47:42
cuando ya me he pasado 00:47:44
y num ya no es menor o igual que n1 00:47:47
y ya me he saltado 1 00:47:49
ya no tengo que contar más 00:47:50
es decir, si n1 es 100 00:47:52
Num irá oscilando entre 1, 2, 3 00:47:55
Hasta 101 la última vez 00:47:59
Pero cuando ya es 101 ya no entro 00:48:01
Bueno, me faltaría aquí mostrar 00:48:03
La cuenta final, el resultado final 00:48:06
Vale, pues aquí hemos dado 00:48:11
Muchos pasos 00:48:13
Muchos saltos 00:48:15
Hasta llegar a la versión del programa 00:48:16
Hemos dado muchos saltos 00:48:18
¿Vale? 00:48:20
El primer salto, el básico 00:48:23
leer los datos, vale, el segundo 00:48:25
salto mental que hemos 00:48:27
dado, tengo que 00:48:29
contar cosas, tengo que contar 00:48:31
vale, pues yo tengo que contar 00:48:32
un contador que me haga 00:48:35
la cuenta empezando a cero, y si 00:48:37
tengo que contar cosas 00:48:39
un bucle 00:48:40
va a tener que haber, un bucle 00:48:41
va a tener que haber en el que se haga la cuenta 00:48:45
un contador, una cuenta 00:48:46
siempre implica un bucle, una cuenta 00:48:49
siempre implica un bucle 00:48:51
en las sucesivas iteraciones 00:48:52
cada pasada del bucle es lo que se llama iteración 00:48:55
en las sucesivas iteraciones 00:48:57
se va incrementando, pero claro 00:48:59
esa cuenta me cuenta 00:49:01
si se cumplen cosas 00:49:03
pero esa cuenta normal es que voy a entrar en un if 00:49:05
claro, si se cumplen cosas 00:49:07
vale, pues yo ahora ya 00:49:08
los siguientes 00:49:11
pasos quedan, a partir de ahí ya son los más 00:49:13
críticos, que es, vale, muy bien 00:49:15
pero ¿cómo? 00:49:17
¿cuál es el hecho que debo comprobar que se cuente 00:49:19
y como, dijimos, ah, vale 00:49:21
pues si yo tengo que comprobar los números 00:49:23
entre 1 y n1 00:49:25
lo que pasa con ellos 00:49:27
pues el salto más difícil aquí es decir, vale, pues una variable 00:49:28
adicional, una variable más 00:49:31
que vaya entre 1 y n1 00:49:33
empieza entre 1 00:49:36
y la voy incrementando 00:49:37
y en cada iteración 00:49:38
voy mirando si es múltiplo 00:49:40
y así 00:49:43
¿vale? 00:49:46
bueno, porque esta 00:49:50
este es su primer valor 00:49:51
o sea, num está declarada afuera 00:49:53
está fuera del if 00:49:55
está fuera del if, no del while 00:49:59
este es el fin del if 00:50:00
es decir, num tú lo incrementas 00:50:04
siempre, es decir 00:50:06
num tiene que pasar por todos los valores 00:50:09
primero el 1 00:50:10
es múltiplo de esta, lo cuentas 00:50:12
y lo pasas al 2 00:50:14
pero tú lo incrementas siempre, da igual 00:50:16
que sea múltiplo o no sea múltiplo 00:50:18
num va pasando por todos 00:50:20
que pase por todos, claro 00:50:22
si el 3 ya ha salido, que pase por todos 00:50:32
por el 3 y por el 4 y por el 5 y por el 6 00:50:34
que pase por todos 00:50:35
y ya está 00:50:36
vale, entonces 00:50:43
bueno, iba a hacer 00:50:45
uno para que hicierais ahora vosotros 00:50:48
pero bueno, el próximo día ya 00:50:50
a través de un listado de ejercicios 00:50:52
y eso ya lo 00:50:53
vamos y vais practicando más 00:50:54
con esto, dime 00:50:57
si, a ver 00:50:59
ya directamente he partido de dos ejemplos 00:51:04
que no son sencillos, o sea son dos ejercicios 00:51:06
que no son sencillos, una forma 00:51:08
muy fácil de ver 00:51:10
al principio como funciona un bucle 00:51:12
pues sería esto 00:51:14
por ejemplo 00:51:16
ya nos vamos 00:51:18
Para que su primer valor sea 1. 00:51:24
Porque la primera vez empieza siendo 1. 00:51:27
Y tú cuentas a ver si el 1 es múltiplo de lo que toca. 00:51:30
Y lo incrementas. 00:51:33
Es decir, NUM tiene que oscilar entre 1 y N1. 00:51:34
Con lo cual, su primer valor es 1. 00:51:39
Lo vas incrementando, lo vas incrementando, lo vas incrementando. 00:51:41
Mientras sea menor o igual que N1. 00:51:44
Cuando ya se ha salido, sale. 00:51:46
Este es su primer valor. 00:51:50
porque el ejercicio te dice que muestres 00:51:52
cuántos entre 1 y n1 00:51:54
luego su primer valor es 1 00:51:56
¿vale? un segundito y ya nos vamos 00:51:58
por ejemplo, una forma más fácil 00:52:01
que estos dos ejercicios 00:52:03
de haber visto finalmente un bucle 00:52:05
podría ser esta, a lo mejor 00:52:07
por ejemplo 00:52:08
una forma más sencilla de entender cómo funciona un bucle 00:52:33
Imaginaos que queremos mostrar todos los números entre 1 y 100. 00:52:36
Momento, que nos vamos en 3 minutos, pero vale. 00:52:41
Imaginaos que ahora lo que queremos es mostrar todos los números entre 1 y 100. 00:52:44
Lo podemos hacer sin bucles, claro. 00:52:48
Podemos hacer system.out.println 1, system.out.println 2 y así copiar hasta 100 líneas. 00:52:50
No tiene sentido que copiemos 100 system.out. 00:52:56
Pues, ¿cómo podríamos hacer esto? 00:52:59
Pues, de nuevo, una variable que empieza siendo 1. 00:53:01
y ahora 00:53:03
nos hacemos un bucle 00:53:05
mientras n sea 00:53:07
menor o igual que 100 00:53:09
¿vale? por ejemplo 00:53:11
una forma más fácil de entender 00:53:23
el bucle 00:53:26
programa que muestra números entre 1 y 100 00:53:26
n empieza siendo 1 00:53:30
lo voy incrementando y en cada iteración del bucle 00:53:32
lo muestro, pues ya está, este programa me mostrará 00:53:34
desde 1 y 100 00:53:36
venga, pues vamos a parar aquí si queréis 00:53:36
y seguimos el jueves 00:53:43
jueves 00:53:46
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
25
Fecha:
16 de octubre de 2024 - 21:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
53′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
679.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid