Saltar navegación

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

Clase 31-10-23 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 31 de octubre de 2023 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues nos quedamos con este antes de irnos. 00:00:00
Entonces, a ver, la pregunta de siempre. 00:00:05
¿Quién lo ha hecho completo sin copiarlo y sin de otro? 00:00:11
Levantadla más, que no veo. 00:00:18
Hablo del 11. 00:00:24
No, perdón, hablo de este, de este. 00:00:26
El 10. 00:00:30
De este 10 hablo. 00:00:34
Vale. 00:00:47
Bueno, y quien no lo ha hecho, ¿por qué no lo ha hecho? 00:00:50
¿Por qué no lo ha intentado? 00:00:55
No es para poner nota, es para saber. 00:00:57
¿Por qué no lo ha intentado quién? 00:00:59
¿Por qué no lo ha intentado uno? 00:01:04
¿Por qué lo ha intentado y no le ha salido? 00:01:07
¿Por qué lo ha intentado más de tres horas y no le ha salido? 00:01:11
Siendo sincero, ¿sí? 00:01:18
¿Tú lo has intentado más de tres horas y no le ha salido? 00:01:21
Bueno, a ver, vamos a ver. 00:01:27
Pues venga, este ejercicio. 00:01:33
Ejercicio 10. 00:01:40
A ver, primero se le ha enunciado y se intenta entender lo que dice. 00:01:48
Leer de forma repetida un número N significa, vamos a leer un montón de veces un número, cada vez uno diferente, claro. 00:01:58
Introduzca número, tal, introduzca número, tal, introduzca número, tal. 00:02:07
Ahí ya, según leemos eso, ya empezamos a visualizar mentalmente que nuestro programa va a tener un bucle 00:02:12
que va a estar ahí pidiendo número, leyéndolo, pidiendo número, leyéndolo. 00:02:19
Ya lo empezamos a visualizar. 00:02:23
Y luego nos dice, ¿y qué hacemos con cada número N? 00:02:26
Pues con cada número N tienes que hacer bla, bla, bla. 00:02:29
Vale, pues ya haremos ese bla, bla, bla. 00:02:32
Pero ya la primera plantilla de mi programa ya la tengo hecha. 00:02:35
Programa que lea de forma repetida un número N y con ese número N haga bla, bla, bla. 00:02:39
Bueno, pues ya resolveremos ese bla, bla, bla. 00:02:44
Pero mi programa ya viene a hacer esto. 00:02:46
Vale, pues de forma repetida tenemos que leer un número N. 00:03:09
De forma repetida significa hacerlo varias veces. 00:03:12
Eso significa que voy a tener un bucle. 00:03:15
Bueno, pues un montón de veces, un montón de veces, no sé cuántas, eso dependerá de la condición que yo ponga aquí, 00:03:17
un montón de veces tendré que hacer. 00:03:24
Introduzca número. 00:03:26
Y leyéndolo. 00:03:32
Como vamos a leer, pues copiamos un escáner por ahí. 00:03:33
¿Dónde tengo el escáner? ¿No tengo ningún escáner por ahí puesto? 00:03:40
Ah, coño, está ahí. Vale. 00:03:45
Introduzca número. 00:03:53
Venga, int N igual a scan punto next int. 00:03:55
Vale, ya tenemos bastante hecho en realidad el programa. 00:04:00
Tenemos lo más importante, que es que ya le he dado una primera plantilla, una primera arquitectura, 00:04:05
que es voy a hacer muchas veces algo. 00:04:10
Pues venga, voy a hacer un montón de veces algo. 00:04:13
Ese algo que es leer número. 00:04:17
Vale, eso está muy claro, leer número. 00:04:19
Y luego me dice, con ese número leído tienes que bla, bla, bla. 00:04:21
Pues vamos a ver qué es todo eso. 00:04:26
Pues todo eso es, con ese número leído tienes que mostrar el resultado de hacer la suma 1 más 2 más 3 más N. 00:04:28
Bueno, pues eso es lo que tenemos que plantearnos aquí. 00:04:36
Ahora nos falta ese trabajo. 00:04:40
Ahora, aquí dentro, aquí dentro, dentro de ese bucle, 00:04:45
pues nos falta hacer ese trabajo que me han dicho. 00:04:52
Ahora tenemos que coger aquí, tenemos que calcular la suma 1 más 2 más N. 00:04:54
Eso es lo que nos toca hacer ahora. 00:05:10
Calcular esa suma aquí dentro. 00:05:13
Vale, estamos dentro del bucle porque eso lo tenemos que hacer muchas veces. 00:05:16
Vale, estamos dentro del bucle, está claro. 00:05:20
Bueno, ahora tenemos otro subproblema. 00:05:22
Estos son subproblemas, son subproblemas independientes. 00:05:24
Uno de ellos era la plantilla general, que es hacer varias veces leer número, lo que sea, leer número, lo que sea. 00:05:27
Ahora aquí yo tengo ya otra caja negra, independiente de la anterior. 00:05:35
Vale, ¿cómo resuelvo, dado este número N, hacer esta suma? 00:05:40
Esto lo hemos hecho ya, eso lo vamos a hacerlo. 00:05:44
Un bucle que va haciendo una suma acumulativa. 00:05:47
Esto es una suma acumulativa, eso ya lo sabemos hacer, lo hemos hecho muchas veces. 00:05:50
Pues eso que ya sé hacer, lo tengo que hacer ahí. 00:05:53
Eso que ya sé hacer, lo tengo que hacer ahí en medio, porque es lo que tengo que hacer ahí. 00:05:56
Me da igual que esté dentro de un bucle, que esté donde esté, lo tengo que hacer en ese punto. 00:06:00
Pues nada, esta suma, es una suma acumulativa, la hemos hecho un montón de veces, ya sabemos resolverlo. 00:06:04
Pues una variable suma, que empieza valiendo 0. 00:06:09
Mientras yo no haya terminado la suma, a esta variable suma, le sumo el sumando que toque. 00:06:14
Estos sumandos, ¿cuáles van a ser? 00:06:25
Pues empiezan valiendo 1 y se van incrementando. 00:06:28
Vale, pues los sumandos los genero, entonces por ejemplo así. 00:06:31
Pues el sumando empieza valiendo 1 y lo voy dejando incrementado. 00:06:35
¡Hala, estupendo! 00:06:40
Pues ya está, esto es lo que hemos hecho ya un montón de veces. 00:06:42
Una suma acumulativa, una variable que empieza siendo 0, suma más iguales a su... 00:06:45
¿Es la expresión que hemos usado siempre? 00:06:54
Suma más sumando, hemos dicho muchas veces que esto... 00:07:00
Pero es lo mismo que abajo, continuamente lo hemos dicho. 00:07:04
Bueno, a ver, me da igual el más más hacerlo antes que después. 00:07:08
Pero vamos, que esto es igual que esto lo hemos dicho todo el curso, 00:07:14
cuando hemos visto el operador, esto y esto es lo mismo, 00:07:18
que lo hemos dicho continuamente. 00:07:21
Vale, hemos dicho, así se ve más claro, pero con este operador se compacta 00:07:24
y es como os lo vais a encontrar normalmente, ya lo explicamos cuando vimos este operador 00:07:28
y cada vez que sale decimos eso, que hay dos formas de ponerlo. 00:07:32
Vale, eso. 00:07:38
Vale, entonces la forma en la que lo vais a encontrar es la de abajo, 00:07:40
pero es que por eso os decía que cuanto antes ya os familiaricéis con que las dos cosas son iguales, 00:07:45
con lo que significa este operador, tenéis que estar familiarizados, 00:07:50
desde el momento en que lo vimos, hace un montón de tiempo, 00:07:54
pues ahí es cuando uno se iba a casa y decía, a ver, a ver, que acabe de entenderlo, 00:07:57
me lo repito mil veces hasta que... 00:08:01
Bueno, pues entonces, la suma acumulativa, que la hemos hecho mil veces también, es esto, 00:08:04
una variable que empieza valiendo cero, y en un bucle lo voy metiendo sumandos. 00:08:08
Ahora ya, estos sumandos, ¿cuáles van a ser? 00:08:12
Pues ya pienso en mi suma en particular, mi suma en particular es la suma uno, dos, 00:08:15
los sumandos van a ser primero uno y luego dos. 00:08:19
Pues ¿cómo lo genero? Esta suma en concreto ya la hemos hecho, 00:08:22
pues los genero con una variable que empieza siendo uno 00:08:25
y la voy incrementando, por ejemplo, o puede empezar siendo cero, 00:08:30
pero sabes que entonces la primera iteración del bucle no te sirve para nada, 00:08:35
porque suma igual a suma más cero, es una iteración que haces de más, 00:08:38
pero que no te molesta, porque sumar a una variable cero no la estropea, 00:08:42
la deja igual. 00:08:47
Lo puedes empezar a cero, pero entonces el bucle se ejecuta una vez más 00:08:48
y es una vez más que le estás sumando un cero que no le... 00:08:52
Pero vamos, no es que estuviera mal, es que es una iteración que no te hace falta. 00:08:55
Entonces empiezas sumando uno y entonces suma más igual sumando, 00:09:00
cada iteración le sumas el numerito que toca y sumando, 00:09:07
después de hacer la suma hay que incrementarlo. 00:09:10
Entonces lo de siempre podríamos hacer aquí sumando más más 00:09:13
o sumando igual a sumando más uno, todo esto de nuevo lo tienes que hacer de memoria. 00:09:16
¿O para qué voy a escribir otra línea? 00:09:20
Si puedo directamente poner un posincremento en una misma expresión, 00:09:24
que también esto lo hemos hecho y lo tenéis que tener ya en la cabeza 00:09:28
memorizado y grabado todas las veces que lo hemos hecho. 00:09:31
¿Para qué? 00:09:33
Lo pongo ahí y ya sé cómo funciona esto. 00:09:34
Que es que primero hago la expresión y luego cuando ya he terminado 00:09:36
a la variable a la que esté afectando el posincremento la incremento. 00:09:41
Así funcionaba esto, ¿no? 00:09:45
Bueno, pues ya tengo hecha gran parte de la suma acumulativa. 00:09:49
Efectivamente a esta variable suma se le va sumando uno, dos, tres, así hasta n. 00:09:52
Claro, pero me falta, oye, ¿cuándo acabo yo de sumar? 00:09:56
Pues ya tengo que pensar en mi situación. 00:09:59
¿Cuándo acabo yo de sumar? 00:10:01
¿Cuándo? 00:10:03
¿Qué pongo aquí? 00:10:04
Para que este bucle ya no entre más. 00:10:05
Mientras sea menor o igual, ¿quién? 00:10:10
¿Qué número? 00:10:15
Sumando menor o igual que n, ¿vale? 00:10:18
Esa sería efectivamente la condición. 00:10:20
Mientras sumando sea menor o igual que n, me interesa seguir sumando. 00:10:25
¿Vale? Pues ya está. 00:10:31
Ya he completado esa caja negra que tenía aquí dentro 00:10:33
que me tocaba a mí hacer ahora. 00:10:36
Entonces, claro, este programa resulta en un bucle dentro de otro, 00:10:39
pero ¿qué más da? 00:10:42
¿Qué más da? 00:10:44
¿Vale? Un bucle ya sabemos que es un conjunto de sentencias que se repiten. 00:10:46
Y esas sentencias que se repiten pueden ser a su vez más bucles. 00:10:50
Y ese bucle a su vez tendrá dentro un conjunto de sentencias que se repiten. 00:10:53
Que a su vez podrá ser bucles, depende de lo que me toque hacer. 00:10:56
Pues aquí me ha tocado hacer esto. 00:10:59
Con este número me ha tocado hacer la suma. 00:11:01
Y como me ha tocado hacer la suma, pues he tenido que plantar esto. 00:11:04
¿Vale? Pero todo lo sabemos hacer. 00:11:07
Lo único que tenemos que hacer es 00:11:09
construirlo para que el resultado final sea el que buscamos. 00:11:12
¿Vale? Entonces, gran parte del programa está hecho. 00:11:15
Un montón de veces, leemos número, calculamos suma. 00:11:18
Leemos número, calculamos suma. 00:11:22
Pero nos faltan cosas aquí por perfilar, como cuántas veces estoy, qué hago. 00:11:24
Bueno, el enunciado, ¿qué nos dice? 00:11:28
El enunciado nos dice que muestra la suma. 00:11:32
Nos la he mostrado. 00:11:34
Bueno, pues... 00:11:36
Por ejemplo, como solo tiene el bucle while aquí, solo tiene una sentencia. 00:11:38
Le puedo quitar la llave, por ejemplo. 00:11:44
Le quito la llave porque solo tiene una sentencia. 00:11:46
¿Vale? 00:11:51
Ahora dice, calcule y muestre. 00:11:52
Bueno, me falta mostrarla. 00:11:54
Claro, y aquí tendría que poner. 00:11:56
La suma de... 00:11:59
Uno más dos, más... 00:12:02
N es... 00:12:07
Y le pongo ahora aquí, pues suma. 00:12:12
¡Hala, ya está! 00:12:16
Para que se vea. 00:12:17
¿Vale? Pues ya he mostrado la suma. 00:12:19
Y luego aquí me falta lo de... 00:12:23
Vale, pero ¿esto se está ejecutando cuándo? ¿Hasta el infinito? 00:12:25
¿Cuántas veces está el programa pidiéndome un número? 00:12:27
Esa información me la tiene que haber dado el enunciado. 00:12:30
Pues a ver qué me dice el enunciado al respecto. 00:12:33
A ver, yo aquí estoy haciendo una cosa mal por rapidez, 00:12:36
que es como ir, según voy resolviendo, 00:12:38
voy mirando el enunciado. 00:12:42
No. 00:12:44
Antes de empezar a pensar, 00:12:45
un enunciado tiene que haber leído una y mil veces 00:12:47
y tener muy claro lo que tiene que hacer. 00:12:49
Y luego ya se hace este proceso que digo yo, 00:12:51
que es decir, vale, esto es algo que se hace muchas veces. 00:12:54
¡Plan! Un bucle. 00:12:56
¿Qué se hace muchas veces? Esto. 00:12:57
¿Esto cómo lo hago? 00:12:59
De esta manera, que a su vez es otro bucle. 00:13:00
Pues venga. 00:13:02
Yo estoy sobre la marcha mirando el enunciado 00:13:03
por un tema de rapidez. 00:13:05
Pero en condiciones normales, 00:13:09
uno tiene que tener muy claro lo que hace 00:13:11
antes de empezar a plantear el programa. 00:13:13
Porque si es una cosa larga, 00:13:15
pues luego le puede ser complicado 00:13:17
el irla retocando. 00:13:19
Vale, pues aquí ya me da la información 00:13:22
sobre lo que me faltaba a mí, que es 00:13:24
¿me estoy hasta el infinito? 00:13:26
Me dice no. 00:13:28
Cada vez que muestra el resultado del programa, 00:13:29
le dice si desea continuar o no. 00:13:31
Y el bucle 00:13:33
se volverá a ejecutar 00:13:36
se volverá a ejecutar 00:13:38
si se introduce una S 00:13:40
y en cualquier otro caso no. 00:13:42
Vale, pues entonces, 00:13:44
eso lo podemos hacer, efectivamente, 00:13:46
la condición puede ser en función de 00:13:48
una cadena que yo leo. 00:13:50
Si la cadena es S, 00:13:52
pues entonces 00:13:55
vuelvo a entrar y si no, no. 00:13:57
Vale, pues podemos 00:13:59
preguntarle ya aquí. 00:14:01
¿Desea continuar? 00:14:04
Y le damos esta información, 00:14:10
bueno, para que sepa lo que escribir. 00:14:12
Ahora, el dato 00:14:16
S, N, 00:14:18
como es una cadena de texto, 00:14:20
aunque solo tenga un carácter, 00:14:22
lo podemos tratar como cadena de texto. 00:14:24
Es una cadena de texto con un carácter. 00:14:26
Lo podemos guardar en un string, 00:14:28
para no complicarnos la vida. 00:14:30
Lo guardamos en un string. 00:14:32
Vale. 00:14:42
Pues entonces, ahora ya, 00:14:44
en función de esta opción, 00:14:46
aquí arriba, 00:14:48
podemos definir la condición. 00:14:50
Vale, entonces, 00:14:53
primera cosa que se me plantea aquí, 00:14:55
yo voy a tener aquí que trabajar 00:14:57
con si opción diferente de N, 00:14:59
de opción igual a S. 00:15:01
Cuidado, entonces, la primera cosa 00:15:03
que ya voy a tener que modificar antes que nada, 00:15:05
es el qué. 00:15:07
¿No? Porque si yo hago aquí, 00:15:09
venga, mientras opción 00:15:11
sea 00:15:13
igual a S, por ejemplo. 00:15:15
Opción es un string. 00:15:17
Como dijimos el otro día, que comparábamos 00:15:19
la igualdad de un string y otro. 00:15:21
No con el doble igual. 00:15:24
¿Que eso puede funcionar o no? 00:15:28
Así lo comparábamos, ¿verdad? 00:15:30
Si opción es igual a S, 00:15:34
entonces, 00:15:36
entro otra vez. 00:15:38
Y le vuelvo a preguntar. 00:15:40
Vuelvo arriba. Opción es igual a S. 00:15:42
Como podíamos prever, 00:15:44
aquí en orden de compilación, 00:15:46
se me pone rojo. ¿Por qué? 00:15:48
Se me pone rojo ahí. 00:15:51
¿Perdón? 00:15:53
Claro, porque 00:15:57
está declarado aquí dentro. 00:15:59
Entonces, cuando el programa llega 00:16:01
por aquí, opción todavía ni existe 00:16:03
ni está declarado. 00:16:05
Entonces digo, ah, no, cuidado, lo leo aquí. 00:16:07
Lo leo aquí. Pero hombre, 00:16:09
tengo que declararlo antes de su primer uso. 00:16:11
Y si su primer uso está 00:16:13
aquí, acordémonos de que 00:16:15
tenemos que declarar antes de su primer 00:16:17
uso. 00:16:19
Vale, ya lo he declarado desde su primer uso. 00:16:23
Aunque luego lo leo aquí. 00:16:25
Vale, se me sigue poniendo en rojo. 00:16:27
¿Por qué se me sigue 00:16:29
poniendo en rojo? 00:16:31
¿Perdón? 00:16:35
Pero con que no puede resolver, ¿a qué te refieres exactamente? 00:16:37
Eso sí, que no tiene valor. 00:16:41
Que no tiene un valor. Que opción no tiene valor. 00:16:43
Entonces, la primera vez, en la primera vez 00:16:45
que entramos, 00:16:47
opción no tiene ningún valor todavía. 00:16:49
Entonces esto lo podemos resolver de muchas maneras. 00:16:51
Podemos darle un valor 00:16:53
a opción cualquiera para forzar que 00:16:55
entre por primera vez. Esa podría ser 00:16:57
una opción, ¿no? Le damos un valor cualquiera 00:16:59
para forzarle que entre. 00:17:01
Que sería este. 00:17:03
Entonces, si yo a opción 00:17:05
le asigno 00:17:07
la cadena de caracteres ese, 00:17:09
entra ya una primera vez, porque esta condición 00:17:11
opción igual a ese será true. 00:17:13
Entra una primera vez. 00:17:15
Hace lo que me han pedido y pregunta. 00:17:17
¿Que vuelve a meter sí? 00:17:19
Entra una segunda vez. 00:17:21
Hace lo que tenga que hacer 00:17:23
y pregunta. ¿Que ahora ha metido 00:17:25
otra cosa que no es la ese? 00:17:27
¿Que otra cosa que no es la ese? 00:17:29
Cuando evalúe esta condición, ya será falsa. 00:17:31
Entonces saldrá por aquí. 00:17:33
¿Vale? 00:17:35
Y se despedirá y adiós. 00:17:37
¿Vale? 00:17:39
Bueno, pues así tendríamos ya un apaño de programa 00:17:41
perfectamente hecho. 00:17:43
¿Vale? 00:18:13
Una misma cosa se puede hacer de muchas maneras. 00:18:21
Lo que importa es que esté claro 00:18:23
lo que se está haciendo 00:18:25
y que esté bien hecho, claro. 00:18:27
¿Vale? Entonces, 00:18:29
nosotros con nuestro planteamiento hemos llegado a esta solución. 00:18:31
¿Vale? 00:18:33
Se puede hacer de muchas maneras diferentes, 00:18:35
siempre y cuando el resultado final sea el mismo. 00:18:37
Aquí, por ejemplo, 00:18:39
cuando uno ha apañado ya el tema de la condición 00:18:41
y ha dicho 00:18:43
uy, mientras la primera vez 00:18:45
yo quiero entrar sí o sí, 00:18:47
como la primera vez quiero entrar sí o sí, 00:18:49
hemos tenido que hacer el apaño 00:18:51
de poner esto a ese. 00:18:53
Eso ya nos pasó en un ejercicio anterior. 00:18:55
Y dijimos, hombre, a ver, si yo estoy haciendo 00:18:57
un bucle en el cual la primera vez quiero entrar sí o sí, 00:18:59
¿no sería mejor plantearlo 00:19:03
con otra sintaxis? ¿Como cuál? 00:19:05
Con el bucle Duhail. 00:19:07
¿Verdad? Porque el bucle Duhail 00:19:09
es un bucle en el cual 00:19:11
la primera vez entra seguro 00:19:13
y luego ya evalúa condición 00:19:17
y ya la siguiente depende de la condición. 00:19:19
Entonces, estoy en esa situación. 00:19:21
Estoy en una situación en la cual la primera vez 00:19:23
quiero que se haga sí o sí. 00:19:25
Me da igual lo que diga esta condición. 00:19:27
Entonces, como quiero que se haga sí o sí, 00:19:29
quedaría más bonito esto, 00:19:33
quedaría más bonito si le pongo un Duhail, 00:19:35
porque el código ya sabe 00:19:37
que la primera vez se va a hacer sí o sí 00:19:39
y inicializar la condición 00:19:41
no le va a hacer ninguna falta, le va a dar igual, etc. 00:19:43
Un segundito. 00:19:45
Entonces, si yo hiciera el cambio al Duhail, 00:19:47
pues esto simplemente, 00:19:49
vamos a suponer que 00:19:55
lo pusiéramos aquí abajo. 00:19:59
Pues entonces, 00:20:01
con el Duhail, 00:20:05
la condición se va aquí abajo. 00:20:07
Terminada con punto y coma. 00:20:11
Y aquí lo que se pone es el 00:20:13
Duh. 00:20:15
Entonces, con el Duhail, 00:20:17
¿esto cómo funciona? 00:20:21
Entra una primera vez, 00:20:23
con lo cual no necesita que opción 00:20:25
esté inicializado, no le hace ninguna falta. 00:20:27
Opción, 00:20:29
podría yo quitar esto perfectamente, 00:20:31
si es que adopto esa opción de abajo. 00:20:33
Opción ya, no le hace falta ningún tipo de 00:20:39
inicialización, porque esa inicialización era una trampa 00:20:41
para forzar entrar 00:20:43
una primera vez en este while. 00:20:45
Pero si yo hago un Duhail, 00:20:47
opción ya, 00:20:49
no la inicializo pero no me hace ninguna falta. 00:20:51
Y entonces este bucle, entra una primera vez, 00:20:53
esa forzosa, 00:20:55
y ahora ya pregunta. 00:20:57
Y ya las siguientes, 00:20:59
¿que entra una segunda? Depende de opción. 00:21:01
Entra una segunda, hace lo que sea. 00:21:03
¿Entra una tercera? 00:21:05
¿Perdona? 00:21:07
Si, 00:21:09
si pruebo, ¿qué me va a ocurrir? 00:21:11
Lo que me ocurrió el otro día, ¿verdad? 00:21:13
Y dijimos que lo íbamos a arreglar. 00:21:15
A lo mejor es que ya se había ido. 00:21:17
¿Puede ser eso? 00:21:19
Vale. 00:21:21
En cualquier caso, se quedaría grabado. 00:21:23
A ver, que alguien me diga, 00:21:25
si yo pruebo esto, ¿qué me va a ocurrir? 00:21:27
Me va a fallar, 00:21:29
me va a encontrar algo raro en la prueba. 00:21:31
Si yo pruebo este ejercicio, o la versión de arriba, 00:21:35
me da igual. 00:21:37
Sí, claro, ¿pero por qué? 00:21:39
¿Por qué? 00:21:41
Porque ya nos pasó el otro día, 00:21:43
o bueno, ya nos había pasado antes y lo habíamos solucionado 00:21:45
ya todas las veces que nos había pasado. 00:21:47
Que alguien me lo diga. 00:21:49
Eso sí. 00:21:51
¿Vale? 00:21:53
Que hemos repetido unas cuantas veces, 00:21:55
entre ellas el último día. 00:21:57
Y de hecho, lo he dicho 00:21:59
al principio de clase. 00:22:01
Al principio de clase, cuando estábamos repasando la anterior, 00:22:03
lo he vuelto a decir, al principio de la clase. 00:22:05
Que he vuelto a decir 00:22:07
al principio de la clase, 00:22:09
que si tú lees un número, 00:22:11
metes el salto de línea. 00:22:13
El salto de línea se queda en el buffer del teclado. 00:22:15
Y si luego haces un next line, 00:22:17
se queda, 00:22:19
¿vale? 00:22:21
Y lo dije otro día, 00:22:23
el viernes pasado, 00:22:25
y hoy al empezar la clase. 00:22:27
¿Vale? Entonces, 00:22:31
uno, pues si lo ejecuta y le pasa, 00:22:33
dice, ah, vale, vale, ya me acuerdo. 00:22:35
O a lo mejor lo puede prever desde ya, 00:22:37
y decir, ah, mira, estoy leyendo un número, 00:22:39
y luego un next line, cuidadín, 00:22:41
me voy a quitar después del número, 00:22:43
el este, 00:22:45
¿vale? 00:22:47
Me lo voy a quitar, 00:22:49
y ya preveo, prevengo, 00:22:51
ese problema. 00:22:53
Porque después de este número, ya me quita el salto de línea. 00:22:55
Y en el siguiente next line, 00:22:57
ya no va a haber problemas. 00:22:59
¿Vale? 00:23:01
Puedes usar otros métodos de escáner, 00:23:05
cambiar el token, usar un buffer R, 00:23:07
muchas cosas. Pero, 00:23:09
no quiero introduciros 00:23:11
objetos que no, 00:23:13
eh, 00:23:15
podéis entender cómo funcionan. 00:23:17
Bueno. 00:23:19
Entonces, si probáramos esto, ahora ya sí que 00:23:25
uno diría, venga, voy a hacer pruebas. 00:23:27
Y vamos a ver las pruebas, pues venga, 00:23:29
5, la suma 00:23:31
es 15, vale, bueno, suponemos 00:23:33
que es 15. ¿Desea continuar? 00:23:35
Sí. 6, 00:23:37
la suma es 21. ¿Desea continuar? 00:23:39
Sí, la suma es 78. 00:23:41
¿Desea continuar? No, salió. 00:23:43
Solo hemos hecho una prueba, 00:23:45
pero bueno, parece que funciona. 00:23:47
Uno haría pruebas con 00:23:49
isometro negativo, isometro no sé qué, 00:23:51
hace lo que yo quiero que haga, etcétera, etcétera. 00:23:53
¿Vale? 00:23:55
Bueno, pues os recuerdo la importancia 00:23:59
de estudiarse y aprenderse 00:24:01
todo lo que hemos visto, 00:24:03
todo, y repetirlo. 00:24:05
Repetirlo, ¿vale? 00:24:07
Bueno, lo estoy reiniciando aquí, 00:24:14
todo el rato, cada vez. 00:24:16
¿Que por qué no necesito? 00:24:18
Es que una vez acaba, vuelve arriba, 00:24:20
y al volver arriba vuelve a entrar aquí. 00:24:22
¿Cómo? 00:24:24
No te entiendo. 00:24:26
Una vez acabo por aquí, dices, 00:24:31
el while. Ya, pero es que vuelvo a entrar 00:24:33
y al volver a entrar los vuelvo a reiniciar. 00:24:35
Ahí. 00:24:37
Claro, claro, claro. 00:24:39
Si estuviera eso fuera del do while, 00:24:41
entonces sí que sería un problema, 00:24:43
pero es que está dentro. 00:24:45
Entonces se reinicia cada vez. 00:24:47
Si estuviera fuera, tendría que volverlos 00:24:49
a poner a cero y a uno, efectivamente. 00:24:51
Claro, lo que pasa es que lo tengo dentro. 00:24:53
Además es que me ha quedado dentro 00:24:57
directamente, porque es que es la forma 00:24:59
natural, porque cuando yo me he planteado 00:25:01
resolver este problema, 00:25:03
o sea, el problema de hacer la suma 00:25:05
y lo sumando, me ha llegado a mí 00:25:07
y lo he planteado cuando ya estaba aquí dentro. 00:25:09
Entonces, pues ahí dentro me declaro la variable 00:25:11
y lo hago todo. ¿Para qué la voy a declarar arriba? 00:25:13
Eso es un subproblema que está ahí acotadito 00:25:15
dentro de ese while. Ahí me lo guiso 00:25:17
y me lo como todo. 00:25:19
¿Vale? 00:25:21
Vale. 00:25:23
A ver. 00:25:27
El once. 00:25:31
Este lo habéis hecho. 00:25:33
Este ya es un programa de sacar cifras, 00:25:35
ya no particularizado 00:25:37
a que 00:25:39
el número tenga una cifra 00:25:41
o dos o tres, porque en su momento, 00:25:43
cuando veíamos las decisiones, el IF, 00:25:45
sí que hicimos ejercicios 00:25:47
de sacar las centenas o sacar las decenas, 00:25:49
pero claro, 00:25:51
ahí teníamos muy acotado 00:25:53
si el número era de tres cifras o de dos. 00:25:55
Entonces decíamos, hago dos veces 00:25:57
la división por diez y ya está. 00:25:59
Aquí no sé cuánta vez la tengo que hacer. 00:26:01
Aquí el número puede tener 00:26:03
una quinta cifra, puede tener tres, puede tener... 00:26:05
Entonces tengo que hacer divisiones por diez. 00:26:07
Está claro, porque sé que esa es la manera 00:26:09
de sacar cifras decimales, dividiendo por diez. 00:26:11
Pero tengo que hacerla 00:26:13
muchas veces y no sé cuántas en principio. 00:26:15
Luego tengo que meterlo en un bucle. 00:26:17
¿Vale? Entonces esa es la idea 00:26:19
de este ejercicio. Tendré que meter 00:26:21
en un bucle eso que hacíamos 00:26:23
de dividir entre diez, 00:26:25
que es el proceso que ya dijimos en su momento 00:26:27
de sacar cifras decimales. 00:26:29
Entonces... 00:26:31
... 00:26:35
... 00:26:37
... 00:26:39
Y ese proceso, ¿cuál era? 00:26:41
... 00:26:43
... 00:26:45
... 00:26:47
... 00:26:49
... 00:26:51
... 00:26:53
... 00:26:55
Bueno, pues entonces, 00:26:57
en el momento de hacer este ejercicio, 00:26:59
como de sacar cifras decimales, 00:27:01
uno, 00:27:03
lo primero que hace es 00:27:05
revisar ese procedimiento, a ver cómo era. 00:27:07
A ver si uno se acuerda de cómo era ese procedimiento 00:27:09
que dijimos en su momento. 00:27:13
Vale, entonces, si uno tiene un numerito cualquiera, 00:27:19
de cualquiera de las cifras, decíamos que era hacer 00:27:23
sucesivas divisiones por diez 00:27:25
e irnos quedando con el resto, ¿no? 00:27:27
Hacíamos una primera división por diez 00:27:29
del numerito. 00:27:31
Y esa división por diez 00:27:39
tiene su cociente, que es este, 00:27:41
y su resto, que es este. 00:27:43
Entonces, el resto, 00:27:49
el resto, 00:27:51
ya era la primera cifra decimal. 00:27:53
¿Y qué hacíamos con el cociente? 00:27:55
Otra vez lo mismo, 00:27:57
una segunda división por diez. 00:27:59
El cociente era 327. 00:28:01
Pues el cociente, ahora, 00:28:03
lo dividíamos entre diez 00:28:09
y el resto, 00:28:11
327, resto, diez. 00:28:13
Ese resto, 00:28:15
siete, ya tengo la segunda cifra decimal. 00:28:19
Una tercera vez, 00:28:21
vuelvo a hacer lo mismo, 00:28:23
que es una división y un resto. 00:28:25
Pero cada vez usando 00:28:27
el cociente anterior. 00:28:29
Luego habrá una variable cociente que se vaya 00:28:31
quedando pisada cada vez 00:28:33
con los sucesivos cocientes. 00:28:35
Aquí el cociente se ha quedado en treinta y dos. 00:28:37
Pues el nuevo cociente va a ser 00:28:39
treinta y dos entre diez 00:28:41
y el nuevo resto va a ser 00:28:43
treinta y dos por ciento diez. 00:28:45
El nuevo resto, dos. 00:28:47
A la siguiente cifra decimal. 00:28:49
Me falta una cuarta iteración. 00:28:51
Cuarta iteración. 00:28:53
El cociente de dividir, tres entre dos, 00:28:55
que era tres, 00:28:57
pues se vuelve a dividir entre diez. 00:28:59
Y el resto me da tres por ciento diez. 00:29:01
Vale. 00:29:03
El resto que me sale, tres. 00:29:05
La siguiente cifra decimal, ya las tengo todas. 00:29:07
Cuatro, siete, dos, tres. 00:29:09
Y este cociente ya queda cero. 00:29:11
Pues ya tengo el bucle perfilado. 00:29:15
Tengo que hacer un montón de veces. 00:29:17
Obtener una variable c 00:29:21
dividiendo el número entre diez. 00:29:23
Y luego cojo el resto 00:29:25
y ya tengo la primera cifra decimal. 00:29:27
Esa variable c la vuelvo a dividir entre diez. 00:29:29
Y el resto, 00:29:31
me quedo con su resto. 00:29:33
Esa misma variable c, 00:29:35
que se ha quedado pisada, la vuelvo a dividir entre diez. 00:29:37
Y me quedo con el resto. 00:29:39
Entonces ya tengo que hacer un montón de veces esto. 00:29:41
Un montón de veces esto. 00:29:43
Dos operaciones, un montón de veces. 00:29:45
Para que el bucle quede completo 00:29:47
tengo que decir, ¿hasta cuándo? 00:29:49
Pues hasta que esa variable c sea cero. 00:29:51
Porque cuando esa variable c es cero, 00:29:53
ya he terminado. 00:29:55
Ya no sigo dividiendo. 00:29:57
Pues tengo el bucle completo. 00:29:59
Lo que tengo que hacer dentro 00:30:01
y la condición de finalización. 00:30:05
Pues una vez ya entendido esto, 00:30:07
visualizado esto, 00:30:09
uno ya se pone a 00:30:11
programarlo y hacer sus pruebas 00:30:13
a ver cómo les sale. 00:30:15
¿Vale? 00:30:17
Vale. 00:30:21
Pues vamos a intentar programar esto. 00:30:23
Vale. 00:30:51
Pues esto era once. 00:30:55
A ver. 00:31:09
Ejercicio once. 00:31:13
Vale. 00:31:21
Yo aquí con el copia y pega 00:31:45
he debido hacer algo raro. 00:31:47
A ver. 00:31:49
Vale. Saque sus cifras. 00:31:57
Vale. Bueno, pues entonces 00:32:15
¿cómo programaríamos esto? 00:32:17
Vale, ya hemos visto qué necesitamos. 00:32:19
Primero vamos a leer el número. 00:32:21
Primero vamos a leer el número. 00:32:23
Número entero. 00:32:43
Vale. 00:32:47
Pues este número suponer que se ha leído aquí. 00:32:49
Vale. 00:32:59
Y ahora ya es cuando tenemos que hacer 00:33:01
toda esa sucesión de divisiones 00:33:03
que nos vamos quedando. 00:33:05
Cociente y resto, cociente y resto, cociente y resto. 00:33:07
Vale, pues entonces 00:33:09
vamos a necesitar una variable 00:33:11
para guardar el cociente 00:33:13
y para guardar el resto. 00:33:15
Porque una variable ya me va a dar 00:33:17
la cifra 00:33:19
y otra variable, cociente, es la que necesito 00:33:21
para que en la siguiente iteración 00:33:23
pueda yo volver a hacer la división y el resto. 00:33:25
Entonces esta variable cociente 00:33:27
es la que de una iteración a otra 00:33:29
voy actualizando 00:33:31
¿verdad? Voy actualizando 00:33:33
de una división a otra. 00:33:35
La voy actualizando cada vez. 00:33:37
Primero es esta, que es el número inicial. 00:33:39
La siguiente vez ya es esta. 00:33:41
La siguiente es esta y la siguiente es tres. 00:33:43
O sea, de una iteración a otra 00:33:45
la voy actualizando, partiendo del número inicial. 00:33:47
Esa variable cociente. 00:33:49
Bueno, vamos a suponer que, para ser claros, 00:33:51
que lo ponemos así. 00:33:53
Una variable va a ser el cociente 00:33:55
que la inicializo con el número que me han dado 00:33:57
y otra variable va a ser el resto. 00:33:59
Que es la primera, 00:34:01
que irá siendo las cifras decimales 00:34:03
que todavía no he sacado. 00:34:05
¿Qué he hecho yo aquí mal? 00:34:13
Ah, que he puesto a quinto otra vez. 00:34:19
Estaba volviendo de loca. 00:34:21
Vale, ya está. 00:34:23
Venga, pues ahora ya es el bucle 00:34:25
que hemos dicho. 00:34:27
Un bucle que está todo el rato. 00:34:29
¿Que está todo el rato haciendo qué? 00:34:31
Vale, pues podemos sacar 00:34:35
primero la cifra decimal, 00:34:37
que era el resto. 00:34:39
Sacamos 00:34:41
cifra decimal. 00:34:43
Que es resto 00:34:47
igual a 00:34:49
cociente 00:34:51
resto 10. 00:34:53
Esa ya es una cifra decimal. 00:34:55
¿Que vamos a mostrarla? 00:34:59
Pues venga, la mostramos. Como dicen líneas separadas, 00:35:01
pues por eso pongo el println. 00:35:03
Resto. 00:35:05
Y ahora, con esa ya saco el resto. 00:35:07
Ya tengo el resto. 00:35:11
Y ahora actualizo la variable cociente, 00:35:13
porque en la siguiente iteración 00:35:15
tengo que usar 00:35:17
el cociente de birlo entre 10. 00:35:19
Pues venga, 00:35:21
cociente igual 00:35:23
cociente entre 10. 00:35:29
Y ya está. 00:35:35
En la siguiente iteración, 00:35:37
ese cociente que se ha quedado 00:35:39
entre 10, al sacarle 00:35:41
el resto tendré la siguiente cifra. 00:35:43
Y lo vuelvo a actualizar 00:35:47
para que se quede entre 10. 00:35:49
Hemos quedado que, 00:35:51
¿vamos haciendo eso hasta cuándo? 00:35:53
Hemos dicho hasta que cociente sea 0. 00:35:55
¿Vale? 00:35:59
Cuando cociente ya es 0, 00:36:01
ya no tengo que hacer una quinta iteración. 00:36:03
Ya no tengo que hacer una quinta. 00:36:05
Cuando cociente es 0 es porque ya he sacado 00:36:07
la última cifra decimal. 00:36:09
Cuando me dé 0 es que ya saqué la última. 00:36:11
Bueno, pues entonces la condición 00:36:13
de finalización ya la tenemos. 00:36:15
Mientras cociente sea 00:36:17
mayor o igual que 0. 00:36:19
Y ya está, ya tengo ahí sacadas 00:36:23
todas las cifras. 00:36:25
Si ejecutamos esto, 00:36:31
¡Hola! 00:36:37
Porque he puesto mayor o igual. 00:36:41
Quería poner menor o igual. 00:36:43
Espera, espera, espera. 00:36:45
¡Para! A ver, ¿qué he hecho aquí? 00:36:47
¿Qué ha fallado aquí? 00:36:57
Mientras cociente sea... 00:37:01
¡Así! 00:37:03
Me vuelvo loca. 00:37:05
Mientras sea mayor que 0. 00:37:07
He puesto mayor o igual, entonces cuando llega a 0 00:37:09
se está ahí toda la vida, claro, cuando sea mayor que 0. 00:37:11
Error tonto. 00:37:13
Vale. 00:37:15
Venga, pues este. 00:37:19
Pues ya están las cifras. 00:37:21
3, 5, 6, 9 y 8. 00:37:23
¿Vale? 00:37:29
Bueno, es el procedente estándar 00:37:31
con el que uno puede sacar 00:37:33
cifras decimales de un número entero, 00:37:35
de una variable entera. 00:37:37
¿Vale? 00:37:39
Es programar lo que hemos visto. 00:37:45
Vamos haciendo 00:37:47
sucesivos restos 00:37:49
a partir de los sucesivos 00:37:51
cocientes. 00:37:53
Esta sentencia de aquí me va a quedar 00:37:59
mucho más bonita 00:38:01
si la hago así. 00:38:03
Esta sí mucho mejor. 00:38:07
Así más bonita. 00:38:11
Cociente entre 10 00:38:13
y el resultado se lo asigno a cociente. 00:38:15
¿Vale? 00:38:19
Vale. 00:38:31
Vale. 00:38:41
Vale, vámonos 00:38:49
aquí. 00:38:53
Que este nos sirve 00:38:55
para introducir el bucle Ford. 00:38:57
Que va a ser más cómodo. 00:38:59
¿Vale? 00:39:01
Bueno, ¿dudas o preguntas? 00:39:07
Se podría, 00:39:15
pero 00:39:17
A, recursivamente, 00:39:19
que no sabemos hacerlo. 00:39:21
B, metiendo las variables en una array, 00:39:23
que tampoco sabemos hacerlo. 00:39:25
Es que nos falta por saber 00:39:27
como el 99,9% 00:39:29
de lo que tendríamos que saber. 00:39:31
Pero esto, una vez entendido esto, 00:39:33
lo demás es incorporar 00:39:35
datos, entre comillas. 00:39:37
Es incorporar datos. 00:39:39
Pero esto no es incorporar datos, 00:39:41
esto es incorporar formas de pensar. 00:39:43
Sí, lo harías con un while, 00:39:49
pero 00:39:51
el problema es que el ejercicio así 00:39:53
tú vas mostrando las cifras 00:39:55
según se van saliendo. 00:39:57
Y te van saliendo en ese orden, 00:39:59
no lo puedes hacer de otra manera, 00:40:01
porque tú no sabes cuánto tamaño tiene, 00:40:03
entonces tienes que empezar siempre 00:40:05
por las unidades. 00:40:07
Entonces, como te van saliendo así, 00:40:09
las vas mostrando así. 00:40:11
Y no hay alternativa. 00:40:13
Que tú quieres mostrarlas en otro orden, 00:40:15
podrías, en lugar de irlas mostrando 00:40:17
según te salen, 00:40:19
irlas metiendo en una cajita 00:40:21
pero esa cajita es un array 00:40:23
que todavía no sabemos manejar. 00:40:25
Eso, o hacerlo de forma 00:40:27
recursiva, pero de eso por ahora 00:40:29
olvidate que es muy complicado. 00:40:31
Vale, ahora mismo, 00:40:33
con lo que sabemos, 00:40:35
como tienes que tirar de las unidades 00:40:37
porque no puedes tirar 00:40:39
de la otra parte, 00:40:41
pero no sabes cuánto es, 00:40:43
tienes que tirar de las unidades. 00:40:45
Y tal y como te van saliendo las tienes que mostrar, 00:40:47
porque no conocemos una estructura 00:40:49
que puedas tener ahí temporalmente 00:40:51
hasta que ya tengas todas. 00:40:53
No la conocemos todavía. 00:40:55
Con lo que sabemos no hay otra forma. 00:40:57
Pero en cualquier caso tendrías que hacerlo con un while. 00:40:59
Incluso aunque usaras esa estructura temporal, 00:41:01
un bucle tienes que hacer siempre. 00:41:03
Porque tienes que hacer 00:41:05
varias veces sacar una cifra. 00:41:07
Entonces un bucle siempre lo vas a tener que hacer. 00:41:09
¿Eh? 00:41:11
La misma, la misma. 00:41:13
La misma, claro, 00:41:15
porque la operación siempre tiene que ser 00:41:17
igual que ir haciendo divisiones, restos, 00:41:19
divisiones, restos, hasta que el cuente sea cero. 00:41:21
La misma. 00:41:23
Lo que cambiaría es si esas cifras 00:41:25
las vas mostrando 00:41:27
o las vas guardando 00:41:29
para mostrarlas luego. 00:41:31
Es lo que cambiaría. 00:41:33
Si las vas mostrando es que te van a salir en ese orden, 00:41:35
no hay otra. 00:41:37
Y si quieres mostrarlas en otro orden entonces las vas guardando 00:41:39
y luego ya las muestras como te da la gana. 00:41:41
Pero tendrías que irlas guardando. 00:41:45
¿Irlas guardando dónde? 00:41:47
Pues no conocemos estructuras de datos 00:41:49
que se adapten a eso aún. 00:41:51
Vale, pues venga, a ver, 00:41:57
este de aquí. 00:41:59
Bueno, este es de nuevo para jugar otra vez 00:42:01
con un bucle dentro de un bucle. 00:42:03
Este, ¿quién lo ha hecho? 00:42:05
Al doce. 00:42:07
¿No ha llegado nadie todavía? Vale. 00:42:09
Vale. 00:42:13
Lo importante es que todos los que hemos hecho 00:42:15
todos los volváis a hacer 00:42:17
vosotros solos. 00:42:19
Poneos de cero 00:42:21
directamente al cual anunciáis. 00:42:23
Vosotros solos, otra vez lo voy a volver a hacer. 00:42:25
Este mismo. 00:42:27
Y si os veis sueltos, pues ya 00:42:29
vais haciendo programas nuevos. 00:42:31
Bueno, este de aquí. 00:42:33
Este es, 00:42:35
como es mostrar por pantalla, 00:42:37
es hacer System.out.println. 00:42:39
De eso se trata, de hacer System.out.println. 00:42:41
¿Cuántos? Muchos. 00:42:43
Conclusión. 00:42:45
Un bucle que tiene dentro System.out.println. 00:42:47
Ese va a ser mi 00:42:49
mi programa, ¿no? 00:42:51
Un bucle que lo que tenga adentro 00:42:53
es System.out.println. 00:42:55
Eso es lo que, vale. 00:42:57
Bueno, pues, 00:42:59
cada System.out.println 00:43:01
me puedo plantear, 00:43:03
o cada iteración del bucle me puedo plantear 00:43:05
que va a mostrar, la primera iteración va a mostrar esta línea. 00:43:07
La segunda esta. 00:43:09
La tercera esta. 00:43:11
Y así hasta la enésima que me mostrará esta. 00:43:13
Entonces me puedo plantear mi programa 00:43:15
como un bucle 00:43:17
que en cada iteración me muestra una línea, ¿verdad? 00:43:19
Porque lo que nosotros 00:43:21
sí que vemos es que en función 00:43:23
de este numerito n, 00:43:25
ese triángulo es más pequeño o más grande. 00:43:27
Luego las iteraciones son por línea. 00:43:29
¿Que me meten un n que es 4? 00:43:31
Pues ese bucle se va a ejecutar 00:43:33
cuatro veces. 00:43:35
¿Que me meten un n que es 7? Pues ese bucle 00:43:37
es 7 veces. Entonces va a ser un bucle 00:43:39
que en cada iteración muestre una línea. 00:43:41
¿Vale? Eso va a ser. 00:43:43
Bueno, pues entonces 00:43:45
ya uno podría empezar ya 00:43:47
a poner esa estructura. 00:43:49
Este es el 12. 00:43:51
Venga, ejercicio 12. 00:44:09
A ver, no copie denunciado porque... 00:44:11
Vale, pues hemos dicho. 00:44:13
Bueno, habrá que leer el número lo primero. 00:44:15
Pues venga, vamos a leer el número lo primero. 00:44:17
Este. 00:44:23
El número ya está leído. 00:44:25
Lo vamos a llamar 00:44:27
en mayúscula para que se llame igual que el ejercicio. 00:44:29
Pero bueno, vale. 00:44:31
Ya tengo el número leído. 00:44:33
Y ahora, 00:44:35
la idea es 00:44:37
mostrar 00:44:39
estas líneas. 00:44:41
Pues un bucle 00:44:43
que cada iteración me muestra 00:44:45
la línea que le toque. 00:44:47
Pues venga, entonces 00:44:49
te lo podríamos plantear 00:44:51
while no se cuantos. 00:44:53
While no se cuantos. 00:44:57
Aquí que tenemos que hacer. 00:44:59
Mostrar 00:45:01
línea 00:45:03
Linea 00:45:05
Mostrar una línea. 00:45:07
Esa sería la estructura 00:45:09
de mi programa, ¿verdad? 00:45:11
Y ahora ya 00:45:13
hay que empezar a pensarlo. 00:45:15
Que la estructura es esa. Yo leo el numerito n. 00:45:17
Y ahora tengo que hacer un bucle 00:45:19
en el cual en la primera iteración muestro 00:45:21
esta línea. En la segunda 00:45:23
muestro esta. En la tercera muestro 00:45:25
esta. Luego es un bucle en el que estoy todo el rato 00:45:27
mostrando una línea. 00:45:29
Vale. 00:45:31
Bueno, aquí ya hay mucho que 00:45:35
meter. 00:45:37
Bueno, primero vamos a pensar 00:45:39
en la línea que tengo que mostrar. Depende 00:45:41
si estoy en la primera 00:45:43
iteración 00:45:45
tengo que mostrar 1. 00:45:47
Si estoy en la segunda iteración 00:45:49
tengo que mostrar 1 00:45:51
espacio 2. 00:45:53
Si estoy en la tercera iteración tengo que 00:45:55
mostrar 1 espacio 2 00:45:57
espacio 3. 00:45:59
Luego, directamente de lo que estoy 00:46:01
diciendo, ya 00:46:03
extraemos que 00:46:05
en función del número de iteración en la que 00:46:07
yo estoy, si estoy en iteración 1 00:46:09
en la 2, en la 3 00:46:11
muestro cosas distintas. 00:46:13
Luego conviene marcar la iteración en la 00:46:15
que estoy. Conviene marcarla. 00:46:17
De ahí ya me viene el contador. 00:46:19
De ahí ya me viene la idea del contador. 00:46:21
Vale, vamos a marcar un 00:46:23
contador. 00:46:25
Un contador, por ejemplo, que empiece 00:46:27
valiendo 1. 00:46:29
Y ahora ya, ¿qué tengo que hacer? 00:46:31
El contador luego, cuando termine 00:46:33
la iteración, se incrementará. 00:46:35
Y ahora, ¿qué tengo 00:46:37
que hacer aquí? Mostrar una línea 00:46:39
que sea de 1 00:46:41
2, así hasta 00:46:43
con. Ahora ya empieza 00:46:45
a tomar esto un poco más de forma. 00:46:47
¿Verdad? 00:46:49
Si estoy en la primera iteración mostraré 00:46:51
1 solo. Y con se quedará 00:46:53
incrementado. 00:46:55
No, no, no. 00:46:57
Hasta cont. Porque 00:46:59
aquí estoy en la línea de la iteración. 00:47:01
Y la primera línea es 00:47:03
hasta 1 solo. 00:47:05
Hasta n es solo la última. 00:47:07
Entonces, cont va variando. 00:47:09
En la primera iteración, cont es 1. 00:47:11
Por eso, de 1 hasta cont es 1 00:47:13
solo. En la segunda iteración 00:47:15
cont es 2, porque lo has dejado incrementado. 00:47:17
Pues mostrará de 1 a 2. 00:47:19
En la tercera, cont es 3. 00:47:21
Por eso hemos usado, se nos ha ocurrido 00:47:23
esa variable con a. Genial. 00:47:25
Porque así tengo una variable que me 00:47:27
dice en qué número de iteración estoy. 00:47:29
Y el número de iteración en la que estoy es relacionado 00:47:31
directamente con el numerito al que llevo. 00:47:33
Entonces ya 00:47:35
lo vamos perfilando un poco más. Tenemos aquí 00:47:37
un contador de iteraciones. 00:47:39
Por decirlo así. 00:47:41
Un contador de iteraciones. 00:47:43
La primera vez que entramos es 1. 00:47:45
Entonces tendría que mostrar la línea de 1 a 1, 1. 00:47:47
Y lo dejamos incrementado. 00:47:49
La siguiente vez 00:47:51
que entramos es 2. 00:47:53
Tendría que mostrar 1 con 00:47:55
que es 2. La siguiente vez que 00:47:57
entramos es 3. Pues tendríamos que mostrar 00:47:59
1, 2 hasta 3. En cualquier caso 00:48:01
hasta cont. Esto es lo que se nos 00:48:03
queda aquí ahora como caja negra. 00:48:05
Como mostramos esa línea. 1, 2 00:48:07
hasta cont. Que cont va variando. 00:48:09
Eso es una primera caja negra que hay que resolver. 00:48:11
Pero a cambio se nos ha 00:48:13
resuelto esta. 00:48:15
Porque esa ya me permite decir 00:48:17
cuándo acabo el bucle. Qué condición 00:48:19
pondríais ahí. 00:48:21
Fijaos que va valiendo. Aquí vale 1. 00:48:23
Aquí vale 2. Aquí vale 3. 00:48:25
Y así hasta ahí que vale n. 00:48:27
Luego qué condición 00:48:29
pondríais ahí. 00:48:31
Claro, mientras sea menor o igual 00:48:35
que n. Porque en la n también entramos. 00:48:37
¿Vale? Pues esto 00:48:39
ya lo tenemos resuelto. 00:48:41
Esto ya lo tenemos resuelto. 00:48:43
Entonces ya solo se nos ha quedado esto. 00:48:45
¿Cómo muestro yo ahí una línea 00:48:47
que sea la primera iteración 1? 00:48:49
O sea, hasta cont siempre. 00:48:51
Pues no es tan sencillo. 00:48:53
Porque de nuevo 00:48:55
esto a su vez va a tener que ser 00:48:57
otro bucle que se ejecute 00:48:59
cont veces. 00:49:01
Y en cada iteración 00:49:03
un bucle que se ejecute cont veces 00:49:05
y vaya mostrando los numeritos. 1, 2, 3 00:49:07
hasta cont. Ese será un bucle. 00:49:09
Para mostrar esta línea 00:49:11
tendremos que hacer un bucle 00:49:13
que vaya mostrando 00:49:15
todos los números comprendidos 00:49:17
entre 1 y cont. 00:49:19
¿No? Para mostrar todos los números 00:49:21
comprendidos entre 1 y cont, pues un bucle 00:49:23
que se ejecute cont veces 00:49:25
y vaya mostrando todos entre 1 y cont. 00:49:27
Bueno, pues esto lo tendremos que hacer 00:49:29
con otro bucle, entonces. 00:49:31
¿Vale? Pues lo podemos 00:49:33
hacer así. Venga, un bucle 00:49:35
bucle que 00:49:37
muestra 00:49:39
todos 00:49:41
los números desde 00:49:43
hasta cont. 00:49:47
Eso es lo que queremos, un bucle 00:49:49
que vamos mostrando todos desde 1 hasta cont. 00:49:51
¿Vale? Pues bueno, podemos hacer 00:49:53
una variable auxiliar cualquiera 00:49:55
que empieza valiendo 1 00:49:59
y ahora ya 00:50:01
mientras 00:50:03
aux sea 00:50:05
menor o igual que cont 00:50:07
que es el último que quiero mostrar 00:50:09
menor o igual que cont que es el último 00:50:11
pues hacemos 00:50:13
a la corrección, hacemos 00:50:15
mostrar aux 00:50:17
concatenado con un espacio para que no nos quede 00:50:19
muy pegadito al otro 00:50:21
y luego incrementamos 00:50:23
aux 00:50:25
¿Vale? O sea 00:50:35
todo este bucle de aquí 00:50:37
hace esto 00:50:39
primero te muestra 1 00:50:41
luego te muestra 2 00:50:43
luego 3 y así hasta cont 00:50:45
que es justo lo que queríamos, mostrar 00:50:47
todos los números 1, 2, 3 hasta cont 00:50:49
es justo lo que queríamos, esto hemos tenido que hacer en un 00:50:51
bucle, hemos tenido que hacerlo en un bucle 00:50:53
¿Vale? Pues este bucle se ha quedado 00:50:55
dentro de esto. ¿Vale? Vamos siempre 00:50:57
por partes 00:50:59
Aquí lo único es que 00:51:03
println 00:51:07
me mete un salto de línea 00:51:09
entonces yo mostraría 1 y el 2 abajo 00:51:11
y el 3, no, yo quiero que estén en la misma línea 00:51:13
todos hasta cont 00:51:15
pero tenemos otra variante del system.out.println 00:51:17
que es el system.out.print 00:51:19
que no te mete el salto de línea 00:51:21
pues este ya si que se adapta más a lo que queremos 00:51:23
entonces este bucle que nos iría haciendo 00:51:25
primero muestra el 1 00:51:27
luego muestra el 2 00:51:31
luego muestra el 3, todos seguidos, luego muestra el 4 00:51:33
así hasta cont 00:51:35
así hasta cont 00:51:37
pues justo lo que queríamos, esto, justo eso 00:51:39
es lo que necesitábamos, justo eso 00:51:41
pues ya está, con esto 00:51:45
hemos conseguido esto 00:51:47
con este bucle de aquí 00:51:49
hemos conseguido mostrar 00:51:51
esa línea 00:51:53
que queremos que se quede más bonito 00:51:57
compacto una línea, vamos a hacer el postincremento 00:51:59
aquí, lo hacemos aquí 00:52:01
entonces me lo quito de aquí 00:52:03
lo elimino y ya está 00:52:05
y puedo quitar hasta las llaves y todo 00:52:07
pero eso ya es lo de menos 00:52:09
hacerlo justo aquí después de mostrar 00:52:11
porque println 00:52:21
te muestra lo que sea y te salta la línea 00:52:23
entonces 00:52:25
el 1, 2, 3, no te aparecerían en la misma línea 00:52:27
te aparecerían en 00:52:29
líneas separadas 00:52:31
yo creo que aparecerían en la mina 00:52:33
eso, vale 00:52:35
entonces 00:52:41
esto que tenemos aquí hecho 00:52:45
estaría entendido 00:52:47
hemos visto que es un bucle 00:52:49
que N mayúscula veces 00:52:51
está haciendo mostrar 00:52:53
una línea 00:52:55
y esa línea 00:52:57
que tengo que mostrar 00:52:59
depende del número de iteración 00:53:01
en la que estoy 00:53:03
por eso hemos metido el contador 00:53:05
cuando nos hemos dado cuenta de eso 00:53:07
de que lo que tengo que mostrar 00:53:09
depende de la línea en la que estoy 00:53:11
luego marquemos las líneas con un contador 00:53:13
la 1, la 2, la 3 00:53:15
le ponemos puesto el incremento 00:53:17
ejecutamos a ver que sale 00:53:21
vale 00:53:23
entonces uno se pone a hacer pruebas 00:53:27
venga, 3 00:53:29
para que no sea un triángulo muy grande 00:53:31
pues no ha salido 00:53:33
ha salido el triángulo 00:53:35
pero roto 00:53:37
o sea, ha puesto el 1 00:53:39
pero 1, 2 que tendría que ir abajo lo ha puesto ahí 00:53:41
y 1, 2, 3 que tendría que ir abajo 00:53:43
lo ha puesto ahí 00:53:45
era de esperar 00:53:47
porque claro, lo que nos falta es 00:53:49
lo que nos falta es 00:53:51
cuando ya hemos terminado la línea 00:53:53
antes de pasar a la siguiente 00:53:55
ahí sí que queremos bajar 00:53:57
ahí sí 00:53:59
entonces ¿cuándo hemos acabado una línea? aquí 00:54:01
aquí ya hemos acabado una línea 00:54:03
y ya vamos a pasar a la siguiente 00:54:05
pues ahí sí que queremos saltar 00:54:07
bueno, pues no pasa nada, forcemos un salto de línea 00:54:09
así 00:54:11
pasándole un println sin nada 00:54:13
entonces el println no ha mostrado nada 00:54:15
pero como es un ln 00:54:17
no ha mostrado nada abajo 00:54:19
entonces esto simplemente 00:54:21
metí un salto de línea y ya está 00:54:23
queda lo que necesitábamos 00:54:27
meter un salto de línea 00:54:29
entre cada una de las líneas 00:54:31
vale, entonces 00:54:33
volvemos a hacer la prueba 00:54:35
venga, le metemos 8 00:54:37
vale, este ya sí 00:54:39
vale 00:54:41
vale, pues otra vez como siempre 00:54:50
tenemos que resolver el problema por partes 00:54:54
identificar 00:54:56
¿qué es este problema mío así en general que hace? 00:54:58
imprimir muchas líneas 00:55:00
pues un bucle 00:55:02
donde en cada iteración imprimo una 00:55:04
y ahora ya me planteo 00:55:06
¿y cómo imprimo cada línea? 00:55:08
pues ahí ya me tienen que salir los recursos 00:55:10
y es ah, pues lo que imprimo depende del número de línea en la que estoy 00:55:12
vale, podría poner un contador 00:55:14
que se va incrementando, que me dice en qué línea estoy 00:55:16
a partir de ahí ya son los recursos 00:55:18
los recursos de programación que a uno se le van ocurriendo 00:55:20
en función de las cosas que ya hemos visto 00:55:22
y en las que nos podemos apoyar 00:55:24
vale, nos podemos apoyar 00:55:26
en contadores, en sumadores, en todo eso 00:55:28
vale 00:55:36
entonces lo único es que este programa 00:55:38
pues nada, si está bien hecho, ya lo hemos comprobado 00:55:40
pero hombre, por su naturaleza 00:55:42
queda más claro 00:55:44
si utilizamos la tercera sintaxis 00:55:46
que le permite java de un bucle 00:55:48
que es la sintaxis de for 00:55:50
conocemos la while 00:55:52
la de do while 00:55:54
y nos falta una 00:55:56
vale, bueno, nos falta una con matices 00:55:58
porque 00:56:00
vale, bueno, pues vamos a parar aquí 00:56:02
un momentito 00:56:04
y ya lo encontramos 00:56:08
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
31 de octubre de 2023 - 13:43
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
56′ 11″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
1.04

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid