Saltar navegación

20251112 EjerBucles_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 12 de noviembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces, el objetivo de este programa es imprimir esto adaptado a la cantidad de líneas que me den como dato de entrada. 00:00:00
Luego hay un dato de entrada, que es el número de líneas. 00:00:16
Si fuera siempre cuatro, ni bucles ni nada, podríamos hacer los system.out.println y ya está. 00:00:20
Cuatro system.out.println y se acabó. 00:00:25
Pero claro, no es la idea. 00:00:27
Entonces, como el número de líneas es variable 00:00:28
Aquí ya va a ser un bucle 00:00:31
Y el bucle que va a hacer dentro en cada iteración 00:00:34
Pues ahora ya es cuando tenemos que intentar traducirlo un poquito 00:00:38
Ya a nuestro propio diseño 00:00:41
Bueno, pues lo que va a hacer el bucle en cada iteración 00:00:44
Es imprimir una línea 00:00:47
Lo que pasa es que en cada iteración 00:00:49
La línea que imprime es distinta 00:00:52
Pero al fin y al cabo no deja de ser 00:00:54
un bucle que se ejecuta tantas veces como líneas 00:00:56
me han dicho 00:00:59
y en cada iteración imprime una línea 00:01:00
vale, pero al menos la primera parte importante la tengo 00:01:02
que es bucle que se ejecuta tantas veces como líneas 00:01:05
eso seguro, sí o sí 00:01:09
bueno, pues la primera parte ya la tenemos fácil 00:01:10
si yo aquí he leído las líneas que son estas 00:01:14
pues un bucle que se ejecuta tantas veces como valor haya ahí 00:01:17
es un bucle for 00:01:21
vale, pues esto es un bucle for 00:01:23
que se ejecuta 00:01:32
tantas veces como líneas 00:01:34
vale 00:01:37
hasta ahí fácil 00:01:38
ahora 00:01:41
¿qué hacemos en cada iteración? 00:01:42
imprimir una línea 00:01:45
pero esa línea que tiene 00:01:47
pues si ya nos ponemos a analizar cada línea 00:01:48
y decimos 00:01:50
cada línea lo que tiene es 00:01:51
unos cuantos 00:01:53
espacios 00:01:56
y unos cuantos asteriscos 00:01:58
Eso es lo que yo veo, que cada línea tiene unos cuantos espacios y unos cuantos asteriscos 00:02:00
¿Cuántos? 00:02:06
Depende de la línea en la que esté 00:02:08
¿Vale? 00:02:10
Depende de la línea, pues entonces 00:02:12
Vale, dependiendo de la línea en la que estemos 00:02:14
Vale 00:02:30
Esta será 00:02:42
Esta será 00:02:44
La línea igual a cero 00:02:49
Esta será la línea I igual a 1 00:02:52
Esta será la línea I igual a 2 00:02:54
Esta será la línea I igual a 3 00:02:57
Eso cuando son 4 líneas 00:02:59
Cuando sean 7, pues tendré desde la 0 hasta la 6 00:03:00
Bueno, pues en este ejemplo en particular 00:03:03
Esto si yo lo cuadriculo así para verlo mejor 00:03:07
Pues en la línea I igual a 0 00:03:15
Tengo 3 espacios y un solo asterisco 00:03:18
¿Vale? Entonces lo analizo un poquito para ver si hay alguna regla 00:03:23
Y claro, veré que hay una regla 00:03:27
Sin embargo, en la línea I igual a 1, ya no es la 0 00:03:29
Si en la línea I igual a 1 tengo 2 espacios y 3 asteriscos 00:03:33
En la línea I igual a 2 tengo un solo espacio y 5 asteriscos 00:03:40
Y en la última de las líneas, tengo 0 espacios y 7 asteriscos. 00:03:50
Luego ahí ya veo una regla. 00:04:00
Es decir, si tengo n líneas cualquiera, los espacios que tengo, 00:04:03
imaginaos que en lugar de 4, como es aquí, que van de 0, 1, 2 a 3, 00:04:09
esto lo extiendo a que tengo n. 00:04:15
Pues entonces ya veo aquí claramente una regla. 00:04:17
En la primera línea tengo que imprimir n-1 espacios, en la segunda línea tengo que imprimir n-2 espacios, en la siguiente tengo que imprimir n-3 espacios, así hasta que llegue a 0 espacios. 00:04:19
Esto de nuevo lo puedo hacer con un for, ¿vale? Esto n-1, n-2, n-3, esto ya me suena a un for o una variable que se va decrementando, ¿vale? 00:04:34
Y asteriscos, ¿cuántos imprimo? Pues hombre, aquí tengo una sucesión de números impares, una sucesión de números impares la podemos generar siempre, ¿no? De esta manera, 2 por el generador más 1, cuando x sea igual a 0 tengo el primer impar, que es 1, cuando x sea igual a 2, perdón, a 1, tengo el siguiente impar, que es 3, cuando x sea igual a 2, tengo el siguiente impar, que es 5. 00:04:43
entonces esta serie 00:05:11
en algún otro ejercicio ya la usamos 00:05:13
esta serie me va generando 00:05:16
los números impares 00:05:18
para x igual a 0 00:05:19
1, 2, 3 00:05:21
pues para x igual a 0, 1, 2, 3 00:05:23
esta me va generando los impares 00:05:25
1, 3, 5, 7 00:05:27
que es justo lo que me viene muy bien aquí 00:05:28
generar los impares 00:05:31
luego, ahora ya con esto, ¿qué tengo que hacer? 00:05:32
mi bucle 00:05:36
¿qué tiene que imprimir? 00:05:37
mi bucle tiene que imprimir 00:05:39
n menos 1 espacios y luego el impar correspondiente. 00:05:41
Entonces, lo puedo hacer con dos for anidados. 00:05:48
Un primer for para imprimir estos espacios y un segundo for para imprimir los asteriscos. 00:05:50
¿Vale? 00:05:57
Puedo hacer eso. 00:05:58
Un primer for para imprimir los espacios y otro para imprimir los asteriscos. 00:05:59
Y ya está. 00:06:03
Luego hago un salto de línea y he terminado. 00:06:04
Entonces, esto, ¿cuánto? Vale, primero vamos a imprimir los espacios. ¿Cuántos espacios queremos? Pues queremos, para la fila 0, quiero numlíneas menos 1. 00:06:06
Para la fila 1 00:06:26
Quiero numlíneas menos 2 00:06:28
Para la fila 2 00:06:30
Quiero numlíneas menos 3 00:06:32
¿Cuántos espacios 00:06:33
Quiero en general? 00:06:36
Pues 00:06:39
Que re numlíneas 00:06:39
Menos 1 00:06:44
Menos i 00:06:46
Esos son 00:06:48
Los espacios 00:06:50
Que quiero 00:06:52
¿Vale? 00:06:52
Voy a poner una llave 00:06:55
para que se vea más claro 00:06:57
entonces, este bucle 00:06:59
para i igual a cero 00:07:01
se ejecuta en un líneas menos uno 00:07:03
que son justo los espacios que quiero 00:07:05
pero para la fila uno 00:07:07
se ejecuta una vez menos, porque es un espacio menos 00:07:08
y para la fila dos 00:07:11
se ejecuta una vez menos, porque quiere un espacio menos 00:07:12
entonces 00:07:15
sí, a ver 00:07:16
este es un bucle 00:07:19
bueno, vamos a poner primero lo que hay dentro para 00:07:20
entonces aquí importante es 00:07:22
el primer bucle es para los espacios, ¿no? 00:07:25
este primer for 00:07:26
es para los espacios 00:07:29
el de arriba es para las líneas 00:07:31
uno por línea 00:07:35
entonces 00:07:36
yo he cambiado un momento 00:07:38
he cambiado esto 00:07:41
no, no lo había cambiado 00:07:42
este bucle es para las líneas 00:07:44
entonces este se ejecuta una vez por línea 00:07:51
y ahora en cada línea, ¿qué queremos hacer? 00:07:53
pues en la primera línea 00:07:55
En la primera línea, como i es igual a cero, ¿cuántos espacios me hará? 00:07:56
Nun líneas menos uno, que son los que tocan. 00:08:04
Acordaos que si nun líneas era, imaginaos que nun líneas es cinco. 00:08:07
Si nun líneas es cinco, en la primera línea necesito cuatro espacios. 00:08:15
¿Verdad? Cuatro espacios. 00:08:22
Cuando nun líneas era cuatro y tomamos tres espacios. 00:08:23
Era lo que habíamos. 00:08:26
vale, pues justo este bucle 00:08:27
en la primera línea me hace 4 00:08:29
pero en la siguiente fila 00:08:31
me hará solamente 00:08:33
3 espacios, uno menos, porque ya habrá 00:08:34
saltado, ahora ahí sería igual a 1 00:08:37
y en la siguiente línea, que sea la línea igual a 2 00:08:38
me hace un espacio menos 00:08:41
que es justo lo que quiero 00:08:43
y en la siguiente línea me hace 00:08:44
un espacio menos 00:08:47
y ya en la última línea 00:08:47
no me hace espacios 00:08:50
luego con este for estamos consiguiendo hacer los espacios 00:08:52
¿vale? 00:08:55
Pero no hemos terminado todavía, porque una vez que hemos hecho los espacios, nos quedan los asteriscos. 00:08:57
¿Qué cuantos asteriscos necesitamos? 00:09:05
Pues en cada, la sucesión de los números impares. 00:09:08
Ya está, la sucesión de los números impares. 00:09:11
Pues entonces, aquí importante. 00:09:14
No estoy usando println, porque println te imprime lo que sea y te hace un salto de línea. 00:09:17
No, aquí los asteriscos, los espacios, los queremos todos seguidos. 00:09:23
vale, println 00:09:27
el que hemos usado siempre 00:09:29
te imprime lo que tú le des 00:09:31
y luego te mete un salto de línea 00:09:33
no queremos, queremos que te imprima 00:09:34
y no te haga el salto de línea para el siguiente 00:09:37
espacio hacerlo después, el siguiente después 00:09:39
entonces uso la versión 00:09:40
print sin saltos de línea 00:09:42
que no 00:09:45
sabíais esto, no lo habéis buscado 00:09:48
lo podíamos haber hecho con concatenación 00:09:50
acumulativa, vamos a hacer a la versión ahora para que 00:09:53
le perdáis miedo a las concatenaciones acumulativas 00:09:55
que construyen la línea y luego imprimimos la línea y se acabó 00:09:57
vale, pero vamos a completar esta versión 00:09:59
hala, ya he terminado los espacios 00:10:03
pues vamos a hacer ahora 00:10:05
los asteriscos 00:10:06
asteriscos, ¿cuántos se van a hacer? 00:10:09
mirad que aquí 00:10:18
he usado otro nombre 00:10:19
para la variable índice porque la i 00:10:21
ya tiene un uso en el bucle que la 00:10:23
incluye 00:10:25
el i, que es el bucle que lo incluye 00:10:26
significa el número 00:10:29
de fila, luego j 00:10:31
es otra variable distinta 00:10:33
vale, pues aquí 00:10:36
desde j igual a 0, aquí puedo reutilizar 00:10:38
la j porque este bucle ya acabó 00:10:41
este bucle ya acabó, luego puedo 00:10:43
usar la j, este bucle ya acabó, la j 00:10:45
desapareció, vale, pues 00:10:47
¿cuántos asteriscos queremos? mientras j 00:10:49
sea menor que, pues vamos 00:10:51
a generar la lista de los impares 00:10:53
a partir de ahí 00:10:55
vale, para la fila i igual a 0 00:10:56
me sacará 1 00:11:01
pero para la fila 00:11:03
i igual a 2, igual a 1 00:11:05
perdón, me sacará 3 00:11:07
y para la siguiente fila que es la i igual a 2 00:11:09
me sacará 5, luego con esto 00:11:11
voy generando 00:11:14
los impares 00:11:15
asociados a cada fila 00:11:17
repito, para la fila i igual a 0 00:11:19
esto se convierte en 1 00:11:22
que es justo los asteriscos que necesito 00:11:23
sin embargo para la siguiente fila 00:11:25
que es la i igual a 1 00:11:28
eso se convierte en 3, que es justo 00:11:29
Estoy mapeando 0, 1, 2, 3 00:11:32
A los impares correspondientes 00:11:34
0, 1, 2, 3 00:11:35
A 1, 3, 5, 7 00:11:37
A través de esta función 00:11:38
A través de esta función matemática 00:11:40
Que me mapea 0, 1, 2, 3 00:11:42
A 1, 3, 5, 7 00:11:45
Bueno 00:11:47
Y aquí que quiero hacer 00:11:49
Sin el ln 00:11:53
Imprimir asterisco 00:11:54
Ya he terminado de hacer 00:11:57
todos los espacios que me tocan 00:12:00
para cada fila i 00:12:03
i más 1, ¿dónde? 00:12:04
bueno, es 2 por i más 1 00:12:15
esto es para generar los impares 00:12:18
cuando la fila es 0 00:12:20
te generará 1, cuando la fila es 1 00:12:21
te generará 3, cuando la fila es 2 00:12:23
te generará 5, que es justo lo que queremos 00:12:26
mapear 0 a 1, 1 a 3 00:12:27
vale, y una vez que he 00:12:29
completado los espacios y los asteriscos 00:12:31
ahora ya sé que quiero un salto de línea 00:12:34
para la siguiente fila 00:12:35
¿vale? 00:12:37
metemos un salto de línea 00:12:39
para la siguiente fila 00:12:41
ahora ya nos toca meter un salto 00:12:45
de línea para que la siguiente fila se haga abajo 00:12:47
pues eso hacemos un system.out.print.ln 00:12:49
no, porque entonces cada asterisco 00:12:52
lo iría bajando abajo y son todos seguidos 00:12:57
¿vale? 00:13:00
Vale, pues esto ya está. 00:13:01
Si ejecutamos esto, metiendo cualquier cosa, pues ya está. 00:13:05
¿Vale? 00:13:13
Vale. 00:13:18
Entonces, cada fila tiene los espacios que le tocan y los asteriscos que le tocan. 00:13:19
Que son, fila 0, un asterisco. 00:13:26
Fila 1, 3. 00:13:29
Fila 2, 5. 00:13:30
pues justo por eso hacemos 2 por i más 1 00:13:31
para que la fila 0 me dé 1 00:13:34
para que la fila 1 me dé 3 00:13:36
y luego los espacios 00:13:38
si parto de 14 00:13:40
la primera son 3 espacios 00:13:41
pero las siguientes son 12 00:13:44
pero las siguientes son 11 00:13:45
pues por eso he puesto aquí numlíneas menos 1 menos i 00:13:46
porque en la fila 0 00:13:49
si es 14, serán 13 00:13:51
pero en la fila 1 serán 12 00:13:53
pero en la fila 2 serán 11 00:13:55
es decir, cada fila va perdiendo un espacio 00:13:57
por eso le pongo el menos i 00:14:00
cada fila va perdiendo un espacio 00:14:02
vale 00:14:04
entonces aquí también lo único era 00:14:05
pues 00:14:10
conocer 00:14:11
que yo puedo hacer un system out 00:14:13
sin salto de línea como el print 00:14:16
vale, pero vamos a hacerlo de otra manera 00:14:18
esto mismo simplemente, en lugar de ir 00:14:20
imprimiéndolos vamos a ir construyendo 00:14:22
con sumas acumulativas la línea 00:14:24
final y luego mostramos la línea 00:14:26
cuando lo tengamos 00:14:28
y así no tenemos que usar el system out print 00:14:29
Otra versión con concatenaciones 00:14:36
Acumulativas 00:14:42
Vale 00:14:45
Pues esta va a ser 00:14:47
A ver, nuestro for 00:14:49
Gordo es el mismo 00:14:55
Se ejecuta tantas veces como número de líneas 00:14:57
Nuestro for gordote es el mismo 00:14:59
Vale 00:15:01
Ahora, ¿qué va a hacer cada for gordote? 00:15:05
Imprimir una línea 00:15:09
Que vamos a 00:15:10
Construir 00:15:11
Entonces, inicialmente esta línea está en el vacío 00:15:13
Y ahora le vamos a ir concatenando 00:15:17
Los espacios y los asteriscos 00:15:19
Se los vamos a ir concatenando 00:15:21
Cuando ya tengamos la línea construida del todo 00:15:22
La mostramos y se acabó 00:15:25
¿Vale? 00:15:28
O sea, en lugar de ir mostrando carácter por carácter como aquí 00:15:29
Vamos a construir la línea entera 00:15:32
Con todos sus espacios, sus asteriscos 00:15:34
Cuando ya esté entera, se imprime 00:15:37
¿Vale? 00:15:38
Pues 00:15:41
bueno, pues vamos a hacer esa concatenación 00:15:41
acumulativa, recordad que una concatenación acumulativa 00:15:58
que es una suma acumulativa pero de cadenas 00:16:02
es una suma de cadenas, que eso es concatenar una suma de cadenas 00:16:05
pues siempre es a través de un bucle 00:16:08
que le van llegando, los sumando, le van llegando y los va incorporando 00:16:11
siempre se hace a través de un bucle 00:16:14
pues aquí nuestro primer bucle que va a concatenar 00:16:16
los espacios es este 00:16:19
Este es nuestro primer bucle para concatenar los espacios 00:16:21
Vale, pues alinea más igual espacio 00:16:24
¡Hala! Ya hemos hecho la primera concatenación acumulativa 00:16:32
Donde vamos concatenando y acumulando sobre esta línea inicialmente vacía 00:16:37
Los espacios que necesitamos 00:16:42
Que son estos, para cada línea y son esos 00:16:44
Ahora, vamos a concatenarle los asteriscos 00:16:48
Los asteriscos 00:16:52
Pues este bucle 00:16:55
Es en el que yo iré concatenando 00:17:00
Línea más igual, asterisco 00:17:05
Vale, pues así construyo la línea 00:17:07
Voy concatenando los espacios 00:17:10
Los que tocan en función de la línea en la que esté 00:17:13
Y cuando he terminado de concatenar espacios 00:17:15
Me pongo a concatenarle asteriscos 00:17:18
Uno tras otro, uno tras otro, uno tras otro 00:17:21
Los que toquen en función de la línea en la que esté 00:17:24
En la primera línea tocará uno 00:17:26
Pero en la siguiente línea tocarán tres 00:17:28
Cuando ya tengo la línea enterita 00:17:30
La imprimo 00:17:32
Y ya está, salto de línea para volver 00:17:33
En el for de arriba a la siguiente 00:17:36
Vale, pues vamos a ver si nos sale 00:17:38
Bien también 00:17:42
Si le ponemos cuatro, pues sí 00:17:45
Cualquiera de las dos versiones están haciendo lo mismo 00:17:47
Vale 00:17:50
No, líneas 00:17:53
No es igual 00:18:08
Es un efecto óptico 00:18:12
Son iguales 00:18:14
Parece distinta pero son iguales 00:18:17
Vale, pues 00:18:19
Entendido 00:18:22
Pues venga 00:18:24
Vámonos entonces al ejercicio 00:18:45
bueno, pues el ejercicio 31 00:18:48
es imprimir esta 00:19:03
tablita de aquí 00:19:05
vale, la fila de arriba 00:19:06
la podemos ver como una fila 00:19:09
de título que podemos tratarla aparte 00:19:11
si queremos, porque sobre todo 00:19:13
las que nos importan son las de abajo 00:19:14
que son las que tienen los cambios 00:19:16
que como no puedo seleccionar 00:19:18
vale, entonces, olvidándonos de la fila de arriba 00:19:20
que la podemos poner primero arriba como título 00:19:22
y ya está, que no sabéis 00:19:24
mirar 00:19:29
pues 00:19:29
estas de aquí, que rabia que no se puede seleccionar 00:19:31
vale, estas 00:19:34
que son 00:19:37
las que tienen la operativa, pues esto se puede 00:19:39
ver como imprimir 00:19:41
10 líneas, vale, imprimir 10 líneas 00:19:42
hasta ahí bien 00:19:45
bueno 00:19:46
10 líneas, este dato es variable 00:19:49
¿verdad? 00:19:50
si en 00:19:53
n líneas en general 00:19:53
Y en cada fila, ¿qué hace? En cada fila, claro, va imprimiendo una serie de números que va generando en función de la fila. Si la fila es la 1, esta y sumando 1. Si la fila es la 2, esta pero sumando 2. Si la fila es la 3, esta pero sumando 3. Así. 00:19:56
luego se trata de imprimir tantas filas como me han dado n 00:20:14
y luego en cada fila 00:20:17
hacer otro for que me va imprimiendo 00:20:19
numeritos generados 00:20:21
en función de la fila 00:20:23
pues como acabamos de decir por ejemplo 00:20:24
para cada fila parte de ese número 00:20:26
y me los va imprimiendo incrementados en uno 00:20:29
lo podemos plantear así 00:20:31
y esto lo podemos poner al principio como título 00:20:32
y este como es el mismo número pues que lo imprima 00:20:34
dos veces el primero y ya está 00:20:37
claro imprimir el número de fila 00:20:38
y luego ya hacerte todo ese for 00:20:40
Entonces, si nos lo planteamos así, pues nos queda algo como esto, más o menos. 00:20:42
Que es lo primero que se me ocurre. 00:20:50
Bueno, pues primero habrá que pedirle el numérico. 00:20:54
Lo voy a llamar N mayúscula para que sea más rápido de escribir. 00:20:59
Vale, pues lo vamos a llamar N mayúscula, que es más rápido. 00:21:07
Venga, vamos a imprimir el titulito antes de nada. 00:21:14
el titulito 00:21:17
que tiene 00:21:23
ah bueno, aquí era donde tenía esto el problema 00:21:24
de los descuadres 00:21:29
no, pero aquí 00:21:31
también se va a dar el problema de los descuadres 00:21:34
entonces 00:21:35
vamos a hacerlo sin tener eso 00:21:39
en mente y nos va a salir 00:21:41
un cuadrado un poco descuadrado y luego ya 00:21:43
podemos plantear cómo arreglarlo 00:21:45
vale, vamos a imprimir el titulito 00:21:47
hacemos una primera versión con lo que se nos ha ocurrido 00:21:49
Que es lo primero que a mí se me ocurriría de buenas a primeras 00:21:51
Pues 00:21:53
Imprimo la 00:21:55
Imprimo una fila 00:21:58
Y en esta fila 00:21:59
Mientras si sea menor que 00:22:02
Bueno primero 00:22:06
Imprimo el carácter este extraño 00:22:09
Vamos a imprimir el carácter 00:22:12
Este extraño 00:22:14
Que es yo que sé cualquier cosa una X gorda 00:22:15
Vale 00:22:18
Bueno vamos a hacerlo con concatenaciones 00:22:21
Acumulativas 00:22:24
esta es mi línea 00:22:24
que inicialmente es este carácter gordote de aquí 00:22:28
este carácter gordote, y ahora voy a ir concatenando 00:22:32
sobre ese carácter gordote 00:22:36
y menor que N mayúscula, entonces como en realidad 00:22:39
aquí es 1, 2, 3, pues voy a hacer ya el for directamente, para no tener que sumarle 00:22:45
1 a la I todo el rato, vamos a hacer ya el for directamente así 00:22:49
Y así no tenemos que sumarle 1 a la n todo el rato 00:22:52
Pues aquí, alínea más igual y 00:22:57
Ala, como ya parto de la x, esto no es una suma 00:23:01
Esto ya va concatenando, va concatenando con el 1, con el 2, con el 3, con el 4 00:23:06
¿Vale? Entonces ya tengo la línea de arriba 00:23:10
Tengo la línea de arriba 00:23:13
Sin colorcitos y sin nada 00:23:17
Que si lo ejecutamos 00:23:21
Pues vale 00:23:27
Quiero trabajar con 10 00:23:27
Pues a tu línea de arriba 00:23:33
Para que no esté tan pegadito 00:23:34
Vamos a ponerle 00:23:36
Aunque 00:23:42
Le ponemos 2 y así nos queda más 00:23:43
Vale, pues venga 00:23:46
Ala, esta es la línea de arriba 00:23:51
Vale 00:23:53
Ahora, a ver 00:23:55
Vamos a las siguientes líneas 00:23:58
En las siguientes líneas 00:24:00
¿Cuántas líneas más tenemos? 00:24:03
N mayúscula 00:24:08
Pues venga, un for que me imprima cada una 00:24:08
Ahora ya tengo el for 00:24:10
Esta es la cabecera solo 00:24:11
Esta es la que he hecho para la cabecera 00:24:13
Nada más 00:24:14
Para la cabecera 00:24:15
Ahora vamos a imprimirnos ya las N mayúscula líneas 00:24:16
Pues por ejemplo 00:24:19
Desde la línea 1 00:24:21
Voy a partir desde 1 en vez de 0 00:24:23
porque como los propios números empiezan en 1 00:24:25
así no voy sumando más 1 todo el rato 00:24:27
mientras i sea menor que 00:24:29
n mayúscula incrementando i 00:24:31
vale 00:24:33
pues ahora, este es el que me imprime 00:24:35
este bucle menor o igual 00:24:37
este bucle es el que me va a 00:24:39
imprimir estas 00:24:41
líneas, vamos a ir construyéndolas 00:24:43
vale, pues 00:24:45
la vuelvo a resetear, la línea 00:24:47
al vacío, la vuelvo a resetear 00:24:48
para empezar de cero, lo primero 00:24:51
que se le concatena es 00:24:53
el número de la línea 00:24:55
1, 2, 3, 4 00:24:57
es lo primero que se le concatena, vale 00:25:00
y luego ya lo demás, ya es lo que vamos generando 00:25:02
entonces lo primero que se le concatena 00:25:04
el número de la línea, y 00:25:08
que como al x 00:25:10
no le he puesto espacio 00:25:13
al y tampoco se lo voy a poner 00:25:14
bueno, venga, si le pongo un espacio 00:25:17
y a este también 00:25:18
le pongo un espacio 00:25:20
vale 00:25:22
aún así nos va a quedar feo 00:25:24
para que cuadre exactamente a la cantidad de números 00:25:26
habría que hacer otro retoque 00:25:28
bueno, pues ya tengo hecho 00:25:30
ya he construido la primera parte 00:25:32
de la línea, que es este número, y ahora tengo que imprimir 00:25:35
todo esto, ahora ya, lo que imprimo 00:25:36
después, depende de la línea 00:25:38
en la que esté y depende de esta manera 00:25:40
pues si estoy en la 1 00:25:42
parto desde la 1 00:25:44
y el incremento es 1, pero si estoy 00:25:46
en la 2, parto desde la 2 00:25:48
y el incremento es 2, entonces la idea 00:25:50
siempre es encontrar una relación 00:25:52
entre el número de fila 00:25:54
en la que estoy, que esa es la que tiene el for dentro 00:25:56
el número de fila, y lo que quiero 00:25:58
imprimir, pues aquí la primera relación 00:26:00
que se me ocurre es esa, parto 00:26:02
desde la fila en la que estoy 00:26:04
y voy imprimiendo los sucesivos números 00:26:06
con incrementos iguales 00:26:08
precisamente al número de fila en la que estoy 00:26:10
pues entonces 00:26:12
esto dicho así, quedaría 00:26:14
ahora tengo que hacer 00:26:16
el for, y este for 00:26:20
parto 00:26:25
Desde la fila en la que estoy 00:26:29
Si estoy en la fila I 00:26:31
Pues parto desde I 00:26:35
¿Cuántas impresiones tengo que hacer? 00:26:36
Tengo que hacer 00:26:43
10 impresiones 00:26:44
Pues desde J menor que 00:26:47
I más 10 00:26:50
Si me estoy cogiendo los límites 00:26:53
Luego uno lo retoca cuando lo haga 00:26:55
¿Vale? Por no ponernos ahora a pensar 00:26:56
Y ahora 00:26:59
Tengo que hacer 10 impresiones 00:27:00
J más más 00:27:02
Con esto hago 10 impresiones 00:27:04
¿Y qué es lo que imprimimos? 00:27:06
Sí, para que me haga 10 justas 00:27:13
Pero 00:27:15
Ay, perdón, perdón, perdón 00:27:16
Claro, estaba centrada en la esta 00:27:19
Vale, entonces 00:27:20
J vale 2, 3 00:27:22
Pues esto puedo partir 00:27:24
Como sería lo más fácil 00:27:27
O lo puedo hacer J más igual I 00:27:29
Y así concateno la J directamente 00:27:35
Porque el incremento es el número de fila 00:27:38
J más igual I 00:27:40
Y ahora tengo que cambiar ese otro límite 00:27:42
Línea más igual 00:27:43
J más 00:27:46
Pues dos espacios 00:27:49
Y ahora este N me cambiará 00:27:52
Como J lo voy incrementando de I en I 00:27:56
Será de i más 00:28:00
Puede que haya acertado con esto 00:28:02
Con los límites, puede ser 00:28:05
Si me he pasado o no he llegado 00:28:06
Lo podemos arreglar 00:28:08
Lo que nos importa ahora es entender la idea 00:28:09
¿Vale? 00:28:10
Así, vale 00:28:18
Entonces 00:28:19
Puede ser, por eso digo que no 00:28:20
El límite este es el que lo he escrito así 00:28:23
Cogido por los pelos 00:28:25
Ahora cuando lo ejecutemos vamos a probar a 00:28:27
Vale, por ahora vamos a entender 00:28:29
la idea, es como mi primera aproximación 00:28:32
así a lo bestia, mi primera aproximación 00:28:34
luego ya podemos ir retocando 00:28:36
¿vale? pero la primera aproximación es 00:28:37
tantas filas como 00:28:40
N mayúscula, ¿vale? 00:28:42
esto, si se 00:28:47
si se pudiera 00:28:48
esto poner en la tablita 00:28:50
aquí al lado 00:28:54
vale, pues 00:28:55
esto queda 00:29:10
vale 00:29:15
tantas filas 00:29:17
como n mayúscula 00:29:22
vale, si n es 10, 10 filas 00:29:25
tantas filas, en cada fila 00:29:27
que hacemos, lo primero que estoy 00:29:29
concatenando a la línea final 00:29:30
a la que me ha faltado imprimir, que ahora imprimiré 00:29:32
lo primero que concateno a la línea final 00:29:34
es el número de fila 00:29:37
1, 2, 3, 4, lo primero que concateno 00:29:39
y ahora, me pongo a ir haciendo 00:29:41
concatenaciones acumulativas 00:29:43
con los números que van 00:29:45
desde el número de fila en la que estoy 00:29:47
si estoy en la fila 1 00:29:49
empezaré a acumular desde el 1 00:29:51
si estoy en la fila 2 00:29:52
empezaré a acumular desde el 2 00:29:54
pues voy haciendo concatenaciones acumulativas 00:29:56
donde empezando desde el número de fila 00:29:59
voy concatenando los números 00:30:01
con un incremento entre sí de i 00:30:04
porque si estoy en la fila 1 00:30:06
el incremento entre sí es 1 00:30:07
si estoy en la fila 2 00:30:09
el incremento es 2 00:30:10
luego j se va incrementando 00:30:11
tantas veces como número de fila en la que estoy 00:30:14
y esto es lo que he hecho un poco 00:30:17
entre 00:30:18
porque esto 00:30:19
un poco a ojo, o sea, yo lo que quiero es que esto 00:30:22
se ejecute exactamente 00:30:24
n mayúscula veces, no sé 00:30:26
si con esto se me va a ejecutar n mayúscula veces 00:30:28
uno menos o uno más, pero bueno 00:30:30
siempre se puede retocar 00:30:32
¿no? porque 00:30:34
está igual ahí 00:30:35
bueno, vamos a probarlo directamente 00:30:38
a ver que sale 00:30:41
y si nos hemos equivocado en el límite 00:30:43
que casi seguro, pues me decís 00:30:46
cómo arreglarlo, a ver 00:30:48
y ahora ya que tenemos la línea construida 00:30:50
la imprimimos 00:30:53
la línea ya está construida, la imprimimos 00:30:54
y luego pasamos a la siguiente 00:30:57
a ver que nos saca 00:30:59
esto, vamos a ver 00:31:01
que nos saca esto, vamos a 00:31:03
darle primero 00:31:08
algo más pequeñito, 5 00:31:10
podemos acertar la primera, no me puedo creer 00:31:12
la intuición 00:31:14
vale, entonces 00:31:16
pues sí, hace la tabla correctamente 00:31:18
salvo que el formato nos ha quedado feo 00:31:20
porque claro, al poner dos espacios 00:31:22
siempre, en cuanto pasamos de una cifra 00:31:24
a dos 00:31:26
que lo vuelva a ejecutar con 00:31:26
diez 00:31:30
pues sí, me hace la tabla 00:31:30
con 00:31:34
pero me la ha descuadrado un poquito 00:31:35
¿vale? 00:31:38
pero bueno 00:31:41
esto era de alguna manera lo que se pedía 00:31:42
ahora ya que se quede cuadrado 00:31:44
no es tan sencillo 00:31:46
Porque para que se quede cuadrado, lo que se convierte en variable ahora es el número de espacios que yo concateno aquí en cada concatenación. 00:31:48
Que lo tendré que calcular en función del número de filas que tenga. 00:31:58
Claro, en función del número de filas que tenga y de las cifras que tenga el numerito. 00:32:04
es un trabajo que podéis 00:32:09
pensar y hacer 00:32:13
porque esta concatenación 00:32:14
el número de espacios 00:32:17
pues hay que construirla con concatenaciones 00:32:18
de espacios dependiendo de las cifras 00:32:21
que tenga el número y del número de filas que tenga 00:32:23
es un poco 00:32:25
farragoso, no es que sea difícil 00:32:27
pero es lioso 00:32:29
entonces bueno, si alguien tiene curiosidad que lo haga 00:32:30
pero sobre todo el objetivo era jugar 00:32:33
con los form anidados 00:32:35
con diferentes índices 00:32:37
este for 00:32:39
tira del índice 00:32:42
de la de arriba, el de arriba me dice 00:32:44
la fila en la que estoy 00:32:46
y abajo dependo 00:32:47
de la fila en la que estoy pues para hacer 00:32:50
las cosas 00:32:52
pero para cualquier cantidad 00:32:53
dando un espacio donde aquí en vez de 2,1 00:33:04
supongo que dependerá también del 00:33:05
número de 00:33:11
variables que 00:33:12
claro del dato que le des 00:33:14
Claro, si le doy el 3 00:33:16
Ah, bueno, si le doy el 3 00:33:19
Y aquí también pongo 00:33:22
Un espacio, que era aquí, ¿no? 00:33:23
El número de línea 00:33:28
Claro, si le doy el 00:33:29
Claro 00:33:33
Aquí como no me salto nunca de las cifras 00:33:34
Claro 00:33:37
Pero en cuanto ya en una ya me salgan cifras de 2 aquí 00:33:38
Ya la he liado 00:33:41
En cuanto aquí me salgan ya 00:33:43
En el 6 00:33:45
Aquí ya se empiezan a descuadrar 00:33:46
En cuanto haya 00:33:49
Vale 00:33:50
Más cosillas 00:33:51
Que me quedan 46 minutos 00:33:58
De batería, así que 00:34:01
Fijaos todo el tiempo que tenemos 00:34:02
Venga, algún otro ejercicio, o arrancamos con los de Arraiz 00:34:04
Con el listado de Arraiz 00:34:09
Bueno, pues estos tratad de 00:34:10
hacerlos, dudas que tengáis 00:34:20
las decís, etc 00:34:23
vale, vamos a 00:34:24
parar aquí 00:34:26
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:
4
Fecha:
12 de noviembre de 2025 - 18:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
318.14 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid