Saltar navegación

While y For - 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 24 de octubre de 2025 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis o hacéis preguntas, me autorizáis a grabar vuestro. 00:00:00
¿Vale? Os acordáis que estamos en estructura de control. 00:00:06
Había tres tipos de estructura de control. 00:00:11
Había los condicionales, las iterativas y las llamadas a métodos. 00:00:14
Las sentencias de control o estructura de control lo que hacen es alterar el flujo normal de ejecución de un programa. 00:00:18
normalmente el flujo de ejecución normal es secuencial antes de arriba abajo de izquierda 00:00:29
a derecha vale estándar si yo utilizo una de estas estructuras pues lo que hago es cambiarlo 00:00:38
un poco puede hacer que salte un trozo puede hacer que un trozo lo haga a condición que se 00:00:46
cumpla la condición y si no se cumple hacer otra puede hacer varias veces el mismo bloque puedo 00:00:54
hacer un bloque que está en otro lado y luego volver a donde estaba anteriormente se debe 00:01:00
cambiar el orden con que se ejecutan las cosas nosotros movistos condicionales dos tipos de 00:01:05
condicionar eso es grosso modo if the switch vale hemos dicho que son prácticamente equivalentes 00:01:13
puedo hacer cambios y cosas 00:01:20
para hacer lo que hago en uno, en otro 00:01:21
y lo que hago en otro en uno 00:01:23
hoy vamos a ver la segunda 00:01:24
familia de 00:01:27
estructuras de control 00:01:30
cuidado 00:01:32
porque con esta 00:01:33
pequeña 00:01:36
cosa que añadimos 00:01:37
las cosas 00:01:39
los programas se pueden complicar 00:01:41
mucho 00:01:43
¿os acordáis cuando hablamos de 00:01:44
programación estructurada. 00:01:47
Y decimos que tiene una serie de características 00:01:51
que son, que tiene la secuencia, 00:01:52
tiene el condicional, tiene el iterativo. 00:01:55
Pues con esto completamos 00:01:57
sustancialmente, porque 00:01:59
la llamada al método es útil 00:02:00
para estructurar, pero 00:02:02
técnicamente podrías 00:02:04
no utilizarlo, ¿vale? 00:02:06
Y aún así hacer toda la 00:02:08
complejidad que te da la gana. O sea que con 00:02:10
estos tres elementos 00:02:12
ya podemos hacer programas 00:02:13
serios no los haremos porque es principio y porque hacerlo con solo estas tres cosas es un infierno 00:02:16
vale necesitamos más piezas para que sea más cómodo hacer programas complejos y completos 00:02:21
vale pero ya con esto se puede mejorar mucho todo lo que hacemos y también juntitos con los 00:02:28
iterativos van nuestros personales enemigos, los arrays. Entonces dentro de 00:02:38
poco entrarán también en juego los arrays y con eso ya cambia 00:02:44
la forma de ver programación. Ahora he decidido 00:02:52
que puede sufrir. Vale, entonces estructuras iterativas, ¿qué son? ¿Para qué sirven? 00:02:57
Las estructuras iterativas permiten repetir un determinado bloque más de una vez, ¿vale? 00:03:04
Si yo quiero que este bloque se repita y repita y repita mientras una condición sea verdadera, 00:03:10
mientras se cumpla una condición, mientras que esto es verdadero, tengo que utilizar un BLIND. 00:03:19
si quiero en vez 00:03:28
sé cuantas veces voy a hacer 00:03:31
esta interacción, la quiero hacer 6 veces 00:03:33
la quiero hacer 10 veces, la quiero hacer 00:03:35
el número de veces que me ha puesto 00:03:37
el usuario por teclado 00:03:39
y cosas por el estilo, pues eso 00:03:41
es un FOR 00:03:43
son dos estructuras 00:03:45
parecidas que son 00:03:47
hermanas como SWITCH e INFA 00:03:49
es decir que todo lo que puede hacer con un WHILE 00:03:51
lo puede hacer con el FOR 00:03:53
todo lo que hago con el FOR lo puede hacer con el WHILE 00:03:54
Pero en determinados casos un while te sale más sencillo y en determinados casos un for te sale más sencillo. 00:03:57
Por lo tanto, hay que empezar a entender antes o después cuándo usar un while y cuándo usar un for. 00:04:06
En general la regla es sencilla, si no sé cuántas veces voy a hacer una cosa es un while, si sé cuántas veces voy a hacer una cosa es un for. 00:04:12
esto no quiere decir 00:04:21
a tiempo de programación 00:04:23
a tiempo de, mientras yo estoy 00:04:25
haciendo el código, quiere decir que 00:04:27
si cuando empiezo el while 00:04:29
en ejecución, sé cuantas veces 00:04:31
lo tengo que hacer, pues ese es un for 00:04:33
¿sí? ¿qué quiere decir todo esto? 00:04:35
que a lo mejor yo no sé si una cosa 00:04:38
si un trozo lo voy a hacer 00:04:39
seis o diez veces, porque 00:04:41
soy el usuario que me lo escribe 00:04:43
por teclado 00:04:45
yo le digo, ¿cuantas veces 00:04:47
quiero hacer esto? y me dice siete 00:04:49
pues entonces lo hago 7 veces 00:04:51
¿cuántas veces quiero hacer esto? 00:04:52
100, pues lo hago 100 veces 00:04:55
yo a tiempo de 00:04:57
preparación del programa 00:04:58
mientras estoy programando 00:05:01
no sé si esto se va a hacer 5 o 10 veces 00:05:02
pero luego 00:05:05
lo sabré, sé que se va a hacer 00:05:07
n veces, hay una variable que se llama n 00:05:09
y ese número de veces 00:05:11
pues eso es un for 00:05:13
que en vez de yo te digo 00:05:14
¡ay usuario! 00:05:17
me ponga a hacer 00:05:18
algo, ¿vale? Sumas. 00:05:21
Y cuando tú 00:05:24
quieres acabar, me pones 00:05:25
un cero y ese cero 00:05:27
quiere decir que ha acabado. 00:05:29
Cuando yo empiezo este bucle, 00:05:31
no lo sé si el usuario me pondrá uno, 00:05:33
diez o veintisiete. ¿Me entiende? 00:05:35
Entonces, en este 00:05:39
caso sería un while. 00:05:40
Es un while. El comando while se usa 00:05:45
cuando quiero repetir un cierto bloque 00:05:48
instrucciones mientras sea verdadera una determinada condición. Es decir, una cosa 00:05:50
de este estilo. Entro por aquí, hay una condición. Si la condición es falsa, me 00:05:55
salto todo y sigo adelante con la siguiente bloque de instrucción. Si la 00:05:59
condición es verdadera, hago un bloque de instrucción y vuelvo justo antes del 00:06:03
wine. Y vuelvo a comprobar otra vez si la condición es verdadera o falsa. Si es 00:06:08
Si es verdadera, entro otra vez. Si es verdadera, entro otra vez. Si es verdadera, entro otra vez. 00:06:17
Y así, así, así, hasta que algo en estas instrucciones me cambie la condición a falsa, 00:06:22
y entonces saldré por aquí y seguiré grabando. 00:06:28
Cuidado. Un while puede ser eterno. 00:06:31
Si yo, dentro de estas instrucciones, dentro de este bloque de instrucciones, 00:06:37
no cambio la condición nunca, pues este while es un while insignito. 00:06:41
Entra dentro y como no puedo cambiar la instrucción, no puedo cambiar la condición, siempre será verdadera y por lo tanto me quedo atrapado ahí. 00:06:49
¿Es un error? En un 99% de las veces sí, pero hay programas que no acaban nunca. 00:06:58
Hay programas que yo cuando hago un programa, pues quiero volver al principio y pediros a ver de ahí ahora qué hago. 00:07:05
En ese caso estará en un while que no acaba nunca. 00:07:11
normalmente que acabe nunca, nunca, nunca 00:07:14
no existe, habrá una 00:07:16
condición especial de administrador 00:07:18
porque el administrador puede bloquear 00:07:20
habrá un código especial que si 00:07:22
el administrador pone ese código 00:07:24
pues el programa se arresta 00:07:26
y yo puedo hacer mantenimiento para instalar 00:07:28
una nueva versión y arrancarlo otra vez 00:07:30
pensad a un 00:07:32
cajero automático 00:07:33
vas allí, dame 00:07:36
la tarjeta, mete la tarjeta, dame 00:07:38
el dinero, pones el dinero, te da 00:07:40
y a ese punto no hay que decir 00:07:42
he acabado y se apaga 00:07:44
vuelve al principio y dice dame la tarjeta 00:07:46
y tú puedes hacer otra operación 00:07:49
sin embargo está el administrador 00:07:50
que tendrá su forma de toquetear 00:07:53
su código para poner para que él 00:07:55
se arreste de verdad entre modalidad 00:07:56
mantenimiento y yo pueda activar 00:07:58
o actualizar lo que tenga que actualizar 00:08:00
y luego arrancarlo otra vez 00:08:02
cuando las condiciones se vuelven falsas 00:08:04
el programa deja de repetir el bloque 00:08:08
instrucciones y sigue adelante. Ejemplo del while, int i es igual a 0, wille i es menor 00:08:10
o igual que 10, condición, mientras que i sea menor o igual a 10, entra dentro, escribe 00:08:20
system.out.println i y luego dale i++. ¿Qué hace este programa? 00:08:28
Lanzo este programa, que veo 00:08:35
Lanzo este programa, que veo 00:08:48
Lanzo este programa, que veo 00:08:52
Que me sale 00:08:58
Y diez veces 00:08:59
Y diez veces 00:09:01
1, 2, 3, 4, 5 00:09:05
No, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 00:09:10
Eso es lo que veo 00:09:13
¿Sí? Vamos a ver 00:09:14
Vamos a ver 00:09:18
Package 00:09:19
Ejemplos 00:09:35
Plus 00:09:36
Ejemplo 00:09:40
Wille 00:09:42
Entonces, tengo un main 00:09:43
y aquí digo 00:09:47
int i es igual a cero 00:09:54
i es menor o igual a diez 00:09:56
si hizo i 00:10:00
i más más 00:10:04
Si lo lanzo 00:10:08
tengo los números de cero a diez 00:10:11
No hace cero, no hace cero más cero 00:10:19
Tú dices, ¿cuánto vale i? 00:10:21
0. ¿Es menor que 10? 00:10:23
Sí. Escríbeme i. 00:10:26
¿Cuánto vale? 0. 00:10:27
Me ha escrito 0. Lo pongo aquí abajo. 00:10:29
Ha escrito un 0. 00:10:34
Y ahora dice i más más. 00:10:36
¿Qué hace esto? 00:10:38
i es igual a i más 1. 00:10:40
¿Vale? Entonces ahora i vale 00:10:42
1. Vuelvo aquí. 00:10:43
1 es menor 00:10:47
igual a 10. 00:10:47
Sí, por lo tanto entro, escribo 00:10:48
Uno 00:10:51
Hago uno más más 00:10:52
Sería dos 00:10:56
Vuelvo aquí, dos es menor que diez 00:10:57
Sí, entro dentro, escribo dos 00:11:00
Más más 00:11:02
Y así, así, así, así 00:11:04
Hasta llegar a 00:11:05
Diez, ¿vale? 00:11:07
Cuando llega a diez 00:11:10
Cuando llega a diez 00:11:11
Llego aquí, diez es menor o igual que diez 00:11:13
Sí 00:11:15
Entro dentro, escribo 10, voy aquí, 10 más más, 11. 11 es menor o igual que 10, 00:11:19
falso. Entonces esto es lo que sale. De 0, porque la primera vez vale 0, a 10. ¿Qué hace esto? 00:11:27
De 0 a 9 00:11:46
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 00:11:53
¿Correcto? 00:11:54
¿Qué hace esto? 00:11:56
Porque siempre antes lo suma 00:12:17
Y luego lo escribe 00:12:20
Eso quiere decir que cuando entra aquí como 9 00:12:21
Escribe 10 00:12:24
Cuando entra como 0 escribe 1 00:12:25
Cuando entra como 1 escribe 2 00:12:27
Cuando entra como 2 escribe 3 00:12:30
Cuando entra como 9, que es la última vez 00:12:32
Escribe 10 00:12:34
pasa 10, 10 no es menor que 10 00:12:35
y por lo tanto sale 00:12:38
¿sí? ¿qué hace esto? 00:12:38
de 3 a 3 00:12:51
de 4 00:12:52
de 4 a 10 00:12:53
¿vale? 00:12:55
¿sí? 00:13:00
pasa tantos segundos 00:13:21
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30. 00:13:23
La primera vez que entra como 3, suma 1 y escribe 4. 00:13:53
Incluido el 10. 00:14:03
Porque entrará como 9. 00:14:04
Entra como 9, pone 10, escribe 10, pasa 11, llega aquí y sale 9. 00:14:08
¿Sí? 00:14:16
Y así podéis jugar cuanto queráis. 00:14:17
¿Vale? 00:14:20
Hacéis un while, escribís cosas al azar y luego pensáis en lo que tiene que salir y después le dais al play. 00:14:20
¿Pero esto no sería con hold? 00:14:28
No, no tiene que estar ahí. Pero entiéndeme, es el primer while que se lee, ¿vale? 00:14:31
Depende, porque si yo hago esto de... Escribe un número y si es más o menos 10 a cabo, ¿tú sabes cuántas veces lo escribiré? 00:14:37
Y es igual a scan.nexi. 00:14:48
Con el scan no, pero poniéndolo como lo estamos poniendo. 00:14:55
¿Tú sabes cuántas veces voy a entrar aquí? 00:15:00
Así sí lo puedes contar, lo puedes saber más o menos. 00:15:07
Pero si yo te pongo esto, ¿qué hace? 00:15:10
Negativos infinitos. 00:15:26
Desde el 3 al infinito, restando siempre 1. 00:15:28
¿Hasta cuándo? 00:15:41
¿Hasta cuándo? 00:15:44
¿Hasta cuándo? ¿Dos? 00:15:49
¿Dos? 00:15:51
Menos 2.000 millones, grosso modo. 00:15:58
porque luego explotan los ints. 00:16:01
¿Sí? 00:16:03
Fijaos. 00:16:07
Cuando a vosotros 00:16:09
os pasa esto, 00:16:11
aquí tenéis un cuadradito rojo 00:16:13
que os 00:16:15
para la ejecución. 00:16:17
Cuidado, 00:16:19
porque vosotros hacéis esto. 00:16:21
No funciona. 00:16:23
Le doy otra vez. 00:16:29
No funciona. Le doy otra vez. 00:16:31
Y ahora yo tengo 00:16:33
tengo mi CPU al 93% haciendo menos, menos, menos, menos tres veces, ¿vale? Y sigo aquí 00:16:35
hasta que explote. Ahí está la damenzona desde antes, ¿vale? Entonces, tened en cuenta 00:16:52
también que esto tarda relativamente poco en explotar, porque si solo hace esto, llegar 00:17:02
a menos dos millones, no tarda nada. 00:17:09
La tarda un rato. 00:17:20
Entonces, cuidado con esto, porque vosotros no veis que está viendo nada, habéis hecho 00:17:27
un error, no está funcionando, aquí no veo ganas de nada, pues le doy otra vez, y otra 00:17:32
vez y otra vez y tenéis varios while que están haciendo un montón de cosas, sin nada. Cuidado, 00:17:37
porque llega un momento en que él se lía y ya no funciona bien, porque está haciendo demasiadas 00:17:46
cosas. Siempre cuando hacéis con el while y tenéis cuidado, que no sabéis bien si puede ser que sea 00:17:52
un while infinito, siempre un ojo aquí. Si veis que este es rojo, es que os habéis metido en algún 00:18:00
momento de while infinito y tenéis que pararlo de aquí, ¿vale? 00:18:06
Si tú pones valores que son, por ejemplo, letras, ¿qué pasa? Explota. 00:18:16
Aquí no se lee el teclado. 00:18:22
Ya, pero en caso de... 00:18:25
Como antes. No explota el while, explota el hecho que tú estás leyendo un chart cuando tienes que leer un int, explota. 00:18:27
Eh, quería decir algo, pero no me acuerdo, no me acuerdo, va, entonces, cuidado con estas cosas de aquí, cuidado con los while, ah, sí, quería decir, ¿por qué? ¿Por qué este es infinito? 00:18:37
¿Por qué? 00:18:56
Porque por el algoritmo que yo he hecho 00:19:05
La condición no cambia nunca 00:19:08
¿Vale? 00:19:10
Si la condición no cambia nunca 00:19:12
Porque es siempre true 00:19:15
¿Vale? 00:19:16
Pues se queda ahí 00:19:17
Cuidado que en realidad sí cambia 00:19:19
Pero claro, está cambiando de una forma 00:19:21
Que nunca será false 00:19:24
¿Vale? 00:19:25
Si yo hiciera esto 00:19:26
acaba no va a acabar simplemente porque aquí dentro la condición no está cambiando he hecho 00:19:27
un error porque en mi condición no va nunca a cambiar por lo tanto esto no podrá nunca ser 00:19:47
force y por lo tanto seguirá aquí para siempre dudas o de cuidado hasta ahora por cuanto vosotros 00:19:53
hicierais daño en la programación bueno pero ahora ya tenéis en mano algo un poquito más 00:20:04
complejo vale que puede hacer daño o pero sí pero es más sencillo 00:20:11
que no lo puedes hacer 00:20:17
tenemos ahora algunos ejercicios a estos ejercicios que te decía lee cinco vocales 00:20:30
o cinco números y suma los y cosas por el estilo tenía sólo él y pues tenía que usar 00:20:38
de esas cosas. Pues ahora yo te podría decir 00:20:43
lees el número 00:20:45
porque va a venir el código del programa 00:20:47
se va a entre bien el código. Dentro de un 00:20:49
while siempre haces lo mismo. 00:20:51
Ahora, veremos cómo se usa. 00:20:53
Pues literalmente cambiarías el 10 por un 100 00:20:55
y podrías uno más. 00:20:57
Realmente, 00:21:01
si yo quiero 00:21:02
si yo quiero escribir 00:21:03
los números de 1 a 100 00:21:07
¿cómo lo haríais? 00:21:09
Pones aquí un 00:21:11
1 por ejemplo 00:21:20
Y él está escrito de 1 a 100 00:21:22
Y si quise hacerlo hasta 10.000 00:21:25
O si lo queréis ver 00:21:28
A lo mejor lo veis mejor así 00:21:35
Y si quise hacerlo 00:21:36
hacer 10.000.000? Si quisiera hacer hasta, no sé, la complejidad está aumentando. Y 00:21:44
Si quisiera hacerlo, por ejemplo, a ver, 10.000 millones, es una duda y no tiene un máximo. 00:22:07
Había hecho una pregunta. 00:22:20
Es lo mismo. 00:22:21
¿Sí? 00:22:22
No, ahí está. 00:22:23
Ahí está el límite. 00:22:24
¿Veis que caí una cosa? 00:22:25
Estos son 1.000 millones. 00:22:26
¡Tax! 00:22:27
Explota. 00:22:28
El límite. 00:22:29
millones. Tax. Explota. El límite. ¿Entonces qué hago? Estas cosas ya las hemos estudiado, eh. Sé que vosotros en los castings lo habéis visto solo una vez y os da igual, pero este número de aquí como entero no me vale porque sale del rango de enteros, pero si lo miro 00:22:30
como double pues lo puede usar tranquilamente o si le pongo punto cero es un dado si le pongo 00:23:00
una l para long cosas lo hemos visto en clase están grabados y la tenéis que saber porque 00:23:06
antes o después os pillas los dedos dudas vale entonces eso es un guay fácil la sintaxis es 00:23:13
súper fácil es como todo en programación la sintaxis la parte más sencilla es luego utilizarlo 00:23:25
combinar lo que se vuelve complejo, ¿vale? 00:23:30
Existe el hermano del while, que es el do while. 00:23:36
Si os fijáis aquí, ¿cuántas veces se va a ejecutar 00:23:40
este bloque? Vale. 00:23:44
En general, sin saber cuál es la condición, ¿cuántas veces 00:23:49
se ejecuta esto? El mínimo 00:23:54
cero. Si la condición es falsa, si yo aquí pongo 100, 00:23:59
¿Cuántas veces se ejecuta esto? 00:24:07
Cero 00:24:10
Entonces un while ejecuta ese bloque cero 00:24:10
O muchas veces 00:24:13
¿Y qué pasa si yo quiero 00:24:15
Estar seguro que esto al menos una vez 00:24:18
Se ejecute? 00:24:21
Claro, a lo mejor no se vuelve a ejecutar 00:24:23
Pero no cero o más 00:24:25
Más uno o más 00:24:27
Pues uso el do while 00:24:28
El do while 00:24:31
Es un procedimiento que empieza con do 00:24:33
Hace un bloque de instrucciones 00:24:36
Y después del bloque de instrucciones 00:24:38
Hace una condición 00:24:40
Que es una condición igual al while 00:24:42
Y si es verdadera 00:24:43
Vuelve aquí arriba y repite 00:24:45
¿Vale? Ahora estamos como antes 00:24:48
Si en vez de es falsa sale 00:24:50
Pero una vez ha pasado por aquí 00:24:51
Siempre 00:24:53
¿Entendé? 00:24:54
Y esto es la sintaxis 00:24:59
Do es hacer 00:25:02
Hace esto 00:25:04
Mientras 00:25:05
fijaos que tiene una cosa un poquito rara que mientras el while por sí mismo no tiene punto 00:25:07
y coma al final del bloque while el do while sí entonces si usáis el do while al final del 00:25:17
while aquí hay punto y coma porque aquí acaba este comando digamos en el while en vez ejecutaría 00:25:29
sólo lo que viene después que sería este bloque y por lo tanto ya está 00:25:36
cualquier cosa que se puede hacer con un guay se puede hacer con dubai cualquier cosa que se 00:25:44
puede hacer cuando guay se puede hacer con guay es simplemente cambiar un poquito la condición 00:25:49
y forzar que la primera sea verdadera y pues luego compruebe y si tienes cuba ilusión de un guay 00:25:54
¿Por qué? Porque son dos estructuras distintas. 00:26:06
En el while, tú podrías hacer que esto no lo ejecutes nunca. 00:26:09
Porque tú llegas aquí, dices, condición falsa, sales. 00:26:14
Nunca has hecho las instrucciones. 00:26:18
Pero existe otra versión que tú puedes usar o olvidarte, 00:26:21
que es esta de aquí, en que estas instrucciones la primera vez las haces. 00:26:26
Siempre. 00:26:32
y que si es verdadera la condición 00:26:32
vuelves a regirla 00:26:35
si es falsa sigues adelante 00:26:36
pero aquí puede ser que sean 00:26:38
cero o una 00:26:41
o dos o tres 00:26:42
o sea cero o más 00:26:44
este bloque de instrucción 00:26:45
mientras aquí es una vez seguro 00:26:48
y luego puede otra vez 00:26:51
puede otra vez o no 00:26:53
entonces una o más 00:26:54
la primera vez hace las instrucciones sin comprobar 00:26:55
si es verdadero o falso 00:27:00
Si tú fuerzas que la primera vez sea verdadero siempre la condición, con alguna razón, como tú puedas, 00:27:01
pues entonces es equivalente a un while que a un dual. 00:27:10
Pero al final es lo mismo, ¿no? 00:27:13
Al final es lo mismo que esto. Son estructuras iterativas y ya he dicho que todo lo que puedes hacer con un while, 00:27:16
lo puedes hacer con un dual, y todo lo que haces con un dual, lo puedes hacer con un while. 00:27:23
Solo que a veces hay situaciones, hay cosas, que con un do while te sale mucho más elegante que con un while. 00:27:27
Con un while tienes que hacer algunos cambios ahí que te dicen por qué hace eso. 00:27:33
Y es para forzar que la condición sea verdadera y poder entrar. 00:27:37
Entonces tú usas un do while. 00:27:40
Para decir. 00:27:44
Ejemplo de do while, esta cosa de aquí, ¿qué hace? 00:27:49
vamos a ver 00:27:52
sistema 00:28:14
punto 00:28:22
auto.println 00:28:25
y más 00:28:28
huile 00:28:31
menor o igual a 10 00:28:38
punto y coma aquí 00:28:41
vale 00:28:43
aquí pongo i es igual a 1 00:28:48
otra vez 00:28:51
estos dos señores 00:28:53
hacen lo mismo 00:28:56
este escribe de 1 a 10 00:29:01
y este escribe de 1 a 10 00:29:04
son iguales 00:29:06
¿Hace lo mismo? 00:29:08
Imaginaos esto. 00:29:14
Ah, apretad, que aquí también tengo por aquí. 00:29:24
No es trampa. 00:29:27
¿Por qué esto? 00:29:35
Llega aquí y dice 15 menos el que 10. 00:29:37
No. 00:29:40
Entonces se lo salta y se acabó. 00:29:41
Esto empieza de 15 y dice, escríbelo. 00:29:43
Zumba 1, llegas a 16, y ahora dices, ¿16 es menor que 10? 00:29:47
No. 00:29:53
Entonces se acaba. 00:29:54
Pero en esto no lo ha escrito, y en este sí ha escrito el primero. 00:29:56
En este, aquí, ¿cuánto vale y aquí? 00:30:01
En este punto, ¿cuánto vale y? 00:30:11
15. 00:30:12
15. 00:30:13
En este punto, ¿cuánto vale y? 00:30:14
16. 00:30:16
16. 00:30:16
¿Sí? 00:30:18
son muy parecidos 00:30:19
sí 00:30:22
pero pueden tener un comportamiento distinto 00:30:23
esto, este 00:30:26
incremento lo hará siempre al menos 00:30:28
una vez, este de aquí 00:30:30
puede que no lo haga nunca 00:30:32
¿dudas? 00:30:34
vale 00:30:46
si, veamos también el for 00:30:46
tanto lo repasamos la próxima semana 00:30:54
entonces, el otro 00:30:55
while y do while son prácticamente lo mismo 00:30:57
la otra sintaxis 00:31:00
que tenemos, la otra estructura 00:31:02
que podemos utilizar es el for. Se utiliza cuando 00:31:04
se necesita ejecutar una serie de sentencias 00:31:07
un número fijo y conocido de veces. 00:31:10
Quiero hacer esto siete veces. Ejercicio. 00:31:13
Dame diez números y los sumo. 00:31:17
Sé que tengo que leer diez números. Pues es un for. 00:31:19
¿Cómo funciona? Hay tres pasos. 00:31:23
Hay una inicialización. 00:31:30
Luego, como en el while se verifica una condición 00:31:32
Si es verdadera, hace las instrucciones 00:31:36
Y al final de las instrucciones 00:31:40
Hace una actualización de las variables 00:31:42
¿Vale? 00:31:46
Inicializa 00:31:47
Verifica 00:31:48
Actualiza 00:31:50
Y luego empieza aquí 00:31:51
Actualiza y verifica 00:31:53
Actualiza y verifica 00:31:54
Actualiza y verifica 00:31:55
Como sea es esto 00:31:56
¿Vale? 00:31:58
Entonces, for 00:31:59
Para 00:32:00
por, por, por 00:32:01
int i que va 00:32:03
desde cero 00:32:06
mientras que sea menor que diez 00:32:07
la actualización 00:32:10
i más más 00:32:12
lo repito 00:32:13
inicialización, por donde empiezo 00:32:15
tú crea una variable 00:32:18
i que vale cero 00:32:20
al principio 00:32:22
¿cuál es la condición 00:32:22
que voy a utilizar? esta 00:32:25
está en el medio, que i sea menor 00:32:27
que 10. Y cada vez que llego al final, antes de volver a comprobar esta condición, ¿cómo 00:32:30
la actualizo? Pues con i++. Súmale un. Entonces, la primera vez que entro aquí, i valdrá 00:32:38
la segunda a 1, la tercera a 2, la cuarta a 3, y me escribe los números de 0 a 9, porque el menor es tecto. 00:32:46
Cuando entrará aquí, hará la actualización, llegará a 10 y va a mirar si 10 es menor que 10, 00:33:11
aquel no, y sale. 00:33:17
O sea, que esto es parecido 00:33:21
a los otros dos que hemos hecho. 00:33:23
Voy aquí. 00:33:25
Entonces, esto lo vuelvo a 1, 00:33:35
esto lo vuelvo a 1. 00:33:36
Entonces, tengo 00:33:40
mi variable i 00:33:41
que empieza y hace, mientras que 00:33:42
se me enriquece 0, hace esta de aquí, 00:33:45
pues me escribe los números de 1 00:33:47
a 10 incluido. 00:33:49
Este de aquí me escribe los números de 1 00:33:51
a 10 incluido. Es decir, 00:33:53
que estos dos están haciendo lo mismo. 00:33:55
de 1 a 10 00:33:57
ahora si quisiera hacer lo mismo con el for 00:33:58
diría 00:34:02
for 00:34:03
una variable 00:34:04
int j 00:34:07
es igual a 0 00:34:10
podría hacer así 00:34:12
estaría utilizando 00:34:15
la variable id 00:34:18
normalmente en un for 00:34:19
se suele declarar 00:34:21
una nueva variable aquí dentro 00:34:24
y esta variable de aquí es como un índice 00:34:25
es como un contador que te dice 00:34:28
a qué punto del for estoy 00:34:30
¿vale? 00:34:32
punto y coma, o de uno 00:34:34
hemos dicho, porque contamos de uno a diez 00:34:36
mientras que j 00:34:38
sea menor 00:34:40
o igual que diez 00:34:42
por cada ciclo 00:34:43
j más más 00:34:46
piso j 00:34:48
esto 00:34:53
hace lo mismo 00:34:55
que los otros y 00:34:56
de uno a diez 00:34:57
Si os fijáis, alguien lo ha dicho al principio, si no me equivoco, sí, este de aquí, más 00:35:06
o menos, en cuántas veces lo hago, es un Ford, y de hecho, el Ford, aquí me sale mucho 00:35:17
más elegante que esta cosa, mucho más bonito, mucho más compacto, mucho más... 00:35:24
Porque en un caso como esto, que das cuenta de 1 a 10, pues es mejor un Ford que un van, 00:35:30
sé cuántas veces lo tengo que hacer. ¿Dudas? A ver si aquí hay algo más. Vale, este es el primer ejemplo, vale, fijaos que si yo declaro esta variable aquí dentro, en el for, la puedo usar aquí fuera. 00:35:36
puede hacer yo si hizo 00:36:10
de j aquí fuera 00:36:12
no te lo va a detectar 00:36:14
no existe 00:36:16
porque las variables que declaro 00:36:18
aquí solo existen 00:36:21
en este block, solo existen 00:36:23
dentro del for 00:36:25
y como podría hacer para escribir 00:36:26
j aquí 00:36:29
poniéndolo fuera 00:36:29
declaro antes 00:36:32
int j es igual a 0 00:36:35
aquí se enfada 00:36:37
porque dice, oye, j ya existe 00:36:39
entonces no la declaro 00:36:40
simplemente la inicializo 00:36:42
y ahora 00:36:44
cuando ha acabado el for 00:36:47
j sigue existiendo 00:36:48
porque su ámbito 00:36:50
su scope 00:36:53
¿se acuerdan? es el ámbito de una variable, lo hemos visto 00:36:54
pues es el bloque 00:36:57
donde está creada 00:36:59
y el bloque donde está creado no es esto 00:37:00
ma es esto 00:37:02
y entonces la puedo utilizar 00:37:04
¿dudas? 00:37:08
vale, esto es lo que os dice esta transparencia de aquí 00:37:11
dice si yo declaro int fuera 00:37:16
luego la inicializo, pongo 00:37:20
en la condición, pongo la actualización 00:37:23
hago lo que sea, luego la puedo utilizar 00:37:26
fuera, vale 00:37:29
y este de aquí me escribiría 0, 1 y 2 00:37:31
empieza de 0, menor estricto de 3 00:37:35
0, 1 y 2 00:37:38
si lo hago así 00:37:40
sería incorrecto porque la i 00:37:45
la he declarado solo aquí 00:37:47
y es local al bucle 00:37:49
es una variable local dentro de este bloque 00:37:50
por lo tanto fuera 00:37:53
no la puedo utilizar 00:37:55
¿está claro? 00:37:56
puedo anidar un for dentro de un for 00:38:02
y esto es un infierno 00:38:05
¿ok? 00:38:06
esta cosa de aquí 00:38:10
escribe esta cosa de aquí 00:38:12
¿vale? suerte con entender 00:38:14
la vamos a intentar ver 00:38:16
esta 00:38:26
claro 00:38:26
es más, tú 00:38:29
aquí puedes declarar dos o tres variables 00:38:33
si tú quieres, haces 00:38:36
int i es igual a uno, j es igual a tres 00:38:37
coma k es igual a nueve 00:38:40
y luego haces las actualizaciones 00:38:42
con varias cosas, la actualización 00:38:44
nosotros solemos usar i más más 00:38:45
Pero puede ser I más 00:38:47
O sea, I igual a I más 7 00:38:48
O I igual a I por 54 00:38:51
Lo importante es que cambie I 00:38:54
Porque si no cambia esta cosa 00:38:56
Estoy en un for 00:38:59
Entonces, vamos a ver si entendemos esto 00:39:00
A ver, ¿cómo lo escribo yo? 00:39:06
Eint 00:39:21
Vale 00:39:21
Vamos a ver qué pasa 00:39:32
entonces 00:39:35
los for anidados son un for dentro de un for 00:39:40
es una de las cosas 00:39:43
más peligrosas que podéis hacer 00:39:45
en ámbito computacional 00:39:47
¿vale? cuando for entra en the for 00:39:49
y while entra dentro de while 00:39:51
el número de ciclos 00:39:53
que se hace es posible 00:39:57
que explote exponencialmente 00:39:59
entonces cuidado 00:40:02
For dentro de for 00:40:02
Hay que hacerlos bien 00:40:05
Además no se tiene que hacer 00:40:07
Sí, se tiene que hacer 00:40:08
Hay cosas que 00:40:09
Las tienes que hacer con un for dentro de un for 00:40:10
Y un for dentro de un for dentro de un for 00:40:12
Pero cuando empiezas con cosas así 00:40:14
Es posible que 00:40:16
Problemas relativamente sencillos 00:40:18
Pues tarden mucho tiempo en acabarse 00:40:20
Porque estás haciendo un montón de ciclos ahí dentro 00:40:23
¿Vale? 00:40:26
La idea es que aquí hay dos for 00:40:27
Uno aquí 00:40:30
uno 00:40:31
¿cómo se quita esta cosa aquí al lado? 00:40:35
quítate, no te quiero 00:41:02
entonces 00:41:03
uno es este 00:41:13
Ford de aquí 00:41:17
y dentro 00:41:18
hay otro Ford 00:41:23
esto quiere decir que por cada uno 00:41:25
de los ciclos 00:41:30
negros 00:41:31
se harán varios 00:41:33
ciclos rojos. 00:41:35
¿Entiende? 00:41:39
Vamos a probar 00:41:40
a entenderlo. 00:41:42
Entro en la parte negra, 00:41:44
¿vale? Donde 00:41:46
creo una variable y 00:41:47
que vale 00:41:54
¿cuánto vale? 00:41:59
Uno. 00:42:06
¿Están de acuerdo? 00:42:11
Vale. Me dice, ¿y es menor o igual a dos? 00:42:12
Sí. Por lo tanto, entro dentro de este bloque, el bloque negro. 00:42:17
¿Vale? Y encuentro un for, que me dice, oye, mira, 00:42:23
creo una variable j, que vale uno. 00:42:27
Y me pregunto, ¿uno es menor o igual que dos? 00:42:34
Sí. Por lo tanto, entro aquí dentro. 00:42:37
y me encuentro un system.auto.println que me escribe i, j y i más j, i por j, ¿vale? 00:42:39
Entonces, i vale 1, este es el resultado, ¿vale? 1, j vale 1, y 1 por 1, 1. 00:42:47
He acabado el suelo interno 00:43:03
Por lo tanto 00:43:07
Actualizo 00:43:08
Uno más uno 00:43:13
Dos 00:43:15
Vuelvo aquí y me pregunto 00:43:17
¿Dos es menor o igual que dos? 00:43:20
Sí 00:43:22
Por lo tanto entro otra vez aquí dentro 00:43:23
Y escribo I 00:43:26
Uno 00:43:27
Y es uno 00:43:32
¿Cuánto vale j? 2. ¿Y 2 por 1? 2. Llego al final, actualizo j. Por lo tanto, j se transforma en 3. 00:43:36
Y me pregunto, ¿3 es menor o igual que 2? No. Por lo tanto, salgo del bloque rojo. Llego aquí y vuelvo 00:43:52
arriba donde actualizó y entonces y ahora se transforma en 00:44:04
2 teniendo en cuenta que al salir de este for este j 00:44:12
está perdido ya no existe entonces actualizó y a dos me pregunto 00:44:19
dos es menor o igual que dos si entonces centro dentro y me dice hoy mira hay un 00:44:26
for, crea j, veo j, ¿cuánto vale j? 1. Y ahora llego aquí y dice, ¿cuánto vale i? 2. ¿Cuánto 00:44:31
vale j? 1. Y 2 por 1, 2. Llego al final aquí, vuelvo aquí y me dice, oye, actualiza j. Vale, 00:44:46
j se vuelve 2. 00:44:56
2 es menor o igual que 2. 00:44:58
Sí. Entro dentro 00:45:00
y digo, vale, muy bien. 00:45:02
Escribo estas cosas aquí. 00:45:05
Entonces me sale, i es 2, 00:45:06
j es 2, 00:45:09
y 2 por 2 es 4. 00:45:11
Bien. 00:45:13
Ahora llego aquí y actualizo 00:45:14
j. j se transforma 00:45:16
en 3. 3 es menor o igual 00:45:18
que 2. No. 00:45:20
Por lo tanto salgo del bloque rojo 00:45:22
y j desaparece. 00:45:24
porque estoy fuera de su ámbito 00:45:26
ya no existe 00:45:28
vuelvo aquí arriba y actualizo 00:45:30
i, vale 3i 00:45:32
y me pregunto, 3 00:45:37
es menor o igual que 2 00:45:39
no, por lo tanto salgo 00:45:41
también de este bloque y ya no 00:45:43
existe y esto es lo que 00:45:45
he escrito en pantalla 00:45:46
esta parte divertida 00:45:48
la variable existe 00:46:03
por favor chicos, que lo vamos a preguntar 00:46:12
7000 veces, la variable existe 00:46:14
solo en su ámbito 00:46:16
en su ámbito, vale 00:46:17
entonces cuando yo entro en este for y creo 00:46:20
j, j existe 00:46:22
mientras que esté en este bloque 00:46:24
en este bloque aquí 00:46:25
si, en el momento 00:46:27
en que salgo de este bloque 00:46:30
esa variable 00:46:31
se destruye, ya no existe 00:46:33
ya, yo podría 00:46:35
declarar aquí otra variable j 00:46:37
que ya no existe, ahora si vuelvo 00:46:39
a entrar allí dentro, declaro 00:46:41
otra variable j, pero no es 00:46:43
la anterior, es nueva, es otro bloque de memoria 00:46:45
con dentro el valor que me metí 00:46:47
aquí 00:46:49
si yo quisiera 00:46:50
que persistiera 00:46:53
la declaración la debería hacer fuera 00:46:54
y entonces j existe 00:46:57
No sé si me explico de qué. 00:46:59
¿Dudas? 00:47:06
Súper fácil. 00:47:07
Hacemos algún ejercicio de prueba. 00:47:08
¡Venga! 00:47:11
¿Se puede hacer un sistema de planchac con esto ya? 00:47:12
Sí, es ilegal hacerlo en la escuela. 00:47:27
vamos a hacer 00:47:30
a ver 00:47:37
es posible que 00:47:37
alguno de estos ejercicios 00:47:38
que haga ahora 00:47:40
sean ejercicios 00:47:40
que luego os mando 00:47:41
para casa 00:47:42
¿vale? 00:47:43
porque no me da la vida 00:47:43
de recordarme 00:47:45
cuáles están 00:47:47
en la 00:47:47
en los enunciados 00:47:48
¿vale? 00:47:49
entonces 00:47:51
no, no 00:47:51
si estos vienen 00:47:53
de mil años 00:47:54
hace mil años 00:47:54
pero son siempre los mismos 00:47:55
porque son 00:47:56
ejercicio 00:47:56
pido al usuario 00:47:58
10 números 00:48:01
y los sumo 00:48:03
¿sí? 00:48:04
¿cómo lo hago? 00:48:06
scanner, scan es igual a 00:48:09
new scanner 00:48:11
existen punto int 00:48:12
normalmente vosotros 00:48:14
habríais hecho antes 00:48:16
int 00:48:18
n1 es igual a 00:48:24
scan punto next int 00:48:26
¿sí? 00:48:28
y luego habríais hecho esto 00:48:31
Y dos, tres, cuatro, ¿si? Se entiende el sentido. 00:48:33
Y yo os digo, vale, entonces si es así, pues dame cien números. 00:48:43
Y vosotros, porque sois trabajadores, uno, dos, ene, uno, ene, dos, ene, tres, ene, cuatro, ene, cinco, hasta ene, cien. 00:48:46
Dame diez mil números. 00:48:52
Llega un momento en que esto no se puede hacer. 00:48:54
¿Cómo se hace? 00:48:56
Pues int o final, int, si usamos una cosa, números, adendos, ¿cómo se dice? 00:48:58
Números es igual a 10. Este es el número que voy a pedir. 00:49:10
Esto sería mayúsculo, num. 00:49:16
Entonces ahora en vez de pedirlo 10 veces, digo, follow int. 00:49:19
¿For o why? 00:49:28
¿Por qué for? 00:49:29
Porque sé que son este num. 00:49:32
¿Sí? 00:49:34
Entonces digo, for int i es igual a cero, i menor que num, i más más. 00:49:35
¿Cuántas veces lo hago esto? 00:49:45
¿Cuántas veces se ejecutará este ciclo? 00:49:52
¿cuántas veces repito 00:49:56
este bloque? 00:50:06
pongamos nomba 1 00:50:08
¿vale? 00:50:18
y es igual a 0, 0 es menor 00:50:20
que 1, una vez 00:50:22
1 es menor que 1 00:50:24
no, por lo tanto lo he ejecutado una vez 00:50:26
si pongo esta 3 00:50:30
Entra aquí 00:50:32
0 es menor que 3 00:50:34
Sí, una vez 00:50:36
Sumo 1 00:50:38
1 es menor que 3 00:50:39
Sí 00:50:40
2 es menor que 3 00:50:41
3 es menor que 3 00:50:43
¿Cuántas veces? 00:50:45
Entonces, ¿cuántas veces se ejecuta esto? 00:50:47
Y ahora 00:50:52
Y ahora 00:50:52
Entonces, ¿cuántas veces se ejecuta esto? 00:50:55
¿Cuántas veces son? 00:51:01
Nun veces 00:51:04
¿Vale? 00:51:05
No lo sé cuánto es NUM, pero éste se ejecuta NUM veces. 00:51:06
Podría hacer así. 00:51:15
¿Cuántas veces se ejecuta esto? 00:51:18
NUM veces. 00:51:21
¿Cuántas veces se ejecuta esto? 00:51:23
Menos uno NUM veces. 00:51:25
NUM veces menos uno. 00:51:29
NUM menos uno veces. 00:51:31
Dile como quieras. 00:51:33
¿Sí? ¿Está claro? 00:51:35
¿Dudas? 00:51:37
por razones prácticas 00:51:39
legadas o no sabréis 00:51:44
os aconsejo que hagáis así 00:51:45
¿vale? 00:51:47
¿y qué hago aquí? 00:51:49
leo un número 00:51:51
interresultado 00:51:52
por favor chicos 00:51:59
es igual a cero 00:52:00
y aquí te digo que resultado 00:52:03
más igual 00:52:05
Y podría poner, dame el siguiente número para sumar. 00:52:07
Y estamos a más y más uno, más, sobre, más uno. 00:52:37
¡Maravilla! 00:52:55
Empezamos. 00:52:59
Pues, trescientos cincuenta y cinco son muchos, ¿vale? 00:53:02
Vamos a meter un poquito menos. 00:53:05
Vamos, ¿eh? Cinco números. 00:53:07
¡Tazo! 00:53:10
me dice 00:53:10
dame el siguiente 00:53:12
número para sumar 1 de 5 00:53:14
¿vale? sumo 1 00:53:16
dame el 2 de 5 00:53:18
dame el 3 de 5, 1 00:53:21
4 de 5, 1 00:53:23
5 de 5, 1 00:53:25
o sea que resulta 5 00:53:26
obviamente funciona con cualquier número 00:53:28
yo hago 55 00:53:32
55 más 00:53:37
solo que así no tengo ni idea de si esto es correcto. Si le pongo todos unos, sí. Entonces, 00:53:39
vamos a mirar bien el código. ¿Qué hemos hecho? Hemos fijado un número, vale, ok. Hemos puesto un 00:53:52
resultado inicial a cero, vale, diciendo empiezo desde cero, pi por numvejes, lo que he hecho es 00:54:00
escribir, dame el siguiente número. Aquí he usado num, que es el número máximo sobre 5, ¿vale? Y este 00:54:10
de aquí le he puesto i más 1, porque esto va de 0 a num menos 1. Entonces le sumo 1. Si hubiese 00:54:19
ido así, de 1 a mayor o igual, pues entonces aquí le pongo i, porque el número será 1, 2, 3, 4, hasta el último. 00:54:26
Y lo que hago es 00:54:39
Resultado más igual scan.nexint 00:54:41
Esto es equivalente a poner 00:54:43
Resultado es igual a lo que hay en resultado 00:54:45
Más lo que lees de teclado 00:54:48
Como int 00:54:50
Esto es equivalente a poner 00:54:51
Resultado es igual 00:54:55
A resultado 00:54:57
Más scan.nexint 00:54:59
¿Lo tenéis? 00:55:02
¿Si? 00:55:14
La multiplicación 00:55:18
De los primeros 00:55:20
cinco números que te pongo por teclado, lo mismo pero es con multiplicación. Dame cinco 00:55:21
números y te lo multiplico entre ellos. ¿Cómo se hace? ¿Quién lo sabe hacer? Levante la 00:55:33
mano. Veo una mano, pero no veo quién es. Venga, Samir, venga. 00:55:45
esto 00:55:54
esta parte de aquí 00:56:02
vale 00:56:08
tú escribes esto 00:56:09
dame el siguiente número para sumar 00:56:11
ya está 00:56:16
y funcionaría, ¿no? 00:56:17
dice 1, 1, 1, 1, 1 00:56:20
pero no sé cuántos 00:56:22
tengo que poner 00:56:24
porque no me lo está diciendo aquí vale y entonces yo me he inventado y digo mira de 00:56:25
en cada vez que me pide un número me diga a qué punto del algoritmo soy el punto del algoritmo 00:56:33
que soy me lo dice y porque la primera vez valdrá 1 la segunda vez vale 2 la tercera vez vale 3 00:56:40
Entonces le sumo detrás y esto me daría, me pega, lo que hace es, uno, si yo le pongo un número, 00:56:47
me dice dos, si yo le pongo un número, tres, cuatro, cinco. Esto me está diciendo que cada 00:57:03
vez es un ciclo distinto pero no me dice cuántos son en total está diciendo este 00:57:12
es el primero de 7 el primero de 95 todavía no lo sé entonces yo le pegó 00:57:18
detrás de si uno de y cuánto cuántos son todos 00:57:23
esto me pondrá a sumar 1 de 5 2 de 5 3 de 5 entonces ahora lo tengo así 1 de 5 con vuelta 00:57:33
aquí 2 de 5 3 de 5 4 de 5 y el último sí make sense más dudas entonces ejercicio para vosotros 00:57:49
quiero hacer lo mismo pero en vez de sumar, multiplicando. ¿Qué hago? La i de final 00:58:02
deformo cambiando. ¿Qué? Esta i, esta i. 00:58:15
Cambiar los dos signos que hay de la i final, de esa misma línea, a la de num, punto y coma, i, no, arriba, línea 11, 00:58:22
N, NUM, punto y coma, esa que está ahí, cambias los más más por asterisco, asterisco, ¿no? 00:58:35
No, porque esto siempre lo tengo que hacer cinco veces, esto no cambia. 00:58:43
Solo que lo que hago es que en vez de sumar los números que leo, los multiplico. 00:58:50
Justo. Entonces, ¿qué hago? 00:58:55
Es cambiar el más de resultados, más de cal, next, fin, en vez de más, eso. 00:58:57
¿Lo lanzo? ¿Funciona? 00:59:01
¿Quién dice que funciona sin hablar? 00:59:04
¿No podéis hablar? 00:59:07
¿Quién dice que funciona? 00:59:08
¿Quién dice que no sabe las reglas 00:59:12
más básicas de la multiplicación 00:59:14
y que multiplicar por cero da siempre cero? 00:59:16
¿Y quién dice que como resultado 00:59:21
de cero al principio, por lo tanto 00:59:23
esto me dará siempre cero? 00:59:25
Cuidado, señores, ¿eh? 00:59:30
Es verdad, multiplicar multiplicar. 00:59:31
No, porque cero yo no lo he dado nunca. 00:59:35
Yo cero no lo he dado nunca, pero no me da resultado cero. 00:59:40
Cuando multiplica, no, porque no es mi ejercicio. 00:59:43
Yo le doy uno por uno por uno por uno por uno. 00:59:47
¿Cuánto debería dar? 00:59:50
Uno, me da cero. 00:59:52
Cuidado con estas cosillas, ¿vale? 00:59:55
Es verdad, el profe me da un ejercicio fácil, 00:59:57
ah, sí, solo tengo que poner el más el peor de aquí. 00:59:59
No, pensadlo. 01:00:02
Si el resultado empieza con 0 en la multiplicación, cuando hago esta cosa de aquí, 01:00:05
será siempre 0 independientemente del número que pongo. 01:00:11
Entonces si quiero que esto funcione, le pongo el neutro de la multiplicación, el neutro de la suma. 01:00:15
Ahora ya, 2 por 2 por 2 por 2 por 2, 32. 01:00:26
Se sabe que hay que cambiar el 0. 01:00:32
Este 0, pero cuidado, que si ahora vuelvo a la suma, 01:00:35
esto no funciona 01:00:38
¿sí? 01:00:40
porque si yo doy 01:00:43
cinco veces 01:00:44
uno más uno más uno más uno más uno 01:00:46
me dice seis 01:00:48
cuidado con lo que hacéis 01:00:48
¿sí? 01:00:51
si es con la suma aquí va cero 01:00:53
si es con la multiplicación aquí va uno 01:00:55
¿sí? 01:00:57
vale 01:01:02
entonces 01:01:02
dame 01:01:03
un número 01:01:07
nueve 01:01:08
y yo te sumo nueve números. 01:01:11
Dame tres 01:01:17
y yo te sumo tres números. 01:01:17
Dame cincuenta y ocho 01:01:19
y yo te sumo cincuenta y ocho números. 01:01:20
¿Qué cambio? 01:01:23
Lo quito. 01:01:31
¿Qué hago? 01:01:32
Refactor, 01:01:40
rename 01:01:41
y lo llamo end. 01:01:42
Vale, perfecto. 01:01:44
¿Y ahora qué hago? 01:01:47
Hola, en vez de hablar entre vosotros 01:01:51
podéis hacerme caso. 01:01:53
¿Cuántos números quieres sumar? 01:01:55
Entonces me dice, ¿cuántos números quieres sumar? 01:02:19
Siete. 01:02:26
Y me dice, dame el uno de siete. 01:02:28
Bueno, vamos con uno. 01:02:32
2 de 7, 3 de 7, 4 de 7, 5 de 7, 6 de 7, 7 de 7 01:02:33
que guapo 01:02:38
gracias 01:02:40
gracias 01:02:42
entonces ahora 01:02:50
yo ya no estoy solucionando 01:02:53
un problema 01:02:56
mas estoy solucionando una clase de problemas 01:02:57
aquí no hago la suma de cinco números 01:03:00
aquí hago la suma de una serie de números 01:03:04
de una serie larga N de números 01:03:07
esto, la potencia de los problemitas que puedo solucionar 01:03:12
acaba de explotar 01:03:18
puedo hacer problemas mucho más complejos que antes 01:03:20
¿dudas? 01:03:25
Vale 01:03:30
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
24 de octubre de 2025 - 14:24
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 03′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
533.92 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid