1
00:00:00,000 --> 00:00:06,000
Venga, pues vamos a continuar, vale un poquito, solo un poco.

2
00:00:09,000 --> 00:00:18,000
Bueno, pues ahora, vale, entiendo que ahora llegados ya a este punto,

3
00:00:19,000 --> 00:00:27,000
todos tenemos claro y vemos en nuestra cabeza que los Arrays son unas estructuras de datos maravillosas,

4
00:00:27,000 --> 00:00:33,000
cuando yo necesito recoger como datos de mi aplicación un montón de valores del mismo tipo,

5
00:00:33,000 --> 00:00:36,000
¿verdad?, son unas estructuras de datos maravillosas para eso,

6
00:00:37,000 --> 00:00:43,000
que en mi aplicación yo tengo que trabajar con mesas del aula,

7
00:00:43,000 --> 00:00:50,000
son muchas mesas, a lo mejor cada mesa se identifica con una variable de tipo string,

8
00:00:50,000 --> 00:00:57,000
mesa 1, mesa 2, mesa 3, bueno como tengo que trabajar con muchas mesas,

9
00:00:57,000 --> 00:01:06,000
mesa 1, mesa 2, mesa 3, en lugar de 14 variables string independientes,

10
00:01:06,000 --> 00:01:09,000
pues puedo declarar un Array de variables string,

11
00:01:09,000 --> 00:01:18,000
¿verdad?, un Array de 14 posiciones de tipo string y en cada posición de esa Array va una mesa,

12
00:01:18,000 --> 00:01:22,000
esta, esta, esta, esta, ¿vale?, esa es la idea de los Arrays,

13
00:01:22,000 --> 00:01:26,000
que son variables estructuras de datos estupendas cuando mi aplicación tiene que trabajar

14
00:01:26,000 --> 00:01:31,000
con un montón de datos del mismo tipo, no los declaro por separado,

15
00:01:31,000 --> 00:01:36,000
porque entonces luego recorrer todos esos sería imanejable,

16
00:01:36,000 --> 00:01:39,000
sino que los declaro todos juntos en un Array, ¿vale?,

17
00:01:39,000 --> 00:01:43,000
bueno pues el Array, los Arrays tal y como los habéis visto hasta ahora,

18
00:01:43,000 --> 00:01:49,000
y luego todos sus matices de una vez que tengo mi variable Array declarada e inicializada

19
00:01:49,000 --> 00:01:54,000
y su espacio creado, pues como puedo recorrerla de forma sencilla con un Array

20
00:01:54,000 --> 00:01:59,000
para acceder a sus posiciones, todo eso es lo que asumimos que está claro, ¿no?,

21
00:01:59,000 --> 00:02:07,000
vale, bueno pues los Arrays entonces me son muy fáciles para simular situaciones reales,

22
00:02:07,000 --> 00:02:09,000
que es de lo que se trata la programación,

23
00:02:09,000 --> 00:02:13,000
la programación tiene que resolver problemas de la realidad,

24
00:02:13,000 --> 00:02:18,000
nosotros hacemos aplicaciones para resolver problemas relacionados con

25
00:02:18,000 --> 00:02:23,000
gestionar mis clientes y mis facturas, gestionar los alumnos y las matrículas del instituto,

26
00:02:23,000 --> 00:02:28,000
para eso hacemos las aplicaciones y los programas, para gestionar problemas reales,

27
00:02:28,000 --> 00:02:32,000
cosas que están en la realidad, que existen, para eso los hacemos,

28
00:02:33,000 --> 00:02:35,000
por eso el ejemplo que yo he puesto antes,

29
00:02:35,000 --> 00:02:41,000
y yo tengo que gestionar las mesas del aula, para tomar decisiones sobre ella,

30
00:02:41,000 --> 00:02:46,000
para lo que sea, pues como son muchas, un Array de un montón de objetos mesa

31
00:02:46,000 --> 00:02:49,000
o de strings y cada vez una string, vale,

32
00:02:49,000 --> 00:02:52,000
bueno pues ahora imaginémonos otra situación real,

33
00:02:52,000 --> 00:02:54,000
otra situación real, que es esta la que digo,

34
00:02:54,000 --> 00:02:59,000
vale, mi aplicación tiene que gestionar a lo mejor las mesas de este aula,

35
00:03:00,000 --> 00:03:03,000
una variable para cada mesa, vale,

36
00:03:03,000 --> 00:03:06,000
cada mesa es una variable, tiene que ser una variable,

37
00:03:06,000 --> 00:03:09,000
vale, bueno pues hemos dicho, como son muchas, un Array,

38
00:03:09,000 --> 00:03:12,000
son muchas, ¿no?, pues un Array, estupendo,

39
00:03:12,000 --> 00:03:15,000
bueno, pero el siguiente salto que podríamos dar es,

40
00:03:15,000 --> 00:03:20,000
vale, pero a ver, mi aplicación también va a necesitar como información

41
00:03:20,000 --> 00:03:24,000
la posición de la mesa, es decir, la fila y la columna,

42
00:03:24,000 --> 00:03:29,000
vale, no solo el color, sino la fila y la columna,

43
00:03:29,000 --> 00:03:32,000
bueno, pues yo tengo que modelar, ¿cómo modelo eso?,

44
00:03:32,000 --> 00:03:36,000
pues bueno, tengo que pensar como diseño una aplicación que me modele

45
00:03:36,000 --> 00:03:41,000
esa situación, que me permita trabajar con la información de la posición

46
00:03:41,000 --> 00:03:45,000
de forma sencilla, lo que es una situación que se me plantea, ¿no?,

47
00:03:45,000 --> 00:03:48,000
que yo tengo que trabajar con mesas del aula,

48
00:03:48,000 --> 00:03:52,000
cada mesa va a ir a una variable y además se me plantea

49
00:03:52,000 --> 00:03:58,000
que la posición de la mesa, la fila y la columna es interesante,

50
00:03:58,000 --> 00:04:02,000
la posición del plano, entonces ahí se me puede ocurrir

51
00:04:02,000 --> 00:04:06,000
usar entonces para guardar cada variable mesa,

52
00:04:06,000 --> 00:04:09,000
en lugar de un Array y ponerlas todas en fila,

53
00:04:09,000 --> 00:04:12,000
vale, o sea, imaginad que la información de la mesa

54
00:04:12,000 --> 00:04:15,000
la guardamos en una variable string,

55
00:04:15,000 --> 00:04:20,000
entonces según eso, todas mis mesas las podría yo guardar aquí, ¿verdad?,

56
00:04:21,000 --> 00:04:29,000
mesas igual a new string 14,

57
00:04:29,000 --> 00:04:33,000
vale, entonces mesa 0 es esa mesa de ahí,

58
00:04:33,000 --> 00:04:36,000
mesa 1 es esa, mesa 2 es esta, mesa 3 es esta,

59
00:04:36,000 --> 00:04:40,000
mesa 4 es esa, mesa 5 es esa, hasta ahí está claro, ¿no?,

60
00:04:40,000 --> 00:04:44,000
y luego mesa 0 es un string, pues la información que yo quiera

61
00:04:44,000 --> 00:04:46,000
de la mesa en ese string, su color, lo que yo quiero,

62
00:04:46,000 --> 00:04:49,000
mesa 0, mesa 1, mesa 2, mesa 3, mesa 4, mesa 5,

63
00:04:49,000 --> 00:04:54,000
vale, pues puedo plantearme trabajar con mis variables mesa,

64
00:04:54,000 --> 00:04:57,000
que cada una es un string, en esta estructura de datos,

65
00:04:57,000 --> 00:05:00,000
un Array, mesa 0, 1, 2, 3, 4, vale,

66
00:05:00,000 --> 00:05:03,000
pero ahora resulta que la información, lo que he dicho antes,

67
00:05:03,000 --> 00:05:07,000
que la información de la posición, la fila y la columna me interesa,

68
00:05:07,000 --> 00:05:11,000
entonces si la información de la posición me interesa,

69
00:05:11,000 --> 00:05:15,000
¿cómo mezclo yo eso con esto?, pues se me hace un poco complicado,

70
00:05:15,000 --> 00:05:18,000
bueno, pues en cada mesa, que es un string mesa 0,

71
00:05:18,000 --> 00:05:21,000
por ejemplo, que además de la información de la mesa en ese string,

72
00:05:21,000 --> 00:05:24,000
recorra la posición, recoja la posición,

73
00:05:24,000 --> 00:05:28,000
mesa 0 color tal, fila 1, fila 2, fila 1, columna 2,

74
00:05:28,000 --> 00:05:32,000
bueno, se me pueden ocurrir cosas para que además,

75
00:05:32,000 --> 00:05:34,000
en esta estructura de datos, en este Array,

76
00:05:34,000 --> 00:05:36,000
esté recogida la información de la posición,

77
00:05:36,000 --> 00:05:39,000
en realidad, lo único que se me podría ocurrir es esto,

78
00:05:39,000 --> 00:05:43,000
que es bueno, pues cada mesa, mesa 0,

79
00:05:43,000 --> 00:05:46,000
además de tener la información de la mesa que yo quiero,

80
00:05:46,000 --> 00:05:51,000
imaginemos que es el color, pues que tenga también la fila y la columna,

81
00:05:51,000 --> 00:05:59,000
bueno, pero eso es luego más difícil de trabajar con ello,

82
00:05:59,000 --> 00:06:02,000
más difícil, tengo que sacar yo luego del string esto de aquí,

83
00:06:02,000 --> 00:06:08,000
vale, entonces, ¿qué cosas se nos pueden seguir ocurriendo?,

84
00:06:09,000 --> 00:06:16,000
ala, pues resulta que los Arrays que hemos visto,

85
00:06:16,000 --> 00:06:21,000
igual que existen Arrays que son de una única dimensión,

86
00:06:21,000 --> 00:06:26,000
es decir, que son sólo una lista de cosas,

87
00:06:26,000 --> 00:06:29,000
de 10, de 20, de 5.000,

88
00:06:29,000 --> 00:06:33,000
pues también existen Arrays que tienen dos dimensiones,

89
00:06:33,000 --> 00:06:36,000
este tiene sólo una dimensión,

90
00:06:36,000 --> 00:06:39,000
pero también podemos, ahora veremos cómo,

91
00:06:39,000 --> 00:06:43,000
declarar estructuras de datos que no sean solamente filas,

92
00:06:43,000 --> 00:06:48,000
sino que sean matrices,

93
00:06:48,000 --> 00:06:52,000
es decir, esta estructura de datos también se puede declarar,

94
00:06:52,000 --> 00:06:54,000
no sólo esta, la fila de cosas,

95
00:06:54,000 --> 00:06:57,000
que es el Array unidimensional, el único que conocemos,

96
00:06:57,000 --> 00:07:01,000
no sólo esta, sino que esto también se puede declarar,

97
00:07:01,000 --> 00:07:03,000
también, y aquí iría una variable,

98
00:07:03,000 --> 00:07:05,000
igual que aquí va una variable, y aquí va otra,

99
00:07:05,000 --> 00:07:07,000
y aquí va otra, y aquí va otra, y así todas,

100
00:07:07,000 --> 00:07:09,000
pues aquí iría una, y aquí otra, y aquí otra,

101
00:07:09,000 --> 00:07:11,000
y aquí otra, y aquí otra, y aquí una,

102
00:07:11,000 --> 00:07:13,000
y aquí otra, y aquí otra,

103
00:07:13,000 --> 00:07:16,000
vale, entonces, también podemos declarar estructuras de datos

104
00:07:16,000 --> 00:07:19,000
que no sean exclusivamente una fila,

105
00:07:19,000 --> 00:07:23,000
sino que sean esto, una matriz, un casillero,

106
00:07:23,000 --> 00:07:26,000
como lo queráis llamar,

107
00:07:26,000 --> 00:07:30,000
¿cuál es la ventaja de declarar esto?,

108
00:07:30,000 --> 00:07:32,000
pues que aquí cada dato,

109
00:07:32,000 --> 00:07:36,000
cada dato además tiene una posición asociada en el plano,

110
00:07:36,000 --> 00:07:39,000
aquí cada dato solamente tiene asociada

111
00:07:39,000 --> 00:07:41,000
una posición dentro de una única fila,

112
00:07:41,000 --> 00:07:43,000
dentro de una única fila,

113
00:07:43,000 --> 00:07:47,000
pero aquí cada elemento tiene asociada dos valores,

114
00:07:47,000 --> 00:07:51,000
la fila en la que está y la columna en la que está,

115
00:07:51,000 --> 00:07:54,000
entonces, esas variables yo las puedo distribuir en un plano,

116
00:07:54,000 --> 00:07:57,000
es decir, esta está en la fila cero, columna cero,

117
00:07:57,000 --> 00:08:00,000
esta está en la fila cero, columna uno,

118
00:08:00,000 --> 00:08:02,000
esta está en la fila cero, columna dos,

119
00:08:02,000 --> 00:08:04,000
entonces distribuyo mis datos,

120
00:08:04,000 --> 00:08:06,000
distribuyo mis variables,

121
00:08:06,000 --> 00:08:10,000
a lo largo de filas y columnas,

122
00:08:10,000 --> 00:08:14,000
y eso me da una información añadida,

123
00:08:14,000 --> 00:08:20,000
esto representa la realidad de las mesas de un aula,

124
00:08:20,000 --> 00:08:24,000
la representa muchísimo mejor que esto,

125
00:08:24,000 --> 00:08:26,000
porque las mesas de un aula no están en fila,

126
00:08:26,000 --> 00:08:28,000
las mesas de un aula están en un plano,

127
00:08:28,000 --> 00:08:31,000
es decir, tienen una posición dada por dos dimensiones,

128
00:08:31,000 --> 00:08:33,000
están en un plano,

129
00:08:33,000 --> 00:08:38,000
entonces esto representa mucho mejor esa realidad que esto,

130
00:08:38,000 --> 00:08:42,000
entonces, si yo quiero trabajar con objetos,

131
00:08:42,000 --> 00:08:46,000
con cosas que estén distribuidas en planos,

132
00:08:46,000 --> 00:08:49,000
en los cuales puedo decir fila, columna,

133
00:08:49,000 --> 00:08:51,000
o coordenada X, coordenada Y,

134
00:08:51,000 --> 00:08:53,000
como os guste entenderlo,

135
00:08:53,000 --> 00:08:56,000
entonces, esta estructura de datos

136
00:08:56,000 --> 00:08:58,000
va a ser mucho más realista,

137
00:08:58,000 --> 00:09:00,000
se va a aproximar más que esta,

138
00:09:00,000 --> 00:09:03,000
y me va a facilitar extraer información,

139
00:09:03,000 --> 00:09:07,000
por ejemplo, pues la mesa en la que está sentado él,

140
00:09:07,000 --> 00:09:10,000
esa mesa cuál es, la de fila cero, columna uno,

141
00:09:10,000 --> 00:09:12,000
pues esa mesa es directamente esta,

142
00:09:12,000 --> 00:09:14,000
sin embargo, si yo las tengo todas,

143
00:09:14,000 --> 00:09:17,000
las he serializado y las he puesto todas así,

144
00:09:17,000 --> 00:09:19,000
pues es mucho más complicado,

145
00:09:19,000 --> 00:09:20,000
porque aquí iría,

146
00:09:20,000 --> 00:09:22,000
aquí tiene que ir la de fila cero, columna cero,

147
00:09:22,000 --> 00:09:24,000
aquí la de fila cero, columna uno,

148
00:09:24,000 --> 00:09:26,000
aquí la de fila cero, columna dos,

149
00:09:26,000 --> 00:09:28,000
aquí ya la de fila uno, columna cero,

150
00:09:28,000 --> 00:09:30,000
o sea, aquí es muy complicado

151
00:09:30,000 --> 00:09:32,000
ahora ya distinguir cuál es la de cada uno,

152
00:09:32,000 --> 00:09:35,000
porque están todas serializadas ahí en filita,

153
00:09:35,000 --> 00:09:38,000
aquí ya están directamente puestas en su posición real,

154
00:09:38,000 --> 00:09:41,000
ya están directamente puestas en su posición real,

155
00:09:41,000 --> 00:09:43,000
entonces, esto,

156
00:09:43,000 --> 00:09:46,000
el extenderlos a raíz de una dimensión a dos dimensiones,

157
00:09:46,000 --> 00:09:47,000
como ahora veremos,

158
00:09:47,000 --> 00:09:49,000
¿para qué sirve?

159
00:09:49,000 --> 00:09:52,000
pues sirve simplemente para reproducir

160
00:09:52,000 --> 00:09:54,000
una situación real,

161
00:09:54,000 --> 00:09:55,000
reproducirla,

162
00:09:55,000 --> 00:09:58,000
y así que me sea mucho más manejable,

163
00:09:58,000 --> 00:10:00,000
entendible y luego programable esto,

164
00:10:00,000 --> 00:10:01,000
¿vale?

165
00:10:01,000 --> 00:10:02,000
ha sido para eso,

166
00:10:02,000 --> 00:10:04,000
nada más,

167
00:10:04,000 --> 00:10:06,000
uno usa raíz bidimensionales

168
00:10:06,000 --> 00:10:08,000
cuando le facilite la tarea,

169
00:10:08,000 --> 00:10:10,000
porque la realidad que está modelando

170
00:10:10,000 --> 00:10:12,000
es algo que está en un plano,

171
00:10:12,000 --> 00:10:13,000
si es algo que está en un plano,

172
00:10:13,000 --> 00:10:14,000
pues ya está,

173
00:10:14,000 --> 00:10:16,000
si no, no usas raíz bidimensionales,

174
00:10:16,000 --> 00:10:18,000
en los programas hasta ahora,

175
00:10:18,000 --> 00:10:20,000
programa que lee números hasta no sé qué,

176
00:10:20,000 --> 00:10:22,000
pues esos números que estén todos en filita,

177
00:10:22,000 --> 00:10:24,000
para qué quiero yo que estén en dos dimensiones,

178
00:10:24,000 --> 00:10:25,000
¿no? ¿qué más me da?

179
00:10:25,000 --> 00:10:27,000
si la posición de los números en un plano

180
00:10:27,000 --> 00:10:28,000
no pinta nada,

181
00:10:28,000 --> 00:10:29,000
me están dando números uno tras otro,

182
00:10:29,000 --> 00:10:30,000
pues números uno tras otro,

183
00:10:30,000 --> 00:10:31,000
ya está,

184
00:10:31,000 --> 00:10:33,000
pero cuando estoy modelando realidades

185
00:10:33,000 --> 00:10:35,000
en los cuales cada elemento

186
00:10:35,000 --> 00:10:37,000
sí está ubicado en una posición de un plano,

187
00:10:37,000 --> 00:10:39,000
cuando estoy modelando tipo realidades,

188
00:10:39,000 --> 00:10:41,000
pues esto viene fenomenal,

189
00:10:41,000 --> 00:10:42,000
¿vale?

190
00:10:42,000 --> 00:10:45,000
entonces uno elige la estructura de datos

191
00:10:45,000 --> 00:10:47,000
en función de esos datos

192
00:10:47,000 --> 00:10:49,000
qué significado tienen,

193
00:10:49,000 --> 00:10:51,000
qué significado real tienen,

194
00:10:51,000 --> 00:10:53,000
porque hay estructuras de datos

195
00:10:53,000 --> 00:10:54,000
que se adaptan mejor

196
00:10:54,000 --> 00:10:56,000
a unos significados reales que a otros,

197
00:10:56,000 --> 00:10:59,000
y de elegir bien una estructura de datos

198
00:10:59,000 --> 00:11:01,000
depende que esa aplicación

199
00:11:01,000 --> 00:11:03,000
luego es una aplicación buena,

200
00:11:03,000 --> 00:11:05,000
eficiente y con sentido,

201
00:11:05,000 --> 00:11:06,000
¿vale?

202
00:11:06,000 --> 00:11:08,000
bueno, esta sería la motivación

203
00:11:08,000 --> 00:11:11,000
de por qué complicar los arrays

204
00:11:11,000 --> 00:11:12,000
de una dimensión

205
00:11:12,000 --> 00:11:13,000
que ya vemos cómo funcionan,

206
00:11:13,000 --> 00:11:15,000
que son facilísimos de trabajar con ellos, etc.

207
00:11:15,000 --> 00:11:17,000
¿por qué complicarlos?

208
00:11:17,000 --> 00:11:18,000
dándoles otra dimensión más,

209
00:11:18,000 --> 00:11:19,000
¿por qué complicarlos?

210
00:11:19,000 --> 00:11:22,000
pues la razón de por qué los complicamos

211
00:11:22,000 --> 00:11:25,000
es porque al hacerlos bidimensionales

212
00:11:25,000 --> 00:11:27,000
representan algo muy real,

213
00:11:27,000 --> 00:11:30,000
que es que las cosas están situadas en planos,

214
00:11:30,000 --> 00:11:31,000
¿vale?

215
00:11:31,000 --> 00:11:32,000
si uno hace un programa de ajedrez

216
00:11:32,000 --> 00:11:33,000
de tres en raya,

217
00:11:33,000 --> 00:11:35,000
pues cada posición en realidad

218
00:11:35,000 --> 00:11:36,000
está en un plano,

219
00:11:36,000 --> 00:11:37,000
pues hombre,

220
00:11:37,000 --> 00:11:38,000
va a quedar mucho mejor modelado

221
00:11:38,000 --> 00:11:40,000
un tablero de ajedrez

222
00:11:40,000 --> 00:11:41,000
con esto,

223
00:11:41,000 --> 00:11:42,000
que con esto,

224
00:11:42,000 --> 00:11:43,000
va a quedar mucho mejor modelado,

225
00:11:43,000 --> 00:11:44,000
va a quedar un tablero de ajedrez

226
00:11:44,000 --> 00:11:46,000
así que con esto,

227
00:11:46,000 --> 00:11:47,000
¿vale?

228
00:11:47,000 --> 00:11:48,000
bueno,

229
00:11:48,000 --> 00:11:49,000
pues esta sería la razón

230
00:11:49,000 --> 00:11:50,000
de por qué nos complicamos,

231
00:11:50,000 --> 00:11:52,000
por qué le metemos otra dimensión,

232
00:11:52,000 --> 00:11:53,000
ahora ya vamos a ver

233
00:11:53,000 --> 00:11:55,000
cómo se declaran

234
00:11:55,000 --> 00:11:56,000
y cómo se utilizan

235
00:11:56,000 --> 00:11:58,000
los arrays de dos dimensiones.

236
00:12:13,000 --> 00:12:14,000
Vale,

237
00:12:14,000 --> 00:12:15,000
pues a ver,

238
00:12:15,000 --> 00:12:16,000
bueno,

239
00:12:16,000 --> 00:12:17,000
para no arrastrar el string

240
00:12:17,000 --> 00:12:18,000
que es muy largo,

241
00:12:18,000 --> 00:12:19,000
vamos a hacerlo con numeritos,

242
00:12:19,000 --> 00:12:20,000
con int,

243
00:12:20,000 --> 00:12:21,000
que es el más cordito de cualquiera,

244
00:12:21,000 --> 00:12:22,000
bueno,

245
00:12:22,000 --> 00:12:23,000
resulta que queremos guardar

246
00:12:23,000 --> 00:12:25,000
un montón de números,

247
00:12:25,000 --> 00:12:26,000
un montón de números,

248
00:12:26,000 --> 00:12:27,000
vale,

249
00:12:27,000 --> 00:12:28,000
pero no los vamos a guardar

250
00:12:28,000 --> 00:12:29,000
todos en una fila,

251
00:12:29,000 --> 00:12:30,000
no los vamos a guardar

252
00:12:30,000 --> 00:12:31,000
todos en una fila,

253
00:12:31,000 --> 00:12:32,000
los vamos a guardar

254
00:12:32,000 --> 00:12:34,000
en una matriz,

255
00:12:34,000 --> 00:12:35,000
una matriz,

256
00:12:35,000 --> 00:12:36,000
en un casillero,

257
00:12:36,000 --> 00:12:37,000
como lo queréis llamar,

258
00:12:37,000 --> 00:12:38,000
en términos matemáticos

259
00:12:38,000 --> 00:12:39,000
una matriz,

260
00:12:39,000 --> 00:12:40,000
¿no?

261
00:12:40,000 --> 00:12:41,000
vale,

262
00:12:41,000 --> 00:12:42,000
bueno,

263
00:12:42,000 --> 00:12:43,000
pues entonces,

264
00:12:43,000 --> 00:12:45,000
¿cómo se define una matriz?

265
00:12:45,000 --> 00:12:47,000
El tipo de dato

266
00:12:47,000 --> 00:12:48,000
es impepinable,

267
00:12:48,000 --> 00:12:49,000
qué datos va a contener

268
00:12:49,000 --> 00:12:50,000
cada elemento entero,

269
00:12:50,000 --> 00:12:51,000
y ahora,

270
00:12:51,000 --> 00:12:53,000
como tiene filas y columnas,

271
00:12:53,000 --> 00:12:55,000
en lugar de solo

272
00:12:55,000 --> 00:12:56,000
uno de esos corchetes,

273
00:12:56,000 --> 00:12:58,000
ponemos dos,

274
00:12:58,000 --> 00:12:59,000
ya está,

275
00:12:59,000 --> 00:13:00,000
ponemos dos,

276
00:13:00,000 --> 00:13:01,000
eso significa

277
00:13:01,000 --> 00:13:02,000
que la estructura de datos

278
00:13:02,000 --> 00:13:04,000
que hemos declarado ahora

279
00:13:04,000 --> 00:13:05,000
la puedo yo ya visualizar

280
00:13:05,000 --> 00:13:07,000
en mi cabeza,

281
00:13:07,000 --> 00:13:08,000
la puedo visualizar

282
00:13:08,000 --> 00:13:09,000
en mi cabeza,

283
00:13:09,000 --> 00:13:11,000
no como una única fila,

284
00:13:11,000 --> 00:13:13,000
sino como esto,

285
00:13:13,000 --> 00:13:15,000
así la tengo que visualizar

286
00:13:15,000 --> 00:13:16,000
en mi cabeza,

287
00:13:16,000 --> 00:13:17,000
desde el momento

288
00:13:17,000 --> 00:13:18,000
en que decimos

289
00:13:18,000 --> 00:13:19,000
que tiene dos dimensiones,

290
00:13:19,000 --> 00:13:21,000
la visualizamos así,

291
00:13:21,000 --> 00:13:22,000
obviamente luego esto,

292
00:13:22,000 --> 00:13:23,000
la matriz virtual

293
00:13:23,000 --> 00:13:24,000
lo mapea en la RAM,

294
00:13:24,000 --> 00:13:25,000
no en una matriz,

295
00:13:25,000 --> 00:13:26,000
porque la RAM

296
00:13:26,000 --> 00:13:27,000
son una secuencia de posiciones,

297
00:13:27,000 --> 00:13:28,000
pero eso nos da igual,

298
00:13:28,000 --> 00:13:29,000
lo que importa

299
00:13:29,000 --> 00:13:30,000
es cómo lo visualizamos

300
00:13:30,000 --> 00:13:31,000
en nuestra cabeza,

301
00:13:31,000 --> 00:13:32,000
pues cuando declaramos

302
00:13:32,000 --> 00:13:33,000
una array así,

303
00:13:33,000 --> 00:13:34,000
con dos dimensiones,

304
00:13:34,000 --> 00:13:35,000
dos corchetes,

305
00:13:35,000 --> 00:13:36,000
automáticamente

306
00:13:36,000 --> 00:13:37,000
en la cabeza

307
00:13:37,000 --> 00:13:38,000
ya tenemos que visualizar

308
00:13:38,000 --> 00:13:39,000
que la estructura

309
00:13:39,000 --> 00:13:40,000
de datos que tenemos

310
00:13:40,000 --> 00:13:42,000
tiene esta forma,

311
00:13:42,000 --> 00:13:43,000
es un casillero

312
00:13:43,000 --> 00:13:44,000
con celdillas,

313
00:13:44,000 --> 00:13:45,000
ya no es solo

314
00:13:45,000 --> 00:13:46,000
una fila larga,

315
00:13:46,000 --> 00:13:47,000
ya no es solo

316
00:13:47,000 --> 00:13:48,000
una fila larga,

317
00:13:48,000 --> 00:13:49,000
vale, repito,

318
00:13:49,000 --> 00:13:50,000
si hemos optado

319
00:13:50,000 --> 00:13:51,000
por esto,

320
00:13:51,000 --> 00:13:54,000
es porque nos interesa,

321
00:13:54,000 --> 00:13:55,000
no por las buenas,

322
00:13:55,000 --> 00:13:56,000
porque para

323
00:13:56,000 --> 00:13:57,000
una fila larga

324
00:13:57,000 --> 00:13:58,000
es muy fácil de usar,

325
00:13:58,000 --> 00:13:59,000
ya lo hemos visto

326
00:13:59,000 --> 00:14:00,000
que un vector

327
00:14:00,000 --> 00:14:01,000
es una cosa muy cómoda,

328
00:14:01,000 --> 00:14:02,000
una array

329
00:14:02,000 --> 00:14:03,000
muy estupenda,

330
00:14:03,000 --> 00:14:04,000
vale,

331
00:14:04,000 --> 00:14:05,000
entonces yo no elijo esto

332
00:14:05,000 --> 00:14:06,000
porque me da la gana,

333
00:14:06,000 --> 00:14:07,000
lo elijo

334
00:14:07,000 --> 00:14:08,000
porque cuando estamos

335
00:14:08,000 --> 00:14:09,000
declarando,

336
00:14:09,000 --> 00:14:10,000
pues se presta precisamente

337
00:14:10,000 --> 00:14:11,000
a ser reflejada

338
00:14:11,000 --> 00:14:12,000
en un plano,

339
00:14:12,000 --> 00:14:13,000
bueno,

340
00:14:13,000 --> 00:14:14,000
pues con esto

341
00:14:14,000 --> 00:14:15,000
ya visualizamos

342
00:14:15,000 --> 00:14:16,000
que lo que,

343
00:14:16,000 --> 00:14:17,000
la estructura

344
00:14:17,000 --> 00:14:18,000
que estamos

345
00:14:18,000 --> 00:14:19,000
declarando

346
00:14:19,000 --> 00:14:20,000
es esta,

347
00:14:20,000 --> 00:14:21,000
como cualquier variable

348
00:14:21,000 --> 00:14:22,000
hay que darle un nombre,

349
00:14:22,000 --> 00:14:23,000
eso sí,

350
00:14:23,000 --> 00:14:24,000
vale,

351
00:14:24,000 --> 00:14:25,000
como cualquier variable,

352
00:14:25,000 --> 00:14:26,000
pues venga,

353
00:14:26,000 --> 00:14:27,000
yo que sé,

354
00:14:27,000 --> 00:14:28,000
vamos a poner

355
00:14:28,000 --> 00:14:29,000
tablero,

356
00:14:29,000 --> 00:14:30,000
ala,

357
00:14:30,000 --> 00:14:31,000
el nombre que me dé la gana,

358
00:14:31,000 --> 00:14:32,000
el nombre de la variable,

359
00:14:32,000 --> 00:14:33,000
ya sabéis que elegimos

360
00:14:33,000 --> 00:14:34,000
el nombre que queramos,

361
00:14:34,000 --> 00:14:35,000
y esto es otra variable más,

362
00:14:36,000 --> 00:14:38,000
lo que pasa es que este,

363
00:14:38,000 --> 00:14:39,000
¿qué tipo de variable es?

364
00:14:39,000 --> 00:14:40,000
es un tipo de variable

365
00:14:40,000 --> 00:14:41,000
array de dos dimensiones,

366
00:14:43,000 --> 00:14:44,000
igual que esta,

367
00:14:45,000 --> 00:14:47,000
es un tipo de variable

368
00:14:47,000 --> 00:14:49,000
igual array de una dimensión,

369
00:14:50,000 --> 00:14:51,000
e igual que esta,

370
00:14:51,000 --> 00:14:52,000
es un tipo de variable

371
00:14:52,000 --> 00:14:53,000
igual a un entero,

372
00:14:55,000 --> 00:14:56,000
bueno,

373
00:14:56,000 --> 00:14:57,000
pues este es una variable

374
00:14:57,000 --> 00:14:58,000
de tipo array de dos dimensiones,

375
00:14:58,000 --> 00:14:59,000
o matriz,

376
00:15:00,000 --> 00:15:01,000
o casillero,

377
00:15:01,000 --> 00:15:02,000
como lo queráis llamar,

378
00:15:03,000 --> 00:15:04,000
bueno,

379
00:15:04,000 --> 00:15:05,000
pues exactamente igual

380
00:15:05,000 --> 00:15:06,000
que en el caso

381
00:15:06,000 --> 00:15:07,000
de los arrays de una dimensión,

382
00:15:08,000 --> 00:15:09,000
con esta declaración sin más,

383
00:15:10,000 --> 00:15:11,000
yo todavía

384
00:15:11,000 --> 00:15:12,000
el espacio en memoria

385
00:15:12,000 --> 00:15:13,000
no lo tengo,

386
00:15:14,000 --> 00:15:15,000
lo que tenemos aquí

387
00:15:15,000 --> 00:15:16,000
ya lo sabemos,

388
00:15:17,000 --> 00:15:18,000
porque ya es lo mismo

389
00:15:18,000 --> 00:15:19,000
que en el caso

390
00:15:19,000 --> 00:15:20,000
de declarar un array,

391
00:15:20,000 --> 00:15:21,000
cuando nosotros

392
00:15:21,000 --> 00:15:22,000
declaramos un array,

393
00:15:23,000 --> 00:15:24,000
ya insistimos en eso

394
00:15:24,000 --> 00:15:25,000
ayer otra vez,

395
00:15:26,000 --> 00:15:27,000
imaginamos que declaramos

396
00:15:27,000 --> 00:15:28,000
un array,

397
00:15:29,000 --> 00:15:30,000
y en el caso

398
00:15:30,000 --> 00:15:31,000
de declarar un array

399
00:15:32,000 --> 00:15:33,000
con esta declaración

400
00:15:34,000 --> 00:15:35,000
tenemos una variable num,

401
00:15:37,000 --> 00:15:38,000
y esta variable num

402
00:15:38,000 --> 00:15:39,000
que se ha creado,

403
00:15:41,000 --> 00:15:42,000
es una dirección

404
00:15:42,000 --> 00:15:43,000
de memoria simplemente,

405
00:15:44,000 --> 00:15:45,000
esta variable num

406
00:15:45,000 --> 00:15:46,000
es una dirección de memoria,

407
00:15:46,000 --> 00:15:47,000
que apunta a donde,

408
00:15:48,000 --> 00:15:49,000
por ahora a nada,

409
00:15:50,000 --> 00:15:51,000
por ahora a nada,

410
00:15:51,000 --> 00:15:52,000
para que aparezca

411
00:15:52,000 --> 00:15:53,000
realmente el array,

412
00:15:54,000 --> 00:15:55,000
para que aparezca

413
00:15:55,000 --> 00:15:56,000
físicamente en memoria

414
00:15:56,000 --> 00:15:57,000
el array,

415
00:15:57,000 --> 00:15:58,000
ya pueda yo acceder

416
00:15:58,000 --> 00:15:59,000
a las posiciones,

417
00:15:59,000 --> 00:16:00,000
a la cero,

418
00:16:00,000 --> 00:16:01,000
a la uno,

419
00:16:01,000 --> 00:16:02,000
a la dos,

420
00:16:02,000 --> 00:16:03,000
teníamos que hacer esto,

421
00:16:03,000 --> 00:16:04,000
¿verdad?,

422
00:16:04,000 --> 00:16:05,000
inicializarlo,

423
00:16:06,000 --> 00:16:07,000
con new

424
00:16:07,000 --> 00:16:08,000
tipo de dato,

425
00:16:08,000 --> 00:16:09,000
el que fuera

426
00:16:09,000 --> 00:16:10,000
y las posiciones

427
00:16:10,000 --> 00:16:11,000
que yo quiera,

428
00:16:11,000 --> 00:16:12,000
hay que darle unas posiciones,

429
00:16:12,000 --> 00:16:13,000
eso si que no lo podemos

430
00:16:13,000 --> 00:16:14,000
eludir,

431
00:16:14,000 --> 00:16:15,000
hay que darle unas,

432
00:16:15,000 --> 00:16:16,000
vale,

433
00:16:16,000 --> 00:16:17,000
una vez que ya

434
00:16:17,000 --> 00:16:18,000
hacemos esto,

435
00:16:18,000 --> 00:16:19,000
este espacio en memoria

436
00:16:19,000 --> 00:16:20,000
se crea,

437
00:16:20,000 --> 00:16:21,000
con las posiciones

438
00:16:21,000 --> 00:16:22,000
que ya he puesto aquí,

439
00:16:22,000 --> 00:16:23,000
de la cero

440
00:16:23,000 --> 00:16:24,000
a la veintinueve

441
00:16:24,000 --> 00:16:25,000
en este caso,

442
00:16:25,000 --> 00:16:26,000
vale,

443
00:16:26,000 --> 00:16:27,000
pues con el de dos dimensiones

444
00:16:27,000 --> 00:16:28,000
pasa lo mismo,

445
00:16:28,000 --> 00:16:29,000
con la declaración

446
00:16:29,000 --> 00:16:30,000
que hemos hecho hasta ahora,

447
00:16:32,000 --> 00:16:33,000
es declarar una variable

448
00:16:33,000 --> 00:16:34,000
que se llama tablero,

449
00:16:35,000 --> 00:16:36,000
que contiene

450
00:16:37,000 --> 00:16:38,000
una dirección de memoria,

451
00:16:39,000 --> 00:16:40,000
pero por ahora

452
00:16:40,000 --> 00:16:41,000
de una zona

453
00:16:41,000 --> 00:16:42,000
inusable,

454
00:16:42,000 --> 00:16:43,000
que no me vale para nada,

455
00:16:43,000 --> 00:16:44,000
por ahora una zona inusable,

456
00:16:45,000 --> 00:16:46,000
igual que cuando

457
00:16:46,000 --> 00:16:47,000
hacíamos esto,

458
00:16:48,000 --> 00:16:49,000
cuando hacemos esto

459
00:16:49,000 --> 00:16:50,000
tengo una dirección de memoria

460
00:16:50,000 --> 00:16:51,000
de algo que no puedo utilizar,

461
00:16:52,000 --> 00:16:53,000
claro,

462
00:16:53,000 --> 00:16:54,000
pues nos falta efectivamente

463
00:16:54,000 --> 00:16:55,000
inicializar

464
00:16:55,000 --> 00:16:56,000
este array doble,

465
00:16:57,000 --> 00:16:58,000
este array de dos dimensiones,

466
00:16:58,000 --> 00:16:59,000
nos falta crear el espacio

467
00:17:00,000 --> 00:17:01,000
para poder usarlo,

468
00:17:01,000 --> 00:17:02,000
igual que en el array,

469
00:17:04,000 --> 00:17:05,000
bueno,

470
00:17:05,000 --> 00:17:06,000
pues lo creamos

471
00:17:06,000 --> 00:17:07,000
exactamente igual

472
00:17:07,000 --> 00:17:08,000
que creábamos el espacio

473
00:17:08,000 --> 00:17:09,000
para un array,

474
00:17:09,000 --> 00:17:10,000
con el operador new,

475
00:17:11,000 --> 00:17:12,000
el tipo de dato,

476
00:17:14,000 --> 00:17:15,000
y aquí,

477
00:17:15,000 --> 00:17:16,000
como el espacio

478
00:17:16,000 --> 00:17:17,000
que estamos creando

479
00:17:18,000 --> 00:17:19,000
es un plano,

480
00:17:20,000 --> 00:17:21,000
con filas y columnas

481
00:17:21,000 --> 00:17:22,000
tenemos que decirle

482
00:17:22,000 --> 00:17:23,000
cuantas filas

483
00:17:23,000 --> 00:17:24,000
queremos que tenga

484
00:17:24,000 --> 00:17:25,000
y cuantas columnas,

485
00:17:26,000 --> 00:17:27,000
pues que quiero yo

486
00:17:27,000 --> 00:17:28,000
de esto,

487
00:17:34,000 --> 00:17:35,000
algo así en mi cabeza,

488
00:17:35,000 --> 00:17:36,000
la idea que yo tengo

489
00:17:36,000 --> 00:17:37,000
es algo así en mi cabeza,

490
00:17:37,000 --> 00:17:38,000
esto es lo que yo necesito

491
00:17:38,000 --> 00:17:39,000
para modelar la realidad

492
00:17:39,000 --> 00:17:40,000
que estoy,

493
00:17:40,000 --> 00:17:41,000
pues esto serían

494
00:17:41,000 --> 00:17:42,000
cuatro filas

495
00:17:43,000 --> 00:17:44,000
y tres columnas,

496
00:17:46,000 --> 00:17:47,000
vale,

497
00:17:47,000 --> 00:17:48,000
pues entonces pongo aquí

498
00:17:49,000 --> 00:17:50,000
cuatro filas

499
00:17:52,000 --> 00:17:53,000
y tres columnas,

500
00:17:55,000 --> 00:17:56,000
vale,

501
00:17:56,000 --> 00:17:57,000
entonces aquí

502
00:17:57,000 --> 00:17:58,000
automáticamente

503
00:17:58,000 --> 00:17:59,000
ya sí que ha aparecido

504
00:17:59,000 --> 00:18:00,000
este espacio en memoria,

505
00:18:00,000 --> 00:18:01,000
ahora ya sí,

506
00:18:02,000 --> 00:18:03,000
y ya esta dirección tablero,

507
00:18:04,000 --> 00:18:05,000
ya efectivamente

508
00:18:05,000 --> 00:18:06,000
ahora ya sí,

509
00:18:06,000 --> 00:18:07,000
se queda apuntando

510
00:18:07,000 --> 00:18:08,000
a una estructura

511
00:18:09,000 --> 00:18:10,000
de este tipo,

512
00:18:10,000 --> 00:18:11,000
ahora ya sí,

513
00:18:12,000 --> 00:18:13,000
ya este espacio existe

514
00:18:13,000 --> 00:18:14,000
y ya lo puedo utilizar,

515
00:18:15,000 --> 00:18:16,000
utilizar para qué,

516
00:18:16,000 --> 00:18:17,000
para guardar números enteros,

517
00:18:17,000 --> 00:18:18,000
que es para lo que

518
00:18:18,000 --> 00:18:19,000
lo he declarado,

519
00:18:19,000 --> 00:18:20,000
para guardar números enteros,

520
00:18:20,000 --> 00:18:21,000
vale,

521
00:18:21,000 --> 00:18:22,000
pues ahora ya puedo

522
00:18:22,000 --> 00:18:23,000
meter números enteros aquí,

523
00:18:24,000 --> 00:18:25,000
igual que antes

524
00:18:25,000 --> 00:18:26,000
yo tenía una única fila,

525
00:18:27,000 --> 00:18:28,000
pues ahora los puedo meter aquí,

526
00:18:30,000 --> 00:18:31,000
vale,

527
00:18:31,000 --> 00:18:32,000
pero claro,

528
00:18:32,000 --> 00:18:33,000
la diferencia

529
00:18:33,000 --> 00:18:34,000
y la única diferencia

530
00:18:34,000 --> 00:18:35,000
que hay con los arrays

531
00:18:35,000 --> 00:18:36,000
de una dimensión

532
00:18:36,000 --> 00:18:37,000
es que ahora

533
00:18:37,000 --> 00:18:38,000
para acceder a una posición

534
00:18:40,000 --> 00:18:41,000
necesito una información

535
00:18:41,000 --> 00:18:42,000
de uno,

536
00:18:42,000 --> 00:18:43,000
la fila

537
00:18:43,000 --> 00:18:44,000
y la columna,

538
00:18:44,000 --> 00:18:45,000
en una array normal

539
00:18:46,000 --> 00:18:47,000
para acceder a una posición

540
00:18:47,000 --> 00:18:48,000
necesito solo una información,

541
00:18:50,000 --> 00:18:51,000
que es la posición

542
00:18:51,000 --> 00:18:52,000
en la fila,

543
00:18:52,000 --> 00:18:53,000
si es la posición

544
00:18:53,000 --> 00:18:54,000
cero de la fila,

545
00:18:54,000 --> 00:18:55,000
si es la uno de la fila,

546
00:18:55,000 --> 00:18:56,000
la dos de la fila

547
00:18:56,000 --> 00:18:57,000
y ya está,

548
00:18:57,000 --> 00:18:58,000
la única información

549
00:18:58,000 --> 00:18:59,000
que necesito para acceder

550
00:18:59,000 --> 00:19:00,000
a una posición,

551
00:19:00,000 --> 00:19:01,000
la posición de la fila,

552
00:19:01,000 --> 00:19:02,000
aquí necesito dos informaciones,

553
00:19:03,000 --> 00:19:04,000
la fila donde está

554
00:19:04,000 --> 00:19:05,000
el numerito

555
00:19:05,000 --> 00:19:06,000
al que quiero acceder

556
00:19:06,000 --> 00:19:07,000
y la columna

557
00:19:07,000 --> 00:19:08,000
donde está el numerito

558
00:19:08,000 --> 00:19:09,000
al que quiero acceder,

559
00:19:09,000 --> 00:19:10,000
es la única diferencia,

560
00:19:10,000 --> 00:19:11,000
la única,

561
00:19:11,000 --> 00:19:12,000
vale,

562
00:19:12,000 --> 00:19:13,000
por ejemplo,

563
00:19:17,000 --> 00:19:18,000
si yo quisiera,

564
00:19:19,000 --> 00:19:20,000
si yo quisiera

565
00:19:20,000 --> 00:19:21,000
inicializar ahora

566
00:19:22,000 --> 00:19:23,000
todas las posiciones

567
00:19:23,000 --> 00:19:24,000
de este tablero

568
00:19:24,000 --> 00:19:25,000
con cero,

569
00:19:27,000 --> 00:19:28,000
vale,

570
00:19:28,000 --> 00:19:29,000
a lo mejor esto podría ser,

571
00:19:29,000 --> 00:19:30,000
esto podría simular

572
00:19:30,000 --> 00:19:31,000
a lo mejor

573
00:19:31,000 --> 00:19:32,000
un juego de,

574
00:19:33,000 --> 00:19:34,000
un juego de un tablero

575
00:19:35,000 --> 00:19:36,000
donde uno va poniendo fichas

576
00:19:36,000 --> 00:19:37,000
y uno podría haber decidido,

577
00:19:38,000 --> 00:19:39,000
vale,

578
00:19:39,000 --> 00:19:40,000
cuando en una posición

579
00:19:40,000 --> 00:19:41,000
haya un cero,

580
00:19:41,000 --> 00:19:42,000
he puesto una ficha

581
00:19:42,000 --> 00:19:43,000
y cuando en una posición

582
00:19:43,000 --> 00:19:44,000
haya un uno,

583
00:19:45,000 --> 00:19:46,000
he puesto la ficha uno,

584
00:19:46,000 --> 00:19:47,000
por ejemplo,

585
00:19:47,000 --> 00:19:48,000
vale,

586
00:19:49,000 --> 00:19:50,000
es decir,

587
00:19:50,000 --> 00:19:51,000
lo que quiero decir

588
00:19:51,000 --> 00:19:52,000
es que seleccionar

589
00:19:52,000 --> 00:19:53,000
esta estructura

590
00:19:53,000 --> 00:19:54,000
es,

591
00:19:54,000 --> 00:19:55,000
si tiene sentido,

592
00:19:55,000 --> 00:19:56,000
porque lo que yo estoy modelando

593
00:19:56,000 --> 00:19:57,000
le pega,

594
00:19:57,000 --> 00:19:58,000
si no,

595
00:19:58,000 --> 00:19:59,000
es mucho más complejidad

596
00:19:59,000 --> 00:20:00,000
que una fila,

597
00:20:01,000 --> 00:20:02,000
no voy a meter ahí

598
00:20:02,000 --> 00:20:03,000
esa estructura

599
00:20:03,000 --> 00:20:04,000
que es mucho más compleja

600
00:20:04,000 --> 00:20:05,000
que una fila,

601
00:20:05,000 --> 00:20:06,000
alegremente,

602
00:20:06,000 --> 00:20:07,000
pero en ese ejemplo,

603
00:20:07,000 --> 00:20:08,000
yo estoy simulando

604
00:20:08,000 --> 00:20:09,000
un jueguito de un tablero,

605
00:20:09,000 --> 00:20:10,000
vale,

606
00:20:10,000 --> 00:20:11,000
pues,

607
00:20:11,000 --> 00:20:12,000
el tablero

608
00:20:12,000 --> 00:20:13,000
queda perfectamente

609
00:20:13,000 --> 00:20:14,000
bien representado con esto,

610
00:20:15,000 --> 00:20:16,000
ya yo tendría que decir,

611
00:20:16,000 --> 00:20:17,000
vale,

612
00:20:17,000 --> 00:20:18,000
en cada posición

613
00:20:18,000 --> 00:20:19,000
que van,

614
00:20:19,000 --> 00:20:20,000
bueno,

615
00:20:20,000 --> 00:20:21,000
pues pueden ir dos fichas,

616
00:20:21,000 --> 00:20:22,000
entonces,

617
00:20:22,000 --> 00:20:23,000
bueno,

618
00:20:23,000 --> 00:20:24,000
pues yo la simulo

619
00:20:24,000 --> 00:20:25,000
con que una de las fichas

620
00:20:25,000 --> 00:20:26,000
es el número cero

621
00:20:26,000 --> 00:20:27,000
y otra es el número uno,

622
00:20:27,000 --> 00:20:28,000
vale,

623
00:20:28,000 --> 00:20:29,000
pues estupendo,

624
00:20:29,000 --> 00:20:30,000
mi tablero que sea

625
00:20:30,000 --> 00:20:31,000
de números enteros

626
00:20:31,000 --> 00:20:32,000
y cada uno de ellos

627
00:20:32,000 --> 00:20:33,000
tendrá un cero o un uno

628
00:20:33,000 --> 00:20:34,000
en función de la ficha

629
00:20:34,000 --> 00:20:35,000
que tenga,

630
00:20:35,000 --> 00:20:36,000
por ejemplo,

631
00:20:36,000 --> 00:20:37,000
y cada jugador

632
00:20:37,000 --> 00:20:38,000
va poniendo

633
00:20:38,000 --> 00:20:39,000
en cada posición

634
00:20:39,000 --> 00:20:40,000
el cero,

635
00:20:40,000 --> 00:20:41,000
el uno,

636
00:20:41,000 --> 00:20:42,000
lo que sea,

637
00:20:42,000 --> 00:20:43,000
entonces en un ejemplito

638
00:20:43,000 --> 00:20:44,000
como ese,

639
00:20:44,000 --> 00:20:45,000
usar esta estructura

640
00:20:45,000 --> 00:20:46,000
viene muy bien,

641
00:20:46,000 --> 00:20:47,000
porque tengo

642
00:20:47,000 --> 00:20:48,000
perfectamente clavado

643
00:20:48,000 --> 00:20:49,000
ahí ya el tablero,

644
00:20:49,000 --> 00:20:50,000
pero como yo clave

645
00:20:50,000 --> 00:20:51,000
en una fila,

646
00:20:51,000 --> 00:20:52,000
lo tengo complicadísimo

647
00:20:52,000 --> 00:20:53,000
para identificar,

648
00:20:53,000 --> 00:20:54,000
para asociar luego

649
00:20:54,000 --> 00:20:55,000
cada posición

650
00:20:55,000 --> 00:20:56,000
a mi tablero físico real,

651
00:20:56,000 --> 00:20:57,000
al que yo estoy viendo

652
00:20:57,000 --> 00:20:58,000
con los ojos,

653
00:20:58,000 --> 00:20:59,000
lo tengo muy complicado,

654
00:20:59,000 --> 00:21:00,000
esta es esta,

655
00:21:00,000 --> 00:21:01,000
esta es esta,

656
00:21:01,000 --> 00:21:02,000
esta es esta,

657
00:21:02,000 --> 00:21:03,000
esta es esta,

658
00:21:03,000 --> 00:21:04,000
rollo,

659
00:21:04,000 --> 00:21:05,000
pero si mi variable,

660
00:21:05,000 --> 00:21:06,000
mi estructura de datos

661
00:21:06,000 --> 00:21:07,000
es esta,

662
00:21:07,000 --> 00:21:08,000
esto es que es directamente

663
00:21:08,000 --> 00:21:09,000
ya el tablero real

664
00:21:09,000 --> 00:21:10,000
que yo estoy viendo

665
00:21:10,000 --> 00:21:11,000
con los ojos,

666
00:21:11,000 --> 00:21:12,000
ya es directamente él,

667
00:21:12,000 --> 00:21:13,000
lo reproduce mucho mejor,

668
00:21:13,000 --> 00:21:14,000
mucho más fácil

669
00:21:14,000 --> 00:21:15,000
el programa,

670
00:21:15,000 --> 00:21:16,000
¿no?

671
00:21:16,000 --> 00:21:17,000
que llevarme

672
00:21:18,000 --> 00:21:19,000
el tablero real

673
00:21:19,000 --> 00:21:20,000
el que veo con los ojos

674
00:21:20,000 --> 00:21:21,000
a una fila

675
00:21:21,000 --> 00:21:22,000
y serializarlo todo largo,

676
00:21:22,000 --> 00:21:23,000
esto no le pega nada,

677
00:21:23,000 --> 00:21:24,000
bueno,

678
00:21:24,000 --> 00:21:25,000
vale,

679
00:21:25,000 --> 00:21:26,000
pues entonces,

680
00:21:26,000 --> 00:21:27,000
ahora,

681
00:21:27,000 --> 00:21:28,000
en lo que estábamos,

682
00:21:28,000 --> 00:21:29,000
ahora ya para acceder

683
00:21:29,000 --> 00:21:30,000
a las posiciones,

684
00:21:30,000 --> 00:21:31,000
que es de lo que se trata

685
00:21:31,000 --> 00:21:32,000
de acceder a las posiciones,

686
00:21:32,000 --> 00:21:33,000
necesito fila y columna,

687
00:21:33,000 --> 00:21:34,000
¿vale?

688
00:21:34,000 --> 00:21:35,000
igual que en los array,

689
00:21:35,000 --> 00:21:36,000
las primeras empezaban

690
00:21:36,000 --> 00:21:37,000
con la cero,

691
00:21:37,000 --> 00:21:38,000
aquí también,

692
00:21:38,000 --> 00:21:39,000
la cero,

693
00:21:39,000 --> 00:21:40,000
la cero,

694
00:21:40,000 --> 00:21:41,000
la cero,

695
00:21:41,000 --> 00:21:42,000
la cero,

696
00:21:42,000 --> 00:21:43,000
la cero,

697
00:21:43,000 --> 00:21:44,000
la cero,

698
00:21:44,000 --> 00:21:45,000
la cero,

699
00:21:45,000 --> 00:21:46,000
la cero,

700
00:21:46,000 --> 00:21:47,000
aquí también,

701
00:21:47,000 --> 00:21:48,000
las filas empiezan,

702
00:21:48,000 --> 00:21:49,000
cero,

703
00:21:49,000 --> 00:21:50,000
uno,

704
00:21:50,000 --> 00:21:51,000
dos,

705
00:21:51,000 --> 00:21:52,000
en este caso,

706
00:21:52,000 --> 00:21:53,000
y tres,

707
00:21:53,000 --> 00:21:54,000
porque tengo cuatro filas,

708
00:21:54,000 --> 00:21:55,000
y las columnas empiezan

709
00:21:55,000 --> 00:21:56,000
en la cero,

710
00:21:56,000 --> 00:21:57,000
uno y dos,

711
00:21:57,000 --> 00:21:58,000
porque tengo tres,

712
00:21:58,000 --> 00:21:59,000
cero,

713
00:21:59,000 --> 00:22:00,000
uno y dos,

714
00:22:00,000 --> 00:22:01,000
porque son tres en total,

715
00:22:01,000 --> 00:22:02,000
cero,

716
00:22:02,000 --> 00:22:03,000
uno,

717
00:22:03,000 --> 00:22:04,000
dos y tres,

718
00:22:04,000 --> 00:22:05,000
porque son cuatro filas en total,

719
00:22:05,000 --> 00:22:06,000
¿vale?

720
00:22:06,000 --> 00:22:07,000
filas y columna,

721
00:22:07,000 --> 00:22:08,000
¿qué quiere inicializarlo

722
00:22:08,000 --> 00:22:09,000
todo a cero?

723
00:22:09,000 --> 00:22:10,000
por ejemplo,

724
00:22:10,000 --> 00:22:11,000
hombre,

725
00:22:11,000 --> 00:22:12,000
pues puede uno ir a lo bestia,

726
00:22:12,000 --> 00:22:13,000
para acceder a la fila cero,

727
00:22:13,000 --> 00:22:14,000
columna cero,

728
00:22:14,000 --> 00:22:15,000
pues como podéis intuir,

729
00:22:15,000 --> 00:22:16,000
tengo dos posiciones,

730
00:22:16,000 --> 00:22:17,000
la primera a la fila,

731
00:22:17,000 --> 00:22:18,000
y la segunda a la columna,

732
00:22:18,000 --> 00:22:19,000
con esto estoy accediendo

733
00:22:19,000 --> 00:22:20,000
a esta,

734
00:22:20,000 --> 00:22:21,000
porque es fila cero,

735
00:22:21,000 --> 00:22:22,000
columna cero,

736
00:22:22,000 --> 00:22:23,000
¿vale?

737
00:22:23,000 --> 00:22:24,000
con el array de una dimensión,

738
00:22:24,000 --> 00:22:25,000
con poner esto era suficiente,

739
00:22:25,000 --> 00:22:26,000
pero con el array de dos,

740
00:22:26,000 --> 00:22:27,000
tengo que poner la fila,

741
00:22:27,000 --> 00:22:28,000
y dentro de la fila

742
00:22:28,000 --> 00:22:29,000
la columna,

743
00:22:29,000 --> 00:22:30,000
¿vale?

744
00:22:30,000 --> 00:22:31,000
pues esta variable,

745
00:22:31,000 --> 00:22:32,000
ahora ya es una única variable

746
00:22:32,000 --> 00:22:33,000
entera,

747
00:22:33,000 --> 00:22:34,000
que es esta,

748
00:22:34,000 --> 00:22:35,000
y con esa variable entera

749
00:22:35,000 --> 00:22:36,000
hago lo que me dé la gana,

750
00:22:36,000 --> 00:22:37,000
pues por ejemplo,

751
00:22:37,000 --> 00:22:38,000
asignarle el cero,

752
00:22:38,000 --> 00:22:39,000
¿vale?

753
00:22:39,000 --> 00:22:40,000
así,

754
00:22:40,000 --> 00:22:41,000
así,

755
00:22:41,000 --> 00:22:42,000
así,

756
00:22:42,000 --> 00:22:43,000
así,

757
00:22:43,000 --> 00:22:44,000
así,

758
00:22:44,000 --> 00:22:45,000
para asignarle cero,

759
00:22:45,000 --> 00:22:46,000
¿vale?

760
00:22:46,000 --> 00:22:47,000
¿que quiero asociar cero,

761
00:22:47,000 --> 00:22:48,000
asignar cero a todos los demás?

762
00:22:48,000 --> 00:22:49,000
pues tengo que escribir

763
00:22:49,000 --> 00:22:50,000
doce asignaciones de estas,

764
00:22:50,000 --> 00:22:51,000
¿no?

765
00:22:51,000 --> 00:22:52,000
Cuatro por tres,

766
00:22:52,000 --> 00:22:53,000
doce elementos tiene eso,

767
00:22:53,000 --> 00:22:54,000
y así tendría que escribir

768
00:22:54,000 --> 00:22:55,000
doce veces esto.

769
00:22:55,000 --> 00:22:56,000
Tablero,

770
00:22:56,000 --> 00:22:57,000
cero,

771
00:22:57,000 --> 00:22:58,000
uno,

772
00:22:58,000 --> 00:22:59,000
esta sería

773
00:22:59,000 --> 00:23:00,000
la posición cero,

774
00:23:00,000 --> 00:23:01,000
columna uno,

775
00:23:01,000 --> 00:23:02,000
para hacer con ella

776
00:23:02,000 --> 00:23:03,000
lo que yo quiera,

777
00:23:03,000 --> 00:23:04,000
por ejemplo asignarle a un cero,

778
00:23:04,000 --> 00:23:05,000
volvemos a escrever

779
00:23:05,000 --> 00:23:06,000
el assemble,

780
00:23:06,000 --> 00:23:07,000
miren aquí,

781
00:23:07,000 --> 00:23:08,000
con esta variable,

782
00:23:08,000 --> 00:23:09,000
tendría que escribir

783
00:23:09,000 --> 00:23:10,000
la columna doce,

784
00:23:10,000 --> 00:23:11,000
y lo que sería

785
00:23:11,000 --> 00:23:12,000
la regulación al respecto.

786
00:23:14,000 --> 00:23:15,000
Y así,

787
00:23:15,000 --> 00:23:16,000
poner,

788
00:23:16,000 --> 00:23:17,000
esta de aquí,

789
00:23:17,000 --> 00:23:18,000
¿cuál sería?

790
00:23:18,000 --> 00:23:19,000
Tablero,

791
00:23:19,000 --> 00:23:20,000
dos,

792
00:23:20,000 --> 00:23:21,000
uno.

793
00:23:21,000 --> 00:23:22,000
O sea,

794
00:23:22,000 --> 00:23:23,000
si quiero yo

795
00:23:23,000 --> 00:23:24,000
acceder a todas

796
00:23:24,000 --> 00:23:25,000
para asignar el cero,

797
00:23:25,000 --> 00:23:26,000
haciéndolo de esta manera,

798
00:23:26,000 --> 00:23:27,000
pues hombre,

799
00:23:27,000 --> 00:23:28,000
tengo que escribir

800
00:23:28,000 --> 00:23:29,000
doce líneas,

801
00:23:29,000 --> 00:23:30,000
un poco pesado.

802
00:23:30,000 --> 00:23:31,000
Claro,

803
00:23:31,000 --> 00:23:32,000
pero para eso

804
00:23:32,000 --> 00:23:33,000
tenemos los for,

805
00:23:33,000 --> 00:23:34,000
¿verdad?

806
00:23:34,000 --> 00:23:35,000
La ventaja de los Arrays

807
00:23:35,000 --> 00:23:36,000
es que mediante

808
00:23:36,000 --> 00:23:37,000
un bucle

809
00:23:37,000 --> 00:23:38,000
podemos acceder

810
00:23:38,000 --> 00:23:39,000
a todas sus posiciones,

811
00:23:39,000 --> 00:23:40,000
porque ese bucle

812
00:23:40,000 --> 00:23:41,000
me da un índice

813
00:23:41,000 --> 00:23:42,000
y ese índice

814
00:23:42,000 --> 00:23:43,000
va cambiando.

815
00:23:44,000 --> 00:23:45,000
Entonces,

816
00:23:45,000 --> 00:23:46,000
las iteraciones del for

817
00:23:46,000 --> 00:23:48,000
me van accediendo a

818
00:23:48,000 --> 00:23:50,000
posiciones consecutivas

819
00:23:50,000 --> 00:23:51,000
del Array.

820
00:23:51,000 --> 00:23:52,000
Esa es la ventaja

821
00:23:52,000 --> 00:23:53,000
de los Arrays,

822
00:23:53,000 --> 00:23:54,000
que mediante un sencillo

823
00:23:54,000 --> 00:23:55,000
bucle for

824
00:23:55,000 --> 00:23:56,000
podemos acceder

825
00:23:56,000 --> 00:23:57,000
en un código

826
00:23:57,000 --> 00:23:58,000
de dos líneas

827
00:23:58,000 --> 00:23:59,000
a todas sus posiciones.

828
00:23:59,000 --> 00:24:00,000
Bueno,

829
00:24:00,000 --> 00:24:01,000
pues el Array

830
00:24:01,000 --> 00:24:02,000
de dos dimensiones

831
00:24:02,000 --> 00:24:03,000
también,

832
00:24:03,000 --> 00:24:04,000
afortunadamente,

833
00:24:04,000 --> 00:24:05,000
podemos recorrerlo

834
00:24:05,000 --> 00:24:06,000
con un bucle for.

835
00:24:08,000 --> 00:24:09,000
Pero claro,

836
00:24:09,000 --> 00:24:10,000
aquí el recorrido

837
00:24:10,000 --> 00:24:11,000
se complica un poco,

838
00:24:11,000 --> 00:24:12,000
porque yo tengo que ir

839
00:24:12,000 --> 00:24:13,000
por aquí,

840
00:24:13,000 --> 00:24:14,000
voy por aquí,

841
00:24:14,000 --> 00:24:15,000
luego tengo que

842
00:24:15,000 --> 00:24:16,000
volver a bajar aquí,

843
00:24:16,000 --> 00:24:17,000
luego tengo que

844
00:24:17,000 --> 00:24:18,000
volver a bajar aquí.

845
00:24:18,000 --> 00:24:19,000
Entonces,

846
00:24:19,000 --> 00:24:20,000
¿cómo podemos

847
00:24:20,000 --> 00:24:21,000
hacer el recorrido?

848
00:24:21,000 --> 00:24:22,000
Tendremos que hacerlo

849
00:24:22,000 --> 00:24:23,000
con dos bucles for,

850
00:24:23,000 --> 00:24:24,000
uno dentro de otro.

851
00:24:24,000 --> 00:24:25,000
Un primer bucle

852
00:24:25,000 --> 00:24:26,000
for externo

853
00:24:26,000 --> 00:24:27,000
que se va colocando

854
00:24:27,000 --> 00:24:28,000
en la fila

855
00:24:28,000 --> 00:24:29,000
en la que está.

856
00:24:31,000 --> 00:24:32,000
Y en cada fila

857
00:24:32,000 --> 00:24:33,000
otro pequeño bucle

858
00:24:33,000 --> 00:24:34,000
for dentro

859
00:24:34,000 --> 00:24:35,000
que ya va

860
00:24:35,000 --> 00:24:36,000
recorriendo las columnas.

861
00:24:37,000 --> 00:24:38,000
Cuando

862
00:24:38,000 --> 00:24:39,000
esta iteración

863
00:24:39,000 --> 00:24:40,000
ha terminado,

864
00:24:40,000 --> 00:24:41,000
saltamos a esta iteración

865
00:24:41,000 --> 00:24:42,000
del bucle de fuera

866
00:24:42,000 --> 00:24:43,000
y arranca

867
00:24:43,000 --> 00:24:44,000
el bucle de dentro

868
00:24:44,000 --> 00:24:45,000
que va por éste,

869
00:24:45,000 --> 00:24:46,000
por éste

870
00:24:46,000 --> 00:24:47,000
y por éste.

871
00:24:47,000 --> 00:24:48,000
Cuando esta iteración

872
00:24:48,000 --> 00:24:49,000
del bucle de fuera

873
00:24:49,000 --> 00:24:50,000
ha terminado,

874
00:24:50,000 --> 00:24:51,000
saltamos a esta fila,

875
00:24:51,000 --> 00:24:52,000
arranca a la iteración

876
00:24:52,000 --> 00:24:53,000
del bucle de dentro

877
00:24:53,000 --> 00:24:54,000
que va por éste,

878
00:24:54,000 --> 00:24:55,000
por éste

879
00:24:55,000 --> 00:24:56,000
y por éste.

880
00:24:56,000 --> 00:24:57,000
Luego un bucle

881
00:24:57,000 --> 00:24:58,000
que recorre las filas

882
00:24:58,000 --> 00:24:59,000
y dentro de cada fila

883
00:24:59,000 --> 00:25:00,000
un bucle

884
00:25:00,000 --> 00:25:01,000
pequeñito

885
00:25:01,000 --> 00:25:02,000
que recorre las columnas.

886
00:25:02,000 --> 00:25:03,000
Un bucle

887
00:25:03,000 --> 00:25:04,000
dentro de otro.

888
00:25:04,000 --> 00:25:05,000
Entonces se traduciría

889
00:25:05,000 --> 00:25:06,000
en esto.

890
00:25:06,000 --> 00:25:07,000
Esto de recorrer

891
00:25:07,000 --> 00:25:08,000
todas las posiciones

892
00:25:08,000 --> 00:25:09,000
para asignar cero,

893
00:25:09,000 --> 00:25:10,000
hecho con

894
00:25:10,000 --> 00:25:11,000
bucles FOR

895
00:25:12,000 --> 00:25:13,000
se traduciría

896
00:25:13,000 --> 00:25:14,000
en esto de aquí.

897
00:25:15,000 --> 00:25:17,000
El primer FOR de fuera

898
00:25:18,000 --> 00:25:19,000
un bucle

899
00:25:19,000 --> 00:25:20,000
que va a ir pasando

900
00:25:20,000 --> 00:25:21,000
fila por fila.

901
00:25:21,000 --> 00:25:23,000
Filas, ¿cuántas hay?

902
00:25:23,000 --> 00:25:24,000
De cero a tres

903
00:25:24,000 --> 00:25:25,000
hay cuatro.

904
00:25:25,000 --> 00:25:27,000
Pues un índice

905
00:25:27,000 --> 00:25:29,000
que empieza valiendo cero

906
00:25:30,000 --> 00:25:31,000
mientras sea menor

907
00:25:31,000 --> 00:25:33,000
que el número de filas.

908
00:25:33,000 --> 00:25:35,000
En mi caso cuatro.

909
00:25:35,000 --> 00:25:36,000
¿Vale?

910
00:25:36,000 --> 00:25:37,000
Así

911
00:25:37,000 --> 00:25:38,000
paso por la cero,

912
00:25:38,000 --> 00:25:39,000
la uno,

913
00:25:39,000 --> 00:25:40,000
la dos y la tres

914
00:25:40,000 --> 00:25:41,000
incrementando ahí.

915
00:25:42,000 --> 00:25:43,000
Y ahora

916
00:25:43,000 --> 00:25:44,000
para cada fila

917
00:25:44,000 --> 00:25:46,000
para cada fila

918
00:25:46,000 --> 00:25:47,000
tengo que hacer un bucle

919
00:25:47,000 --> 00:25:48,000
que vaya pasando

920
00:25:48,000 --> 00:25:49,000
por la columna cero

921
00:25:49,000 --> 00:25:50,000
la uno y la dos.

922
00:25:50,000 --> 00:25:52,000
Luego para cada fila

923
00:25:52,000 --> 00:25:54,000
para cada í

924
00:25:57,000 --> 00:25:58,000
para cada í

925
00:25:58,000 --> 00:26:00,000
hay que recorrer

926
00:26:00,000 --> 00:26:02,000
toda la fila otra vez.

927
00:26:07,000 --> 00:26:08,000
Pues para recorrer

928
00:26:08,000 --> 00:26:09,000
toda la fila

929
00:26:09,000 --> 00:26:10,000
para cada í

930
00:26:10,000 --> 00:26:12,000
tendré que hacer otro FOR dentro.

931
00:26:12,000 --> 00:26:14,000
Ahora este FOR dentro

932
00:26:14,000 --> 00:26:16,000
tiene que utilizar otra variable

933
00:26:16,000 --> 00:26:17,000
claro, porque la í

934
00:26:17,000 --> 00:26:18,000
ya está usada.

935
00:26:18,000 --> 00:26:19,000
La í es la variable

936
00:26:19,000 --> 00:26:20,000
que me dice la fila

937
00:26:20,000 --> 00:26:21,000
en la que estoy.

938
00:26:21,000 --> 00:26:22,000
En la primera iteración

939
00:26:22,000 --> 00:26:24,000
estará en la cero.

940
00:26:24,000 --> 00:26:25,000
En la segunda

941
00:26:25,000 --> 00:26:26,000
estará en la uno.

942
00:26:26,000 --> 00:26:27,000
La í me dice la fila

943
00:26:27,000 --> 00:26:28,000
en la que estoy.

944
00:26:28,000 --> 00:26:29,000
Pues para cada í

945
00:26:29,000 --> 00:26:30,000
ahora yo avanzo

946
00:26:30,000 --> 00:26:32,000
por cada columna.

947
00:26:32,000 --> 00:26:34,000
Desde j igual a cero

948
00:26:34,000 --> 00:26:35,000
mientras j sea menor

949
00:26:35,000 --> 00:26:37,000
que el número de columnas.

950
00:26:38,000 --> 00:26:39,000
Que el número de columnas

951
00:26:39,000 --> 00:26:40,000
que en mi caso es tres

952
00:26:40,000 --> 00:26:42,000
incrementando j.

953
00:26:42,000 --> 00:26:44,000
Y ahora ya dentro de este FOR

954
00:26:44,000 --> 00:26:46,000
si yo hago

955
00:26:46,000 --> 00:26:48,000
tablero de í

956
00:26:48,000 --> 00:26:50,000
j

957
00:26:50,000 --> 00:26:52,000
ya tengo todas las posiciones.

958
00:26:52,000 --> 00:26:54,000
Por ejemplo, si yo hago esto

959
00:26:56,000 --> 00:26:58,000
pues esto

960
00:26:58,000 --> 00:26:59,000
me irá recorriendo

961
00:26:59,000 --> 00:27:00,000
todas las posiciones.

962
00:27:00,000 --> 00:27:02,000
Para i igual a cero

963
00:27:02,000 --> 00:27:03,000
entra en el FOR de dentro

964
00:27:03,000 --> 00:27:04,000
que hace la cero

965
00:27:04,000 --> 00:27:06,000
cero, cero, uno, cero, dos

966
00:27:06,000 --> 00:27:08,000
y saltamos arriba.

967
00:27:08,000 --> 00:27:09,000
Para i igual a uno

968
00:27:09,000 --> 00:27:10,000
entramos en el bucle de dentro

969
00:27:10,000 --> 00:27:11,000
que hace

970
00:27:11,000 --> 00:27:14,000
uno, cero, uno, uno, uno, dos.

971
00:27:14,000 --> 00:27:16,000
Y saltamos al bucle de arriba.

972
00:27:16,000 --> 00:27:17,000
Para i igual a dos

973
00:27:17,000 --> 00:27:19,000
entramos al bucle de dentro

974
00:27:19,000 --> 00:27:20,000
que hace

975
00:27:20,000 --> 00:27:22,000
dos, cero, dos, uno y dos, dos.

976
00:27:22,000 --> 00:27:24,000
Y saltamos otra vez arriba.

977
00:27:24,000 --> 00:27:26,000
Para i igual a tres

978
00:27:26,000 --> 00:27:27,000
entramos al bucle de dentro

979
00:27:27,000 --> 00:27:28,000
que me hace

980
00:27:28,000 --> 00:27:30,000
tres, cero, tres, uno, tres, dos.

981
00:27:30,000 --> 00:27:32,000
Luego el orden de recorrido

982
00:27:32,000 --> 00:27:35,000
este bucle FOR va a ir recorriendo

983
00:27:35,000 --> 00:27:37,000
tablero, pongo la T solo

984
00:27:37,000 --> 00:27:39,000
cero, cero,

985
00:27:39,000 --> 00:27:41,000
tablero, cero, uno,

986
00:27:42,000 --> 00:27:44,000
tablero, cero, dos

987
00:27:44,000 --> 00:27:46,000
y tablero, cero, tres.

988
00:27:48,000 --> 00:27:49,000
Estos serán

989
00:27:49,000 --> 00:27:50,000
todas las iteraciones

990
00:27:50,000 --> 00:27:51,000
del bucle de dentro

991
00:27:51,000 --> 00:27:52,000
cuando yo es igual a cero.

992
00:27:52,000 --> 00:27:54,000
Saltamos arriba otra vez.

993
00:27:54,000 --> 00:27:56,000
Para i igual a uno

994
00:27:56,000 --> 00:27:57,000
pues para i igual a uno

995
00:27:57,000 --> 00:27:58,000
otra vez

996
00:27:58,000 --> 00:28:00,000
T, uno, cero

997
00:28:00,000 --> 00:28:02,000
T, uno, uno

998
00:28:03,000 --> 00:28:05,000
T, uno, dos

999
00:28:06,000 --> 00:28:08,000
y T, uno, tres

1000
00:28:10,000 --> 00:28:12,000
Este bucle acabó.

1001
00:28:12,000 --> 00:28:13,000
Saltamos otra vez.

1002
00:28:13,000 --> 00:28:15,000
Ahora T es igual a dos

1003
00:28:15,000 --> 00:28:17,000
bucle de dentro

1004
00:28:17,000 --> 00:28:19,000
T, dos, cero

1005
00:28:19,000 --> 00:28:21,000
T, dos, uno

1006
00:28:23,000 --> 00:28:25,000
T, dos, dos

1007
00:28:27,000 --> 00:28:29,000
y T, dos, tres

1008
00:28:29,000 --> 00:28:30,000
Y bueno, nos faltaría ya

1009
00:28:30,000 --> 00:28:32,000
la última iteración

1010
00:28:32,000 --> 00:28:33,000
que ya no la escribo

1011
00:28:33,000 --> 00:28:35,000
para i igual a tres

1012
00:28:35,000 --> 00:28:36,000
este iría pasando

1013
00:28:36,000 --> 00:28:37,000
por todos los valores

1014
00:28:37,000 --> 00:28:38,000
T, tres, cero

1015
00:28:38,000 --> 00:28:39,000
T, tres, uno

1016
00:28:39,000 --> 00:28:40,000
T, tres, dos

1017
00:28:40,000 --> 00:28:41,000
T, tres, tres

1018
00:28:41,000 --> 00:28:42,000
Luego el resultado

1019
00:28:42,000 --> 00:28:43,000
de estos dos bucles FOR

1020
00:28:43,000 --> 00:28:44,000
uno dentro de otro

1021
00:28:44,000 --> 00:28:45,000
es efectivamente

1022
00:28:45,000 --> 00:28:48,000
recorrer todas las doce posiciones

1023
00:28:48,000 --> 00:28:49,000
pasando por esta

1024
00:28:49,000 --> 00:28:50,000
bajando por aquí

1025
00:28:50,000 --> 00:28:51,000
bajando por aquí

1026
00:28:51,000 --> 00:28:52,000
bajando por aquí

1027
00:28:52,000 --> 00:28:53,000
para hacer yo lo que quiera

1028
00:28:53,000 --> 00:28:54,000
con esas posiciones

1029
00:28:54,000 --> 00:28:55,000
lo que quiera

1030
00:28:55,000 --> 00:28:56,000
en este caso

1031
00:28:56,000 --> 00:28:57,000
lo que estoy haciendo es

1032
00:28:57,000 --> 00:28:59,000
asignarle cero

1033
00:29:00,000 --> 00:29:01,000
pero podría querer hacer

1034
00:29:01,000 --> 00:29:02,000
cualquier otra cosa

1035
00:29:03,000 --> 00:29:04,000
¿vale?

1036
00:29:06,000 --> 00:29:07,000
Vale, pues

1037
00:29:11,000 --> 00:29:12,000
vamos a poner aquí

1038
00:29:12,000 --> 00:29:13,000
un pequeño

1039
00:29:15,000 --> 00:29:16,000
enunciado

1040
00:29:17,000 --> 00:29:18,000
para que hagáis ahora

1041
00:29:18,000 --> 00:29:19,000
a ver si esto está

1042
00:29:20,000 --> 00:29:21,000
claro

1043
00:29:31,000 --> 00:29:32,000
Venga

1044
00:29:33,000 --> 00:29:34,000
Programa que solicite primero

1045
00:29:34,000 --> 00:29:35,000
un número de filas

1046
00:29:35,000 --> 00:29:36,000
y otro número de columnas

1047
00:29:50,000 --> 00:29:51,000
Una vez que tiene

1048
00:29:51,000 --> 00:29:52,000
ese número de filas

1049
00:29:52,000 --> 00:29:53,000
y ese número de columnas

1050
00:29:53,000 --> 00:29:54,000
declaro una raíz

1051
00:29:54,000 --> 00:29:55,000
de dos dimensiones

1052
00:29:56,000 --> 00:29:57,000
con ese número

1053
00:29:57,000 --> 00:29:58,000
de filas y columnas

1054
00:30:00,000 --> 00:30:01,000
¿vale?

1055
00:30:12,000 --> 00:30:13,000
Luego ¿qué va a hacer?

1056
00:30:14,000 --> 00:30:15,000
En lugar de rellenarlo

1057
00:30:15,000 --> 00:30:16,000
con valores leídos

1058
00:30:16,000 --> 00:30:17,000
por teclado

1059
00:30:17,000 --> 00:30:18,000
que vais a estar luego

1060
00:30:18,000 --> 00:30:19,000
haciendo la prueba

1061
00:30:19,000 --> 00:30:20,000
un montón de rato

1062
00:30:20,000 --> 00:30:21,000
metiendo números

1063
00:30:21,000 --> 00:30:22,000
pa pa pa

1064
00:30:22,000 --> 00:30:23,000
que los rellene

1065
00:30:23,000 --> 00:30:24,000
con valores aleatorios

1066
00:30:25,000 --> 00:30:26,000
todo ese array

1067
00:30:26,000 --> 00:30:27,000
entre cero y cincuenta

1068
00:30:27,000 --> 00:30:28,000
por ejemplo

1069
00:30:30,000 --> 00:30:31,000
¿vale?

1070
00:30:47,000 --> 00:30:48,000
Vale, y ahora

1071
00:30:48,000 --> 00:30:49,000
viene la complicación

1072
00:30:50,000 --> 00:30:51,000
y ahora

1073
00:30:53,000 --> 00:30:54,000
pedirá un número de filas

1074
00:30:56,000 --> 00:30:57,000
y sumará

1075
00:30:58,000 --> 00:30:59,000
todos los valores

1076
00:31:00,000 --> 00:31:01,000
que haya en esa fila

1077
00:31:02,000 --> 00:31:03,000
dirá

1078
00:31:03,000 --> 00:31:04,000
los valores de esa fila

1079
00:31:04,000 --> 00:31:05,000
suman patatín

1080
00:31:31,000 --> 00:31:32,000
¿vale?

1081
00:31:37,000 --> 00:31:38,000
Pues venga

1082
00:31:40,000 --> 00:31:41,000
Entonces, lo primero

1083
00:31:42,000 --> 00:31:43,000
de rellenar

1084
00:31:43,000 --> 00:31:44,000
con valores aleatorios

1085
00:31:44,000 --> 00:31:45,000
una vez declarado

1086
00:31:45,000 --> 00:31:46,000
es bueno

1087
00:31:46,000 --> 00:31:47,000
es calcar ese for

1088
00:31:47,000 --> 00:31:48,000
que hemos escrito

1089
00:31:48,000 --> 00:31:49,000
calcarlo

1090
00:31:49,000 --> 00:31:50,000
pero en lugar de asignarle cero

1091
00:31:50,000 --> 00:31:51,000
se hace un número aleatorio

1092
00:31:51,000 --> 00:31:52,000
y luego ya

1093
00:31:52,000 --> 00:31:53,000
habrá que volverlo

1094
00:31:53,000 --> 00:31:54,000
a recorrer

1095
00:31:54,000 --> 00:31:55,000
y el resultado

1096
00:31:55,000 --> 00:31:56,000
será hacer una suma acumulativa

1097
00:31:57,000 --> 00:31:58,000
pero claro

1098
00:31:58,000 --> 00:31:59,000
esa variable suma

1099
00:31:59,000 --> 00:32:00,000
que inicializáis a cero

1100
00:32:00,000 --> 00:32:01,000
y va tomando resultados

1101
00:32:01,000 --> 00:32:02,000
a variable suma

1102
00:32:02,000 --> 00:32:03,000
tiene que incorporar

1103
00:32:04,000 --> 00:32:05,000
solamente en su suma

1104
00:32:06,000 --> 00:32:07,000
de todo el recorrido

1105
00:32:07,000 --> 00:32:08,000
que hagáis

1106
00:32:08,000 --> 00:32:09,000
las posiciones

1107
00:32:10,000 --> 00:32:11,000
cuyo índice de fila

1108
00:32:11,000 --> 00:32:12,000
sea

1109
00:32:12,000 --> 00:32:13,000
el que habéis pedido

1110
00:32:13,000 --> 00:32:14,000
¿vale?

1111
00:32:14,000 --> 00:32:15,000
Esa es la complicación

1112
00:32:15,000 --> 00:32:16,000
luego hacer un último recorrido

1113
00:32:17,000 --> 00:32:18,000
para ir haciendo la suma

1114
00:32:19,000 --> 00:32:20,000
pero en esa suma

1115
00:32:20,000 --> 00:32:21,000
no sumarlos todos

1116
00:32:21,000 --> 00:32:22,000
sino meter un if

1117
00:32:22,000 --> 00:32:23,000
para que se sumen

1118
00:32:23,000 --> 00:32:24,000
todas aquellas posiciones

1119
00:32:25,000 --> 00:32:26,000
cuyo

1120
00:32:26,000 --> 00:32:27,000
índice de fila

1121
00:32:28,000 --> 00:32:29,000
sea la que

1122
00:32:29,000 --> 00:32:30,000
se ha pedido antes

1123
00:32:33,000 --> 00:32:34,000
¿vale?

1124
00:32:34,000 --> 00:32:35,000
Es un recorrido

1125
00:32:35,000 --> 00:32:36,000
para hacer la suma acumulativa

1126
00:32:36,000 --> 00:32:37,000
pero metiendo un if dentro

1127
00:32:37,000 --> 00:32:38,000
a ver

1128
00:32:39,000 --> 00:32:40,000
¿vale?