Saltar navegación

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

Clase 21-11-23 - 2 - 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 21 de noviembre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues la primera parte que habréis hecho todos, pues bueno, es simplemente pedir número 00:00:00
de filas, número de columnas, tal y como dice el ejercicio, declarar la variable, declarar 00:00:10
la variable con su número de filas y columnas, declarar la variable, y ahora ya el recorrido 00:00:17
que recorre todas y cada una de las posiciones, cada fila y cada columna en este doble for, 00:00:23
en este caso para asignarle un valor aleatorio. Vale, aquí antes de seguir convendría mostrar 00:00:28
a ver qué números ha generado, por ejemplo. Bueno, pues podemos plantearnos, podríamos 00:00:35
haberlo hecho en el mismo, pero vamos a hacerlo aparte. Otro recorrido, simplemente ahora 00:00:40
para recorrer y mostrar, ¿vale?, que podríamos haber mostrado en el mismo a la vez que recorremos, 00:00:44
pero bueno, lo estamos separando para insistir en lo de los recorridos. Venga, este es solamente 00:00:50
para este recorrido, era para rellenar la matriz y este recorrido para mostrar la matriz, 00:00:55
¿vale? Entonces, si hacemos esto, tablero y j, pues sí hombre, efectivamente se me 00:01:08
van a mostrar todas las posiciones, pero se me van a mostrar feas, porque se me van 00:01:22
a mostrar todas seguidas, ¿no? Si ejecutamos esto, venga, 3 filas por 2 columnas, entonces 00:01:26
así será, 3 por 2, 6 posiciones, pues me las muestra todas seguidas, esta es la primera 00:01:35
fila, esta es la segunda, vale hombre, la matriz tiene estos valores, pero hombre, ya 00:01:41
que nos ponemos a mostrarla, vamos a mostrarla respetando su distribución, entonces, eso 00:01:45
significa que, en lugar del println, mostramos con print, sin más, y vamos a concatenar 00:01:54
con un espacio, y ahora ya, cuando hemos terminado de mostrar una fila, y la fila que hemos terminado 00:02:05
de mostrarla, cuando este for ha acabado, cuando este for ha acabado, ya hemos terminado 00:02:11
de mostrar una fila, pues ahí, en ese punto, le ponemos ya un salto de línea, para que 00:02:17
vaya a la línea de abajo, ¿vale? Bueno, pues este for es simplemente para mostrar 00:02:23
los valores, entonces, esto me irá mostrando los de cada fila, todos seguidos, con un espacio 00:02:29
entre medio, cuando la fila ahí ha terminado, salta abajo, ojo, cuidado con estos errores, 00:02:35
ahora mi for de arriba tiene dos sentencias, no se olvide poner las llaves, mi for de cada 00:02:41
fila tiene, mostrar todos sus elementos, y salto a la siguiente, mostrar todos los elementos 00:02:49
y salto a la siguiente, vamos a ver ahora si lo muestra más bonito, venga, tres filas 00:02:55
por tres columnas, vale, ahora ya lo muestra más bonito, este for me va mostrando fila 00:03:04
por fila, separado por espacio, y este, una vez que ya he mostrado una fila enterita, 00:03:10
salto abajo, salto abajo, para que la siguiente fila me la muestre abajo, solo para mostrar, 00:03:16
ya aprovechando, como ha surgido ahí, para seguir introduciendo caracteres, ya aprovechando, 00:03:22
hay una cosa, que seguramente os sonarán, de otras materias que no son programación, 00:03:28
que son los caracteres ASCII que se llaman de escape, que son los tabuladores, los espacios, 00:03:35
los raros, entonces cuando uno quiere mostrar un carácter de esos, por ejemplo un tabulador, 00:03:41
vamos a suponer que yo aquí he puesto que sea entre mil, si yo he puesto entre mil y 00:03:48
ejecuto esto, número de filas, tres y tres, vale, pues vale, si me la ha mostrado bien, 00:03:54
pero hombre, no me queda muy bonito, porque al haber puesto yo solo un espacio entre ellos, 00:04:02
pues hombre, como que se queda descuadrado, entonces nos gustaría más, después de cada uno, 00:04:06
meter un tabulador, después de cada uno meter un tabulador, solamente para que quedara más bonito, 00:04:11
a ver, para qué uso esto, para qué digo esto, simplemente para ir introduciendo el concepto 00:04:16
de caracteres de escape, que son caracteres más de la tabla ASCII, como el salto de línea, 00:04:22
el enter, el tabulador, caracteres más de la tabla ASCII, que puedo yo querer escribir en mi System.out.println, 00:04:28
igual que aquí he escrito un espacio, pues en lugar de un espacio, quiero poder escribir un tabulador, 00:04:34
porque es un carácter más, esos caracteres, como escribo yo un tabulador, pues son los que se llaman 00:04:38
caracteres de escape, y en los lenguajes de programación, se escriben siempre poniendo la barra esta, 00:04:43
que es la barra de escape, para decir, ojo, que viene un carácter de escape después de la barra, 00:04:50
eso significa esta barra, ojo, y ahora ponemos una letra, que cada letra se corresponde con un carácter de escape, 00:04:55
la T en particular se corresponde con el tabulador, entonces si yo quiero imprimir un tabulador, 00:05:01
pongo barrita para decir viene carácter de escape y luego T, y quiero imprimir un salto de línea, 00:05:08
el salto de línea también es un carácter raro, pues ojo, que viene carácter de escape, 00:05:15
¿qué letrita va asociada al salto de línea? La N, pondría esto, pero bueno, nos interesa un tabulador, 00:05:21
pues venga, vamos a cambiar el espacio por un tabulador, barrita para decir, ojo, que viene carácter de escape, 00:05:28
y ahora la letra correspondiente a ese carácter, tabulador, para un salto de línea, N viene de nueva línea, 00:05:37
entonces si yo ahora pongo 3, 3, pues ahora sí que me queda más bonito, porque he metido todo un tabulador 00:05:46
después de cada carácter, ¿vale? Vale, bueno, eso en cuanto a carácteres, que suene que la tabla ASCII 00:05:53
tiene todos los carácteres que conocemos, A, B, C, J, H, coma, tilde, todos esos, y también tiene carácteres de escape, 00:06:02
tabuladores, saltos de línea, que si yo quiero escribirlos en la consola, tengo que buscar el código al que se corresponde, 00:06:10
el código al que se corresponde, y en particular el tabulador, que se usa mucho, pues es carácter de escape, 00:06:19
pero bueno, esto como anécdota. Vale, pues ya tenemos nuestra matriz, ahora el siguiente paso del ejercicio 00:06:25
era pedir un número de fila, pues nada, venga, le pedimos un número de fila, vale, ya tenemos el número de fila, 00:06:33
y ahora ya es cuando viene el algoritmo, el algoritmo que es, tenemos que hacer una suma de muchos valores, vale, 00:06:56
esos valores donde van a estar, son valores de la matriz, luego tenemos que recorrer la matriz e ir incorporando valores de esa matriz 00:07:06
en una variable suma, bueno, ese algoritmo de suma acumulativa, pues ya nos sabemos de memoria como es, 00:07:17
tendré ya una variable resultante que inicializa a cero, y ahora ya me pongo a recorrer y voy incorporando a la suma lo que haga falta, 00:07:24
entonces si lo hacemos sin pensar mucho, yendo a piñón fijo, vale, vamos a recorrer otra vez la matriz, que es lo que sabemos hacer, 00:07:33
recorremos la matriz y vamos incorporando en la variable suma los valores que yo quiera, vale, bueno, pues vamos a recorrer la matriz otra vez, 00:07:42
luego los for, los mismitos, y ahora, aquí van pasando todos y cada uno los valores, ahora que tenemos que hacer, 00:07:53
pues estos valores se irán incorporando a la suma, todos, no todos, solo algunos, si yo no distingo y hago esto, pues obviamente este ejercicio lo que haría 00:08:10
es sumar todos los elementos de la matriz, porque este va recorriendo los todos, este lo incorporo a la suma, este a la suma, este a la suma, 00:08:27
este a la suma, este a la suma, este a la suma, este a la suma, este a la suma, este a la suma, …., que ahora yo quiero dar el salto de no quiero sumarlos todos, 00:08:36
quiero solo sumar aquellos cuya fila sea la que me han dado, bueno, pues ahí podría meter esa modificación, oye, ojo, que no quiero sumarlos todos, 00:08:41
no quiero recorrerlos y sumarlos todos, no, todos no, todos no, voy a meter esto en un if, porque no quiero sumarlos todos, 00:08:53
lo meto en un if, de tal forma que voy a sumar solo cuales, voy a sumar solo aquellos en los cuales la fila en la que estén sea la fila que me han pedido, 00:09:01
pues esa condición yo la podría poner, sí, un momento, así no, entonces yendo así incrementalmente, pues ya está, llego a esto y esto hace lo que tiene que hacer, 00:09:15
vale, hago una suma acumulativa, recorro la matriz, pero a la suma, en lugar de incorporarlos todos, los que voy recorriendo, pa, pa, pa, pa, pa, pa, 00:09:30
incorporo solo los que cumplen que la posición y es igual a la c, y así en principio eso, pues ya está, esto a priori está, es incuestionable, está bien, vale, 00:09:43
otra cosa es que ahora uno diga, uff, pues sí que te estás complicando, sí, efectivamente, vale, otra cosa es que uno, claro, pero si uno va un poquito a piñón fijo sacando las cosas que hemos visto, 00:09:57
pues bueno, puede llegar a esto, no, vale, tengo que recorrer todos, no a suma acumulativa, recorro y sumo, pero espera, no todos, voy a sacar solo los que tengo, bueno, 00:10:09
ahora ya, uno ya está más suelto en esto y dice, hombre, vamos a pensar, este bucle for, en realidad, solo está sumando, solo está sumando cuando i es igual que en un fila, 00:10:19
pues para qué quiero yo pasar por todas, voy a olvidarme del for de fuera, vamos a ponerlo aquí, otra forma más fácil, volvemos a poner suma cero para comprobar que da lo mismo, 00:10:35
vamos a poner aquí la suma, vale, otra forma más fácil, en lugar de ir pasando por todas las filas, la cero, la uno, la dos, y solamente hacer la suma cuando estoy en la que sea igual a un fila, 00:10:57
pues directamente me olvido del bucle de fuera y hago esto, oye, sumame desde j igual a cero, mientras j sea menor que el número de columnas incrementando j, 00:11:22
sumame a la variable suma, tablero en un fila, de j, vale, entonces, esto es más sencillo que esto, porque este pasa por la cero, pero a lo mejor la cero ni entra aquí nunca, 00:11:37
luego pasa por la uno, la uno ni entra aquí nunca, es que solamente entra aquí para el i igual a un fila, solo entra para el i igual a un fila, pues vamos a olvidarnos de este for, 00:12:03
y hacemos un único for que vaya sumando todas y cada una de las columnas de esta fila, ya está, para qué recorrer todas las filas y sumar solo las de i igual a un fila, 00:12:14
pues me quedo ya en esta fila, me quedo en esta fila, y voy sumando sobre la variable suma, la cero, la una, la dos, esa variable la he puesto j simplemente para que quede más claro 00:12:30
que estamos hablando de columnas, vamos a comprobar que da lo mismo por si algo hemos escrito mal, vale, venga, dos filas, tres columnas, 00:12:43
vale, pues vamos a la fila cero, vale, pues si, ambas opciones hacen lo mismo, lo que pasa es que la primera, el bucle de fuera está perdiendo aquí un montón de tiempo, 00:13:10
está perdiendo un montón de tiempo, se está ejecutando un montón de veces para que aquí no entre, para no entrar ahí, vale, bueno, ¿está claro? 00:13:28
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:14:28
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:14:58
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:15:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:15:31
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:15:51
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:16:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:16:31
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:16:51
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:17:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:17:31
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:17:51
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:18:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:18:31
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:18:51
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:19:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:19:31
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:19:51
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:20:11
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:20:39
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:20:49
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime. 00:21:09
Entonces, si nos pasa eso aquí, no tenemos acceso a la zona donde se declaró 00:21:39
que pongo aquí y que pongo aquí. 00:21:44
En el caso de los arrays lo teníamos solucionado, ¿no? ¿Cómo lo teníamos solucionado? 00:21:47
Con la variable punto len, que dado un array te decía el número de posiciones 00:21:52
para las cuales se habían reservado, las que fueran, ¿vale? 00:21:57
Y aquí hay algún punto len, pues es complicado, tendría que haber dos puntos len, ¿no? 00:22:02
Porque aquí hay filas y hay columnas. 00:22:07
Bueno, pues hay una forma de, dada una variable array de dos dimensiones, 00:22:10
saber cuántas filas tiene y cuántas columnas. 00:22:16
Y para eso hay que entender cómo maneja la máquina virtual por dentro del array de dos dimensiones. 00:22:20
Para la máquina virtual cuando declara esto, fijaos lo que está haciendo. 00:22:27
Está declarando. 00:22:31
Antes cuando veíamos arrays decía, cada vez que veáis esto, es que está diciendo muchos de algo, ¿verdad? 00:22:34
¿Verdad que sí, María? 00:22:43
Que luego me dices, uy, es que como no te estaba haciendo mi caso, 00:22:45
es que esto que has puesto, pues es que no lo he puesto. 00:22:48
¿Vale? 00:22:52
Cuando declaramos un array poníamos, cuando yo pongo los corchetes, 00:22:54
pongo estos muchos de lo que hay aquí. 00:22:58
Vale, muchos enteros, muy bien. 00:23:01
Si ponemos string y esto es muchos cadenas. 00:23:03
Vale, pues aquí estamos poniendo muchos arrays. 00:23:07
Es lo que le estamos diciendo a la máquina virtual. 00:23:11
Haz muchos arrays. 00:23:13
Luego la máquina virtual para ella, esto es un array de arrays. 00:23:15
Es decir, esto es un array de dos dimensiones. 00:23:20
Perdón, de una. 00:23:24
Y esto es otro. 00:23:25
Y esto es otro. 00:23:26
Y a su vez tiene un array de muchos de estos. 00:23:28
Tiene un array de tres arrays de estos. 00:23:33
Esto sería un array de tres posiciones, donde cada posición tiene a su vez un array de cuatro. 00:23:39
Luego un array de dos dimensiones es un array, pero donde en cada posición a su vez es un array. 00:23:47
Es decir, es esto. 00:23:54
Esto es en realidad el array de dos dimensiones. 00:23:59
Un array donde en cada posición a su vez hay otro. 00:24:01
Esto es en realidad. 00:24:05
¿Vale? 00:24:07
Esto que yo he dibujado así como un tablero es una primera posición donde hay un array enterito. 00:24:08
Otra segunda posición donde hay otro array enterito. 00:24:13
Otra tercera posición donde hay un array enterito. 00:24:16
Y luego, como tablero es un array de arrays, si nosotros hacemos tablero.ler, ¿qué numerito me sacará con esto? 00:24:19
¿El número de qué? 00:24:29
¿De filas? 00:24:32
¿Vale? 00:24:34
Tablero es un array de arrays. 00:24:35
Es esto. 00:24:37
¿Pero solo de las filas? 00:24:38
Sí, tablero es un array donde en cada array a su vez es un array. 00:24:40
Luego, si yo hago el tamaño de este array, ¿me dice las filas? 00:24:44
Eso es lo que me dicen, las filas. 00:24:49
Con lo cual, esta parte ya la tengo solucionada. 00:24:51
Las filas, sé que la puedo sacar así. 00:24:54
¿Pero y qué pasará con las columnas? 00:25:04
Bueno, pues las columnas, una vez que yo me he colocado en un array concreto, 00:25:08
para este en concreto puedo sacar su tamaño con el .len. 00:25:13
Pero claro, ¿este en concreto cuál es? 00:25:17
Pues este es tablero de cero. 00:25:19
¿Verdad? 00:25:22
Tablero de cero es todo este. 00:25:23
Todo este es tablero de cero. 00:25:25
Y este es tablero de uno. 00:25:28
Todo este. 00:25:31
Por eso cuando hacemos tablero cero cero es esta de aquí. 00:25:33
Y cuando hacemos tablero cero uno es esta de aquí. 00:25:36
Y tablero de dos es todo este. 00:25:39
Todo este. 00:25:42
Luego, cada una de las filas, ¿cómo podría sacar su longitud? 00:25:44
Para la fila i, para toda la fila i, ¿cómo puedo sacar su longitud? 00:25:52
¿Qué pondríais ahí? 00:25:56
Eso sí, ¿vale? 00:25:59
¿Qué es tablero de i? 00:26:08
Tablero de i es toda la fila i enterita. 00:26:10
Todo el array fila i enterita. 00:26:13
Toda. 00:26:15
Entonces si yo quiero, toda. 00:26:16
Entonces si yo quiero la posición cero, por eso hago tablero de i de cero. 00:26:18
Pero me quedo en la cero. 00:26:21
Si quiero la uno, por eso hago tablero de i de uno. 00:26:23
Porque me quedo en la uno. 00:26:25
Pero tablero de i es todo el array entero. 00:26:27
Entonces si yo quiero toda la longitud de este, pues tablero de i punto len. 00:26:29
¿Vale? 00:26:39
Entonces ahora ya esto me generaliza. 00:26:40
Y yo no tengo por qué saber las dimensiones del tablero. 00:26:43
Sé que con este voy por todas y cada una de las filas. 00:26:46
Y ahora para cada fila, el tamaño de cada fila me viene dado por tablero de i punto len. 00:26:50
Para cada fila, tablero de i punto cero, tablero de i punto uno. 00:26:55
No, eso te saca el tamaño de cada fila, que a su vez serán las columnas. 00:27:03
Esta es una fila. 00:27:09
Tablero de i punto len es uno, dos, tres y cuatro su tamaño. 00:27:11
Con lo que es lo mismo las columnas. 00:27:14
¿Eh? 00:27:17
A ver, pero estamos hablando del número de columnas que hay. 00:27:22
Y el número de columnas es el tamaño de cada fila. 00:27:26
Si tú pones filas de cinco, ¿cuántas columnas hay? Cinco. 00:27:33
Si pones filas de seis, ¿cuántas columnas hay? Seis. 00:27:37
¿Vale? 00:27:42
Entonces con esto ya podemos generalizar y decir, vale, yo aquí sé seguro que voy a recorrer todo el tablero. 00:27:44
Esto lo he puesto al revés. 00:27:51
Y no tengo necesidad de saber cuántas dimensiones tiene. 00:27:54
¿Vale? Entonces esto es un poco raro, pero si lo revisáis, si lo repasáis, lo entenderéis. 00:28:00
Que tablero de i en sí es algo, pero que es una raya enterito. 00:28:05
Tablero de i es una raya enterito, que es la fila i. 00:28:10
Entonces a tablero de i como tal yo no accedo. 00:28:13
Yo accedo a tablero de i de cero. 00:28:16
Tablero de i de uno. 00:28:18
Porque a una raya yo accedo a las posiciones. 00:28:19
Y tablero de i es todo una raya. 00:28:22
Todo una raya. 00:28:24
¿Vale? 00:28:27
Y de hecho esto me permite, el que esto funcione así, el que para la máquina virtual 00:28:30
una raya de dos dimensiones sea una raya de arraies, me permitiría tener arraies, 00:28:34
perdón, arraies bidimensionales, donde el tamaño de las filas es distinto entre sí. 00:28:40
Es decir, yo puedo tener una raya de arraies. 00:28:58
Esto es una raya. 00:29:01
Y ahora dentro de este array en cada posición hay un array. 00:29:03
Pero aquí hay uno de tres. 00:29:06
Y aquí quiero uno de cuatro. 00:29:08
Y aquí quiero uno de dos. 00:29:11
Y aquí quiero uno de cinco. 00:29:13
Y aquí quiero uno de dos. 00:29:16
Eso también es posible. 00:29:18
¿Vale? Esto ya no va a ser una matriz cuadradita como antes, que todos tenían tres o todos tenían cuatro. 00:29:20
No es una matriz cuadradita. 00:29:26
Pero a lo mejor me interesa. 00:29:27
¿Vale? 00:29:30
Y ahora la pregunta complicada, a ver si conseguís no perderos, 00:29:44
pero es que estas cosas hay que incorporarlas. 00:29:48
Ahora la pregunta es, imaginaos que queremos esta estructura de datos. 00:29:51
Yo quiero un array de arraies. 00:29:54
Pero ahora quiero que cada uno tenga un tamaño distinto. 00:29:57
No como antes. 00:30:00
Mi situación de antes era un array de arraies. 00:30:01
Por ejemplo este donde todos tienen lo mismo. 00:30:04
Tres, tres y tres. 00:30:06
Y esto lo veíamos como una matriz de tres por tres. 00:30:09
Tres por tres. 00:30:13
Y declaramos con tres por tres. 00:30:14
¿Vale? 00:30:15
Esta ya no es complicada de declarar. 00:30:16
¿Verdad? 00:30:18
Vamos a ver que son enteros. 00:30:19
Como es de dos dimensiones, porque es array de arraies, sigue siendo así. 00:30:20
Sigue siendo esto. 00:30:26
Ahora le doy el nombre que me dé la gana. 00:30:28
Vale. 00:30:30
El nombre que yo quiera. 00:30:32
Y ahora viene lo raro. 00:30:34
¿Qué es? 00:30:36
Vale, el número de filas lo tengo claro. 00:30:38
El número de filas lo tengo que decir. 00:30:40
¿Cuántas filas quieres? 00:30:42
Pues, si queremos hacer exactamente esta estructura. 00:30:45
Quiero cinco filas. 00:30:49
Pero claro, esta parte es la que se queda confusa. 00:30:53
¿Cuántas columnas quiero? 00:30:59
Depende, para la primera posición quiero que sean tres. 00:31:01
Pero es que para la segunda quiero que sean cuatro. 00:31:04
Pero es que para esta quiero que sean dos. 00:31:06
Entonces, ¿aquí qué pongo? 00:31:08
Cuando estábamos en esta situación, poníamos tres, porque quiero tres para todas. 00:31:10
Y ya teníamos tranquilamente nuestra array de tres por tres. 00:31:15
Pero en una situación así, ¿qué pongo aquí? 00:31:20
Ni idea. 00:31:22
Con lo cual, se deja vacío. 00:31:24
Se deja vacío. 00:31:28
Y ahora vamos creando los arrays fila uno por uno. 00:31:30
¿Vale? 00:31:35
Vale, esto lo digo. 00:31:40
Lo pensáis, tratáis de entenderlo, pero bueno, tampoco es algo en lo que nos vayamos a meter. 00:31:42
Por ejemplo, para la posición cero. 00:31:46
Tablero de cero. 00:31:48
Tablero de cero es todo un array. 00:31:50
Todo un array. 00:31:52
Pues vamos a crearlo. 00:31:53
new int, porque es un array de enteros. 00:31:55
¿Y de cuántos? 00:31:58
De tres. 00:32:00
¡Hala! 00:32:01
Ya tenemos esta primera creada. 00:32:03
Tablero de uno. 00:32:07
Tablero de uno es todo un array entero. 00:32:11
Ese. 00:32:14
Decido yo el tamaño que quiero. 00:32:16
new int de cuatro, por ejemplo. 00:32:18
Y así con todos. 00:32:22
Luego esta sería la forma, si es que nos interesa, que esto ya es más raro que nos interese, es más raro. 00:32:23
Debe declarar un array de arrays, o lo que es lo mismo, un array de dos dimensiones. 00:32:29
Pero donde cada fila tiene un tamaño distinto. 00:32:33
Tendría que ir yo declarando fila por fila. 00:32:36
Aquí lo dejo vacío diciendo, oye, va a tener tantas filas. 00:32:39
Pero ahora vete fila por fila decidiendo cuántas. 00:32:43
Y una vez que ya tengo todas las filas instanciadas con el tamaño que yo quiero. 00:32:47
Ahora ya es un array de dos dimensiones y lo recorro exactamente igual que hemos visto. 00:32:52
Tranquilamente. 00:32:56
Lo recorrería hasta tablero.lets y luego cada fila hasta tablerodei.lets y cada una sería distinta. 00:32:57
¿Vale? 00:33:03
Ahora mi for de recorrido. 00:33:04
Sería, para todas las filas, tablero.lets es la longitud del array de filas, que es el número de filas. 00:33:07
Y ahora, para cada fila, el recorrido lo haría desde igual a j, desde j igual a cero, perdón. 00:33:21
Mientras j sea menor que qué? 00:33:29
Que el tamaño de esa fila, el que sea. 00:33:31
Cada una es una. 00:33:34
La fila tablerodei, cada una tiene su tamaño. 00:33:35
Pues tablerodei.len. 00:33:39
Bueno, pues yo aquí iría recorriendo todo. 00:33:47
Este, este y este. Luego este, este, este y este. Luego este y este. Luego este, este, este y este. 00:33:49
¿Vale? 00:33:54
Pues si necesito una estructura así, pues ya está. 00:33:55
No tengo que declarar así. 00:33:58
Esto lo dejo por ahora vacío. 00:33:59
Creo las filas solamente. 00:34:02
Y ahora ya voy rellenando las filas con el array concreto que yo quiera. 00:34:04
Pero repito, esta estructura es mucho menos útil. 00:34:09
Un tablero exacto cuadrado, sí. 00:34:12
Porque esto reproduce una situación real muy habitual, que es un plano. 00:34:16
Un plano de cosas. 00:34:19
Un tablero de juego, lo que sea. 00:34:21
Entonces esta puede tener su utilidad porque no nos complica la vida. 00:34:23
Al contrario, nos la facilita. 00:34:26
Porque visualizamos algo real. 00:34:28
Y en este caso, pues yo aquí ya pongo directamente las filas y las columnas porque son todas iguales. 00:34:30
Lo pongo aquí y se acabó. 00:34:35
Y ya se crea de golpe todo. 00:34:37
Las filas y todas las columnas iguales. 00:34:38
Se crea todo de golpe. 00:34:40
Y esto no me hace falta. 00:34:41
Se crean todas. 00:34:42
Pero si yo dejo esto en blanco, se crean solo las filas, o sea, el número de posiciones, y luego tengo que ir una por una. 00:34:43
Pero lo importante es que lo entendáis. 00:34:53
Porque en realidad, de entenderlo, todo esto es de nuevo Arrays. 00:34:55
Cada uno es un Array. 00:35:00
Bueno, ¿está claro? 00:35:08
Bueno, y vamos a decirle un ultimito que es una chorrada de Arrays. 00:35:26
Que creo que está todo lo que necesitamos ahora más o menos. 00:35:35
Bueno, a ver. 00:35:39
Esto de los Arrays de dos dimensiones se podría extender hasta el infinito. 00:35:40
¿Vale? 00:35:45
Que uno quiere un Array de tres dimensiones. 00:35:46
Vale, no lo vamos a hacer, ni vamos a hacer ejercicio, ni nada. 00:35:49
Pero es que lo podéis extender. 00:35:52
¿Qué puede simular un Array de tres dimensiones? 00:35:54
Las posiciones que hay en un cubo. 00:35:56
¿Verdad? 00:35:59
Perfectamente, las puede simular. 00:36:00
¿Vale? 00:36:05
Si uno hace un cubo con cubitos pequeños, pa pa pa, hace su torre de cubos. 00:36:06
Tres cubos, otros tres cubos, otros tres cubos. 00:36:09
Pues, y quiere simular cada uno de esos cubitos. 00:36:12
Pues hombre, eso queda perfectamente simulado por un Array ahora de tres. 00:36:16
Que son la fila, la columna y la profundidad. 00:36:20
Ahora hay tres posiciones porque ahora no es un plano. 00:36:25
Que es fila, columna. 00:36:27
Ahora es fila, columna y profundidad. 00:36:29
Para la fila cero, columna cero, profundidad cero será este cubito. 00:36:32
Pero para la fila cero, columna cero, profundidad uno será el cubito que tiene justo detrás. 00:36:36
Para la fila cero, columna cero, profundidad dos será el cubito que tiene justo detrás. 00:36:41
Si uno quiere simular esa realidad de un cubo porque le interesa, 00:36:46
pues le viene que ni pintado una raíz, pero ahora de tres. 00:36:51
Pues como si son de 20.000. 00:36:56
Yo extiendo aquí los corchetes hasta donde me dé la gana. 00:36:58
Como si quiero poner 20.000 corchetes, pero para qué. 00:37:01
Ya para qué, perdería el sentido. 00:37:04
Como mucho tres puede tener sentido si quiero simular esto. 00:37:06
Pero más allá de eso... 00:37:09
Entonces yo puedo aquí tranquilamente hacer esto, por ejemplo, pues eso. 00:37:12
Tres, tres y tres. 00:37:18
Pues este sería un cubo de tres caras. 00:37:23
Tres caras así y luego tres de estas y ya está. 00:37:27
Uno lo puede hacer del tamaño que quiera. 00:37:34
Para recorrer, ¿qué tendría que hacer? Pues tres foranidados en vez de dos, tres. 00:37:37
El primero que te va diciendo en qué fila estás. 00:37:42
El de dentro, que dentro de la fila te marca en qué columna estás. 00:37:45
Y luego uno interno, que dentro de la columna en la que estás, te marca la profundidad en la que estás. 00:37:48
Y así recorres todo. Vas por aquí, por ahí, por ahí, etc. 00:37:52
Entonces el funcionamiento es igual. 00:37:58
Que uno quiera hacer una raíz y extender aquí los corchetes hasta 20 corchetes. 00:38:01
Pues lo extiende. 00:38:05
¿Pero qué va a querer simular con eso? 00:38:07
Pues bueno, ya es una complejidad innecesaria. 00:38:09
¿Vale? 00:38:14
Vale. 00:38:21
A ver, por último, que esto se ha ido quedando en el tintero siempre. 00:38:23
Lo apunto ahora antes de que... 00:38:29
A ver, cuando queramos una raíz cualquiera. 00:38:32
Para cambiar, que estamos siempre con los ints. 00:38:35
Un string, por ejemplo. 00:38:38
Vamos a suponer... 00:38:44
Esto es una cosa para inicializar a raíz de forma sencilla. 00:38:45
Vale. 00:38:50
Nosotros imaginamos que queremos trabajar con una raíz de nombres. 00:38:51
Cada nombre es una cadena de texto. 00:38:55
Pues boh, la estructura de datos que le pega es esa. 00:38:57
Un array de string. Esa es la que le pega. 00:39:00
Vale. 00:39:03
Ahora yo no puedo trabajar con este array si antes no creo el espacio. 00:39:04
Ya nosotros sabemos de memoria. 00:39:07
Bueno, pues entonces haríamos... 00:39:09
New string. 00:39:12
Y la cantidad de nombres que yo quiero. 00:39:14
El espacio que yo quiero. 00:39:16
Que son 3. 00:39:17
Pues venga, 3. 00:39:19
Y ahora ya puedo recorrer para inicializar para lo que me dé la gana. 00:39:21
¿Nombres de 0? Pepito. 00:39:24
¿Nombres de 1? Juanito. Vale. 00:39:25
Bueno, pues hay una forma rápida y sencilla. 00:39:27
Que a la vez crea espacio para array e inicializa. 00:39:30
¿Vale? 00:39:34
Entonces incorporémosla, que siempre se me olvida. 00:39:36
Forma rápida para hacer dos cosas a la vez. 00:39:40
Crear el espacio para el array, que es lo que te hace el new. 00:39:45
Y además dar valores iniciales a la array. 00:39:47
¿Vale? 00:40:00
Vale, y esta forma rápida que habréis visto en mil sitios, pues es esta. 00:40:08
¿Vale? En lugar de crear espacio y luego darle valores, puedo yo de golpe hacer las dos cosas. 00:40:13
De golpe. 00:40:18
¿Qué es? Pongo igual y abro aquí unas llaves, tenemos por punto y coma. 00:40:20
Y pongo los valores iniciales que yo quiero separados por comas. 00:40:24
Y ya está. 00:40:29
Entonces, esto te hace dos cosas en una. 00:40:35
Primera, te hace como el new. 00:40:38
Te crea un espacio en memoria. ¿Para cuántas? Tanto valores. Tres. 00:40:41
Y ahora, una vez que te ha creado el espacio en memoria, les asigna los valores que te has puesto aquí. 00:40:45
Entonces si tú quieres crear un array y a la vez darle los valores iniciales, pues eso es muy cómodo. 00:40:52
¿Vale? 00:40:57
Esto solo se puede hacer la primera vez que se usa un array que está declarado. 00:41:00
Si luego yo quiero, me he bajado por ahí por el código y a nombres le quiero cambiar y darle ahora otra cosa, otra cosa, ya no me va a dejar. 00:41:08
Ya no me deja. Esto me deja solo la primera vez que uso un array que he declarado. Luego no me deja. 00:41:19
Si yo a nombres le quiero cambiar y darle otros valores, lo recorro para dárselos. 00:41:24
O si le quiero cambiar el tamaño, lo voy a tener que hacer con new. 00:41:30
Si lo hago con new otra vez, entonces ningún problema. 00:41:34
Si yo hago esto otra vez, el array de antes se va a la basura y creo uno nuevo de tamaño 4 que guarde el nombre, si quiero. 00:41:38
¿Vale? Pero no puedo volver a hacer esto si ya lo he hecho para un array. 00:41:46
Eso porque a veces uno lo hace en un momento y le sale un error y se está ahí dos horas, pero ¿por qué me sale error si sintácticamente está bien? 00:41:49
Porque solo se puede usar esto la primera vez que usas un array que has declarado. 00:41:57
La primera vez que lo usas, luego ya no. 00:42:03
¿Vale? Entonces una forma cómoda para crear espacio y poner array e inicializarlo. 00:42:06
Y a lo mejor con esta forma, a lo mejor se entiende más esto que hemos dicho de los arrays de dos dimensiones. 00:42:11
Imaginaos que yo aquí quiero un array de dos dimensiones para números. 00:42:23
Un tablero, por ejemplo. 00:42:27
Pues también puedo usar esta forma. 00:42:33
Esta forma rara de inicializar, lo puedo. 00:42:36
Entonces entre llaves tienen que ir los diferentes valores del array tablero. 00:42:38
¿Y los diferentes valores del array tablero cuáles son? 00:42:45
A su vez un array. 00:42:48
Pues le pongo aquí esto por ejemplo. 00:42:50
Y separo por coma. 00:42:53
Dos, tres, siete. 00:42:55
Y separo por coma. 00:42:57
Cinco, nueve, seis. 00:42:59
Eso también sería válido. 00:43:02
Esto es un array de arrays, tablero. 00:43:04
Pues yo me hago un array donde la primera fila es uno y dos. 00:43:06
La siguiente dos, tres y siete. 00:43:11
Y la siguiente cinco, nueve, seis. 00:43:13
A lo mejor viendo esto, entendéis más que esto en realidad es un array de arrays. 00:43:15
Aquí habría construido esto. 00:43:21
Habría construido aquí el uno, dos. 00:43:23
Aquí habría construido dos, tres, siete. 00:43:26
Y aquí habría construido cinco, nueve, seis. 00:43:29
Esto habría construido con esto. 00:43:32
Un array donde esta fila tiene dos, esta tiene tres y esta tiene dos. 00:43:33
¿Vale? 00:43:37
Vale, ahora sí que vamos a parlar. 00:43:39
Un momentito. 00:43:43
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
21 de noviembre de 2023 - 14:04
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
834.61 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid