Saltar navegación

20241024 ProgrEstruct-Bucles-ejercicios_10 - 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 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces, vale, nos habíamos quedado con esto, 00:00:00
pero a ver, estaba claro, ¿no? 00:00:04
Que esto es, tenemos que ver si algo pasa o no pasa. 00:00:05
De partida, asumimos que no hay ninguno. 00:00:07
Empezamos a leer, empezamos a leer y en cuanto nos encontramos 00:00:11
un contraejemplo que se llama algo que me hace cambiar de opinión 00:00:14
porque ya he encontrado uno, como es aquí, 00:00:18
en cuanto he encontrado uno que me hace cambiar de opinión 00:00:20
porque está suspenso, pues ya lo pongo a tú. 00:00:23
Y ya está. 00:00:26
los siguientes que vengan 00:00:26
ya dan igual 00:00:29
en realidad, ya dan igual 00:00:30
van a seguir poniendo la true a lo mejor 00:00:32
si es menor que 5, pero es que ya estaba 00:00:34
de antes, entonces dan igual 00:00:37
entonces 00:00:38
bueno, sí, a ver 00:00:39
el número que sea, da igual 00:00:44
el número que sea, vale, entonces ¿en qué nos habíamos quedado? 00:00:46
pues en lo más importante 00:00:49
que es, a ver, ojo 00:00:51
cuando ya hemos encontrado alguno 00:00:52
que cumple esto, luego es true 00:00:54
ya lo que pase con los demás 00:00:56
me da lo mismo, porque ya he encontrado 00:00:59
uno que me ha hecho cambiar de opinión y decir que sí 00:01:01
hay uno al menos que ha cambiado de opinión 00:01:03
entonces aquí querríamos 00:01:05
ya dejar de ejecutar el bucle 00:01:07
porque efectivamente si el bucle tiene 50.000 00:01:08
pues vaya rollo estar ahí 00:01:11
entonces siempre podemos 00:01:12
hacer esto si queremos salir de un 00:01:15
bucle, pero bueno como es 00:01:17
feo, habíamos 00:01:18
incorporado esto de arriba 00:01:21
que en el for recordad 00:01:23
que esta es la condición que hace que yo siga 00:01:25
que yo siga 00:01:27
entonces ¿cuándo vamos a seguir? 00:01:28
si se cumple simultáneamente 00:01:30
que no los he recorrido todos 00:01:32
y además todavía no he encontrado 00:01:34
ninguno suspenso 00:01:37
si se ocurren 00:01:38
simultáneamente las dos cosas 00:01:40
que no he acabado con todos 00:01:42
y que además todavía no he encontrado 00:01:44
ningún suspenso, seguiré 00:01:46
pero 00:01:48
imaginaos que ya he terminado 00:01:49
ya he recorrido los cinco 00:01:52
aunque no haya encontrado ningún suspenso todavía 00:01:54
luego esto es falso, perdón, luego esto es true 00:01:56
pues si ya he recorrido 00:01:58
todo, será falso 00:02:00
y true, falso, saldrá 00:02:02
porque ya los ha recorrido todos 00:02:04
aunque algún suspenso siga siendo falso 00:02:05
porque es que no he encontrado ninguno 00:02:08
esa será una de las posibilidades 00:02:09
que harán que salga del bucle 00:02:12
la otra, que no he recorrido 00:02:13
todos, es decir, esta es true 00:02:16
pero ya esto 00:02:17
se ha puesto true, porque ya he encontrado a uno 00:02:20
luego esto automáticamente se ha convertido en false 00:02:22
luego será la otra opción 00:02:24
por la que pueda salir 00:02:26
porque no los he recorrido todos aún 00:02:27
luego eso sigue siendo true, pero esto me saltó a false 00:02:30
me saltó a false 00:02:32
porque entré por aquí 00:02:34
al entrar por aquí se puso a true 00:02:35
con el no delante se ha puesto a false 00:02:38
luego consigo el efecto del break 00:02:40
que en cuanto yo entro por aquí 00:02:42
porque uno es suspenso 00:02:44
en cuanto entro se ha puesto a true 00:02:46
entonces al ponerse esto a true 00:02:48
esta automáticamente se pone a falso 00:02:49
luego ya la siguiente iteración 00:02:52
ya no se va a hacer, que era justo lo que quería 00:02:54
que ya no se hagan más 00:02:56
iteraciones desde el momento 00:02:58
en que me encuentro ya un suspeso 00:03:00
los demás ya se ignoran 00:03:02
¿vale? 00:03:04
no lo entiendo 00:03:09
a ver, ya sabía 00:03:10
¿por qué no has explicado 00:03:12
lo que parece? 00:03:12
pues si es más fácil de lo que parece es que te lo he explicado 00:03:16
muy bien, porque no te parecería 00:03:18
fácil. 00:03:20
Ok, lo siento, profe, perdóname. 00:03:22
No cuente más. 00:03:23
Vale, a ver. 00:03:25
Y no significa que tienen que pasar 00:03:28
las dos cosas. Claro, pero esta es la condición 00:03:30
con la que sigues entrando. 00:03:32
Entonces tú sigues entrando. 00:03:34
Si no has completado todos 00:03:35
y además todavía 00:03:37
no has encontrado uno suspenso 00:03:40
porque es negada. 00:03:42
Entonces si se... A ver, 00:03:44
no es fácil de ver. Si se cumplen 00:03:46
que tú no has encontrado todos 00:03:48
y además todavía no hay ningún 00:03:50
suspenso porque 00:03:52
sigues en false, luego esto es true 00:03:54
pues tú sigues 00:03:56
¿cuándo termina el bucle? 00:03:57
el bucle terminará 00:04:00
porque esta es falsa o porque 00:04:01
esta es falsa, porque el and 00:04:04
se convierte en false en cuanto 00:04:05
uno de los dos es falsa 00:04:08
entonces ¿cuándo terminará el bucle? 00:04:09
cuando esta es falsa o 00:04:12
esta es falsa, porque 00:04:14
para cualquiera de esos dos casos 00:04:16
la total es falsa, luego no entra más 00:04:17
bueno, pues cuando 00:04:20
terminará el bucle 00:04:22
cuando ya he comprobado los 5 00:04:22
cuando ya he comprobado los 5, termina sí o sí 00:04:25
esta se ha hecho falsa, el total es falsa 00:04:27
luego ya no entra, esta es la condición 00:04:29
que me marcaría 00:04:31
que yo entrara, si se ha hecho falsa no entra 00:04:33
vale, pero no solo 00:04:35
no solo va a dejar de entrar cuando esta es falsa 00:04:37
también cuando esta lo es 00:04:39
entonces 00:04:41
esta de aquí 00:04:43
algún suspenso, sabemos 00:04:44
que desde el momento en que yo entro 00:04:47
aquí, porque estoy en la iteración 3 00:04:49
por ejemplo, estoy en la 3 00:04:51
ese es suspenso, vale 00:04:52
pues entonces algún suspenso ha puesto a true 00:04:55
estaba false de antes, pero ahora se ha puesto a true 00:04:56
vale, pues entonces cuando yo venga 00:04:59
por aquí arriba, como esta ha cambiado a true 00:05:01
esta tiene el negado 00:05:03
delante, luego esta se ha hecho 00:05:05
false, entonces 00:05:07
esta se ha hecho false 00:05:09
el and con un false es 00:05:10
falso, me da igual 00:05:13
lo que sea esto, falso 00:05:15
and lo que sea es falso, pues a cabo ya no 00:05:17
entra, porque esta es la condición 00:05:19
esto es como si fuera un while 00:05:21
esta es la condición que si se cumple entra 00:05:22
lo tienes que pensar tú solito 00:05:25
en la intimidad, ponte a pensarlo 00:05:27
y lo, hasta que lo veas 00:05:29
claro 00:05:31
¿vale? 00:05:31
lo ponéis y 00:05:35
bueno, más o menos 00:05:36
bueno, pues 00:05:39
A ver 00:05:42
Yo ya prácticamente 00:05:45
He hecho todo lo que podía hacer 00:05:48
Por vosotros 00:05:51
Todos los ejercicios 00:05:53
Que quieran 00:05:56
Ahora ya, claro, muchos de ellos ya son 00:05:56
Bastante más difíciles 00:05:58
Pero todo se puede hacer con todo lo que hemos visto 00:06:00
Son las 4 o 5 ideas 00:06:02
4 o 5 ideas que hemos visto 00:06:05
Combinadas 00:06:06
Todo el rato lo mismo, 4 o 5 ideas 00:06:07
Lo que pasa es que, claro 00:06:10
Hay algunos que son 00:06:11
Más difíciles y más fáciles 00:06:14
Vale, pues entonces 00:06:17
El lunes empezamos con 00:06:19
Otra cosa, pero hoy y mañana 00:06:21
Vamos a hacer un repaso 00:06:23
De estos de aquí 00:06:25
Cuál os parece más difícil 00:06:26
Cuál queremos, cuáles hacemos aquí 00:06:28
Etcétera, vale 00:06:30
Venga, por ejemplo 00:06:32
Eh, o sea 00:06:37
Damos por corregidos 00:06:38
Hasta aquí 00:06:40
Porque estos tres en realidad son iguales 00:06:42
Hemos hecho este 00:06:46
Pero es que este y este son prácticamente el mismo 00:06:47
Entonces los hace 00:06:49
Los hacéis y ya está 00:06:51
Vale, pues a partir de aquí 00:06:53
Del 19 al 38 00:06:56
Vale, ¿alguna petición? 00:06:58
Del 19 al 38 00:07:02
Sí, pero es que no podemos corregirlos todos 00:07:03
Porque se nos haría diciembre 00:07:06
Pero vamos, podemos ir 00:07:07
Aunque el lunes empecemos 00:07:09
Algo nuevo, podemos ir 00:07:12
Haciendo de estos también 00:07:14
Pero peticiones, ¿cuál te gusta? 00:07:16
El 30, ala, lo bestia 00:07:19
Sabía que os ibais a las estrellitas 00:07:21
Sí 00:07:23
Sois la generación de que os tiene que entrar por los ojos 00:07:24
Las cosas 00:07:27
De lo visual 00:07:27
Pero vale, venga 00:07:29
Empezamos con el 30 00:07:33
Vale, aparte del 30 00:07:34
Yo quiero que hagamos el de los números primos 00:07:38
Y algún otro por ahí 00:07:41
¿Vale? 00:07:43
Hay unos cuantos que sí que quiero que hagamos aquí 00:07:44
Pero vamos a empezar con el 30, ¿vale? 00:07:47
No, le ha gustado ese, pobrecito 00:07:52
Déjale 00:07:54
Bueno 00:07:55
Pues os vais a cagar 00:08:08
que no, que no, que es una broma 00:08:11
vale, el arbolito de navidad 00:08:15
venga 00:08:18
espera, vamos a detener esto mientras 00:08:18
vale, pues el programa dice 00:08:25
mostrar esta figura 00:08:31
¿el plátano? 00:08:39
pero aún no estamos 00:08:43
pero casi 00:08:48
vale 00:08:51
si fuera esta figura 00:08:51
fija tal cual 00:08:55
pues me hago 4 system out y listo 00:08:56
pero claro, me están diciendo 00:08:59
tú mete un dato de entrada 00:09:00
que es el número de filas 00:09:02
y el arbolito de navidad tiene que tener 00:09:03
tantas filas 00:09:10
en cada iteración 00:09:13
metes una más 00:09:14
¿Vale? Tantas filas como te digan 00:09:15
Bueno, un asterisco más no 00:09:18
Ya, pero 00:09:22
Lo que tú me estás diciendo sería esto 00:09:24
Sí 00:09:27
El triángulo 00:09:28
Pero vamos a hacer el arbolito 00:09:29
También hay otra parte abajo 00:09:31
Bueno, lo de abajo es el rombo 00:09:32
¿Vale? A ver, podríamos hacer esta primera 00:09:35
Versión, efectivamente 00:09:38
Esta es más sencilla de hacer 00:09:40
¿Vale? Vamos a hacer esta primera versión 00:09:41
que es el triangulito 00:09:43
y luego ya hacemos el arco 00:09:45
vale, entonces vamos a imaginar 00:09:48
que nos han pedido esto 00:09:50
bueno, pues esta 00:09:51
es fácil porque decimos 00:10:01
tengo que hacer varias veces 00:10:03
mostrar una línea 00:10:05
varias veces mostrar una línea 00:10:07
vale, pues entonces 00:10:09
esto 00:10:12
estas son las filas 00:10:13
que tenemos 00:10:19
entonces, yo sé exactamente 00:10:19
el número de iteraciones 00:10:23
que necesito, que son 00:10:25
N mayúscula 00:10:26
luego me planto un 00:10:28
bucle for 00:10:30
que se ejecute N veces 00:10:34
vale 00:10:39
bueno, pues entonces, hasta ahí he llegado 00:10:44
tengo que hacer algo N mayúscula 00:10:47
veces, vale, ese algo 00:10:49
que tengo que hacer, ¿qué es? 00:10:51
e imprimir cosas por pantalla 00:10:52
imprimir 00:10:55
vale, la primera vez 00:10:56
que es la vez para i igual a 0 00:10:58
tengo que mostrar un asterisco 00:11:00
pero la segunda vez 00:11:03
que es la de i igual a 1 00:11:05
porque recordad que este for 00:11:06
esta variable i 00:11:08
cuando la primera vez que entramos vale 0 00:11:10
pero la siguiente vez que entramos ya vale 1 00:11:12
entonces la propia variable i 00:11:14
nos está valiendo como una especie de contador 00:11:15
cuando i vale 0 00:11:18
un asterisco, pero cuando i vale 00:11:20
dos son dos asteriscos los que tenemos que mostrar 00:11:22
pero cuando y valga 00:11:24
dos son tres 00:11:26
asteriscos, entonces 00:11:31
si nos hacemos aquí un bucle 00:11:33
que lo que haga sea 00:11:35
mostrar un asterisco 00:11:37
pues entonces 00:11:39
este bucle esta vez se ejecutará 00:11:40
y más una veces 00:11:43
y la segunda vez se ejecutará también y más una veces 00:11:44
y la tercera vez se ejecutará 00:11:47
y más una veces también 00:11:50
luego si yo me planteo cada línea 00:11:51
cada línea me la planteo 00:11:54
como un bucle 00:11:56
que lo que se hace en cada iteración es mostrar un único asterisco 00:11:57
pues ese bucle 00:12:00
es en las veces que se ejecuta 00:12:02
la primera vez y más una, la segunda y más una 00:12:03
la tercera y más una, luego es un bucle 00:12:06
que se ejecuta siempre y más una veces 00:12:08
entonces 00:12:10
pues aquí dentro me hago otro bucle 00:12:11
que se va a ejecutar exactamente 00:12:14
y más una veces 00:12:16
¿no? 00:12:18
para igual a cero una vez 00:12:19
para igual a uno dos veces, para igual a dos tres veces 00:12:20
luego es un bucle que se ejecuta y más una vez 00:12:23
pues me hago un bucle for que se ejecuta 00:12:25
y más una vez 00:12:27
aquí no voy a usar la variable y otra vez 00:12:28
esta ya está usada, tiene aquí un uso 00:12:31
pues me 00:12:33
uso otra 00:12:36
¿vale? entonces este for está 00:12:38
dentro del de arriba 00:12:46
entonces este es un for que se ejecuta 00:12:46
y más una vez 00:12:50
luego en la primera 00:12:51
iteración del for de arriba 00:12:53
este se ejecuta una vez 00:12:55
porque y vale c 00:12:57
en la siguiente iteración del for de arriba 00:12:58
este se ejecuta 00:13:02
dos veces porque i vale uno 00:13:04
en la siguiente iteración del for de arriba 00:13:05
este se ejecuta tres veces 00:13:08
porque i vale dos 00:13:10
que es justo lo que yo quiero 00:13:11
vale, ¿y qué es lo que tengo que hacer en el for de dentro? 00:13:13
mostrar el asterisco 00:13:16
mostrar el asterisco 00:13:17
pero se va a ejecutar i veces 00:13:19
porque has puesto menor 00:13:21
no menor igual 00:13:23
entonces se va a ejecutar i veces 00:13:24
no, se ejecuta i más una 00:13:26
o sea, si yo quiero que, es como este 00:13:28
este desde 0 hasta n 00:13:31
se ejecuta n veces, este desde 0 y más 1 00:13:32
se ejecuta y más 1 00:13:35
entonces, aquí el único tema es que 00:13:36
el asterisco que yo quiero mostrar 00:13:39
si lo muestro así 00:13:40
con el system.out.println que hemos usado siempre 00:13:42
así 00:13:45
el system.out.println 00:13:47
te muestra un asterisco 00:13:49
pero te salta la línea 00:13:50
con lo cual, cuando nosotros 00:13:52
estemos en esta iteración 00:13:55
la segunda, el primer asterisco 00:13:56
me deja la línea saltada, luego este asterisco 00:14:00
me lo muestra abajo también 00:14:01
pero no pasa nada, tenemos una variante 00:14:03
del system.out.print.ln 00:14:05
que es system.out.print 00:14:07
que me muestra 00:14:09
y no me deja la línea 00:14:11
saltada, me muestra 00:14:14
entonces 00:14:15
este bucle, así tal cual 00:14:17
que nos hace, vale, iteración 0 00:14:19
primera vez que entro por aquí, iteración 0 00:14:21
este bucle 00:14:24
se va a ejecutar una vez. 00:14:25
Una vez. ¿Y qué va a hacer? 00:14:28
Mostrar un asterisco. 00:14:29
Iteración para i igual a 1. 00:14:33
Este bucle se va a ejecutar dos veces. 00:14:35
Porque ahora valdrá 00:14:38
desde 0 hasta 2, dos veces. 00:14:39
Y muestra un asterisco 00:14:42
y muestra otro más, porque se ejecuta dos veces. 00:14:43
Iteración i igual a 2. 00:14:46
Este bucle se va a ejecutar tres veces. 00:14:49
Me muestra un asterisco, otro asterisco, 00:14:52
otro asterisco. 00:14:53
¿Qué falla aquí? 00:14:56
Ojo, que cada vez que yo acabo esto, 00:14:57
cada vez que acabamos esto, 00:15:00
es porque hemos acabado una línea enterita. 00:15:02
Queremos que el cursor se vaya abajo 00:15:05
para que la siguiente línea sea abajo. 00:15:07
Entonces, este for es para mostrar cada una de las líneas. 00:15:10
Para eso vale. 00:15:14
Entonces, una vez que yo he terminado de mostrar una línea, 00:15:16
que este for es el que lo hace, 00:15:18
asterisco, asterisco, asterisco, 00:15:19
tantas veces como haga falta, 00:15:20
asterisco, asterisco, 00:15:21
tantas veces como haga falta, 00:15:23
me falta meter un salto de línea 00:15:24
me falta meter un salto de línea 00:15:26
para que la siguiente línea se haga abajo 00:15:27
vale, pues ¿cómo puedo meter 00:15:30
yo un salto de línea? le hago un system.out.print 00:15:32
ln vacío 00:15:34
y es el efecto que tienes, no mostrar 00:15:35
nada, nada más que un salto de línea 00:15:38
vale, ya 00:15:40
estaría ese triángulo hecho 00:15:42
entonces si ejecutáis este código 00:15:43
variando n, 2, 7 00:15:51
8, pues os saldrá este 00:15:54
triángulo, pues con tantas líneas 00:15:55
como tú 00:15:58
la hayáis dicho 00:15:59
pero eso no sale así 00:16:01
no... 00:16:04
ya, claro, pero es que lo he dicho hace dos minutos 00:16:05
vamos a hacer primero esta versión 00:16:08
y cuando la tengáis clara 00:16:09
vamos a hacer ahora la otra 00:16:11
¿esto lo entendéis? 00:16:13
sí, segurísimo, segurísimo 00:16:16
pero me dice que solo me sale la primera línea 00:16:18
está bien así 00:16:20
¿tiene que salir el triángulo? 00:16:21
a mí no me sale el triángulo 00:16:24
a mí me sale una fila 00:16:25
Pero le habéis quitado aquí el LN 00:16:27
Que os he dicho 00:16:32
A ver, a ver, vamos a ver 00:16:32
¿Te sale el triángulo ya? 00:16:39
O sea, no hace falta ni que lo compruebe, ¿no? 00:16:48
A ver, Pablo, mírale 00:16:52
Lo que ha hecho 00:16:53
Porque así no tengo que 00:16:55
¿Me has hecho quitar eso con lo que me cuesta? 00:16:58
Vale, a ver, lo que está ahí tiene que funcionar 00:17:00
Igual algo has copiado mal, no lo sé 00:17:10
A ver, ¿alguien no entiende este código? 00:17:11
Si lo entiendo, que lo tengo 00:17:28
No, él no lo entiende 00:17:30
Nada ha pasado 00:17:31
¿Por qué? 00:17:34
Yo soy el único que... 00:17:35
El único valiente, querremos decir. 00:17:38
Vale, ¿entendéis todo el mundo este código? 00:17:42
Entonces, aquí hemos identificado. 00:17:44
Tenemos que varias veces imprimir una línea de cosas. 00:17:47
Vale, una línea de cosas. 00:17:54
Pues por eso hay un for que se ejecuta tantas veces como líneas. 00:17:55
¿Está claro, no? 00:17:59
Vale, ahora ya. 00:18:00
Dentro de este for grande toca imprimir la línea. 00:18:02
ahora viene el subproblema 00:18:05
el subproblema es, muy bien 00:18:07
ahora como imprimo yo una filita de asteriscos 00:18:08
pues si imprimo una fila de asteriscos 00:18:12
es imprimir un asterisco 00:18:14
y otro y otro, luego de nuevo es un bucle for 00:18:16
un bucle for donde se imprime 00:18:18
un asterisco y otro y otro 00:18:20
para que queden seguidos 00:18:21
sin el ln aquí, ln es de line 00:18:23
que es que te salta la siguiente 00:18:25
te imprime y se queda el cursor 00:18:27
ahí para que el siguiente sea en la misma línea 00:18:30
bueno pues esto 00:18:32
es lo que tenemos que hacer varias veces 00:18:33
aquí una vez, pero aquí dos veces 00:18:35
pero aquí tres veces 00:18:38
es decir, dependiendo del i 00:18:39
de la iteración de fuera 00:18:41
dependiendo del i 00:18:43
lo hago una vez, dos, tres 00:18:45
es decir, siempre lo voy a hacer 00:18:48
una vez más que lo que valga la i 00:18:49
entonces cuando yo entro en este for 00:18:51
y la primera vez vale cero 00:18:54
la segunda valdrá uno 00:18:55
la segunda valdrá dos, no lo sé, pero lo que sí que sé 00:18:57
es que este for se va a hacer siempre 00:19:00
y más una vez 00:19:02
el print sin el LN 00:19:03
no imprime nada 00:19:06
no, no, no, hace un salto de línea 00:19:06
un salto de línea sin más 00:19:08
no, digo el print que no lleva el LN 00:19:10
ese no imprime nada 00:19:13
hasta que no hagas un print LN 00:19:15
no, no, no, sí, imprime en este disco 00:19:17
lo que no hace es dejarte el salto de línea 00:19:19
metido 00:19:21
este, el print es 00:19:22
imprime esto sin salto de línea 00:19:25
y el print LN es imprime esto con salto de línea 00:19:26
entonces como pone 00:19:29
ah, vale, porque 00:19:30
vale, entonces este bucle 00:19:32
sé que se va a ejecutar y más una 00:19:37
veces, porque tengo que imprimir 00:19:39
y más un asterisco, pues un bucle que sé las veces 00:19:40
que se va a ejecutar, lo planto 00:19:42
tal cual, bucle que se ejecuta y 00:19:44
más una veces, como la variable 00:19:46
y ya está usada, porque 00:19:48
es el índice del bucle de arriba 00:19:50
este bucle for lo planteo con otra 00:19:52
variable, claro, otra 00:19:54
y este es un bucle for que se ejecuta 00:19:56
exactamente y más una veces 00:19:59
igual que este, es un bucle for 00:20:01
que se ejecuta exactamente 00:20:03
entonces este bucle for 00:20:04
para la primera iteración cuando i es igual a 0 00:20:06
se ejecuta solo una vez 00:20:09
y me imprime en este disco 00:20:10
pero para la siguiente iteración 00:20:13
cuando i es igual a 1 00:20:15
se ejecuta dos veces, luego me imprime dos 00:20:17
no, dos filas no, dos asteriscos 00:20:19
a ver, y más uno es la cantidad de veces 00:20:22
que se hace este print 00:20:29
entonces para la iteración 00:20:30
i igual a 7 00:20:32
se imprimirán 8 asteriscos 00:20:33
entonces 00:20:36
todo este for 00:20:37
enterito es para una línea 00:20:40
como una vez acabada la línea 00:20:41
tenemos que pasar a la línea siguiente 00:20:44
pues ponemos 00:20:46
aquí esto con la única idea de 00:20:48
pasar a la línea siguiente y ya está 00:20:50
¿vale? bueno 00:20:51
¿he entendido el código más o menos? 00:20:54
entonces, se puede anidar 00:20:57
for como se puede anidar todo, pero cuidado 00:20:59
si una anida for no vaya a utilizar 00:21:00
la misma variable 00:21:03
porque dentro de este for y ya está usada 00:21:04
ya tiene un uso 00:21:07
que es el índice del bucle de arriba 00:21:08
entonces no uséis 00:21:10
la misma variable índice 00:21:13
en for anidados 00:21:15
vale, pues entonces 00:21:16
siguiente variante, el arbolito 00:21:20
vale, pues a ver 00:21:22
siguiente variante 00:21:59
el arbolito este 00:22:02
entonces este arbolito es la misma idea 00:22:05
es n veces 00:22:07
imprimir una línea 00:22:09
luego el for de arriba es idéntico 00:22:11
el for de arriba es idéntico 00:22:13
porque yo n veces tengo que imprimir 00:22:15
una línea 00:22:17
lo que cambia es la línea 00:22:18
porque aquí la línea eran 00:22:20
y más un asterisco 00:22:22
y ya está 00:22:24
entonces aquí lo que cambia es que para imprimir 00:22:25
cada línea, no es esto 00:22:28
cada línea tendré 00:22:30
que hacer, primero imprimir 00:22:32
unos espacios, los que toquen 00:22:35
y luego ya imprimir asteriscos 00:22:37
entonces aquí imprimir la línea 00:22:39
será imprimir unos cuantos 00:22:40
espacios y luego después 00:22:42
imprimir unos cuantos asteriscos, en eso 00:22:44
consiste ahora imprimir la línea 00:22:46
y aquí era más fácil, aquí imprimía asteriscos y más 00:22:47
aquí no, aquí 00:22:50
en cada iteración de la i 00:22:52
para i igual a 0 00:22:54
pues imprimo dos espacios 00:22:55
en este caso, cuando n es igual a 3 00:22:58
y un asterisco 00:23:00
pero cuando y es igual a 1 00:23:02
imprimo un espacio 00:23:04
y tres asteriscos 00:23:06
y cuando y es igual a 2, que sería la última 00:23:07
imprimo cero espacios 00:23:10
y cinco asteriscos 00:23:12
luego 00:23:14
claro, entonces 00:23:15
la línea desde luego no la consigo 00:23:17
con esto, con esto conseguía imprimir 00:23:20
y más un asterisco sin más 00:23:22
luego la línea con esto no se consigue 00:23:23
Entonces, ¿cómo consigo la línea? 00:23:26
Bueno, pues hago en secuencia 00:23:29
Primero imprimo los espacios 00:23:30
Y luego imprimo los asteriscos 00:23:33
Entonces, vamos a imprimir primero los espacios 00:23:35
¿Cuántos espacios? 00:23:38
Todavía no lo sé, vamos a pensarlo 00:23:39
Pero sé que 00:23:41
Habrá un número de espacios a imprimir 00:23:44
Y aquí yo 00:23:46
Imprimiré los espacios 00:23:49
Print, para que no salte 00:23:51
Print, espacio 00:23:55
vale, cuando ya he terminado los espacios 00:23:57
este for ya acabó 00:24:00
este for ya acabó, ya he terminado de imprimir los espacios 00:24:01
voy con los asteriscos 00:24:04
pues otro for 00:24:06
aquí sí que puedo reutilizar 00:24:07
la jota, porque este no es 00:24:10
un for interno 00:24:12
vale, pues 00:24:13
claro, este for de arriba 00:24:15
ya acabó, la jota ya desapareció 00:24:20
la puedo volver a usar aquí 00:24:21
vale, pues a falta 00:24:23
de esto, que es todavía 00:24:37
la incógnita, el programa 00:24:40
estaría. 00:24:42
Imprimo en líneas. ¿Cada línea en qué consiste? 00:24:44
Primero, imprimo 00:24:47
una serie de espacios, no sé cuántos. 00:24:48
Y luego imprimo 00:24:51
una serie de asteriscos, no sé cuántos. 00:24:52
Y cuando ya lo he hecho, me voy a línea siguiente. 00:24:54
Este tiene que seguir 00:24:57
estando aquí, cada línea siguiente. 00:24:58
Aquí, cuidado, no pongo llaves, porque 00:25:00
solo hay una sentencia en cada uno. 00:25:02
¿Vale? En cada unzo. 00:25:04
vale, ahora la pregunta es 00:25:06
oye, pero ¿cuántos espacios y cuántos asteriscos 00:25:08
se imprimen en cada línea? 00:25:11
hombre, pues podemos sacar la regla fácilmente 00:25:12
fijaos en el caso de n igual a 3 00:25:14
imprimimos espacios 00:25:17
¿cuántos? 2, 1 y 0 00:25:19
pero si n fuera igual a 4 00:25:20
si n fuera igual a 4 00:25:22
tendríamos este árbol de navidad 00:25:26
¿y cuántos espacios nos costaría imprimir? 00:25:27
nos tendríamos que imprimir 00:25:30
3, 2, 1 y 0 00:25:31
claro, luego el número de espacios que hay que imprimir 00:25:32
en cada línea 00:25:36
empieza siempre 00:25:37
siendo 00:25:39
uno menos que el número de líneas 00:25:40
y se va incrementando 00:25:43
¿no? 00:25:44
claro 00:25:47
es decir 00:25:47
para i igual a cero 00:25:50
¿cuántos espacios tenemos que imprimir? 00:25:52
en espacios 00:25:56
menos 00:25:57
i más uno ¿verdad? 00:25:58
y los mismos 00:26:05
para este, los mismos para esta 00:26:06
es decir, para el caso 3 00:26:09
en la línea 1 tengo que imprimir 00:26:11
3 menos 1, 2 espacios 00:26:14
luego, este es el 00:26:16
número de espacios 00:26:19
que tengo que imprimir en la línea i 00:26:20
ese, n menos i más 1 00:26:23
lo podéis probar 00:26:25
para varios ejemplos, para este 00:26:29
cuando n es igual a 4 00:26:31
estamos en el caso de n es igual a 4 00:26:32
para n igual a 4 00:26:36
e i igual a 0, ¿cuántos espacios 00:26:40
tengo que imprimir? 00:26:42
4 menos 00:26:43
1, 3, justo 00:26:45
pero para i igual a 1 00:26:47
¿cuántos? 4 menos 00:26:49
2, 2, justo 00:26:51
luego se trata de sacar la regla 00:26:52
que me relaciona 00:26:55
número de espacios con 00:26:56
número de filas 00:26:58
y fila en la que estoy 00:27:01
pues esa es la relación 00:27:02
n igual menos i más 1, este es el número de espacios 00:27:04
que tengo que imprimir 00:27:07
empezando con n menos 1 00:27:08
y cada vez siendo 1 menos 00:27:13
¿Esta es la regla? 00:27:15
¿Sí o no? 00:27:21
Sí, no es fácil de ver 00:27:23
Entonces, n menos i más 1 00:27:25
¿En qué se va convirtiendo? 00:27:27
n menos i más 1 se va convirtiendo 00:27:29
Igual es más fácil de ver 00:27:31
La regla esta así 00:27:33
En lugar de n menos i más 1 00:27:34
n menos 1 menos i 00:27:37
Así igual es más fácil de verlo 00:27:40
Para la fila 0 00:27:42
n menos 1 espacios 00:27:43
Pero para la fila 1 00:27:45
n menos 2 espacios 00:27:46
Para la fila 2, n menos 3 espacios 00:27:48
Para la fila n menos 1, que es la última, 0 espacios 00:27:51
Quizás así lo veis más fácil 00:27:56
Que es lo mismo que lo que había puesto antes 00:28:00
Es decir, cada fila tendrá un número de espacios igual a n menos 1 menos la fila en la que estoy 00:28:03
De tal forma que en la fila 0 serán n menos 1 00:28:10
En la fila 1, n menos 2 00:28:15
en la fila 2 00:28:17
n-3 cada vez uno menos 00:28:19
¿verdad? porque ahí se va incrementando 00:28:21
cada vez un espacio menos 00:28:23
y se va incrementando 0, 1, 2 00:28:24
luego cada vez un espacio menos justo 00:28:27
empezando ¿por cuál? por n-1 00:28:29
la condición del for 00:28:31
para poner eso 00:28:32
a ver, esta es la cantidad de veces que se ejecuta el for de arriba 00:28:34
pues es plantar eso ahí, ya está 00:28:37
j menor que n-1 00:28:38
claro 00:28:41
n-1 menos i, menos i más 1 00:28:42
ya está, lo que yo quería era saber 00:28:45
el número de espacios que tenía que imprimir 00:28:47
en cada fila. Pues el número de espacios 00:28:49
que tengo que imprimir en cada fila es este. 00:28:51
Pues ya está. Esto ya lo tengo. 00:28:54
¿Vale? Para la primera 00:28:59
fila, que es la 0, n-1. 00:29:00
Está claro. 00:29:02
Para la segunda fila, que es la 1, 00:29:04
n-2. 00:29:06
Para la tercera fila, que es la 2, 00:29:07
n-3. 00:29:10
Para la última fila, que es la 3, 00:29:11
n-4. Justo. 00:29:14
Ningún espacio. Ninguno. Se acabó. 00:29:16
Pues ya está. Esa es la cantidad 00:29:18
que me faltaba, el número de espacios 00:29:20
el número de espacios es 00:29:22
m-1 menos i 00:29:23
y ahora, número de asteriscos 00:29:24
pues para la fila 0 00:29:28
1, a ver si sacamos 00:29:30
la regla, para la fila 0 00:29:35
hay que imprimir un espacio 00:29:37
pero para la fila 1 00:29:38
¿cuántos espacios hay que imprimir? 3 00:29:40
pero para la fila 2 00:29:42
¿cuántos? 5 00:29:44
para la fila 3 00:29:47
¿cuántos? 7 00:29:49
Luego 00:29:51
¿Qué regla 00:29:53
Podemos sacar para pasar 00:29:56
De 0 a 1, de 1 a 3 00:29:58
De 2 a 5 00:30:00
¿Qué regla sacamos? 00:30:01
No hay más o menos porque en la primera vez 00:30:03
Se hace así 00:30:05
Es decir, lo que me pide es que me saquéis 00:30:06
¿Qué función 00:30:09
De i 00:30:10
Me devuelve este número? 00:30:12
¿Qué función de i me devuelve este número? 00:30:14
Para saber 00:30:18
Este número, ¿cuánto va a ser? 00:30:19
o lo que es lo mismo, ¿cuántos asteriscos 00:30:20
voy a tener que imprimir en función de i? 00:30:22
¿Cuántos asteriscos voy a tener que imprimir 00:30:25
en función de i? 00:30:26
¿Encontráis alguna función matemática? 00:30:28
¿Alguien ve alguna expresión matemática 00:30:38
que me dé este valor en función 00:30:39
de lo que valga i? 00:30:41
El número de líneas 00:30:45
menos el número de espacios. 00:30:46
No hace falta ni la n. 00:30:48
De 0 tengo que pasar a 1. 00:30:51
De 1 a 3, de 2 a 5, de 3 a 7. 00:30:52
Ah, números impares. 00:30:55
¿Y cómo? ¿Cómo lo expreso? 00:30:57
No, no, yo no lo he fundido. 00:31:01
A ver. 00:31:03
Esto, ¿y ahora tenéis? 00:31:05
2 por i más 1. 00:31:07
2 por i más 1. 00:31:14
Cuando i es igual a 0, 1. 00:31:17
Cuando i es igual a 1, 3. 00:31:19
Cuando i es igual a 2, 5. 00:31:22
o sea, es la sucesión aritmética 00:31:24
de los números impares de toda la línea de matemática 00:31:26
es decir, 2 por i más 1 00:31:29
me dice para cada fila 00:31:32
cuántos asteriscos tengo que poner 00:31:34
para la fila 0 me saca 1, estupendo 00:31:36
para la fila 1 me saca 3 00:31:39
para la fila 2 00:31:41
me saca 5, luego 2 por i más 1 00:31:42
es el número de asteriscos 00:31:45
que tengo que poner en cada fila 00:31:46
pues ya está, ya lo tengo 00:31:48
lo planto aquí en mi siguiente interrogación 00:31:50
y acabe el programa 00:31:52
2 por i 00:31:53
Más 1 00:31:56
Y ya está 00:31:57
Sacarla 00:31:59
Algo de esto 00:32:02
Son sin líneas de código 00:32:05
Pero sí 00:32:06
Por eso decía que a partir de ahí 00:32:07
Algunos son más fáciles, más difíciles 00:32:10
Entonces 00:32:12
Esto no va a caer 00:32:12
Pues sí 00:32:16
Pero este mismo ya lo tenéis hecho 00:32:17
No, ejercicios tan difíciles 00:32:20
o tal, no 00:32:23
no te preocupes, va a caer esto 00:32:24
pero con stream y con chat 00:32:29
y con tablas 00:32:30
vale, a ver 00:32:31
la cosa es que bueno, a ver, es la primera vez 00:32:35
que os enfrentáis a este tipo de ejercicios 00:32:37
pero la primera vez 00:32:39
es la que os tiene que 00:32:41
servir para hacer un poquito 00:32:43
ya la conexión neuronal y decir, vale 00:32:45
esta forma de funcionar ya la he 00:32:47
usado una vez 00:32:49
a ver si cuando tenga que hacer algo parecido se me enciende 00:32:50
la luz para decir 00:32:53
ya sé, ya sé 00:32:54
cómo se trabajaba 00:32:57
pues venga, hago mi conexión 00:32:58
que sí, hombre, sí 00:33:01
que hay mucha luz 00:33:05
vale, entonces en este caso ha sido 00:33:06
tenemos que hacer n líneas 00:33:08
y en este caso para cada línea 00:33:10
he visto 00:33:13
unos cuantos espacios y unos cuantos 00:33:13
asteriscos, vale, el misterio 00:33:17
ha sido, ¿cuántos espacios? 00:33:19
pues los he tenido que sacar 00:33:21
para cada línea en función de i y n 00:33:22
¿cuántos espacios? ¿cuántos asteriscos? 00:33:25
pues para cada línea, en este caso 00:33:27
con i ya me salían, no necesito la n 00:33:29
entonces si ejecutáis esto pues ya está 00:33:31
a ver, sobre todo 00:33:35
lo que cuesta entender es sacar la relación 00:33:41
matemática, la relación matemática 00:33:43
entre la fila en la que estoy 00:33:45
y la cantidad de asteriscos 00:33:47
o espacios, la relación matemática entre una y otra 00:33:49
a ver, la relación matemática entiendo 00:33:51
que es más complicado, pero lo otro 00:34:06
ya no, porque lo otro es lo que estamos trabajando todo el rato 00:34:08
que es pensar 00:34:10
modularmente, pensar por módulos 00:34:11
entonces vos te vas a tener que ir pensando 00:34:13
a ver, este programa como se plantea 00:34:16
varias veces una línea 00:34:18
ahí ya tienes el primer for 00:34:20
Ahora ya, como tú estás pensando modularmente 00:34:21
Dices, muy bien, tengo un primer for 00:34:24
Ahora, ¿qué tengo que hacer aquí debajo? 00:34:25
Vale, pues lo que tengo que hacer aquí debajo 00:34:28
Es imprimir una línea, ¿cómo lo hago? 00:34:30
Anda, pues para hacerlo, tengo que hacer 00:34:31
Varios espacios 00:34:34
Un for, y varios asteriscos 00:34:35
Otro for 00:34:37
Vale, entonces tenéis que tener ese pensamiento 00:34:38
Modular 00:34:42
Claro 00:34:42
De aquí lo complicás la relación 00:34:45
Sacar la relación matemática 00:34:48
entre espacios y asteriscos, pero eso ya es una cosa 00:34:50
más al margen de la programación 00:34:52
¿vale? 00:34:53
claro, sacar la relación entre 00:34:57
el número en función 00:34:59
de n y de i 00:35:02
que en este caso ha dependido de n 00:35:03
los espacios 00:35:06
y los asteriscos solo de i 00:35:07
bueno, pues 00:35:09
en el primer caso son n-1 00:35:12
siempre 00:35:14
si tienes 4 filas son 3 espacios 00:35:14
n-1 siempre 00:35:18
por eso la fórmula es 00:35:19
n menos 1 menos i 00:35:21
para que cuando dice igual a 0 te dene menos 1 00:35:23
y cuando dice igual a 1 te dene menos 2 00:35:25
y cuando dice igual a 2 te dene menos 3 00:35:28
que es la relación que hemos visto que seguimos 00:35:30
¿vale? 00:35:32
¿sí me alía? 00:35:33
¿cómo la mitad? 00:35:37
vale, hombre pues tiene que salir 00:35:44
Si lo tienes exactamente igual, no puede ser. 00:35:46
Vamos a ver. 00:35:52
Vale. 00:36:09
Esto vamos a decirle que introduzca el N mayúscula. 00:36:10
Y ahora 00:36:15
Un momento, no mováis 00:36:18
Vamos a comprobar que lo hace bien 00:36:21
Falta una cosa más por deciros 00:36:23
Relax, vale 00:36:26
Sí, pero espero 00:36:28
Quiero que os relajéis 00:36:29
Y ahora, este for tiene tres partes 00:36:31
Primero 00:36:38
Desde j igual a 0 00:36:40
Mientras j sea menor que n 00:36:43
Menos 1 menos i 00:36:47
E incrementando J 00:36:48
En ese caso haces 00:36:51
El espacio 00:36:53
A ver si es que, David 00:36:58
En lugar del espacio has puesto una cadena vacía 00:37:01
Pues será 00:37:04
Y aquí haces esto mismo 00:37:09
Pero 2 por I 00:37:12
Por I más 1 00:37:14
Y aquí pones asterisco 00:37:18
esto así no es 00:37:20
esto así no es 00:37:24
y esto 00:37:25
ahora ya sí 00:37:28
vale, lo ejecutamos 00:37:29
vale, ya está 00:37:40
vale 00:37:41
sería eso, que no has puesto 00:37:43
espacio 00:37:46
sino que has puesto cadena vacía 00:37:48
Bueno, pero obviamente sí que funciona 00:37:49
Lo acabo de probar yo y sí funciona 00:37:55
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
24 de octubre de 2024 - 17:23
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
946.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid