Saltar navegación

20251027 EjerBucles_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 27 de octubre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, ejercicio 4. Algunos igual lo habéis hecho, vais a quitar en casa o... Vale. Ejemplifica una estructura básica en programación, que es la de contar. ¿Vale? Entonces, en muchos de nuestros programas necesitamos, dentro de todo el conjunto de funcionalidades a resolver, necesitamos contar muchas veces. 00:00:00
¿Vale? Contar. Bueno, pues entonces, para nosotros, contar rápidamente va a estar asociado a un bucle. Entonces, en cualquier aplicación, repito, puede ser necesario que yo haga una cuenta, que es, pues, por favor, ¿cuántos usuarios tienen un pase válido? ¿Cuántas facturas están pagadas? 00:00:32
¿Cuántas pagadas? ¿Cuántos paquetes han llegado? ¿Vale? Dentro de las funcionalidades de una aplicación grandota, contar puede ser uno de los requisitos que tiene que hacer. Contar, vale. Pues contar siempre lo vamos a realizar dentro de un bucle. 00:00:56
Vale, a ver 00:01:15
Con 00:01:29
Ahora 00:01:30
Aquí 00:01:32
Ah, jolines 00:01:35
Pesado 00:01:43
Aquí, vale 00:01:44
Voy a escribir grandote, pero vamos 00:01:54
¿Vale? 00:01:56
Sí 00:02:01
A ver 00:02:02
Repito, contar es 00:02:05
A lo mejor alguna pequeña parte 00:02:08
Que una aplicación grandota va a tener que hacer 00:02:10
Por ejemplo, cuántas facturas están pagadas 00:02:12
Cuántos paquetes han llegado 00:02:14
Entonces, esto en programación 00:02:16
¿En qué se va a traducir? 00:02:18
Se va a traducir en un trozo de programa 00:02:20
En el que va a haber un bucle 00:02:22
En el que va a haber aquí un bucle 00:02:24
Y este bucle 00:02:26
Va a recorrer 00:02:31
Va a recorrer 00:02:32
Todos 00:02:35
va a recorrer todos los eventos 00:02:38
que tenemos que contar. 00:02:41
Si tenemos facturas, va a recorrer todas las facturas. 00:02:43
Si tenemos que contar paquetes, 00:02:45
va a recorrer todos los paquetes. 00:02:47
Cuando nosotros contamos, ¿qué hacemos? 00:02:49
Tenemos un montón de cosas por ahí. 00:02:51
Cuando contamos, tenemos un montón de cosas por aquí. 00:02:53
Yo ahora voy a contar 00:02:55
todos los alumnos que llevan gafas. 00:02:56
Pues tengo un montón de alumnos. 00:02:59
Tengo un montón de alumnos y tendré que ir uno por uno. 00:03:01
Y en cada uno de ellos, mirar a ver si tiene gafas. 00:03:03
Y si tiene, contarlo. 00:03:06
¿vale? eso es lo que haré si tengo que contar 00:03:07
unos que llevan gafas, si tengo que contar 00:03:09
mesas que están rotas 00:03:11
pues siempre parto de que tengo 00:03:13
un montón de mesas, ¿vale? entonces voy 00:03:15
una por una 00:03:17
me voy parando en cada una de ellas y en cada una de ellas 00:03:18
hago lo mismo, mirar a ver si está 00:03:21
rota, luego eso automáticamente es 00:03:23
un bucle, que es, voy a esta mesa 00:03:25
miro si está rota, voy a esta mesa, miro si está rota 00:03:27
voy a esta mesa, miro si está rota 00:03:29
luego eso es un bucle, porque un montón de veces 00:03:31
hago, ir mesa y mirar, ir mesa y mirar 00:03:33
Luego, un bucle va a haber. Pero claro, además tengo que contar, no solo ir a la mesa y mirar, ir a la mesa y mirar, ir a la mesa y mirar. Además, tendré que hacer una cuenta. Es decir, tendré que llevar yo en una variable un registro del incremento de esa cuenta. 00:03:36
Entonces, este bucle mío va a servir para ir observando cada elemento dentro de todos aquellos que tengo que contar, ¿vale? 00:03:55
Este bucle mío va a servir para observar cada elemento, ¿vale? 00:04:25
¿Cómo observo cada elemento? Pues depende, observar cada elemento dependerá, ya veremos. 00:04:34
de los elementos que tenga 00:04:40
y qué es lo que tengo que fijarme yo en ellos 00:04:41
qué es lo que tengo que fijarme, observar cada elemento 00:04:44
pero luego aparte tengo que llevar la cuenta 00:04:46
y esta es la estructura que siempre 00:04:47
hacemos de la misma manera 00:04:50
tendremos una variable 00:04:51
que me sirve a mí como contador 00:04:53
a la que le daré 00:04:56
lógicamente el número 00:04:58
que me dé la gana, el nombre que me dé la gana 00:05:00
pero claro, lo que sí 00:05:02
que es inamovible es que 00:05:04
una cuenta empieza desde cero 00:05:06
cualquier cuenta antes de iniciarse 00:05:07
está a cero 00:05:11
vale 00:05:11
y ahora aquí observaremos cada elemento 00:05:13
y aquí 00:05:16
puede que el contador se incremente 00:05:18
puede que no 00:05:21
en función del resultado de esta observación 00:05:21
entonces una estructura 00:05:24
en la que yo estoy contando 00:05:28
cosas 00:05:30
va a ser siempre algo de este estilo 00:05:31
lógicamente adaptado a cada situación 00:05:34
no adaptado a los elementos 00:05:37
que yo tengo que observar 00:05:39
pero va a ser siempre algo de este estilo 00:05:40
siempre va a haber un bucle 00:05:42
que es en el que yo me voy parando en cada elemento 00:05:44
me paro en uno, me paro en otro 00:05:46
me paro en otro, me paro en otro 00:05:48
la condición de finalización estará asociada 00:05:50
a que he terminado de mirarlos todos 00:05:52
pero siempre va a ser eso 00:05:54
me paro en uno, me paro en uno 00:05:56
luego es un bucle 00:05:57
y luego además tendré una variable contadora 00:05:58
que empieza valiendo cero 00:06:01
como todas las cuentas 00:06:03
están a cero siempre al principio 00:06:05
y aquí habrá algo de este estilo 00:06:07
si esto que yo 00:06:09
si este elemento que estoy observando 00:06:11
tengo que incorporar a la cuenta 00:06:13
pues entonces incremento 00:06:15
¿vale? 00:06:17
pues esta es la estructura 00:06:19
mental de una cuenta 00:06:21
en Java ¿vale? un bucle 00:06:23
que va parándose 00:06:25
y en cada parada que hace 00:06:25
en cada parada mira a ver si le toca incrementar 00:06:28
la cuenta o no 00:06:31
Una cuenta que se iniciaba a cero 00:06:31
Y ahora esto ya 00:06:35
Pues bueno, se adapta a la situación 00:06:36
Que toque 00:06:38
Entonces, en nuestro 00:06:39
En nuestro ejemplo de aquí 00:06:42
Vale 00:06:51
En nuestro enunciado de aquí 00:07:03
Aquí lo leemos, programa que 00:07:04
Cuente todos los múltiplos 00:07:06
de 7 convenidos de 1 y 100. Uy, tengo que contar. 00:07:09
Tengo que contar porque ya sabemos que en nuestra cabeza es algo de ese estilo 00:07:12
que yo he escrito antes lo que tendremos que hacer. Porque tenemos que contar. 00:07:16
Bueno, pues entonces vamos a hacer, por ejemplo, este ejercicio. 00:07:21
Ejercicios, bucles. 00:07:26
El 4. Vale. Entonces, aquí 00:07:29
una cuenta hay que hacer. Pues mira, ya voy ganándome 00:07:46
Voy ganando tiempo haciéndome un contador inicialmente a cero. 00:07:50
Variable, nombre que uno le dé la gana. 00:07:57
Acordándonos de que cuanto más explicativo sea mejor. 00:07:59
Si la llamo x, ¿qué nombre tan feo? 00:08:02
Llamarla x. 00:08:04
Pues cont, contador, cuenta, algo explicativo. 00:08:05
Entonces, aquí va a haber siempre algo así. 00:08:09
Va a haber siempre algo así. 00:08:14
durante un tiempo, no sé qué tiempo 00:08:16
durante un tiempo, todo el que yo tarde en recorrer 00:08:21
todos los elementos susceptibles a ser contados 00:08:24
habrá que irlo perfilando 00:08:27
durante un tiempo, pues yo haré aquí cosas 00:08:29
para ir generando esos elementos 00:08:33
susceptibles de ser contados 00:08:36
ya veremos de dónde salen 00:08:39
y si cumplen cierta condición esos elementos 00:08:40
pues entonces los contaré 00:08:44
y el resultado será 00:08:48
pues lo que sea, resultado 00:08:56
contador, vale 00:09:02
bueno, pues la estructura de nuestro programa va a ser esto, yo tengo que contar algo 00:09:07
tendré que completar efectivamente pues todo esto, tendré que completar 00:09:11
como genero aquí los elementos susceptibles de ser contados 00:09:17
cuándo termino de generarlos, 00:09:21
de dónde me provienen 00:09:24
y luego ya qué es lo que hace 00:09:25
que los cuente o que no los cuente. 00:09:28
¿Qué es lo que hace? 00:09:30
Esto está así completamente destripado. 00:09:31
Luego, en función de la situación, 00:09:34
pues puede quedar más sencillo, más complicado. 00:09:35
Vale, pues entonces ya podemos seguir pensando. 00:09:38
A ver, ¿cuáles son los elementos 00:09:40
susceptibles de ser contados? 00:09:43
Pues todos los que están entre 1 y 100. 00:09:46
esos son los elementos susceptibles de ser contados 00:09:48
con mi ejemplo de alumnos que llevan gafas 00:09:52
mis elementos susceptibles de ser contados 00:09:55
eran todos los alumnos 00:09:57
con lo cual yo tendría que ver 00:09:59
cómo generarlos dentro del bucle 00:10:00
cómo hacer que vayan apareciendo 00:10:01
o como en el ejemplo de las mesas 00:10:03
todos mis elementos susceptibles de ser contados 00:10:05
eran todas las mesas 00:10:08
luego en mi bucle tendría que ir viendo 00:10:09
cómo hago aparecer las mesas 00:10:11
bueno pues aquí los elementos susceptibles de ser contados 00:10:13
son todos los comprendidos 00:10:16
entre 1 y 100, los susceptibles de ser 00:10:18
contados, de eso solo contaré 00:10:20
algunos, habrá que ver qué condición, claro 00:10:22
pero todos los susceptibles, todos los que 00:10:24
entran a jugar 00:10:26
son todos los comprendidos entre 1 y 100 00:10:27
igual que en el caso anterior, los que entran 00:10:30
a jugar son todos los alumnos 00:10:32
aunque yo solo cuente los de gafas 00:10:34
o los que entran a jugar son todas 00:10:36
las mesas, aunque yo solo cuente las rotas 00:10:38
pues aquí todos los que entran a jugar son 00:10:40
entre 1 y 100, pues tendremos 00:10:42
que ver cómo los generamos 00:10:44
para que entren en el juego, para que 00:10:47
entren a jugar. Pues ya lo sabemos 00:10:48
porque en los 00:10:50
servicios anteriores ya 00:10:52
hemos hecho un bucle 00:10:54
en el que yo iba haciendo aparecer 00:10:55
los números, ¿vale? 00:10:58
En el que yo los iba haciendo aparecer. 00:11:00
¿Cómo? Bueno, 00:11:03
pues lo podemos hacer así. 00:11:04
Mi primer numerito es el n 00:11:08
igual a 1, ¿vale? 00:11:10
Aquí ya tendrá... 00:11:12
Dime. 00:11:14
A ver, pero aquí no metemos números 00:11:16
¿Desde el teclado dices? 00:11:28
Estoy haciendo el 4 00:11:34
Todos los múltiplos de 7 00:11:35
No, no, estoy haciendo el 4 00:11:36
No, estoy haciendo el 4 00:11:38
¿Vale? 00:11:41
Entonces 00:11:43
Los elementos susceptibles de ser contados 00:11:43
Van a ser números entre 1 y 100 00:11:47
Pues esos necesitaré un espacio para que vivan ellos. 00:11:50
El espacio de contador ya tiene un uso. 00:11:54
Ese espacio es para que viva mi cuenta, 00:11:57
la que empieza siendo cero y se irá incrementando. 00:11:59
Esa variable ya tiene un uso. 00:12:02
Vale, pero los elementos que entran a jugar, que son los números, 00:12:04
tienen que vivir en otro sitio. 00:12:08
¿Dónde van a vivir? 00:12:09
En mi variable n, otra que necesito, mi variable n, por ejemplo. 00:12:10
Vale, pues esos números tienen que ir llegando a lo largo del bucle. 00:12:15
el primero va a ser el 1 00:12:18
porque me han dicho entre 1 y 100 00:12:20
pues lo puedo inicializar a 1 de partida 00:12:22
y ahora 00:12:24
me irán llegando 00:12:26
en el resto del bucle, lo único que tengo que hacer yo es 00:12:28
si yo voy 00:12:30
haciendo aquí un n++ 00:12:32
¿vale? 00:12:33
pues estos numeritos 00:12:36
en cada iteración del bucle 00:12:38
van apareciendo 00:12:39
la primera vez que entre en el bucle 00:12:42
n es 1, ya está ahí 00:12:44
pero antes de salir 00:12:46
lo dejo incrementado, luego 00:12:48
la siguiente vez que entre en el bucle, ahora 00:12:50
n es 2 00:12:52
haré con él lo que sea y se vuelve 00:12:53
a quedar incrementado, la tercera vez 00:12:56
que entre en el bucle, n es 3 00:12:58
vale, pues ya he conseguido 00:13:00
que en mi bucle, en cada iteración 00:13:02
vayan apareciendo 00:13:04
cada uno de los elementos 00:13:06
que 00:13:08
entran a jugar, vale 00:13:09
en la primera iteración entra el 1, venga 00:13:12
haz conmigo, que toca hacer, lo que sea 00:13:14
En la siguiente iteración entra el 2, en la siguiente iteración entra el 3, ¿vale? 00:13:16
Gracias simplemente a esto, a una variable n igual a 1 que se va incrementando. 00:13:22
Bueno, pues ya tenemos la primera parte, que es conseguir que dentro del bucle, 00:13:28
en cada iteración vaya apareciendo cada uno de los elementos susceptibles de ser contados 00:13:32
y que entran a jugar en cada iteración cada uno de ellos. 00:13:39
pues en este caso, repito 00:13:42
como mis elementos 00:13:44
que entran a jugar son desde el 1 00:13:45
hasta el 100, pues la forma 00:13:48
más fácil de irlos generando 00:13:50
para que me vayan apareciendo en cada iteración del bucle 00:13:52
un n que empieza siendo 1 00:13:54
en la primera iteración 00:13:56
ya es 1, pero en la siguiente 00:13:58
ahora se convierte en 2, y en la siguiente 00:14:00
se convierte en 3, y en la siguiente se convierte en 4 00:14:02
luego en este caso esta es la 00:14:04
forma más sencilla de irlos generando 00:14:06
en otras cuentas 00:14:08
por ejemplo, facturas que están pagadas 00:14:10
lo que me tiene que aparecer aquí es todas y cada una de las facturas 00:14:13
pues no será tan sencillo 00:14:17
tendré yo que tener todas mis facturas en una caja 00:14:19
llamémosla array, como veremos más adelante 00:14:22
y de esa cajita tendré que ver cómo hago para sacar una de cada vez 00:14:25
en cada iteración 00:14:30
en la primera iteración saco la primera factura de la caja 00:14:31
en la segunda iteración saco la segunda factura de la caja 00:14:35
en la tercera saco la tercera factura 00:14:38
de la caja, vale, en ese caso será 00:14:41
más complejo, pero en este caso 00:14:43
como son números enteros sin más 00:14:45
pues hombre, una única variable 00:14:47
n que inicialmente vale 1 y en 00:14:49
cada vuelta de tuerca 00:14:51
se va incrementando 00:14:52
¿vale? 00:14:54
esta situación es sencilla 00:14:56
otras pues no lo serán, repito 00:14:59
otras tendremos que ver cómo hacemos para que 00:15:01
en este while vaya apareciendo 00:15:03
cada vez uno de los elementos 00:15:05
en otra situación no será tan fácil 00:15:06
pero lo que hay de fondo siempre es lo mismo 00:15:08
cuando contamos algo 00:15:10
siempre tenemos que tener claro 00:15:11
muestra de elementos a contar 00:15:13
todos los números 00:15:16
todas las mesas, todas las facturas 00:15:18
muestra, esa muestra donde va 00:15:20
veremos a ver donde va 00:15:22
en este caso una variable n ha ido 00:15:24
porque eran números, hay una variable n 00:15:26
en otro caso era otro sitio 00:15:27
y ahora, ¿cómo hago para que me aparezca 00:15:29
uno de cada vez? 00:15:32
¿cómo hago para que en cahidración 00:15:34
aparezca uno? en este caso así 00:15:35
se ha quedado. Empezándolo en uno y luego 00:15:37
incrementando. En otro caso 00:15:39
no será tan fácil. Tendré que ver cómo hago 00:15:41
para ir sacando uno de cada vez 00:15:43
de esa caja que tiene facturas, 00:15:46
mesas, pero eso ya es otro problema. 00:15:47
¿Vale? Bueno, pues ahora ya. 00:15:50
Ahora ya lo único que nos falta es 00:15:52
ver 00:15:53
qué hacemos, ver 00:15:54
bajo qué condiciones este numerito 00:15:57
se cuenta o no se cuenta 00:16:00
y cuándo dejamos 00:16:01
de contar. Es lo único que nos falta. 00:16:03
Bueno, ¿cuándo dejamos de contar? 00:16:05
Nos han dicho que contemos 00:16:07
Nuestro espacio muestral 00:16:09
De elementos susceptibles de ser contados 00:16:11
Eran entre 1 y 100 00:16:14
Luego 00:16:16
¿Cuándo dejo de contar? 00:16:18
Pues cuando 00:16:21
N sea mayor que 100 00:16:22
O lo que es lo mismo 00:16:23
Voy a contar mientras el numerito 00:16:24
No haya llegado a ser 100 00:16:28
¿Vale? 00:16:29
¿Y para qué quería? 00:16:30
¿Por qué no contaba? 00:16:33
porque tienen información distinta. 00:16:33
Esta incorpora la cuenta y esta el número. 00:16:38
Si solo usas una variable, 00:16:41
una te pisa la otra. 00:16:42
Cada una, n es 00:16:47
1, 2, 3, 4, 5. 00:16:48
Y contador, 00:16:52
es 1 una temporada larga, 00:16:53
luego puede ser 3, luego puede ser 7. 00:16:55
O sea, tienen información distinta. 00:16:57
vamos a completarlo, ¿vale? 00:16:58
vale, entonces 00:17:20
pero si es importante 00:17:21
otra cosa es que un programa en concreto 00:17:23
un programa en concreto 00:17:26
uno pueda 00:17:27
luego plantearlo haciendo ciertas simplificaciones 00:17:29
pero tenéis que entender 00:17:32
que la cuenta 00:17:34
Imagínate que esto fueran facturas 00:17:37
Bueno, da igual, es que aunque fuera un número 00:17:39
O sea, la cuenta es una variable que tiene una función 00:17:41
¿Qué es contar? 00:17:43
¿Vale? ¿Qué es contar? 00:17:46
Entonces, este bucle de aquí 00:17:48
Puede terminar con cuenta valiendo 7 00:17:49
Con cuenta valiendo 12 00:17:51
Con cuenta valiendo, ¿vale? 00:17:53
Depende de los números que yo te voy a contar 00:17:54
Sin embargo, este siempre va a terminar valiendo 100 00:17:56
Porque este tiene un uso 00:17:59
Que es todos los números entre 1 y 100 00:18:00
O sea, son variables con usos distintos 00:18:02
¿Vale? Son varios usos distintos 00:18:04
ahora vamos a ver qué es lo que contamos 00:18:06
otra cosa es que si estamos contando una cosa 00:18:08
en concreto, en un caso 00:18:10
particular, porque yo estoy contando 00:18:12
una característica 00:18:14
concreta de N 00:18:16
pues a lo mejor me pueda coincidir 00:18:18
y puede hacer extrapolar una cosa a la otra 00:18:20
pero no es la idea general 00:18:22
¿vale? 00:18:25
entonces 00:18:27
contador me lleva la cuenta 00:18:27
y tiene su uso 00:18:31
y no la puedo pisar con ninguna otra información 00:18:32
y este tiene los datos 00:18:35
y son dos cosas muy distintas 00:18:37
una cosa es la cuenta 00:18:38
y otra cosa son los datos 00:18:40
¿vale? 00:18:42
si esto fueran alumnos 00:18:45
contador podría ser alumnos 00:18:46
no podría serlo, ¿a que no? 00:18:49
esto serían mis alumnos y sería el contador 00:18:51
no es lo mismo 00:18:53
bueno, pues entonces, vamos a contar 00:18:54
mientras n sea menor o igual que 100 00:18:59
y ahora 00:19:00
esto no me hace falta 00:19:01
porque esto era para irlos generando 00:19:04
Ya lo estoy generando aquí, esto fuera. 00:19:06
Y ahora, ¿qué va a hacer que ese número sea contado o no sea contado? 00:19:10
Vamos a mirar. 00:19:14
Ese número va a ser contado si es múltiplo de 7. 00:19:18
Ah, pues ya está. 00:19:22
Ya tengo la condición que me hace que ese múltiplo sea contado. 00:19:23
¿Vale? 00:19:34
Pues ya está. 00:19:35
Y este es mi programa. 00:19:36
Que lo que yo quiero contar ahora es que el número sea patatín. 00:19:38
Pues cambio aquí la condición por patatín. 00:19:42
¿Vale? 00:19:46
Que quiero contar, pues, ¿vale? 00:19:46
Entonces, esta es la estructura de mi programa. 00:19:54
Dime. 00:19:56
No, no, no, porque aquí no hay llaves. 00:20:02
No, no, no, claro, aquí no hay llaves. 00:20:05
¿Vale? 00:20:08
Como no hay llaves, lo único que está dentro del if es contador. 00:20:09
¿Vale? 00:20:14
¿Cómo que es todo lo que está dentro del if? 00:20:16
¿Está ahí? 00:20:18
no, esto, esta sentencia 00:20:18
es lo único 00:20:21
que se hace dentro del IF 00:20:23
si la condición es cierta es la de incrementar 00:20:25
esta se hace siempre 00:20:26
¿vale? entonces familiarizaros ya 00:20:27
con el hecho de 00:20:31
que las llaves pueden no estar si es solo una sentencia 00:20:32
nos lo deja más claro 00:20:35
si hemos tabulado bien 00:20:36
¿vale? nos lo deja más claro 00:20:38
pero aún así pues 00:20:40
iros familiarizando con que si solamente tengo una sentencia 00:20:44
pues no hace falta que ponga llaves, entonces aquí este programa 00:20:47
me va generando 00:20:50
un segundito, vamos a volver a repetir 00:20:51
me va generando mis datos 00:20:54
mis datos vienen 00:20:56
de una fuente de datos 00:20:57
en este caso mi fuente de los datos 00:20:59
es la variable n, que son mis datos 00:21:01
empiezan valiendo 1 00:21:03
y se van incrementando 00:21:05
luego mis datos son 1, 2, 3, todos desde 1 00:21:07
hasta 100 y están aquí en n 00:21:09
y ahora otra cosa completamente distinta 00:21:11
a mis datos es la cuenta 00:21:13
que es cuántos de esos datos 00:21:15
cumbre no sé qué, es otra cosa bastante distinta 00:21:18
en este caso son números enteros 00:21:19
pero es casualidad, mis datos podrían ser 00:21:21
alumnos, mesas, números de Abel 00:21:23
cualquier cosa 00:21:25
estos son mis datos, que empiezan en 1 00:21:26
se van incrementando 00:21:30
2, 3, 4 y acaban en 100 00:21:32
mis datos, y ahora otra cosa es 00:21:33
la variable que lleva la cuenta 00:21:36
que es así, que siempre es un número entero 00:21:37
porque las cuentas son 1, 2, 3, entero 00:21:39
y ahora la que lleva la cuenta 00:21:41
empieza valiendo 0 00:21:43
Y la que lleva la cuenta 00:21:44
Se incrementa solo si se cumple la condición 00:21:46
Solo si se cumple la condición 00:21:49
Que yo quiero contar ahora 00:21:52
Otras cosas, no los múltiplos de 7 00:21:55
Cambio la condición 00:21:57
Y ya está 00:21:58
¿Vale? 00:21:59
Lenin, ¿qué ibas a decir? 00:22:09
Sí, claro 00:22:13
¿Cómo si los cerramos? 00:22:14
¿Dónde? 00:22:20
si ponemos la llave 00:22:22
¿y la llave dónde? 00:22:26
si ponemos la llave al final ahí 00:22:29
hombre, si la pones aquí y aquí, claro 00:22:31
o sea, me refiero que 00:22:34
yo, omitirla 00:22:36
es lo mismo 00:22:38
que hacer esto 00:22:39
claro 00:22:41
hombre, es por no poner aquí una línea 00:22:44
adicional, porque 00:22:46
si dentro del if solo hay una 00:22:48
pues podemos omitir las llaves 00:22:50
¿vale? pero que quede muy claro 00:22:52
para que no os confundáis 00:22:53
¿vale? lo que 00:22:55
quitar estas llaves 00:22:56
y ponerlas 00:22:59
es lo mismo 00:23:01
¿vale? 00:23:02
vale 00:23:07
a ver, Yasmín, ¿qué me querías decir tú? 00:23:07
no, antes 00:23:12
cuando me decías que por qué en el contador 00:23:13
no podemos utilizar la misma variable 00:23:15
es que no te he llegado a entender 00:23:17
ah, no, no, porque yo pensé que estabas diciendo 00:23:19
vale, bueno, da igual 00:23:21
vale, no 00:23:27
Pues a nada 00:23:29
Bueno, esto está claro, ¿no? 00:23:30
Dime 00:23:36
Bueno, porque 00:23:37
Hay 14 múltiplos de 7 00:23:42
¿Tantos múltiplos de 7 hay? 00:23:48
Creía yo que había menos múltiplos de 7 00:23:53
Sí, o sea que hay 14 múltiplos de 7 00:23:55
Pues entonces da los múltiplos de 7 00:24:00
No, no, no 00:24:02
Que cuenta los múltiplos 00:24:07
Pues hay 14 00:24:09
Porque es contar, pues contar 00:24:10
Hay 14 00:24:12
Bueno, pues si tuviera que mostrarlos 00:24:12
Podríamos aprovechar 00:24:16
Y a la vez que le contamos 00:24:17
Le mostramos, por ejemplo 00:24:20
Entonces este mostraría 00:24:22
Además de contarle 00:24:25
Para incrementar la cuenta 00:24:27
Además lo mostraría 00:24:28
Claro. Entonces, aquí sí que serían imprescindibles las llaves, porque aquí ya sí que tendría dos sentencias dentro de ley. 00:24:30
Pues cuando Lenin me ha dicho, y si ponen las llaves es igual, en ese momento lo he puesto. 00:24:43
Sí, es lo que acabo de decir 00:24:49
Que aquí ya sí que tendría que ponerlas 00:24:55
Porque aquí ya habrían aparecido 00:24:56
Dos sentencias, aquí tendría que ponerlas 00:24:59
Sí o sí, ¿vale? 00:25:01
Entonces aquí, aparte de mostrarte 00:25:02
Vale, pues son todos estos 00:25:06
Los múltiplos de 7 00:25:14
¿Cuántos hay? 14 00:25:16
Si contamos todos estos, nos saldrá 14, efectivamente 00:25:18
98 es múltiplo de 7 00:25:21
y 91. ¿Quién lo diría? 00:25:23
Vale. 00:25:26
Vale. A ver, 00:25:27
saltamos denunciado. 00:25:29
Venga, pues el 5. Vamos a modificar 00:25:33
lo anterior de forma que cuente 00:25:35
todos los números múltiplos 00:25:37
de uno que hemos solicitado. 00:25:39
Entonces, aquí el programa va a tener 3 datos 00:25:44
de entrada. Va a tener 00:25:46
un número inicial 00:25:47
y otro número final 00:25:52
y un tercero. Entonces, tiene que 00:25:53
contar cuántos múltiplos 00:25:56
de este tercer número hay entre 00:25:58
inicial y el final. 00:26:00
¿Vale? Pues venga, 5. 00:26:02
Lo hacéis ahora, en 5 00:26:04
minutillos. 00:26:05
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
2
Fecha:
27 de octubre de 2025 - 10:26
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 10″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
342.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid