Saltar navegación

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

Clase 21-11-23 - 1 - Contenido educativo

Ajuste de pantalla

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

Subido el 21 de noviembre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a continuar, vale un poquito, solo un poco. 00:00:00
Bueno, pues ahora, vale, entiendo que ahora llegados ya a este punto, 00:00:09
todos tenemos claro y vemos en nuestra cabeza que los Arrays son unas estructuras de datos maravillosas, 00:00:19
cuando yo necesito recoger como datos de mi aplicación un montón de valores del mismo tipo, 00:00:27
¿verdad?, son unas estructuras de datos maravillosas para eso, 00:00:33
que en mi aplicación yo tengo que trabajar con mesas del aula, 00:00:37
son muchas mesas, a lo mejor cada mesa se identifica con una variable de tipo string, 00:00:43
mesa 1, mesa 2, mesa 3, bueno como tengo que trabajar con muchas mesas, 00:00:50
mesa 1, mesa 2, mesa 3, en lugar de 14 variables string independientes, 00:00:57
pues puedo declarar un Array de variables string, 00:01:06
¿verdad?, un Array de 14 posiciones de tipo string y en cada posición de esa Array va una mesa, 00:01:09
esta, esta, esta, esta, ¿vale?, esa es la idea de los Arrays, 00:01:18
que son variables estructuras de datos estupendas cuando mi aplicación tiene que trabajar 00:01:22
con un montón de datos del mismo tipo, no los declaro por separado, 00:01:26
porque entonces luego recorrer todos esos sería imanejable, 00:01:31
sino que los declaro todos juntos en un Array, ¿vale?, 00:01:36
bueno pues el Array, los Arrays tal y como los habéis visto hasta ahora, 00:01:39
y luego todos sus matices de una vez que tengo mi variable Array declarada e inicializada 00:01:43
y su espacio creado, pues como puedo recorrerla de forma sencilla con un Array 00:01:49
para acceder a sus posiciones, todo eso es lo que asumimos que está claro, ¿no?, 00:01:54
vale, bueno pues los Arrays entonces me son muy fáciles para simular situaciones reales, 00:01:59
que es de lo que se trata la programación, 00:02:07
la programación tiene que resolver problemas de la realidad, 00:02:09
nosotros hacemos aplicaciones para resolver problemas relacionados con 00:02:13
gestionar mis clientes y mis facturas, gestionar los alumnos y las matrículas del instituto, 00:02:18
para eso hacemos las aplicaciones y los programas, para gestionar problemas reales, 00:02:23
cosas que están en la realidad, que existen, para eso los hacemos, 00:02:28
por eso el ejemplo que yo he puesto antes, 00:02:33
y yo tengo que gestionar las mesas del aula, para tomar decisiones sobre ella, 00:02:35
para lo que sea, pues como son muchas, un Array de un montón de objetos mesa 00:02:41
o de strings y cada vez una string, vale, 00:02:46
bueno pues ahora imaginémonos otra situación real, 00:02:49
otra situación real, que es esta la que digo, 00:02:52
vale, mi aplicación tiene que gestionar a lo mejor las mesas de este aula, 00:02:54
una variable para cada mesa, vale, 00:03:00
cada mesa es una variable, tiene que ser una variable, 00:03:03
vale, bueno pues hemos dicho, como son muchas, un Array, 00:03:06
son muchas, ¿no?, pues un Array, estupendo, 00:03:09
bueno, pero el siguiente salto que podríamos dar es, 00:03:12
vale, pero a ver, mi aplicación también va a necesitar como información 00:03:15
la posición de la mesa, es decir, la fila y la columna, 00:03:20
vale, no solo el color, sino la fila y la columna, 00:03:24
bueno, pues yo tengo que modelar, ¿cómo modelo eso?, 00:03:29
pues bueno, tengo que pensar como diseño una aplicación que me modele 00:03:32
esa situación, que me permita trabajar con la información de la posición 00:03:36
de forma sencilla, lo que es una situación que se me plantea, ¿no?, 00:03:41
que yo tengo que trabajar con mesas del aula, 00:03:45
cada mesa va a ir a una variable y además se me plantea 00:03:48
que la posición de la mesa, la fila y la columna es interesante, 00:03:52
la posición del plano, entonces ahí se me puede ocurrir 00:03:58
usar entonces para guardar cada variable mesa, 00:04:02
en lugar de un Array y ponerlas todas en fila, 00:04:06
vale, o sea, imaginad que la información de la mesa 00:04:09
la guardamos en una variable string, 00:04:12
entonces según eso, todas mis mesas las podría yo guardar aquí, ¿verdad?, 00:04:15
mesas igual a new string 14, 00:04:21
vale, entonces mesa 0 es esa mesa de ahí, 00:04:29
mesa 1 es esa, mesa 2 es esta, mesa 3 es esta, 00:04:33
mesa 4 es esa, mesa 5 es esa, hasta ahí está claro, ¿no?, 00:04:36
y luego mesa 0 es un string, pues la información que yo quiera 00:04:40
de la mesa en ese string, su color, lo que yo quiero, 00:04:44
mesa 0, mesa 1, mesa 2, mesa 3, mesa 4, mesa 5, 00:04:46
vale, pues puedo plantearme trabajar con mis variables mesa, 00:04:49
que cada una es un string, en esta estructura de datos, 00:04:54
un Array, mesa 0, 1, 2, 3, 4, vale, 00:04:57
pero ahora resulta que la información, lo que he dicho antes, 00:05:00
que la información de la posición, la fila y la columna me interesa, 00:05:03
entonces si la información de la posición me interesa, 00:05:07
¿cómo mezclo yo eso con esto?, pues se me hace un poco complicado, 00:05:11
bueno, pues en cada mesa, que es un string mesa 0, 00:05:15
por ejemplo, que además de la información de la mesa en ese string, 00:05:18
recorra la posición, recoja la posición, 00:05:21
mesa 0 color tal, fila 1, fila 2, fila 1, columna 2, 00:05:24
bueno, se me pueden ocurrir cosas para que además, 00:05:28
en esta estructura de datos, en este Array, 00:05:32
esté recogida la información de la posición, 00:05:34
en realidad, lo único que se me podría ocurrir es esto, 00:05:36
que es bueno, pues cada mesa, mesa 0, 00:05:39
además de tener la información de la mesa que yo quiero, 00:05:43
imaginemos que es el color, pues que tenga también la fila y la columna, 00:05:46
bueno, pero eso es luego más difícil de trabajar con ello, 00:05:51
más difícil, tengo que sacar yo luego del string esto de aquí, 00:05:59
vale, entonces, ¿qué cosas se nos pueden seguir ocurriendo?, 00:06:02
ala, pues resulta que los Arrays que hemos visto, 00:06:09
igual que existen Arrays que son de una única dimensión, 00:06:16
es decir, que son sólo una lista de cosas, 00:06:21
de 10, de 20, de 5.000, 00:06:26
pues también existen Arrays que tienen dos dimensiones, 00:06:29
este tiene sólo una dimensión, 00:06:33
pero también podemos, ahora veremos cómo, 00:06:36
declarar estructuras de datos que no sean solamente filas, 00:06:39
sino que sean matrices, 00:06:43
es decir, esta estructura de datos también se puede declarar, 00:06:48
no sólo esta, la fila de cosas, 00:06:52
que es el Array unidimensional, el único que conocemos, 00:06:54
no sólo esta, sino que esto también se puede declarar, 00:06:57
también, y aquí iría una variable, 00:07:01
igual que aquí va una variable, y aquí va otra, 00:07:03
y aquí va otra, y aquí va otra, y así todas, 00:07:05
pues aquí iría una, y aquí otra, y aquí otra, 00:07:07
y aquí otra, y aquí otra, y aquí una, 00:07:09
y aquí otra, y aquí otra, 00:07:11
vale, entonces, también podemos declarar estructuras de datos 00:07:13
que no sean exclusivamente una fila, 00:07:16
sino que sean esto, una matriz, un casillero, 00:07:19
como lo queráis llamar, 00:07:23
¿cuál es la ventaja de declarar esto?, 00:07:26
pues que aquí cada dato, 00:07:30
cada dato además tiene una posición asociada en el plano, 00:07:32
aquí cada dato solamente tiene asociada 00:07:36
una posición dentro de una única fila, 00:07:39
dentro de una única fila, 00:07:41
pero aquí cada elemento tiene asociada dos valores, 00:07:43
la fila en la que está y la columna en la que está, 00:07:47
entonces, esas variables yo las puedo distribuir en un plano, 00:07:51
es decir, esta está en la fila cero, columna cero, 00:07:54
esta está en la fila cero, columna uno, 00:07:57
esta está en la fila cero, columna dos, 00:08:00
entonces distribuyo mis datos, 00:08:02
distribuyo mis variables, 00:08:04
a lo largo de filas y columnas, 00:08:06
y eso me da una información añadida, 00:08:10
esto representa la realidad de las mesas de un aula, 00:08:14
la representa muchísimo mejor que esto, 00:08:20
porque las mesas de un aula no están en fila, 00:08:24
las mesas de un aula están en un plano, 00:08:26
es decir, tienen una posición dada por dos dimensiones, 00:08:28
están en un plano, 00:08:31
entonces esto representa mucho mejor esa realidad que esto, 00:08:33
entonces, si yo quiero trabajar con objetos, 00:08:38
con cosas que estén distribuidas en planos, 00:08:42
en los cuales puedo decir fila, columna, 00:08:46
o coordenada X, coordenada Y, 00:08:49
como os guste entenderlo, 00:08:51
entonces, esta estructura de datos 00:08:53
va a ser mucho más realista, 00:08:56
se va a aproximar más que esta, 00:08:58
y me va a facilitar extraer información, 00:09:00
por ejemplo, pues la mesa en la que está sentado él, 00:09:03
esa mesa cuál es, la de fila cero, columna uno, 00:09:07
pues esa mesa es directamente esta, 00:09:10
sin embargo, si yo las tengo todas, 00:09:12
las he serializado y las he puesto todas así, 00:09:14
pues es mucho más complicado, 00:09:17
porque aquí iría, 00:09:19
aquí tiene que ir la de fila cero, columna cero, 00:09:20
aquí la de fila cero, columna uno, 00:09:22
aquí la de fila cero, columna dos, 00:09:24
aquí ya la de fila uno, columna cero, 00:09:26
o sea, aquí es muy complicado 00:09:28
ahora ya distinguir cuál es la de cada uno, 00:09:30
porque están todas serializadas ahí en filita, 00:09:32
aquí ya están directamente puestas en su posición real, 00:09:35
ya están directamente puestas en su posición real, 00:09:38
entonces, esto, 00:09:41
el extenderlos a raíz de una dimensión a dos dimensiones, 00:09:43
como ahora veremos, 00:09:46
¿para qué sirve? 00:09:47
pues sirve simplemente para reproducir 00:09:49
una situación real, 00:09:52
reproducirla, 00:09:54
y así que me sea mucho más manejable, 00:09:55
entendible y luego programable esto, 00:09:58
¿vale? 00:10:00
ha sido para eso, 00:10:01
nada más, 00:10:02
uno usa raíz bidimensionales 00:10:04
cuando le facilite la tarea, 00:10:06
porque la realidad que está modelando 00:10:08
es algo que está en un plano, 00:10:10
si es algo que está en un plano, 00:10:12
pues ya está, 00:10:13
si no, no usas raíz bidimensionales, 00:10:14
en los programas hasta ahora, 00:10:16
programa que lee números hasta no sé qué, 00:10:18
pues esos números que estén todos en filita, 00:10:20
para qué quiero yo que estén en dos dimensiones, 00:10:22
¿no? ¿qué más me da? 00:10:24
si la posición de los números en un plano 00:10:25
no pinta nada, 00:10:27
me están dando números uno tras otro, 00:10:28
pues números uno tras otro, 00:10:29
ya está, 00:10:30
pero cuando estoy modelando realidades 00:10:31
en los cuales cada elemento 00:10:33
sí está ubicado en una posición de un plano, 00:10:35
cuando estoy modelando tipo realidades, 00:10:37
pues esto viene fenomenal, 00:10:39
¿vale? 00:10:41
entonces uno elige la estructura de datos 00:10:42
en función de esos datos 00:10:45
qué significado tienen, 00:10:47
qué significado real tienen, 00:10:49
porque hay estructuras de datos 00:10:51
que se adaptan mejor 00:10:53
a unos significados reales que a otros, 00:10:54
y de elegir bien una estructura de datos 00:10:56
depende que esa aplicación 00:10:59
luego es una aplicación buena, 00:11:01
eficiente y con sentido, 00:11:03
¿vale? 00:11:05
bueno, esta sería la motivación 00:11:06
de por qué complicar los arrays 00:11:08
de una dimensión 00:11:11
que ya vemos cómo funcionan, 00:11:12
que son facilísimos de trabajar con ellos, etc. 00:11:13
¿por qué complicarlos? 00:11:15
dándoles otra dimensión más, 00:11:17
¿por qué complicarlos? 00:11:18
pues la razón de por qué los complicamos 00:11:19
es porque al hacerlos bidimensionales 00:11:22
representan algo muy real, 00:11:25
que es que las cosas están situadas en planos, 00:11:27
¿vale? 00:11:30
si uno hace un programa de ajedrez 00:11:31
de tres en raya, 00:11:32
pues cada posición en realidad 00:11:33
está en un plano, 00:11:35
pues hombre, 00:11:36
va a quedar mucho mejor modelado 00:11:37
un tablero de ajedrez 00:11:38
con esto, 00:11:40
que con esto, 00:11:41
va a quedar mucho mejor modelado, 00:11:42
va a quedar un tablero de ajedrez 00:11:43
así que con esto, 00:11:44
¿vale? 00:11:46
bueno, 00:11:47
pues esta sería la razón 00:11:48
de por qué nos complicamos, 00:11:49
por qué le metemos otra dimensión, 00:11:50
ahora ya vamos a ver 00:11:52
cómo se declaran 00:11:53
y cómo se utilizan 00:11:55
los arrays de dos dimensiones. 00:11:56
Vale, 00:12:13
pues a ver, 00:12:14
bueno, 00:12:15
para no arrastrar el string 00:12:16
que es muy largo, 00:12:17
vamos a hacerlo con numeritos, 00:12:18
con int, 00:12:19
que es el más cordito de cualquiera, 00:12:20
bueno, 00:12:21
resulta que queremos guardar 00:12:22
un montón de números, 00:12:23
un montón de números, 00:12:25
vale, 00:12:26
pero no los vamos a guardar 00:12:27
todos en una fila, 00:12:28
no los vamos a guardar 00:12:29
todos en una fila, 00:12:30
los vamos a guardar 00:12:31
en una matriz, 00:12:32
una matriz, 00:12:34
en un casillero, 00:12:35
como lo queréis llamar, 00:12:36
en términos matemáticos 00:12:37
una matriz, 00:12:38
¿no? 00:12:39
vale, 00:12:40
bueno, 00:12:41
pues entonces, 00:12:42
¿cómo se define una matriz? 00:12:43
El tipo de dato 00:12:45
es impepinable, 00:12:47
qué datos va a contener 00:12:48
cada elemento entero, 00:12:49
y ahora, 00:12:50
como tiene filas y columnas, 00:12:51
en lugar de solo 00:12:53
uno de esos corchetes, 00:12:55
ponemos dos, 00:12:56
ya está, 00:12:58
ponemos dos, 00:12:59
eso significa 00:13:00
que la estructura de datos 00:13:01
que hemos declarado ahora 00:13:02
la puedo yo ya visualizar 00:13:04
en mi cabeza, 00:13:05
la puedo visualizar 00:13:07
en mi cabeza, 00:13:08
no como una única fila, 00:13:09
sino como esto, 00:13:11
así la tengo que visualizar 00:13:13
en mi cabeza, 00:13:15
desde el momento 00:13:16
en que decimos 00:13:17
que tiene dos dimensiones, 00:13:18
la visualizamos así, 00:13:19
obviamente luego esto, 00:13:21
la matriz virtual 00:13:22
lo mapea en la RAM, 00:13:23
no en una matriz, 00:13:24
porque la RAM 00:13:25
son una secuencia de posiciones, 00:13:26
pero eso nos da igual, 00:13:27
lo que importa 00:13:28
es cómo lo visualizamos 00:13:29
en nuestra cabeza, 00:13:30
pues cuando declaramos 00:13:31
una array así, 00:13:32
con dos dimensiones, 00:13:33
dos corchetes, 00:13:34
automáticamente 00:13:35
en la cabeza 00:13:36
ya tenemos que visualizar 00:13:37
que la estructura 00:13:38
de datos que tenemos 00:13:39
tiene esta forma, 00:13:40
es un casillero 00:13:42
con celdillas, 00:13:43
ya no es solo 00:13:44
una fila larga, 00:13:45
ya no es solo 00:13:46
una fila larga, 00:13:47
vale, repito, 00:13:48
si hemos optado 00:13:49
por esto, 00:13:50
es porque nos interesa, 00:13:51
no por las buenas, 00:13:54
porque para 00:13:55
una fila larga 00:13:56
es muy fácil de usar, 00:13:57
ya lo hemos visto 00:13:58
que un vector 00:13:59
es una cosa muy cómoda, 00:14:00
una array 00:14:01
muy estupenda, 00:14:02
vale, 00:14:03
entonces yo no elijo esto 00:14:04
porque me da la gana, 00:14:05
lo elijo 00:14:06
porque cuando estamos 00:14:07
declarando, 00:14:08
pues se presta precisamente 00:14:09
a ser reflejada 00:14:10
en un plano, 00:14:11
bueno, 00:14:12
pues con esto 00:14:13
ya visualizamos 00:14:14
que lo que, 00:14:15
la estructura 00:14:16
que estamos 00:14:17
declarando 00:14:18
es esta, 00:14:19
como cualquier variable 00:14:20
hay que darle un nombre, 00:14:21
eso sí, 00:14:22
vale, 00:14:23
como cualquier variable, 00:14:24
pues venga, 00:14:25
yo que sé, 00:14:26
vamos a poner 00:14:27
tablero, 00:14:28
ala, 00:14:29
el nombre que me dé la gana, 00:14:30
el nombre de la variable, 00:14:31
ya sabéis que elegimos 00:14:32
el nombre que queramos, 00:14:33
y esto es otra variable más, 00:14:34
lo que pasa es que este, 00:14:36
¿qué tipo de variable es? 00:14:38
es un tipo de variable 00:14:39
array de dos dimensiones, 00:14:40
igual que esta, 00:14:43
es un tipo de variable 00:14:45
igual array de una dimensión, 00:14:47
e igual que esta, 00:14:50
es un tipo de variable 00:14:51
igual a un entero, 00:14:52
bueno, 00:14:55
pues este es una variable 00:14:56
de tipo array de dos dimensiones, 00:14:57
o matriz, 00:14:58
o casillero, 00:15:00
como lo queráis llamar, 00:15:01
bueno, 00:15:03
pues exactamente igual 00:15:04
que en el caso 00:15:05
de los arrays de una dimensión, 00:15:06
con esta declaración sin más, 00:15:08
yo todavía 00:15:10
el espacio en memoria 00:15:11
no lo tengo, 00:15:12
lo que tenemos aquí 00:15:14
ya lo sabemos, 00:15:15
porque ya es lo mismo 00:15:17
que en el caso 00:15:18
de declarar un array, 00:15:19
cuando nosotros 00:15:20
declaramos un array, 00:15:21
ya insistimos en eso 00:15:23
ayer otra vez, 00:15:24
imaginamos que declaramos 00:15:26
un array, 00:15:27
y en el caso 00:15:29
de declarar un array 00:15:30
con esta declaración 00:15:32
tenemos una variable num, 00:15:34
y esta variable num 00:15:37
que se ha creado, 00:15:38
es una dirección 00:15:41
de memoria simplemente, 00:15:42
esta variable num 00:15:44
es una dirección de memoria, 00:15:45
que apunta a donde, 00:15:46
por ahora a nada, 00:15:48
por ahora a nada, 00:15:50
para que aparezca 00:15:51
realmente el array, 00:15:52
para que aparezca 00:15:54
físicamente en memoria 00:15:55
el array, 00:15:56
ya pueda yo acceder 00:15:57
a las posiciones, 00:15:58
a la cero, 00:15:59
a la uno, 00:16:00
a la dos, 00:16:01
teníamos que hacer esto, 00:16:02
¿verdad?, 00:16:03
inicializarlo, 00:16:04
con new 00:16:06
tipo de dato, 00:16:07
el que fuera 00:16:08
y las posiciones 00:16:09
que yo quiera, 00:16:10
hay que darle unas posiciones, 00:16:11
eso si que no lo podemos 00:16:12
eludir, 00:16:13
hay que darle unas, 00:16:14
vale, 00:16:15
una vez que ya 00:16:16
hacemos esto, 00:16:17
este espacio en memoria 00:16:18
se crea, 00:16:19
con las posiciones 00:16:20
que ya he puesto aquí, 00:16:21
de la cero 00:16:22
a la veintinueve 00:16:23
en este caso, 00:16:24
vale, 00:16:25
pues con el de dos dimensiones 00:16:26
pasa lo mismo, 00:16:27
con la declaración 00:16:28
que hemos hecho hasta ahora, 00:16:29
es declarar una variable 00:16:32
que se llama tablero, 00:16:33
que contiene 00:16:35
una dirección de memoria, 00:16:37
pero por ahora 00:16:39
de una zona 00:16:40
inusable, 00:16:41
que no me vale para nada, 00:16:42
por ahora una zona inusable, 00:16:43
igual que cuando 00:16:45
hacíamos esto, 00:16:46
cuando hacemos esto 00:16:48
tengo una dirección de memoria 00:16:49
de algo que no puedo utilizar, 00:16:50
claro, 00:16:52
pues nos falta efectivamente 00:16:53
inicializar 00:16:54
este array doble, 00:16:55
este array de dos dimensiones, 00:16:57
nos falta crear el espacio 00:16:58
para poder usarlo, 00:17:00
igual que en el array, 00:17:01
bueno, 00:17:04
pues lo creamos 00:17:05
exactamente igual 00:17:06
que creábamos el espacio 00:17:07
para un array, 00:17:08
con el operador new, 00:17:09
el tipo de dato, 00:17:11
y aquí, 00:17:14
como el espacio 00:17:15
que estamos creando 00:17:16
es un plano, 00:17:18
con filas y columnas 00:17:20
tenemos que decirle 00:17:21
cuantas filas 00:17:22
queremos que tenga 00:17:23
y cuantas columnas, 00:17:24
pues que quiero yo 00:17:26
de esto, 00:17:27
algo así en mi cabeza, 00:17:34
la idea que yo tengo 00:17:35
es algo así en mi cabeza, 00:17:36
esto es lo que yo necesito 00:17:37
para modelar la realidad 00:17:38
que estoy, 00:17:39
pues esto serían 00:17:40
cuatro filas 00:17:41
y tres columnas, 00:17:43
vale, 00:17:46
pues entonces pongo aquí 00:17:47
cuatro filas 00:17:49
y tres columnas, 00:17:52
vale, 00:17:55
entonces aquí 00:17:56
automáticamente 00:17:57
ya sí que ha aparecido 00:17:58
este espacio en memoria, 00:17:59
ahora ya sí, 00:18:00
y ya esta dirección tablero, 00:18:02
ya efectivamente 00:18:04
ahora ya sí, 00:18:05
se queda apuntando 00:18:06
a una estructura 00:18:07
de este tipo, 00:18:09
ahora ya sí, 00:18:10
ya este espacio existe 00:18:12
y ya lo puedo utilizar, 00:18:13
utilizar para qué, 00:18:15
para guardar números enteros, 00:18:16
que es para lo que 00:18:17
lo he declarado, 00:18:18
para guardar números enteros, 00:18:19
vale, 00:18:20
pues ahora ya puedo 00:18:21
meter números enteros aquí, 00:18:22
igual que antes 00:18:24
yo tenía una única fila, 00:18:25
pues ahora los puedo meter aquí, 00:18:27
vale, 00:18:30
pero claro, 00:18:31
la diferencia 00:18:32
y la única diferencia 00:18:33
que hay con los arrays 00:18:34
de una dimensión 00:18:35
es que ahora 00:18:36
para acceder a una posición 00:18:37
necesito una información 00:18:40
de uno, 00:18:41
la fila 00:18:42
y la columna, 00:18:43
en una array normal 00:18:44
para acceder a una posición 00:18:46
necesito solo una información, 00:18:47
que es la posición 00:18:50
en la fila, 00:18:51
si es la posición 00:18:52
cero de la fila, 00:18:53
si es la uno de la fila, 00:18:54
la dos de la fila 00:18:55
y ya está, 00:18:56
la única información 00:18:57
que necesito para acceder 00:18:58
a una posición, 00:18:59
la posición de la fila, 00:19:00
aquí necesito dos informaciones, 00:19:01
la fila donde está 00:19:03
el numerito 00:19:04
al que quiero acceder 00:19:05
y la columna 00:19:06
donde está el numerito 00:19:07
al que quiero acceder, 00:19:08
es la única diferencia, 00:19:09
la única, 00:19:10
vale, 00:19:11
por ejemplo, 00:19:12
si yo quisiera, 00:19:17
si yo quisiera 00:19:19
inicializar ahora 00:19:20
todas las posiciones 00:19:22
de este tablero 00:19:23
con cero, 00:19:24
vale, 00:19:27
a lo mejor esto podría ser, 00:19:28
esto podría simular 00:19:29
a lo mejor 00:19:30
un juego de, 00:19:31
un juego de un tablero 00:19:33
donde uno va poniendo fichas 00:19:35
y uno podría haber decidido, 00:19:36
vale, 00:19:38
cuando en una posición 00:19:39
haya un cero, 00:19:40
he puesto una ficha 00:19:41
y cuando en una posición 00:19:42
haya un uno, 00:19:43
he puesto la ficha uno, 00:19:45
por ejemplo, 00:19:46
vale, 00:19:47
es decir, 00:19:49
lo que quiero decir 00:19:50
es que seleccionar 00:19:51
esta estructura 00:19:52
es, 00:19:53
si tiene sentido, 00:19:54
porque lo que yo estoy modelando 00:19:55
le pega, 00:19:56
si no, 00:19:57
es mucho más complejidad 00:19:58
que una fila, 00:19:59
no voy a meter ahí 00:20:01
esa estructura 00:20:02
que es mucho más compleja 00:20:03
que una fila, 00:20:04
alegremente, 00:20:05
pero en ese ejemplo, 00:20:06
yo estoy simulando 00:20:07
un jueguito de un tablero, 00:20:08
vale, 00:20:09
pues, 00:20:10
el tablero 00:20:11
queda perfectamente 00:20:12
bien representado con esto, 00:20:13
ya yo tendría que decir, 00:20:15
vale, 00:20:16
en cada posición 00:20:17
que van, 00:20:18
bueno, 00:20:19
pues pueden ir dos fichas, 00:20:20
entonces, 00:20:21
bueno, 00:20:22
pues yo la simulo 00:20:23
con que una de las fichas 00:20:24
es el número cero 00:20:25
y otra es el número uno, 00:20:26
vale, 00:20:27
pues estupendo, 00:20:28
mi tablero que sea 00:20:29
de números enteros 00:20:30
y cada uno de ellos 00:20:31
tendrá un cero o un uno 00:20:32
en función de la ficha 00:20:33
que tenga, 00:20:34
por ejemplo, 00:20:35
y cada jugador 00:20:36
va poniendo 00:20:37
en cada posición 00:20:38
el cero, 00:20:39
el uno, 00:20:40
lo que sea, 00:20:41
entonces en un ejemplito 00:20:42
como ese, 00:20:43
usar esta estructura 00:20:44
viene muy bien, 00:20:45
porque tengo 00:20:46
perfectamente clavado 00:20:47
ahí ya el tablero, 00:20:48
pero como yo clave 00:20:49
en una fila, 00:20:50
lo tengo complicadísimo 00:20:51
para identificar, 00:20:52
para asociar luego 00:20:53
cada posición 00:20:54
a mi tablero físico real, 00:20:55
al que yo estoy viendo 00:20:56
con los ojos, 00:20:57
lo tengo muy complicado, 00:20:58
esta es esta, 00:20:59
esta es esta, 00:21:00
esta es esta, 00:21:01
esta es esta, 00:21:02
rollo, 00:21:03
pero si mi variable, 00:21:04
mi estructura de datos 00:21:05
es esta, 00:21:06
esto es que es directamente 00:21:07
ya el tablero real 00:21:08
que yo estoy viendo 00:21:09
con los ojos, 00:21:10
ya es directamente él, 00:21:11
lo reproduce mucho mejor, 00:21:12
mucho más fácil 00:21:13
el programa, 00:21:14
¿no? 00:21:15
que llevarme 00:21:16
el tablero real 00:21:18
el que veo con los ojos 00:21:19
a una fila 00:21:20
y serializarlo todo largo, 00:21:21
esto no le pega nada, 00:21:22
bueno, 00:21:23
vale, 00:21:24
pues entonces, 00:21:25
ahora, 00:21:26
en lo que estábamos, 00:21:27
ahora ya para acceder 00:21:28
a las posiciones, 00:21:29
que es de lo que se trata 00:21:30
de acceder a las posiciones, 00:21:31
necesito fila y columna, 00:21:32
¿vale? 00:21:33
igual que en los array, 00:21:34
las primeras empezaban 00:21:35
con la cero, 00:21:36
aquí también, 00:21:37
la cero, 00:21:38
la cero, 00:21:39
la cero, 00:21:40
la cero, 00:21:41
la cero, 00:21:42
la cero, 00:21:43
la cero, 00:21:44
la cero, 00:21:45
aquí también, 00:21:46
las filas empiezan, 00:21:47
cero, 00:21:48
uno, 00:21:49
dos, 00:21:50
en este caso, 00:21:51
y tres, 00:21:52
porque tengo cuatro filas, 00:21:53
y las columnas empiezan 00:21:54
en la cero, 00:21:55
uno y dos, 00:21:56
porque tengo tres, 00:21:57
cero, 00:21:58
uno y dos, 00:21:59
porque son tres en total, 00:22:00
cero, 00:22:01
uno, 00:22:02
dos y tres, 00:22:03
porque son cuatro filas en total, 00:22:04
¿vale? 00:22:05
filas y columna, 00:22:06
¿qué quiere inicializarlo 00:22:07
todo a cero? 00:22:08
por ejemplo, 00:22:09
hombre, 00:22:10
pues puede uno ir a lo bestia, 00:22:11
para acceder a la fila cero, 00:22:12
columna cero, 00:22:13
pues como podéis intuir, 00:22:14
tengo dos posiciones, 00:22:15
la primera a la fila, 00:22:16
y la segunda a la columna, 00:22:17
con esto estoy accediendo 00:22:18
a esta, 00:22:19
porque es fila cero, 00:22:20
columna cero, 00:22:21
¿vale? 00:22:22
con el array de una dimensión, 00:22:23
con poner esto era suficiente, 00:22:24
pero con el array de dos, 00:22:25
tengo que poner la fila, 00:22:26
y dentro de la fila 00:22:27
la columna, 00:22:28
¿vale? 00:22:29
pues esta variable, 00:22:30
ahora ya es una única variable 00:22:31
entera, 00:22:32
que es esta, 00:22:33
y con esa variable entera 00:22:34
hago lo que me dé la gana, 00:22:35
pues por ejemplo, 00:22:36
asignarle el cero, 00:22:37
¿vale? 00:22:38
así, 00:22:39
así, 00:22:40
así, 00:22:41
así, 00:22:42
así, 00:22:43
para asignarle cero, 00:22:44
¿vale? 00:22:45
¿que quiero asociar cero, 00:22:46
asignar cero a todos los demás? 00:22:47
pues tengo que escribir 00:22:48
doce asignaciones de estas, 00:22:49
¿no? 00:22:50
Cuatro por tres, 00:22:51
doce elementos tiene eso, 00:22:52
y así tendría que escribir 00:22:53
doce veces esto. 00:22:54
Tablero, 00:22:55
cero, 00:22:56
uno, 00:22:57
esta sería 00:22:58
la posición cero, 00:22:59
columna uno, 00:23:00
para hacer con ella 00:23:01
lo que yo quiera, 00:23:02
por ejemplo asignarle a un cero, 00:23:03
volvemos a escrever 00:23:04
el assemble, 00:23:05
miren aquí, 00:23:06
con esta variable, 00:23:07
tendría que escribir 00:23:08
la columna doce, 00:23:09
y lo que sería 00:23:10
la regulación al respecto. 00:23:11
Y así, 00:23:14
poner, 00:23:15
esta de aquí, 00:23:16
¿cuál sería? 00:23:17
Tablero, 00:23:18
dos, 00:23:19
uno. 00:23:20
O sea, 00:23:21
si quiero yo 00:23:22
acceder a todas 00:23:23
para asignar el cero, 00:23:24
haciéndolo de esta manera, 00:23:25
pues hombre, 00:23:26
tengo que escribir 00:23:27
doce líneas, 00:23:28
un poco pesado. 00:23:29
Claro, 00:23:30
pero para eso 00:23:31
tenemos los for, 00:23:32
¿verdad? 00:23:33
La ventaja de los Arrays 00:23:34
es que mediante 00:23:35
un bucle 00:23:36
podemos acceder 00:23:37
a todas sus posiciones, 00:23:38
porque ese bucle 00:23:39
me da un índice 00:23:40
y ese índice 00:23:41
va cambiando. 00:23:42
Entonces, 00:23:44
las iteraciones del for 00:23:45
me van accediendo a 00:23:46
posiciones consecutivas 00:23:48
del Array. 00:23:50
Esa es la ventaja 00:23:51
de los Arrays, 00:23:52
que mediante un sencillo 00:23:53
bucle for 00:23:54
podemos acceder 00:23:55
en un código 00:23:56
de dos líneas 00:23:57
a todas sus posiciones. 00:23:58
Bueno, 00:23:59
pues el Array 00:24:00
de dos dimensiones 00:24:01
también, 00:24:02
afortunadamente, 00:24:03
podemos recorrerlo 00:24:04
con un bucle for. 00:24:05
Pero claro, 00:24:08
aquí el recorrido 00:24:09
se complica un poco, 00:24:10
porque yo tengo que ir 00:24:11
por aquí, 00:24:12
voy por aquí, 00:24:13
luego tengo que 00:24:14
volver a bajar aquí, 00:24:15
luego tengo que 00:24:16
volver a bajar aquí. 00:24:17
Entonces, 00:24:18
¿cómo podemos 00:24:19
hacer el recorrido? 00:24:20
Tendremos que hacerlo 00:24:21
con dos bucles for, 00:24:22
uno dentro de otro. 00:24:23
Un primer bucle 00:24:24
for externo 00:24:25
que se va colocando 00:24:26
en la fila 00:24:27
en la que está. 00:24:28
Y en cada fila 00:24:31
otro pequeño bucle 00:24:32
for dentro 00:24:33
que ya va 00:24:34
recorriendo las columnas. 00:24:35
Cuando 00:24:37
esta iteración 00:24:38
ha terminado, 00:24:39
saltamos a esta iteración 00:24:40
del bucle de fuera 00:24:41
y arranca 00:24:42
el bucle de dentro 00:24:43
que va por éste, 00:24:44
por éste 00:24:45
y por éste. 00:24:46
Cuando esta iteración 00:24:47
del bucle de fuera 00:24:48
ha terminado, 00:24:49
saltamos a esta fila, 00:24:50
arranca a la iteración 00:24:51
del bucle de dentro 00:24:52
que va por éste, 00:24:53
por éste 00:24:54
y por éste. 00:24:55
Luego un bucle 00:24:56
que recorre las filas 00:24:57
y dentro de cada fila 00:24:58
un bucle 00:24:59
pequeñito 00:25:00
que recorre las columnas. 00:25:01
Un bucle 00:25:02
dentro de otro. 00:25:03
Entonces se traduciría 00:25:04
en esto. 00:25:05
Esto de recorrer 00:25:06
todas las posiciones 00:25:07
para asignar cero, 00:25:08
hecho con 00:25:09
bucles FOR 00:25:10
se traduciría 00:25:12
en esto de aquí. 00:25:13
El primer FOR de fuera 00:25:15
un bucle 00:25:18
que va a ir pasando 00:25:19
fila por fila. 00:25:20
Filas, ¿cuántas hay? 00:25:21
De cero a tres 00:25:23
hay cuatro. 00:25:24
Pues un índice 00:25:25
que empieza valiendo cero 00:25:27
mientras sea menor 00:25:30
que el número de filas. 00:25:31
En mi caso cuatro. 00:25:33
¿Vale? 00:25:35
Así 00:25:36
paso por la cero, 00:25:37
la uno, 00:25:38
la dos y la tres 00:25:39
incrementando ahí. 00:25:40
Y ahora 00:25:42
para cada fila 00:25:43
para cada fila 00:25:44
tengo que hacer un bucle 00:25:46
que vaya pasando 00:25:47
por la columna cero 00:25:48
la uno y la dos. 00:25:49
Luego para cada fila 00:25:50
para cada í 00:25:52
para cada í 00:25:57
hay que recorrer 00:25:58
toda la fila otra vez. 00:26:00
Pues para recorrer 00:26:07
toda la fila 00:26:08
para cada í 00:26:09
tendré que hacer otro FOR dentro. 00:26:10
Ahora este FOR dentro 00:26:12
tiene que utilizar otra variable 00:26:14
claro, porque la í 00:26:16
ya está usada. 00:26:17
La í es la variable 00:26:18
que me dice la fila 00:26:19
en la que estoy. 00:26:20
En la primera iteración 00:26:21
estará en la cero. 00:26:22
En la segunda 00:26:24
estará en la uno. 00:26:25
La í me dice la fila 00:26:26
en la que estoy. 00:26:27
Pues para cada í 00:26:28
ahora yo avanzo 00:26:29
por cada columna. 00:26:30
Desde j igual a cero 00:26:32
mientras j sea menor 00:26:34
que el número de columnas. 00:26:35
Que el número de columnas 00:26:38
que en mi caso es tres 00:26:39
incrementando j. 00:26:40
Y ahora ya dentro de este FOR 00:26:42
si yo hago 00:26:44
tablero de í 00:26:46
ya tengo todas las posiciones. 00:26:50
Por ejemplo, si yo hago esto 00:26:52
pues esto 00:26:56
me irá recorriendo 00:26:58
todas las posiciones. 00:26:59
Para i igual a cero 00:27:00
entra en el FOR de dentro 00:27:02
que hace la cero 00:27:03
cero, cero, uno, cero, dos 00:27:04
y saltamos arriba. 00:27:06
Para i igual a uno 00:27:08
entramos en el bucle de dentro 00:27:09
que hace 00:27:10
uno, cero, uno, uno, uno, dos. 00:27:11
Y saltamos al bucle de arriba. 00:27:14
Para i igual a dos 00:27:16
entramos al bucle de dentro 00:27:17
que hace 00:27:19
dos, cero, dos, uno y dos, dos. 00:27:20
Y saltamos otra vez arriba. 00:27:22
Para i igual a tres 00:27:24
entramos al bucle de dentro 00:27:26
que me hace 00:27:27
tres, cero, tres, uno, tres, dos. 00:27:28
Luego el orden de recorrido 00:27:30
este bucle FOR va a ir recorriendo 00:27:32
tablero, pongo la T solo 00:27:35
cero, cero, 00:27:37
tablero, cero, uno, 00:27:39
tablero, cero, dos 00:27:42
y tablero, cero, tres. 00:27:44
Estos serán 00:27:48
todas las iteraciones 00:27:49
del bucle de dentro 00:27:50
cuando yo es igual a cero. 00:27:51
Saltamos arriba otra vez. 00:27:52
Para i igual a uno 00:27:54
pues para i igual a uno 00:27:56
otra vez 00:27:57
T, uno, cero 00:27:58
T, uno, uno 00:28:00
T, uno, dos 00:28:03
y T, uno, tres 00:28:06
Este bucle acabó. 00:28:10
Saltamos otra vez. 00:28:12
Ahora T es igual a dos 00:28:13
bucle de dentro 00:28:15
T, dos, cero 00:28:17
T, dos, uno 00:28:19
T, dos, dos 00:28:23
y T, dos, tres 00:28:27
Y bueno, nos faltaría ya 00:28:29
la última iteración 00:28:30
que ya no la escribo 00:28:32
para i igual a tres 00:28:33
este iría pasando 00:28:35
por todos los valores 00:28:36
T, tres, cero 00:28:37
T, tres, uno 00:28:38
T, tres, dos 00:28:39
T, tres, tres 00:28:40
Luego el resultado 00:28:41
de estos dos bucles FOR 00:28:42
uno dentro de otro 00:28:43
es efectivamente 00:28:44
recorrer todas las doce posiciones 00:28:45
pasando por esta 00:28:48
bajando por aquí 00:28:49
bajando por aquí 00:28:50
bajando por aquí 00:28:51
para hacer yo lo que quiera 00:28:52
con esas posiciones 00:28:53
lo que quiera 00:28:54
en este caso 00:28:55
lo que estoy haciendo es 00:28:56
asignarle cero 00:28:57
pero podría querer hacer 00:29:00
cualquier otra cosa 00:29:01
¿vale? 00:29:03
Vale, pues 00:29:06
vamos a poner aquí 00:29:11
un pequeño 00:29:12
enunciado 00:29:15
para que hagáis ahora 00:29:17
a ver si esto está 00:29:18
claro 00:29:20
Venga 00:29:31
Programa que solicite primero 00:29:33
un número de filas 00:29:34
y otro número de columnas 00:29:35
Una vez que tiene 00:29:50
ese número de filas 00:29:51
y ese número de columnas 00:29:52
declaro una raíz 00:29:53
de dos dimensiones 00:29:54
con ese número 00:29:56
de filas y columnas 00:29:57
¿vale? 00:30:00
Luego ¿qué va a hacer? 00:30:12
En lugar de rellenarlo 00:30:14
con valores leídos 00:30:15
por teclado 00:30:16
que vais a estar luego 00:30:17
haciendo la prueba 00:30:18
un montón de rato 00:30:19
metiendo números 00:30:20
pa pa pa 00:30:21
que los rellene 00:30:22
con valores aleatorios 00:30:23
todo ese array 00:30:25
entre cero y cincuenta 00:30:26
por ejemplo 00:30:27
¿vale? 00:30:30
Vale, y ahora 00:30:47
viene la complicación 00:30:48
y ahora 00:30:50
pedirá un número de filas 00:30:53
y sumará 00:30:56
todos los valores 00:30:58
que haya en esa fila 00:31:00
dirá 00:31:02
los valores de esa fila 00:31:03
suman patatín 00:31:04
¿vale? 00:31:31
Pues venga 00:31:37
Entonces, lo primero 00:31:40
de rellenar 00:31:42
con valores aleatorios 00:31:43
una vez declarado 00:31:44
es bueno 00:31:45
es calcar ese for 00:31:46
que hemos escrito 00:31:47
calcarlo 00:31:48
pero en lugar de asignarle cero 00:31:49
se hace un número aleatorio 00:31:50
y luego ya 00:31:51
habrá que volverlo 00:31:52
a recorrer 00:31:53
y el resultado 00:31:54
será hacer una suma acumulativa 00:31:55
pero claro 00:31:57
esa variable suma 00:31:58
que inicializáis a cero 00:31:59
y va tomando resultados 00:32:00
a variable suma 00:32:01
tiene que incorporar 00:32:02
solamente en su suma 00:32:04
de todo el recorrido 00:32:06
que hagáis 00:32:07
las posiciones 00:32:08
cuyo índice de fila 00:32:10
sea 00:32:11
el que habéis pedido 00:32:12
¿vale? 00:32:13
Esa es la complicación 00:32:14
luego hacer un último recorrido 00:32:15
para ir haciendo la suma 00:32:17
pero en esa suma 00:32:19
no sumarlos todos 00:32:20
sino meter un if 00:32:21
para que se sumen 00:32:22
todas aquellas posiciones 00:32:23
cuyo 00:32:25
índice de fila 00:32:26
sea la que 00:32:28
se ha pedido antes 00:32:29
¿vale? 00:32:33
Es un recorrido 00:32:34
para hacer la suma acumulativa 00:32:35
pero metiendo un if dentro 00:32:36
a ver 00:32:37
¿vale? 00:32:39
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
21 de noviembre de 2023 - 14:02
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
626.28 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid