1
00:00:00,000 --> 00:00:10,280
Vale, pues la primera parte que habréis hecho todos, pues bueno, es simplemente pedir número

2
00:00:10,280 --> 00:00:17,000
de filas, número de columnas, tal y como dice el ejercicio, declarar la variable, declarar

3
00:00:17,000 --> 00:00:23,240
la variable con su número de filas y columnas, declarar la variable, y ahora ya el recorrido

4
00:00:23,240 --> 00:00:28,800
que recorre todas y cada una de las posiciones, cada fila y cada columna en este doble for,

5
00:00:28,800 --> 00:00:35,240
en este caso para asignarle un valor aleatorio. Vale, aquí antes de seguir convendría mostrar

6
00:00:35,240 --> 00:00:40,000
a ver qué números ha generado, por ejemplo. Bueno, pues podemos plantearnos, podríamos

7
00:00:40,000 --> 00:00:44,000
haberlo hecho en el mismo, pero vamos a hacerlo aparte. Otro recorrido, simplemente ahora

8
00:00:44,000 --> 00:00:50,320
para recorrer y mostrar, ¿vale?, que podríamos haber mostrado en el mismo a la vez que recorremos,

9
00:00:50,320 --> 00:00:55,400
pero bueno, lo estamos separando para insistir en lo de los recorridos. Venga, este es solamente

10
00:00:55,400 --> 00:01:08,520
para este recorrido, era para rellenar la matriz y este recorrido para mostrar la matriz,

11
00:01:08,520 --> 00:01:22,520
¿vale? Entonces, si hacemos esto, tablero y j, pues sí hombre, efectivamente se me

12
00:01:22,520 --> 00:01:26,360
van a mostrar todas las posiciones, pero se me van a mostrar feas, porque se me van

13
00:01:26,360 --> 00:01:35,880
a mostrar todas seguidas, ¿no? Si ejecutamos esto, venga, 3 filas por 2 columnas, entonces

14
00:01:35,880 --> 00:01:41,120
así será, 3 por 2, 6 posiciones, pues me las muestra todas seguidas, esta es la primera

15
00:01:41,120 --> 00:01:45,720
fila, esta es la segunda, vale hombre, la matriz tiene estos valores, pero hombre, ya

16
00:01:45,720 --> 00:01:54,960
que nos ponemos a mostrarla, vamos a mostrarla respetando su distribución, entonces, eso

17
00:01:54,960 --> 00:02:05,160
significa que, en lugar del println, mostramos con print, sin más, y vamos a concatenar

18
00:02:05,160 --> 00:02:11,920
con un espacio, y ahora ya, cuando hemos terminado de mostrar una fila, y la fila que hemos terminado

19
00:02:11,920 --> 00:02:17,680
de mostrarla, cuando este for ha acabado, cuando este for ha acabado, ya hemos terminado

20
00:02:17,680 --> 00:02:23,640
de mostrar una fila, pues ahí, en ese punto, le ponemos ya un salto de línea, para que

21
00:02:23,640 --> 00:02:29,280
vaya a la línea de abajo, ¿vale? Bueno, pues este for es simplemente para mostrar

22
00:02:29,280 --> 00:02:35,120
los valores, entonces, esto me irá mostrando los de cada fila, todos seguidos, con un espacio

23
00:02:35,120 --> 00:02:41,200
entre medio, cuando la fila ahí ha terminado, salta abajo, ojo, cuidado con estos errores,

24
00:02:41,200 --> 00:02:49,200
ahora mi for de arriba tiene dos sentencias, no se olvide poner las llaves, mi for de cada

25
00:02:49,200 --> 00:02:55,240
fila tiene, mostrar todos sus elementos, y salto a la siguiente, mostrar todos los elementos

26
00:02:55,240 --> 00:03:04,240
y salto a la siguiente, vamos a ver ahora si lo muestra más bonito, venga, tres filas

27
00:03:04,240 --> 00:03:10,200
por tres columnas, vale, ahora ya lo muestra más bonito, este for me va mostrando fila

28
00:03:10,200 --> 00:03:16,760
por fila, separado por espacio, y este, una vez que ya he mostrado una fila enterita,

29
00:03:16,760 --> 00:03:22,960
salto abajo, salto abajo, para que la siguiente fila me la muestre abajo, solo para mostrar,

30
00:03:22,960 --> 00:03:28,880
ya aprovechando, como ha surgido ahí, para seguir introduciendo caracteres, ya aprovechando,

31
00:03:28,880 --> 00:03:35,520
hay una cosa, que seguramente os sonarán, de otras materias que no son programación,

32
00:03:35,520 --> 00:03:41,520
que son los caracteres ASCII que se llaman de escape, que son los tabuladores, los espacios,

33
00:03:41,520 --> 00:03:48,520
los raros, entonces cuando uno quiere mostrar un carácter de esos, por ejemplo un tabulador,

34
00:03:48,520 --> 00:03:54,520
vamos a suponer que yo aquí he puesto que sea entre mil, si yo he puesto entre mil y

35
00:03:54,520 --> 00:04:02,520
ejecuto esto, número de filas, tres y tres, vale, pues vale, si me la ha mostrado bien,

36
00:04:02,520 --> 00:04:06,520
pero hombre, no me queda muy bonito, porque al haber puesto yo solo un espacio entre ellos,

37
00:04:06,520 --> 00:04:11,520
pues hombre, como que se queda descuadrado, entonces nos gustaría más, después de cada uno,

38
00:04:11,520 --> 00:04:16,520
meter un tabulador, después de cada uno meter un tabulador, solamente para que quedara más bonito,

39
00:04:16,520 --> 00:04:22,520
a ver, para qué uso esto, para qué digo esto, simplemente para ir introduciendo el concepto

40
00:04:22,520 --> 00:04:28,520
de caracteres de escape, que son caracteres más de la tabla ASCII, como el salto de línea,

41
00:04:28,520 --> 00:04:34,520
el enter, el tabulador, caracteres más de la tabla ASCII, que puedo yo querer escribir en mi System.out.println,

42
00:04:34,520 --> 00:04:38,520
igual que aquí he escrito un espacio, pues en lugar de un espacio, quiero poder escribir un tabulador,

43
00:04:38,520 --> 00:04:43,520
porque es un carácter más, esos caracteres, como escribo yo un tabulador, pues son los que se llaman

44
00:04:43,520 --> 00:04:50,520
caracteres de escape, y en los lenguajes de programación, se escriben siempre poniendo la barra esta,

45
00:04:50,520 --> 00:04:55,520
que es la barra de escape, para decir, ojo, que viene un carácter de escape después de la barra,

46
00:04:55,520 --> 00:05:01,520
eso significa esta barra, ojo, y ahora ponemos una letra, que cada letra se corresponde con un carácter de escape,

47
00:05:01,520 --> 00:05:08,520
la T en particular se corresponde con el tabulador, entonces si yo quiero imprimir un tabulador,

48
00:05:08,520 --> 00:05:15,520
pongo barrita para decir viene carácter de escape y luego T, y quiero imprimir un salto de línea,

49
00:05:15,520 --> 00:05:20,520
el salto de línea también es un carácter raro, pues ojo, que viene carácter de escape,

50
00:05:21,520 --> 00:05:28,520
¿qué letrita va asociada al salto de línea? La N, pondría esto, pero bueno, nos interesa un tabulador,

51
00:05:28,520 --> 00:05:37,520
pues venga, vamos a cambiar el espacio por un tabulador, barrita para decir, ojo, que viene carácter de escape,

52
00:05:37,520 --> 00:05:45,520
y ahora la letra correspondiente a ese carácter, tabulador, para un salto de línea, N viene de nueva línea,

53
00:05:46,520 --> 00:05:53,520
entonces si yo ahora pongo 3, 3, pues ahora sí que me queda más bonito, porque he metido todo un tabulador

54
00:05:53,520 --> 00:06:02,520
después de cada carácter, ¿vale? Vale, bueno, eso en cuanto a carácteres, que suene que la tabla ASCII

55
00:06:02,520 --> 00:06:10,520
tiene todos los carácteres que conocemos, A, B, C, J, H, coma, tilde, todos esos, y también tiene carácteres de escape,

56
00:06:10,520 --> 00:06:19,520
tabuladores, saltos de línea, que si yo quiero escribirlos en la consola, tengo que buscar el código al que se corresponde,

57
00:06:19,520 --> 00:06:25,520
el código al que se corresponde, y en particular el tabulador, que se usa mucho, pues es carácter de escape,

58
00:06:25,520 --> 00:06:33,520
pero bueno, esto como anécdota. Vale, pues ya tenemos nuestra matriz, ahora el siguiente paso del ejercicio

59
00:06:33,520 --> 00:06:56,520
era pedir un número de fila, pues nada, venga, le pedimos un número de fila, vale, ya tenemos el número de fila,

60
00:06:56,520 --> 00:07:06,520
y ahora ya es cuando viene el algoritmo, el algoritmo que es, tenemos que hacer una suma de muchos valores, vale,

61
00:07:06,520 --> 00:07:17,520
esos valores donde van a estar, son valores de la matriz, luego tenemos que recorrer la matriz e ir incorporando valores de esa matriz

62
00:07:17,520 --> 00:07:24,520
en una variable suma, bueno, ese algoritmo de suma acumulativa, pues ya nos sabemos de memoria como es,

63
00:07:24,520 --> 00:07:33,520
tendré ya una variable resultante que inicializa a cero, y ahora ya me pongo a recorrer y voy incorporando a la suma lo que haga falta,

64
00:07:33,520 --> 00:07:42,520
entonces si lo hacemos sin pensar mucho, yendo a piñón fijo, vale, vamos a recorrer otra vez la matriz, que es lo que sabemos hacer,

65
00:07:42,520 --> 00:07:53,520
recorremos la matriz y vamos incorporando en la variable suma los valores que yo quiera, vale, bueno, pues vamos a recorrer la matriz otra vez,

66
00:07:53,520 --> 00:08:10,520
luego los for, los mismitos, y ahora, aquí van pasando todos y cada uno los valores, ahora que tenemos que hacer,

67
00:08:10,520 --> 00:08:27,520
pues estos valores se irán incorporando a la suma, todos, no todos, solo algunos, si yo no distingo y hago esto, pues obviamente este ejercicio lo que haría

68
00:08:27,520 --> 00:08:35,520
es sumar todos los elementos de la matriz, porque este va recorriendo los todos, este lo incorporo a la suma, este a la suma, este a la suma,

69
00:08:36,520 --> 00:08:41,520
este a la suma, este a la suma, este a la suma, este a la suma, este a la suma, este a la suma, …., que ahora yo quiero dar el salto de no quiero sumarlos todos,

70
00:08:41,520 --> 00:08:53,520
quiero solo sumar aquellos cuya fila sea la que me han dado, bueno, pues ahí podría meter esa modificación, oye, ojo, que no quiero sumarlos todos,

71
00:08:53,520 --> 00:09:01,520
no quiero recorrerlos y sumarlos todos, no, todos no, todos no, voy a meter esto en un if, porque no quiero sumarlos todos,

72
00:09:01,520 --> 00:09:15,520
lo meto en un if, de tal forma que voy a sumar solo cuales, voy a sumar solo aquellos en los cuales la fila en la que estén sea la fila que me han pedido,

73
00:09:15,520 --> 00:09:29,520
pues esa condición yo la podría poner, sí, un momento, así no, entonces yendo así incrementalmente, pues ya está, llego a esto y esto hace lo que tiene que hacer,

74
00:09:30,520 --> 00:09:43,520
vale, hago una suma acumulativa, recorro la matriz, pero a la suma, en lugar de incorporarlos todos, los que voy recorriendo, pa, pa, pa, pa, pa, pa,

75
00:09:43,520 --> 00:09:57,520
incorporo solo los que cumplen que la posición y es igual a la c, y así en principio eso, pues ya está, esto a priori está, es incuestionable, está bien, vale,

76
00:09:57,520 --> 00:10:09,520
otra cosa es que ahora uno diga, uff, pues sí que te estás complicando, sí, efectivamente, vale, otra cosa es que uno, claro, pero si uno va un poquito a piñón fijo sacando las cosas que hemos visto,

77
00:10:09,520 --> 00:10:18,520
pues bueno, puede llegar a esto, no, vale, tengo que recorrer todos, no a suma acumulativa, recorro y sumo, pero espera, no todos, voy a sacar solo los que tengo, bueno,

78
00:10:19,520 --> 00:10:35,520
ahora ya, uno ya está más suelto en esto y dice, hombre, vamos a pensar, este bucle for, en realidad, solo está sumando, solo está sumando cuando i es igual que en un fila,

79
00:10:35,520 --> 00:10:57,520
pues para qué quiero yo pasar por todas, voy a olvidarme del for de fuera, vamos a ponerlo aquí, otra forma más fácil, volvemos a poner suma cero para comprobar que da lo mismo,

80
00:10:57,520 --> 00:11:22,520
vamos a poner aquí la suma, vale, otra forma más fácil, en lugar de ir pasando por todas las filas, la cero, la uno, la dos, y solamente hacer la suma cuando estoy en la que sea igual a un fila,

81
00:11:22,520 --> 00:11:37,520
pues directamente me olvido del bucle de fuera y hago esto, oye, sumame desde j igual a cero, mientras j sea menor que el número de columnas incrementando j,

82
00:11:37,520 --> 00:12:03,520
sumame a la variable suma, tablero en un fila, de j, vale, entonces, esto es más sencillo que esto, porque este pasa por la cero, pero a lo mejor la cero ni entra aquí nunca,

83
00:12:03,520 --> 00:12:14,520
luego pasa por la uno, la uno ni entra aquí nunca, es que solamente entra aquí para el i igual a un fila, solo entra para el i igual a un fila, pues vamos a olvidarnos de este for,

84
00:12:14,520 --> 00:12:29,520
y hacemos un único for que vaya sumando todas y cada una de las columnas de esta fila, ya está, para qué recorrer todas las filas y sumar solo las de i igual a un fila,

85
00:12:30,520 --> 00:12:43,520
pues me quedo ya en esta fila, me quedo en esta fila, y voy sumando sobre la variable suma, la cero, la una, la dos, esa variable la he puesto j simplemente para que quede más claro

86
00:12:43,520 --> 00:13:10,520
que estamos hablando de columnas, vamos a comprobar que da lo mismo por si algo hemos escrito mal, vale, venga, dos filas, tres columnas,

87
00:13:10,520 --> 00:13:28,520
vale, pues vamos a la fila cero, vale, pues si, ambas opciones hacen lo mismo, lo que pasa es que la primera, el bucle de fuera está perdiendo aquí un montón de tiempo,

88
00:13:28,520 --> 00:13:41,520
está perdiendo un montón de tiempo, se está ejecutando un montón de veces para que aquí no entre, para no entrar ahí, vale, bueno, ¿está claro?

89
00:14:28,520 --> 00:14:38,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

90
00:14:58,520 --> 00:15:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

91
00:15:11,520 --> 00:15:31,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

92
00:15:31,520 --> 00:15:51,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

93
00:15:51,520 --> 00:16:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

94
00:16:11,520 --> 00:16:31,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

95
00:16:31,520 --> 00:16:51,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

96
00:16:51,520 --> 00:17:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

97
00:17:11,520 --> 00:17:31,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

98
00:17:31,520 --> 00:17:51,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

99
00:17:51,520 --> 00:18:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

100
00:18:11,520 --> 00:18:31,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

101
00:18:31,520 --> 00:18:51,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

102
00:18:51,520 --> 00:19:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

103
00:19:11,520 --> 00:19:31,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

104
00:19:31,520 --> 00:19:51,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

105
00:19:51,520 --> 00:20:11,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

106
00:20:11,520 --> 00:20:39,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

107
00:20:39,520 --> 00:20:49,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

108
00:20:49,520 --> 00:21:09,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

109
00:21:09,520 --> 00:21:38,520
¿Ves esto entonces? Tiene que ser fila, claro, te lo has puesto cambiando, vale, dime.

110
00:21:39,520 --> 00:21:44,520
Entonces, si nos pasa eso aquí, no tenemos acceso a la zona donde se declaró

111
00:21:44,520 --> 00:21:47,520
que pongo aquí y que pongo aquí.

112
00:21:47,520 --> 00:21:52,520
En el caso de los arrays lo teníamos solucionado, ¿no? ¿Cómo lo teníamos solucionado?

113
00:21:52,520 --> 00:21:57,520
Con la variable punto len, que dado un array te decía el número de posiciones

114
00:21:57,520 --> 00:22:02,520
para las cuales se habían reservado, las que fueran, ¿vale?

115
00:22:02,520 --> 00:22:07,520
Y aquí hay algún punto len, pues es complicado, tendría que haber dos puntos len, ¿no?

116
00:22:07,520 --> 00:22:10,520
Porque aquí hay filas y hay columnas.

117
00:22:10,520 --> 00:22:16,520
Bueno, pues hay una forma de, dada una variable array de dos dimensiones,

118
00:22:16,520 --> 00:22:20,520
saber cuántas filas tiene y cuántas columnas.

119
00:22:20,520 --> 00:22:27,520
Y para eso hay que entender cómo maneja la máquina virtual por dentro del array de dos dimensiones.

120
00:22:27,520 --> 00:22:31,520
Para la máquina virtual cuando declara esto, fijaos lo que está haciendo.

121
00:22:31,520 --> 00:22:34,520
Está declarando.

122
00:22:34,520 --> 00:22:43,520
Antes cuando veíamos arrays decía, cada vez que veáis esto, es que está diciendo muchos de algo, ¿verdad?

123
00:22:43,520 --> 00:22:45,520
¿Verdad que sí, María?

124
00:22:45,520 --> 00:22:48,520
Que luego me dices, uy, es que como no te estaba haciendo mi caso,

125
00:22:48,520 --> 00:22:52,520
es que esto que has puesto, pues es que no lo he puesto.

126
00:22:52,520 --> 00:22:54,520
¿Vale?

127
00:22:54,520 --> 00:22:58,520
Cuando declaramos un array poníamos, cuando yo pongo los corchetes,

128
00:22:58,520 --> 00:23:01,520
pongo estos muchos de lo que hay aquí.

129
00:23:01,520 --> 00:23:03,520
Vale, muchos enteros, muy bien.

130
00:23:03,520 --> 00:23:07,520
Si ponemos string y esto es muchos cadenas.

131
00:23:07,520 --> 00:23:11,520
Vale, pues aquí estamos poniendo muchos arrays.

132
00:23:11,520 --> 00:23:13,520
Es lo que le estamos diciendo a la máquina virtual.

133
00:23:13,520 --> 00:23:15,520
Haz muchos arrays.

134
00:23:15,520 --> 00:23:20,520
Luego la máquina virtual para ella, esto es un array de arrays.

135
00:23:20,520 --> 00:23:24,520
Es decir, esto es un array de dos dimensiones.

136
00:23:24,520 --> 00:23:25,520
Perdón, de una.

137
00:23:25,520 --> 00:23:26,520
Y esto es otro.

138
00:23:26,520 --> 00:23:28,520
Y esto es otro.

139
00:23:28,520 --> 00:23:33,520
Y a su vez tiene un array de muchos de estos.

140
00:23:33,520 --> 00:23:39,520
Tiene un array de tres arrays de estos.

141
00:23:39,520 --> 00:23:47,520
Esto sería un array de tres posiciones, donde cada posición tiene a su vez un array de cuatro.

142
00:23:47,520 --> 00:23:54,520
Luego un array de dos dimensiones es un array, pero donde en cada posición a su vez es un array.

143
00:23:54,520 --> 00:23:59,520
Es decir, es esto.

144
00:23:59,520 --> 00:24:01,520
Esto es en realidad el array de dos dimensiones.

145
00:24:01,520 --> 00:24:05,520
Un array donde en cada posición a su vez hay otro.

146
00:24:05,520 --> 00:24:07,520
Esto es en realidad.

147
00:24:07,520 --> 00:24:08,520
¿Vale?

148
00:24:08,520 --> 00:24:13,520
Esto que yo he dibujado así como un tablero es una primera posición donde hay un array enterito.

149
00:24:13,520 --> 00:24:16,520
Otra segunda posición donde hay otro array enterito.

150
00:24:16,520 --> 00:24:19,520
Otra tercera posición donde hay un array enterito.

151
00:24:19,520 --> 00:24:29,520
Y luego, como tablero es un array de arrays, si nosotros hacemos tablero.ler, ¿qué numerito me sacará con esto?

152
00:24:29,520 --> 00:24:32,520
¿El número de qué?

153
00:24:32,520 --> 00:24:34,520
¿De filas?

154
00:24:34,520 --> 00:24:35,520
¿Vale?

155
00:24:35,520 --> 00:24:37,520
Tablero es un array de arrays.

156
00:24:37,520 --> 00:24:38,520
Es esto.

157
00:24:38,520 --> 00:24:40,520
¿Pero solo de las filas?

158
00:24:40,520 --> 00:24:44,520
Sí, tablero es un array donde en cada array a su vez es un array.

159
00:24:44,520 --> 00:24:49,520
Luego, si yo hago el tamaño de este array, ¿me dice las filas?

160
00:24:49,520 --> 00:24:51,520
Eso es lo que me dicen, las filas.

161
00:24:51,520 --> 00:24:54,520
Con lo cual, esta parte ya la tengo solucionada.

162
00:24:54,520 --> 00:24:58,520
Las filas, sé que la puedo sacar así.

163
00:25:04,520 --> 00:25:08,520
¿Pero y qué pasará con las columnas?

164
00:25:08,520 --> 00:25:13,520
Bueno, pues las columnas, una vez que yo me he colocado en un array concreto,

165
00:25:13,520 --> 00:25:17,520
para este en concreto puedo sacar su tamaño con el .len.

166
00:25:17,520 --> 00:25:19,520
Pero claro, ¿este en concreto cuál es?

167
00:25:19,520 --> 00:25:22,520
Pues este es tablero de cero.

168
00:25:22,520 --> 00:25:23,520
¿Verdad?

169
00:25:23,520 --> 00:25:25,520
Tablero de cero es todo este.

170
00:25:25,520 --> 00:25:28,520
Todo este es tablero de cero.

171
00:25:28,520 --> 00:25:31,520
Y este es tablero de uno.

172
00:25:31,520 --> 00:25:33,520
Todo este.

173
00:25:33,520 --> 00:25:36,520
Por eso cuando hacemos tablero cero cero es esta de aquí.

174
00:25:36,520 --> 00:25:39,520
Y cuando hacemos tablero cero uno es esta de aquí.

175
00:25:39,520 --> 00:25:42,520
Y tablero de dos es todo este.

176
00:25:42,520 --> 00:25:44,520
Todo este.

177
00:25:44,520 --> 00:25:52,520
Luego, cada una de las filas, ¿cómo podría sacar su longitud?

178
00:25:52,520 --> 00:25:56,520
Para la fila i, para toda la fila i, ¿cómo puedo sacar su longitud?

179
00:25:56,520 --> 00:25:58,520
¿Qué pondríais ahí?

180
00:25:59,520 --> 00:26:02,520
Eso sí, ¿vale?

181
00:26:08,520 --> 00:26:10,520
¿Qué es tablero de i?

182
00:26:10,520 --> 00:26:13,520
Tablero de i es toda la fila i enterita.

183
00:26:13,520 --> 00:26:15,520
Todo el array fila i enterita.

184
00:26:15,520 --> 00:26:16,520
Toda.

185
00:26:16,520 --> 00:26:18,520
Entonces si yo quiero, toda.

186
00:26:18,520 --> 00:26:21,520
Entonces si yo quiero la posición cero, por eso hago tablero de i de cero.

187
00:26:21,520 --> 00:26:23,520
Pero me quedo en la cero.

188
00:26:23,520 --> 00:26:25,520
Si quiero la uno, por eso hago tablero de i de uno.

189
00:26:25,520 --> 00:26:27,520
Porque me quedo en la uno.

190
00:26:27,520 --> 00:26:29,520
Pero tablero de i es todo el array entero.

191
00:26:29,520 --> 00:26:34,520
Entonces si yo quiero toda la longitud de este, pues tablero de i punto len.

192
00:26:39,520 --> 00:26:40,520
¿Vale?

193
00:26:40,520 --> 00:26:43,520
Entonces ahora ya esto me generaliza.

194
00:26:43,520 --> 00:26:46,520
Y yo no tengo por qué saber las dimensiones del tablero.

195
00:26:46,520 --> 00:26:50,520
Sé que con este voy por todas y cada una de las filas.

196
00:26:50,520 --> 00:26:55,520
Y ahora para cada fila, el tamaño de cada fila me viene dado por tablero de i punto len.

197
00:26:55,520 --> 00:26:59,520
Para cada fila, tablero de i punto cero, tablero de i punto uno.

198
00:27:03,520 --> 00:27:07,520
No, eso te saca el tamaño de cada fila, que a su vez serán las columnas.

199
00:27:09,520 --> 00:27:11,520
Esta es una fila.

200
00:27:11,520 --> 00:27:14,520
Tablero de i punto len es uno, dos, tres y cuatro su tamaño.

201
00:27:14,520 --> 00:27:16,520
Con lo que es lo mismo las columnas.

202
00:27:17,520 --> 00:27:18,520
¿Eh?

203
00:27:22,520 --> 00:27:26,520
A ver, pero estamos hablando del número de columnas que hay.

204
00:27:26,520 --> 00:27:31,520
Y el número de columnas es el tamaño de cada fila.

205
00:27:33,520 --> 00:27:37,520
Si tú pones filas de cinco, ¿cuántas columnas hay? Cinco.

206
00:27:37,520 --> 00:27:41,520
Si pones filas de seis, ¿cuántas columnas hay? Seis.

207
00:27:42,520 --> 00:27:43,520
¿Vale?

208
00:27:44,520 --> 00:27:51,520
Entonces con esto ya podemos generalizar y decir, vale, yo aquí sé seguro que voy a recorrer todo el tablero.

209
00:27:51,520 --> 00:27:53,520
Esto lo he puesto al revés.

210
00:27:54,520 --> 00:27:58,520
Y no tengo necesidad de saber cuántas dimensiones tiene.

211
00:28:00,520 --> 00:28:05,520
¿Vale? Entonces esto es un poco raro, pero si lo revisáis, si lo repasáis, lo entenderéis.

212
00:28:05,520 --> 00:28:10,520
Que tablero de i en sí es algo, pero que es una raya enterito.

213
00:28:10,520 --> 00:28:13,520
Tablero de i es una raya enterito, que es la fila i.

214
00:28:13,520 --> 00:28:16,520
Entonces a tablero de i como tal yo no accedo.

215
00:28:16,520 --> 00:28:18,520
Yo accedo a tablero de i de cero.

216
00:28:18,520 --> 00:28:19,520
Tablero de i de uno.

217
00:28:19,520 --> 00:28:22,520
Porque a una raya yo accedo a las posiciones.

218
00:28:22,520 --> 00:28:24,520
Y tablero de i es todo una raya.

219
00:28:24,520 --> 00:28:25,520
Todo una raya.

220
00:28:27,520 --> 00:28:28,520
¿Vale?

221
00:28:30,520 --> 00:28:34,520
Y de hecho esto me permite, el que esto funcione así, el que para la máquina virtual

222
00:28:34,520 --> 00:28:40,520
una raya de dos dimensiones sea una raya de arraies, me permitiría tener arraies,

223
00:28:40,520 --> 00:28:46,520
perdón, arraies bidimensionales, donde el tamaño de las filas es distinto entre sí.

224
00:28:58,520 --> 00:29:01,520
Es decir, yo puedo tener una raya de arraies.

225
00:29:01,520 --> 00:29:02,520
Esto es una raya.

226
00:29:03,520 --> 00:29:06,520
Y ahora dentro de este array en cada posición hay un array.

227
00:29:06,520 --> 00:29:08,520
Pero aquí hay uno de tres.

228
00:29:08,520 --> 00:29:10,520
Y aquí quiero uno de cuatro.

229
00:29:11,520 --> 00:29:13,520
Y aquí quiero uno de dos.

230
00:29:13,520 --> 00:29:16,520
Y aquí quiero uno de cinco.

231
00:29:16,520 --> 00:29:18,520
Y aquí quiero uno de dos.

232
00:29:18,520 --> 00:29:19,520
Eso también es posible.

233
00:29:20,520 --> 00:29:26,520
¿Vale? Esto ya no va a ser una matriz cuadradita como antes, que todos tenían tres o todos tenían cuatro.

234
00:29:26,520 --> 00:29:27,520
No es una matriz cuadradita.

235
00:29:27,520 --> 00:29:29,520
Pero a lo mejor me interesa.

236
00:29:30,520 --> 00:29:32,520
¿Vale?

237
00:29:44,520 --> 00:29:48,520
Y ahora la pregunta complicada, a ver si conseguís no perderos,

238
00:29:48,520 --> 00:29:51,520
pero es que estas cosas hay que incorporarlas.

239
00:29:51,520 --> 00:29:54,520
Ahora la pregunta es, imaginaos que queremos esta estructura de datos.

240
00:29:54,520 --> 00:29:57,520
Yo quiero un array de arraies.

241
00:29:57,520 --> 00:30:00,520
Pero ahora quiero que cada uno tenga un tamaño distinto.

242
00:30:00,520 --> 00:30:01,520
No como antes.

243
00:30:01,520 --> 00:30:04,520
Mi situación de antes era un array de arraies.

244
00:30:04,520 --> 00:30:06,520
Por ejemplo este donde todos tienen lo mismo.

245
00:30:06,520 --> 00:30:09,520
Tres, tres y tres.

246
00:30:09,520 --> 00:30:13,520
Y esto lo veíamos como una matriz de tres por tres.

247
00:30:13,520 --> 00:30:14,520
Tres por tres.

248
00:30:14,520 --> 00:30:15,520
Y declaramos con tres por tres.

249
00:30:15,520 --> 00:30:16,520
¿Vale?

250
00:30:16,520 --> 00:30:18,520
Esta ya no es complicada de declarar.

251
00:30:18,520 --> 00:30:19,520
¿Verdad?

252
00:30:19,520 --> 00:30:20,520
Vamos a ver que son enteros.

253
00:30:20,520 --> 00:30:25,520
Como es de dos dimensiones, porque es array de arraies, sigue siendo así.

254
00:30:26,520 --> 00:30:28,520
Sigue siendo esto.

255
00:30:28,520 --> 00:30:30,520
Ahora le doy el nombre que me dé la gana.

256
00:30:30,520 --> 00:30:32,520
Vale.

257
00:30:32,520 --> 00:30:34,520
El nombre que yo quiera.

258
00:30:34,520 --> 00:30:36,520
Y ahora viene lo raro.

259
00:30:36,520 --> 00:30:38,520
¿Qué es?

260
00:30:38,520 --> 00:30:40,520
Vale, el número de filas lo tengo claro.

261
00:30:40,520 --> 00:30:42,520
El número de filas lo tengo que decir.

262
00:30:42,520 --> 00:30:45,520
¿Cuántas filas quieres?

263
00:30:45,520 --> 00:30:49,520
Pues, si queremos hacer exactamente esta estructura.

264
00:30:49,520 --> 00:30:52,520
Quiero cinco filas.

265
00:30:53,520 --> 00:30:59,520
Pero claro, esta parte es la que se queda confusa.

266
00:30:59,520 --> 00:31:01,520
¿Cuántas columnas quiero?

267
00:31:01,520 --> 00:31:04,520
Depende, para la primera posición quiero que sean tres.

268
00:31:04,520 --> 00:31:06,520
Pero es que para la segunda quiero que sean cuatro.

269
00:31:06,520 --> 00:31:08,520
Pero es que para esta quiero que sean dos.

270
00:31:08,520 --> 00:31:10,520
Entonces, ¿aquí qué pongo?

271
00:31:10,520 --> 00:31:15,520
Cuando estábamos en esta situación, poníamos tres, porque quiero tres para todas.

272
00:31:15,520 --> 00:31:19,520
Y ya teníamos tranquilamente nuestra array de tres por tres.

273
00:31:20,520 --> 00:31:22,520
Pero en una situación así, ¿qué pongo aquí?

274
00:31:22,520 --> 00:31:24,520
Ni idea.

275
00:31:24,520 --> 00:31:28,520
Con lo cual, se deja vacío.

276
00:31:28,520 --> 00:31:30,520
Se deja vacío.

277
00:31:30,520 --> 00:31:35,520
Y ahora vamos creando los arrays fila uno por uno.

278
00:31:35,520 --> 00:31:37,520
¿Vale?

279
00:31:40,520 --> 00:31:42,520
Vale, esto lo digo.

280
00:31:42,520 --> 00:31:46,520
Lo pensáis, tratáis de entenderlo, pero bueno, tampoco es algo en lo que nos vayamos a meter.

281
00:31:46,520 --> 00:31:48,520
Por ejemplo, para la posición cero.

282
00:31:48,520 --> 00:31:50,520
Tablero de cero.

283
00:31:50,520 --> 00:31:52,520
Tablero de cero es todo un array.

284
00:31:52,520 --> 00:31:53,520
Todo un array.

285
00:31:53,520 --> 00:31:55,520
Pues vamos a crearlo.

286
00:31:55,520 --> 00:31:58,520
new int, porque es un array de enteros.

287
00:31:58,520 --> 00:32:00,520
¿Y de cuántos?

288
00:32:00,520 --> 00:32:01,520
De tres.

289
00:32:01,520 --> 00:32:03,520
¡Hala!

290
00:32:03,520 --> 00:32:05,520
Ya tenemos esta primera creada.

291
00:32:07,520 --> 00:32:09,520
Tablero de uno.

292
00:32:11,520 --> 00:32:14,520
Tablero de uno es todo un array entero.

293
00:32:14,520 --> 00:32:16,520
Ese.

294
00:32:16,520 --> 00:32:18,520
Decido yo el tamaño que quiero.

295
00:32:18,520 --> 00:32:20,520
new int de cuatro, por ejemplo.

296
00:32:22,520 --> 00:32:23,520
Y así con todos.

297
00:32:23,520 --> 00:32:29,520
Luego esta sería la forma, si es que nos interesa, que esto ya es más raro que nos interese, es más raro.

298
00:32:29,520 --> 00:32:33,520
Debe declarar un array de arrays, o lo que es lo mismo, un array de dos dimensiones.

299
00:32:33,520 --> 00:32:36,520
Pero donde cada fila tiene un tamaño distinto.

300
00:32:36,520 --> 00:32:39,520
Tendría que ir yo declarando fila por fila.

301
00:32:39,520 --> 00:32:43,520
Aquí lo dejo vacío diciendo, oye, va a tener tantas filas.

302
00:32:43,520 --> 00:32:47,520
Pero ahora vete fila por fila decidiendo cuántas.

303
00:32:47,520 --> 00:32:52,520
Y una vez que ya tengo todas las filas instanciadas con el tamaño que yo quiero.

304
00:32:52,520 --> 00:32:56,520
Ahora ya es un array de dos dimensiones y lo recorro exactamente igual que hemos visto.

305
00:32:56,520 --> 00:32:57,520
Tranquilamente.

306
00:32:57,520 --> 00:33:03,520
Lo recorrería hasta tablero.lets y luego cada fila hasta tablerodei.lets y cada una sería distinta.

307
00:33:03,520 --> 00:33:04,520
¿Vale?

308
00:33:04,520 --> 00:33:06,520
Ahora mi for de recorrido.

309
00:33:07,520 --> 00:33:21,520
Sería, para todas las filas, tablero.lets es la longitud del array de filas, que es el número de filas.

310
00:33:21,520 --> 00:33:29,520
Y ahora, para cada fila, el recorrido lo haría desde igual a j, desde j igual a cero, perdón.

311
00:33:29,520 --> 00:33:31,520
Mientras j sea menor que qué?

312
00:33:31,520 --> 00:33:34,520
Que el tamaño de esa fila, el que sea.

313
00:33:34,520 --> 00:33:35,520
Cada una es una.

314
00:33:35,520 --> 00:33:39,520
La fila tablerodei, cada una tiene su tamaño.

315
00:33:39,520 --> 00:33:41,520
Pues tablerodei.len.

316
00:33:47,520 --> 00:33:49,520
Bueno, pues yo aquí iría recorriendo todo.

317
00:33:49,520 --> 00:33:54,520
Este, este y este. Luego este, este, este y este. Luego este y este. Luego este, este, este y este.

318
00:33:54,520 --> 00:33:55,520
¿Vale?

319
00:33:55,520 --> 00:33:58,520
Pues si necesito una estructura así, pues ya está.

320
00:33:58,520 --> 00:33:59,520
No tengo que declarar así.

321
00:33:59,520 --> 00:34:01,520
Esto lo dejo por ahora vacío.

322
00:34:02,520 --> 00:34:04,520
Creo las filas solamente.

323
00:34:04,520 --> 00:34:09,520
Y ahora ya voy rellenando las filas con el array concreto que yo quiera.

324
00:34:09,520 --> 00:34:12,520
Pero repito, esta estructura es mucho menos útil.

325
00:34:12,520 --> 00:34:16,520
Un tablero exacto cuadrado, sí.

326
00:34:16,520 --> 00:34:19,520
Porque esto reproduce una situación real muy habitual, que es un plano.

327
00:34:19,520 --> 00:34:21,520
Un plano de cosas.

328
00:34:21,520 --> 00:34:23,520
Un tablero de juego, lo que sea.

329
00:34:23,520 --> 00:34:26,520
Entonces esta puede tener su utilidad porque no nos complica la vida.

330
00:34:26,520 --> 00:34:28,520
Al contrario, nos la facilita.

331
00:34:28,520 --> 00:34:30,520
Porque visualizamos algo real.

332
00:34:30,520 --> 00:34:35,520
Y en este caso, pues yo aquí ya pongo directamente las filas y las columnas porque son todas iguales.

333
00:34:35,520 --> 00:34:37,520
Lo pongo aquí y se acabó.

334
00:34:37,520 --> 00:34:38,520
Y ya se crea de golpe todo.

335
00:34:38,520 --> 00:34:40,520
Las filas y todas las columnas iguales.

336
00:34:40,520 --> 00:34:41,520
Se crea todo de golpe.

337
00:34:41,520 --> 00:34:42,520
Y esto no me hace falta.

338
00:34:42,520 --> 00:34:43,520
Se crean todas.

339
00:34:43,520 --> 00:34:53,520
Pero si yo dejo esto en blanco, se crean solo las filas, o sea, el número de posiciones, y luego tengo que ir una por una.

340
00:34:53,520 --> 00:34:55,520
Pero lo importante es que lo entendáis.

341
00:34:55,520 --> 00:35:00,520
Porque en realidad, de entenderlo, todo esto es de nuevo Arrays.

342
00:35:00,520 --> 00:35:02,520
Cada uno es un Array.

343
00:35:08,520 --> 00:35:10,520
Bueno, ¿está claro?

344
00:35:26,520 --> 00:35:30,520
Bueno, y vamos a decirle un ultimito que es una chorrada de Arrays.

345
00:35:35,520 --> 00:35:39,520
Que creo que está todo lo que necesitamos ahora más o menos.

346
00:35:39,520 --> 00:35:40,520
Bueno, a ver.

347
00:35:40,520 --> 00:35:45,520
Esto de los Arrays de dos dimensiones se podría extender hasta el infinito.

348
00:35:45,520 --> 00:35:46,520
¿Vale?

349
00:35:46,520 --> 00:35:49,520
Que uno quiere un Array de tres dimensiones.

350
00:35:49,520 --> 00:35:52,520
Vale, no lo vamos a hacer, ni vamos a hacer ejercicio, ni nada.

351
00:35:52,520 --> 00:35:54,520
Pero es que lo podéis extender.

352
00:35:54,520 --> 00:35:56,520
¿Qué puede simular un Array de tres dimensiones?

353
00:35:56,520 --> 00:35:59,520
Las posiciones que hay en un cubo.

354
00:35:59,520 --> 00:36:00,520
¿Verdad?

355
00:36:00,520 --> 00:36:02,520
Perfectamente, las puede simular.

356
00:36:05,520 --> 00:36:06,520
¿Vale?

357
00:36:06,520 --> 00:36:09,520
Si uno hace un cubo con cubitos pequeños, pa pa pa, hace su torre de cubos.

358
00:36:09,520 --> 00:36:12,520
Tres cubos, otros tres cubos, otros tres cubos.

359
00:36:12,520 --> 00:36:16,520
Pues, y quiere simular cada uno de esos cubitos.

360
00:36:16,520 --> 00:36:20,520
Pues hombre, eso queda perfectamente simulado por un Array ahora de tres.

361
00:36:20,520 --> 00:36:25,520
Que son la fila, la columna y la profundidad.

362
00:36:25,520 --> 00:36:27,520
Ahora hay tres posiciones porque ahora no es un plano.

363
00:36:27,520 --> 00:36:29,520
Que es fila, columna.

364
00:36:29,520 --> 00:36:32,520
Ahora es fila, columna y profundidad.

365
00:36:32,520 --> 00:36:36,520
Para la fila cero, columna cero, profundidad cero será este cubito.

366
00:36:36,520 --> 00:36:41,520
Pero para la fila cero, columna cero, profundidad uno será el cubito que tiene justo detrás.

367
00:36:41,520 --> 00:36:46,520
Para la fila cero, columna cero, profundidad dos será el cubito que tiene justo detrás.

368
00:36:46,520 --> 00:36:51,520
Si uno quiere simular esa realidad de un cubo porque le interesa,

369
00:36:51,520 --> 00:36:56,520
pues le viene que ni pintado una raíz, pero ahora de tres.

370
00:36:56,520 --> 00:36:58,520
Pues como si son de 20.000.

371
00:36:58,520 --> 00:37:01,520
Yo extiendo aquí los corchetes hasta donde me dé la gana.

372
00:37:01,520 --> 00:37:04,520
Como si quiero poner 20.000 corchetes, pero para qué.

373
00:37:04,520 --> 00:37:06,520
Ya para qué, perdería el sentido.

374
00:37:06,520 --> 00:37:09,520
Como mucho tres puede tener sentido si quiero simular esto.

375
00:37:09,520 --> 00:37:11,520
Pero más allá de eso...

376
00:37:12,520 --> 00:37:18,520
Entonces yo puedo aquí tranquilamente hacer esto, por ejemplo, pues eso.

377
00:37:18,520 --> 00:37:22,520
Tres, tres y tres.

378
00:37:23,520 --> 00:37:27,520
Pues este sería un cubo de tres caras.

379
00:37:27,520 --> 00:37:33,520
Tres caras así y luego tres de estas y ya está.

380
00:37:34,520 --> 00:37:37,520
Uno lo puede hacer del tamaño que quiera.

381
00:37:37,520 --> 00:37:42,520
Para recorrer, ¿qué tendría que hacer? Pues tres foranidados en vez de dos, tres.

382
00:37:42,520 --> 00:37:45,520
El primero que te va diciendo en qué fila estás.

383
00:37:45,520 --> 00:37:48,520
El de dentro, que dentro de la fila te marca en qué columna estás.

384
00:37:48,520 --> 00:37:52,520
Y luego uno interno, que dentro de la columna en la que estás, te marca la profundidad en la que estás.

385
00:37:52,520 --> 00:37:57,520
Y así recorres todo. Vas por aquí, por ahí, por ahí, etc.

386
00:37:58,520 --> 00:38:01,520
Entonces el funcionamiento es igual.

387
00:38:01,520 --> 00:38:05,520
Que uno quiera hacer una raíz y extender aquí los corchetes hasta 20 corchetes.

388
00:38:05,520 --> 00:38:07,520
Pues lo extiende.

389
00:38:07,520 --> 00:38:09,520
¿Pero qué va a querer simular con eso?

390
00:38:09,520 --> 00:38:13,520
Pues bueno, ya es una complejidad innecesaria.

391
00:38:14,520 --> 00:38:15,520
¿Vale?

392
00:38:21,520 --> 00:38:22,520
Vale.

393
00:38:23,520 --> 00:38:27,520
A ver, por último, que esto se ha ido quedando en el tintero siempre.

394
00:38:29,520 --> 00:38:31,520
Lo apunto ahora antes de que...

395
00:38:32,520 --> 00:38:35,520
A ver, cuando queramos una raíz cualquiera.

396
00:38:35,520 --> 00:38:38,520
Para cambiar, que estamos siempre con los ints.

397
00:38:38,520 --> 00:38:40,520
Un string, por ejemplo.

398
00:38:44,520 --> 00:38:45,520
Vamos a suponer...

399
00:38:45,520 --> 00:38:48,520
Esto es una cosa para inicializar a raíz de forma sencilla.

400
00:38:50,520 --> 00:38:51,520
Vale.

401
00:38:51,520 --> 00:38:54,520
Nosotros imaginamos que queremos trabajar con una raíz de nombres.

402
00:38:55,520 --> 00:38:57,520
Cada nombre es una cadena de texto.

403
00:38:57,520 --> 00:39:00,520
Pues boh, la estructura de datos que le pega es esa.

404
00:39:00,520 --> 00:39:02,520
Un array de string. Esa es la que le pega.

405
00:39:03,520 --> 00:39:04,520
Vale.

406
00:39:04,520 --> 00:39:07,520
Ahora yo no puedo trabajar con este array si antes no creo el espacio.

407
00:39:07,520 --> 00:39:09,520
Ya nosotros sabemos de memoria.

408
00:39:09,520 --> 00:39:11,520
Bueno, pues entonces haríamos...

409
00:39:12,520 --> 00:39:13,520
New string.

410
00:39:14,520 --> 00:39:16,520
Y la cantidad de nombres que yo quiero.

411
00:39:16,520 --> 00:39:17,520
El espacio que yo quiero.

412
00:39:17,520 --> 00:39:18,520
Que son 3.

413
00:39:19,520 --> 00:39:20,520
Pues venga, 3.

414
00:39:21,520 --> 00:39:24,520
Y ahora ya puedo recorrer para inicializar para lo que me dé la gana.

415
00:39:24,520 --> 00:39:25,520
¿Nombres de 0? Pepito.

416
00:39:25,520 --> 00:39:26,520
¿Nombres de 1? Juanito. Vale.

417
00:39:27,520 --> 00:39:29,520
Bueno, pues hay una forma rápida y sencilla.

418
00:39:30,520 --> 00:39:34,520
Que a la vez crea espacio para array e inicializa.

419
00:39:34,520 --> 00:39:35,520
¿Vale?

420
00:39:36,520 --> 00:39:38,520
Entonces incorporémosla, que siempre se me olvida.

421
00:39:40,520 --> 00:39:44,520
Forma rápida para hacer dos cosas a la vez.

422
00:39:45,520 --> 00:39:47,520
Crear el espacio para el array, que es lo que te hace el new.

423
00:39:47,520 --> 00:39:50,520
Y además dar valores iniciales a la array.

424
00:40:00,520 --> 00:40:01,520
¿Vale?

425
00:40:08,520 --> 00:40:12,520
Vale, y esta forma rápida que habréis visto en mil sitios, pues es esta.

426
00:40:13,520 --> 00:40:18,520
¿Vale? En lugar de crear espacio y luego darle valores, puedo yo de golpe hacer las dos cosas.

427
00:40:18,520 --> 00:40:19,520
De golpe.

428
00:40:20,520 --> 00:40:24,520
¿Qué es? Pongo igual y abro aquí unas llaves, tenemos por punto y coma.

429
00:40:24,520 --> 00:40:29,520
Y pongo los valores iniciales que yo quiero separados por comas.

430
00:40:29,520 --> 00:40:30,520
Y ya está.

431
00:40:35,520 --> 00:40:38,520
Entonces, esto te hace dos cosas en una.

432
00:40:38,520 --> 00:40:40,520
Primera, te hace como el new.

433
00:40:41,520 --> 00:40:44,520
Te crea un espacio en memoria. ¿Para cuántas? Tanto valores. Tres.

434
00:40:45,520 --> 00:40:51,520
Y ahora, una vez que te ha creado el espacio en memoria, les asigna los valores que te has puesto aquí.

435
00:40:52,520 --> 00:40:56,520
Entonces si tú quieres crear un array y a la vez darle los valores iniciales, pues eso es muy cómodo.

436
00:40:57,520 --> 00:40:58,520
¿Vale?

437
00:41:00,520 --> 00:41:07,520
Esto solo se puede hacer la primera vez que se usa un array que está declarado.

438
00:41:08,520 --> 00:41:18,520
Si luego yo quiero, me he bajado por ahí por el código y a nombres le quiero cambiar y darle ahora otra cosa, otra cosa, ya no me va a dejar.

439
00:41:19,520 --> 00:41:23,520
Ya no me deja. Esto me deja solo la primera vez que uso un array que he declarado. Luego no me deja.

440
00:41:24,520 --> 00:41:29,520
Si yo a nombres le quiero cambiar y darle otros valores, lo recorro para dárselos.

441
00:41:30,520 --> 00:41:33,520
O si le quiero cambiar el tamaño, lo voy a tener que hacer con new.

442
00:41:34,520 --> 00:41:37,520
Si lo hago con new otra vez, entonces ningún problema.

443
00:41:38,520 --> 00:41:45,520
Si yo hago esto otra vez, el array de antes se va a la basura y creo uno nuevo de tamaño 4 que guarde el nombre, si quiero.

444
00:41:46,520 --> 00:41:49,520
¿Vale? Pero no puedo volver a hacer esto si ya lo he hecho para un array.

445
00:41:49,520 --> 00:41:56,520
Eso porque a veces uno lo hace en un momento y le sale un error y se está ahí dos horas, pero ¿por qué me sale error si sintácticamente está bien?

446
00:41:57,520 --> 00:42:02,520
Porque solo se puede usar esto la primera vez que usas un array que has declarado.

447
00:42:03,520 --> 00:42:05,520
La primera vez que lo usas, luego ya no.

448
00:42:06,520 --> 00:42:11,520
¿Vale? Entonces una forma cómoda para crear espacio y poner array e inicializarlo.

449
00:42:11,520 --> 00:42:22,520
Y a lo mejor con esta forma, a lo mejor se entiende más esto que hemos dicho de los arrays de dos dimensiones.

450
00:42:23,520 --> 00:42:26,520
Imaginaos que yo aquí quiero un array de dos dimensiones para números.

451
00:42:27,520 --> 00:42:28,520
Un tablero, por ejemplo.

452
00:42:33,520 --> 00:42:35,520
Pues también puedo usar esta forma.

453
00:42:36,520 --> 00:42:38,520
Esta forma rara de inicializar, lo puedo.

454
00:42:38,520 --> 00:42:44,520
Entonces entre llaves tienen que ir los diferentes valores del array tablero.

455
00:42:45,520 --> 00:42:47,520
¿Y los diferentes valores del array tablero cuáles son?

456
00:42:48,520 --> 00:42:49,520
A su vez un array.

457
00:42:50,520 --> 00:42:52,520
Pues le pongo aquí esto por ejemplo.

458
00:42:53,520 --> 00:42:54,520
Y separo por coma.

459
00:42:55,520 --> 00:42:56,520
Dos, tres, siete.

460
00:42:57,520 --> 00:42:58,520
Y separo por coma.

461
00:42:59,520 --> 00:43:01,520
Cinco, nueve, seis.

462
00:43:02,520 --> 00:43:03,520
Eso también sería válido.

463
00:43:04,520 --> 00:43:06,520
Esto es un array de arrays, tablero.

464
00:43:06,520 --> 00:43:10,520
Pues yo me hago un array donde la primera fila es uno y dos.

465
00:43:11,520 --> 00:43:12,520
La siguiente dos, tres y siete.

466
00:43:13,520 --> 00:43:14,520
Y la siguiente cinco, nueve, seis.

467
00:43:15,520 --> 00:43:20,520
A lo mejor viendo esto, entendéis más que esto en realidad es un array de arrays.

468
00:43:21,520 --> 00:43:22,520
Aquí habría construido esto.

469
00:43:23,520 --> 00:43:25,520
Habría construido aquí el uno, dos.

470
00:43:26,520 --> 00:43:28,520
Aquí habría construido dos, tres, siete.

471
00:43:29,520 --> 00:43:31,520
Y aquí habría construido cinco, nueve, seis.

472
00:43:32,520 --> 00:43:33,520
Esto habría construido con esto.

473
00:43:33,520 --> 00:43:36,520
Un array donde esta fila tiene dos, esta tiene tres y esta tiene dos.

474
00:43:37,520 --> 00:43:38,520
¿Vale?

475
00:43:39,520 --> 00:43:41,520
Vale, ahora sí que vamos a parlar.

476
00:43:43,520 --> 00:43:44,520
Un momentito.