1
00:00:05,050 --> 00:00:11,380
Bueno llegamos al capítulo de los vectores los Sarris y los slicks.

2
00:00:11,380 --> 00:00:17,950
Vamos a ver qué son los enlaces y vamos a saber cómo manejar todo lo que tiene que ver con vectores

3
00:00:18,370 --> 00:00:19,570
y Arráiz engo.

4
00:00:19,600 --> 00:00:28,780
Vamos a crearnos como ya estamos haciendo costumbre una nueva carpeta vamos a nuestra carpeta aguó vamos

5
00:00:28,780 --> 00:00:33,420
a crear la carpeta Eger 0 7.

6
00:00:33,490 --> 00:00:42,030
Muy bien dentro de ejercer OS 7 nuestro archivo Main punto y punto.

7
00:00:42,130 --> 00:00:44,330
Escribimos lo habitual.

8
00:00:44,350 --> 00:00:52,120
Bueno muy bien y estamos aquí vamos a empezar despacito vamos a ver distintas variantes distintas características

9
00:00:52,120 --> 00:00:55,450
que tienen que ver con los vectores con los Sarris.

10
00:00:55,570 --> 00:01:02,330
Ustedes saben que un vector o una raíz no es más que una colección de datos en memoria.

11
00:01:02,500 --> 00:01:08,830
No voy a adentrarme en lo que la terminología y lo que tiene que ver con la explicación de Arráiz porque

12
00:01:08,830 --> 00:01:15,100
se supone que ustedes ya vienen de otros lenguajes y conocen así que lo que vamos a ver es cómo maneja

13
00:01:15,100 --> 00:01:18,040
Goh un vector o una raíz.

14
00:01:18,070 --> 00:01:23,030
El primer ejemplo que vamos a ver es vamos a ir por fuera de nuestra función main.

15
00:01:23,050 --> 00:01:31,910
Vamos a hacer una declaración con simple bar vamos a llamarlo tabla como solemos llamar a veces a nuestros

16
00:01:31,910 --> 00:01:40,630
Herráiz entre corchetes vamos a poner la longitud de la tabla y le vamos a decir que es de tipo entero.

17
00:01:40,750 --> 00:01:50,500
Recuerden que podemos poner que el tipo entero específico así es de 8 bits 64 32 o 16 y tengan en cuenta

18
00:01:50,500 --> 00:01:57,950
que una vez que declaren ese tipo de datos luego solamente le van a poder mover ese tipo de datos.

19
00:01:57,950 --> 00:02:05,180
Cuidado con eso porque hay muchas funciones que van a mover simplemente un entero y al ser un entero

20
00:02:05,180 --> 00:02:10,430
de 32 lo va a tomar como que es un dato diferente y nos va a dar error.

21
00:02:10,460 --> 00:02:12,840
Cómo se asigna valores a este array.

22
00:02:12,850 --> 00:02:20,660
Recuerden que en todas las declaraciones que yo hago se inicializar a diferencia de otros lenguajes

23
00:02:20,960 --> 00:02:25,310
inicializar en cero o con una cadena vacía o con un fouls.

24
00:02:25,310 --> 00:02:35,240
En este caso esta tabla de posiciones enteras se va inicializar con precisamente diez posiciones en

25
00:02:35,240 --> 00:02:48,980
cero yo puedo forzar que en la posición cero por ejemplo grabe 1 1 y que la posición 5 grabe otro dato

26
00:02:48,980 --> 00:02:49,440
verdad.

27
00:02:49,490 --> 00:02:55,070
Puede ser un 15 por ejemplo muy bien si yo ahora muestro por pantalla

28
00:03:01,790 --> 00:03:12,020
precisamente la tabla completa vamos a grabar esto vamos a ir a nuestra terminal nos vamos a posicionar

29
00:03:12,530 --> 00:03:22,200
en ejerceré 7 y vamos a hacer un corral de Main punto vamos a saber qué ocurre

30
00:03:25,490 --> 00:03:26,210
muy bien.

31
00:03:26,240 --> 00:03:36,520
Fíjense yo ya tengo a mi mi tabla de 10 posiciones en la posición cero la primera recuerden que lenguajes

32
00:03:36,550 --> 00:03:38,170
C y demás.

33
00:03:38,180 --> 00:03:44,660
Todo lo que tiene que ver con vectores arranca de la posición cero en la posición cero tengo un 1 que

34
00:03:44,660 --> 00:03:55,480
lo he definido aquí y en la posición 5 tengo un 15 cero uno dos tres cuatro y en las cinco tengo un

35
00:03:55,490 --> 00:03:56,490
15.

36
00:03:56,540 --> 00:04:03,620
Muy bien ahora vamos a ver una variante de esto vamos a ir viendo variantes porque ustedes van a aprender

37
00:04:03,800 --> 00:04:06,870
distintas maneras de crear vectores.

38
00:04:06,890 --> 00:04:15,950
Vamos a ver cómo podemos directamente crear dentro de Main un vector vamos a sacarlo de aquí vamos a

39
00:04:15,950 --> 00:04:24,140
ir a nuestro Main y vamos a colocar por ejemplo una asignación.

40
00:04:24,200 --> 00:04:31,550
Esto es para diréctamente para que lo creé un vector le vamos a decir que es un vector de 10 fíjense

41
00:04:31,550 --> 00:04:33,400
como comienza.

42
00:04:34,040 --> 00:04:42,860
Le vamos a decir que es de tipo entero e inmediatamente le voy a grabar valores cualquier cosa que no

43
00:04:42,870 --> 00:04:47,010
sea diez posiciones y le voy a grabar valores.

44
00:04:47,030 --> 00:04:55,530
Si yo ahora muestro tabla vamos a agravarlo vamos a ir a nuestra consola y lo vamos a correr a esperar

45
00:04:55,530 --> 00:05:00,450
que ejecute muy bien y ahí tenemos los diez valores que acabamos de ingresar.

46
00:05:00,540 --> 00:05:06,400
Entonces ustedes pueden crear un vector por fuera de main.

47
00:05:06,540 --> 00:05:12,420
Ojo con él es Copp porque al crearlo por fuera va a estar presente en todas las funciones y si lo crean

48
00:05:12,420 --> 00:05:21,510
dentro de esa tabla solamente va a estar presente dentro de Main pero les muestro que esto es una forma

49
00:05:21,510 --> 00:05:23,800
de crear un vector.

50
00:05:24,030 --> 00:05:34,800
También podían haber puesto así es válido lo mismo que colocaron aquí es exactamente lo mismo y ahora

51
00:05:34,830 --> 00:05:42,960
nuestra tabla está presente en toda la ejecución y en todas las funciones y todos los métodos que vamos

52
00:05:42,960 --> 00:05:47,460
a crear en nuestra en nuestro desarrollo.

53
00:05:47,460 --> 00:05:56,490
Vamos a ver una forma de recorrer una tabla por ejemplo vamos a vamos a dejar esto lo vamos a quitar

54
00:05:56,730 --> 00:06:06,690
y aquí lo que vamos a hacer es vamos a mostrar los elementos de una manera diferente vamos a crear un

55
00:06:06,690 --> 00:06:16,140
foro donde vamos inicializar una variable de tipo entera y vamos a recorrer toda la tabla fíjense que

56
00:06:16,140 --> 00:06:23,490
usamos Selem es la función que me permite saber el largo de nuestro vector de nuestro arrullar de nuestro

57
00:06:23,490 --> 00:06:28,770
Rey y vamos muy bien a mostrar.

58
00:06:28,770 --> 00:06:37,440
Vamos a colocar el FMI aquí adentro perfecto y aquí vamos a mostrar elemento por elemento que vamos

59
00:06:37,440 --> 00:06:42,360
a lograr con esto que cada elemento se va a mostrar en una línea diferente.

60
00:06:42,360 --> 00:06:50,160
Vamos a grabarlo vamos a ejecutarlo y vamos a ver que en lugar de mostrarse horizontal se muestran uno

61
00:06:50,160 --> 00:06:51,420
debajo del otro.

62
00:06:51,630 --> 00:06:54,280
Muy bien aquí tenemos el resultado.

63
00:06:54,360 --> 00:07:01,020
Esta es la manera de recorrer una tabla tenemos un león que es una función que me permite conocer la

64
00:07:01,020 --> 00:07:07,910
cantidad de elementos que tiene un vector y esto es obviamente indispensable.

65
00:07:08,100 --> 00:07:15,210
Vamos a ver ahora el tema matrices en el tema matrices son ni más ni menos que vectores pero con dos

66
00:07:15,210 --> 00:07:25,860
dimensiones vamos a crear un vector llamado matriz y le vamos a decir que es un vector que tiene cinco

67
00:07:25,860 --> 00:07:35,400
filas y siete columnas como si fuera una planilla Excel y luego yo internamente obviamente puedo vamos

68
00:07:35,400 --> 00:07:42,600
a quitar todo esto porque en realidad no nos sirve para este ejemplo y yo aquí lo que puedo hacer es

69
00:07:42,600 --> 00:07:51,180
decirle perdón si esto es muy básico van a haber cosas que las tengo que explicar así que en la posición

70
00:07:51,180 --> 00:08:06,010
3 columna 5 Le voy a grabar un uno muy bien si ahora yo muestro matriz no sé por qué quedó ahí muy bien

71
00:08:06,510 --> 00:08:12,700
vamos a grabar vamos a ver qué pasa cuando muestra la matriz.

72
00:08:12,700 --> 00:08:20,440
Muy bien aquí vemos que una matriz es un conjunto de vectores en realidad y que en el primer vector

73
00:08:20,440 --> 00:08:28,660
no tengo nada porque en realidad estoy sesteando el vector número tres cero uno dos tres en el vector

74
00:08:28,660 --> 00:08:37,720
3 estoy moviendo un valor en la posición cinco cero uno dos tres cuatro cinco ahí tengo el 1 que yo

75
00:08:37,750 --> 00:08:40,990
acabo de mover y esto es muy útil las matrices.

76
00:08:40,990 --> 00:08:46,660
No hace falta que yo les explique lo útiles que son para alojar datos para hacer cálculos para hacer

77
00:08:46,960 --> 00:08:48,240
muchas cosas.

78
00:08:48,570 --> 00:08:55,300
Bueno esto es todo lo que tiene que ver con vectores luego van a tener que practicar con el Lean y recorrerlo

79
00:08:55,330 --> 00:08:56,590
y hacer cálculos.

80
00:08:56,590 --> 00:09:02,490
Por supuesto esto puede ser entero puede ser de tipo string puede ser de tipo booleano puede ser de

81
00:09:02,710 --> 00:09:08,010
cualquier tipo de dato que ustedes tengan actualmente habilitados engo.

82
00:09:08,200 --> 00:09:15,910
Bueno lo que vamos a saber ahora es slices Luis son en definitiva vectores dinámicos que significa que

83
00:09:15,910 --> 00:09:24,160
sean vectores dinámicos son vectores donde yo puedo ampliar las dimensiones en tiempo real en tiempo

84
00:09:24,160 --> 00:09:30,250
de ejecución cosas que con los vectores normales no se puede una vez que yo definí una matriz.

85
00:09:30,250 --> 00:09:42,010
Por ejemplo aquí tenía definido una matriz y le digo que es de cinco y que tiene siete columnas.

86
00:09:42,010 --> 00:09:45,070
Esto ya no lo puedo variar más.

87
00:09:45,100 --> 00:09:53,890
Esto yo no lo puedo variar en un vector normal Lashes Lish es una creación de Google para asemejar lo

88
00:09:53,890 --> 00:09:54,840
que son las listas.

89
00:09:54,850 --> 00:10:01,960
Igual tenemos listas en Google pero vamos a ver este tipo de vectores dinámicos que me sirven para ir

90
00:10:01,960 --> 00:10:08,350
alojando información en memoria y en un momento puede ser que me haya quedado sin espacio iban a ver

91
00:10:08,350 --> 00:10:17,900
que yo puedo ir agregando dimensiones constantemente hasta cubrir la necesidad que tenga de alojar información.

92
00:10:18,010 --> 00:10:26,850
Vamos a ver un ejemplo vamos a borrar esto de aquí vamos a hacer el nuestro en nuestra función main

93
00:10:26,890 --> 00:10:31,060
vamos a hacer una asignación de matriz.

94
00:10:31,240 --> 00:10:39,670
Por ejemplo le vamos a decir que matriz en realidad va a ser un desliz cuando yo no le coloco ningún

95
00:10:39,670 --> 00:10:47,380
tipo de longitud entre corchetes eso significa que se va a convertir en un desliz.

96
00:10:47,380 --> 00:10:55,240
No le estoy asignando ninguna longitud y ahora lo que voy a hacer es asignarle unos valores vamos a

97
00:10:55,300 --> 00:11:06,630
colocar tres valores y vamos a hacer un vamos a quitar esto de aquí y vamos a mostrar por por consola

98
00:11:07,310 --> 00:11:08,740
qué es lo que tenemos aquí.

99
00:11:09,000 --> 00:11:17,850
Vamos a correr y nos va a mostrar lo que para nosotros a simple vista es un vector muy bien pero no

100
00:11:17,850 --> 00:11:25,440
es un vector cualquiera es un slicks porque porque inicialmente más allá de que yo le he definido valores

101
00:11:25,770 --> 00:11:30,290
no le he puesto ningún argumento de largo.

102
00:11:30,420 --> 00:11:38,010
Esto que significa me lo creo de tres pero ahora como sabe que es un desliz el compilador me va a dejar

103
00:11:38,760 --> 00:11:44,160
que yo trabaje internamente con esa matriz y le agregue elementos y demás.

104
00:11:44,370 --> 00:11:54,650
Vamos a ver una primera variante la vamos a llamar variante variante 2 porque en realidad la primera

105
00:11:54,650 --> 00:12:05,570
fue una variante vamos a crear una función variante 2 que no recibe ningún parámetro vamos a escribir

106
00:12:05,570 --> 00:12:11,200
bien esto muy bien qué vamos a hacer aquí en variante 2.

107
00:12:11,240 --> 00:12:23,420
Aquí lo que vamos a hacer es un ejemplo desliz vamos a crear por ejemplo elementos y vamos a crear elementos

108
00:12:23,870 --> 00:12:30,860
y le voy a decir Fíjense que ahora lo que estoy creando es un vector ok.

109
00:12:31,060 --> 00:12:40,870
Si le coloco si le estoy colocando una longitud es un vector muy bien creo un vector simple ahora no

110
00:12:40,910 --> 00:12:46,270
me permite crear un desliz en base aún a un vector.

111
00:12:46,490 --> 00:12:47,960
Cómo se hace este slice.

112
00:12:47,960 --> 00:12:55,940
Este es se puede hacer de elementos por ejemplo puedo hacer esto puedo decirle que me creé un slice

113
00:12:56,000 --> 00:13:03,110
llamado porcion con el que después voy a trabajar lo vamos a ver y que me lo cree.

114
00:13:03,110 --> 00:13:09,890
En base a un vector llamado elementos desde la posición 3 hasta la última.

115
00:13:09,890 --> 00:13:21,530
Esto significa eso desde la posición 3 que sería esta hasta la última si yo aquí hago si muestro por

116
00:13:21,530 --> 00:13:22,970
consola porcion.

117
00:13:23,000 --> 00:13:33,290
Vamos a agravarlo vamos a correrlo vamos a ver 2 2 display porque en realidad mantengo 1 fijense mantengo

118
00:13:33,290 --> 00:13:42,520
este lo vamos a deshabilitar ahora para que no me lo muestre en lo sucesivo y me traen los elementos

119
00:13:42,520 --> 00:13:43,810
4 y 5 por qué.

120
00:13:43,810 --> 00:13:52,750
Porque porcion se creó es un vector de tipos Leys que se creó desde el vector elementos.

121
00:13:52,750 --> 00:13:55,090
Esto puede ser así puede ser.

122
00:13:55,120 --> 00:13:58,620
Vamos a saber por ejemplo puede ser así.

123
00:13:58,720 --> 00:14:04,210
Esto es lo mismo que decir del primer elemento hasta el cuarto.

124
00:14:04,210 --> 00:14:07,860
Esto puede ser así desde el segundo elemento hasta el cuarto.

125
00:14:07,870 --> 00:14:10,900
Esto lo pueden hacer ustedes como quieran.

126
00:14:10,990 --> 00:14:18,730
Me permite crear vectores de tipos Lish en base a vectores más grandes y los voy particionado y voy

127
00:14:18,970 --> 00:14:29,050
juntando porciones de elementos en otros es Lish pero vamos a ver en la variante 3 porque por ahora

128
00:14:29,700 --> 00:14:31,810
por ahora estamos viendo vectores.

129
00:14:31,810 --> 00:14:38,140
En realidad yo les digo que esto es un desliz pero todavía no queda muy claro que cuál es la gracia

130
00:14:38,140 --> 00:14:40,160
de tener un slice verdad.

131
00:14:40,210 --> 00:14:47,010
Muy bien vamos a crear una variante 3 variantes 3 va a ser un funk.

132
00:14:47,260 --> 00:14:57,730
Variante 3 y lo que vamos a ver ahora lo que vamos a ver ahora es qué necesitamos qué necesitamos para

133
00:14:57,730 --> 00:15:02,170
que un lápiz para crear una hélice con un comando especial.

134
00:15:02,290 --> 00:15:09,450
Porque estos son slice pero no fueron creados con un comando especial sino que fueron por asignacion.

135
00:15:09,520 --> 00:15:16,090
Vamos a ver un comando especial que me permite crear es Lish y dotarlos de toda la capacidad necesaria

136
00:15:16,480 --> 00:15:21,730
para que yo pueda adicionar elementos en algún momento de la ejecución.

137
00:15:21,730 --> 00:15:26,680
Ese comando del cual yo les hablo es el comando MEIC.

138
00:15:26,680 --> 00:15:36,340
Entonces vamos a crear vamos a crear un enlace de tipo elementos y le vamos a decir que vamos a usar

139
00:15:36,550 --> 00:15:37,960
la función MEIC.

140
00:15:37,960 --> 00:15:47,890
Fíjense que Goh me la reconoce como una función donde me pide el tipo de dato que voy a usar y la la

141
00:15:47,890 --> 00:15:57,120
medida de lo Leslie que voy a crear ahora MEIC tiene en realidad más que dos parámetros tiene tres parámetros

142
00:15:57,420 --> 00:15:59,970
y vamos a hablar muy bien de estos tres parámetros.

143
00:16:00,150 --> 00:16:06,690
Primero qué es lo que vamos a crear vamos a crear un lápiz de tipo entero.

144
00:16:07,170 --> 00:16:16,140
Recuerden que si no le coloco ningún tipo de dimensión lo asume como un elemento en base a MEIC va a

145
00:16:16,140 --> 00:16:24,810
ser creado de tipos líes con un primer parámetro que es el largo el largo de elementos vamos a decirle

146
00:16:24,810 --> 00:16:33,920
que es de tipo cinco de tipo de un largo cinco y luego me pide la capacidad y aquí metemos algo nuevo.

147
00:16:34,070 --> 00:16:44,310
Engo que hace una diferenciación entre lo que es capacidad y lo que es el largo de un vector A qué se

148
00:16:44,310 --> 00:16:52,980
refiere en memoria va a reservar lo que yo coloque como capacidad me va a crear en memoria un espacio

149
00:16:52,980 --> 00:17:03,000
que va a soportar hasta 20 elementos pero inicialmente me va a crear un vector de cinco elementos me

150
00:17:03,000 --> 00:17:10,350
reservo el espacio pero me crea un vector de 5 para qué se hace esto ustedes piensen que GOW es un lenguaje

151
00:17:10,350 --> 00:17:18,050
que fue creado para soportar una carga de trabajo gigantesca estamos hablando de sitios como Google.

152
00:17:18,270 --> 00:17:24,750
Entonces Google no quería crear vectores de 5 elementos y que cuando se quedara chico hubiera que hacer

153
00:17:24,750 --> 00:17:33,270
todo un artilugio en memoria para ustedes saben que lo que es concatenación de textos y no lo es si

154
00:17:33,270 --> 00:17:41,190
no lo saben lo van a aprender ahora una de las cosas más costosas en sistemas más costosas en cuanto

155
00:17:41,190 --> 00:17:49,530
a tiempo de procesador más costosa en cuanto a recursos que utiliza un lenguaje de programación y un

156
00:17:50,010 --> 00:17:55,530
ragtime es el tema de la concatenan concatenación de strings.

157
00:17:55,980 --> 00:18:02,190
Si ustedes le preguntan a un ingeniero que trabaja en Microsoft a un ingeniero que trabaje en cualquier

158
00:18:02,190 --> 00:18:09,450
proyecto de lenguaje de programación lo más costoso en cantidad de operaciones es cuando uno quiere

159
00:18:09,450 --> 00:18:16,170
concatenar en memoria un string con otro por la cantidad de operaciones que tienen que hacer de reserva

160
00:18:16,530 --> 00:18:23,640
operaciones de bajo nivel se entiende operaciones de lenguaje ensamblador de reserva de espacio de memoria

161
00:18:23,640 --> 00:18:26,170
de migrar datos de un lado para el otro.

162
00:18:26,250 --> 00:18:27,770
Entonces qué pasa.

163
00:18:27,990 --> 00:18:35,160
Google lo que pensó con el tema de la capacidad es bueno vamos a dar la posibilidad de que los programadores

164
00:18:35,160 --> 00:18:39,010
tengan una cantidad máxima de capacidad.

165
00:18:39,030 --> 00:18:46,590
Ellos saben que van a trabajar con cinco elementos pero podría llegar a crecer y que ellos puedan determinar

166
00:18:46,590 --> 00:18:47,930
una cantidad máxima.

167
00:18:48,090 --> 00:18:54,780
Si lleváramos esto a base de datos sería como el famoso bar Char donde yo defino un campo de tipo parchar

168
00:18:55,080 --> 00:18:55,980
de 200.

169
00:18:55,980 --> 00:19:02,910
Pero por ahí internamente el campo grabó diez caracteres y va a ocupar 10 caracteres.

170
00:19:02,910 --> 00:19:11,640
Esto vendría a ser algo parecido con la diferencia de que Goh va a reservar 20 posiciones en memoria

171
00:19:12,120 --> 00:19:14,430
pero yo no quiero 20 posiciones.

172
00:19:14,430 --> 00:19:20,700
Yo ya sé que voy a trabajar inicialmente con cinco podría crecer pero Gome va a reservar ese espacio

173
00:19:21,000 --> 00:19:27,780
porque va a ser mucho más dinámico mucho más performance en el momento en que yo tenga que agregar elementos

174
00:19:28,780 --> 00:19:35,590
si ya tengo reservado el espacio que si yo me quedé sin espacio y en tiempo real estoy constantemente

175
00:19:35,590 --> 00:19:39,580
agregando elementos mi aplicación se va a resentir.

176
00:19:39,580 --> 00:19:45,850
Imagínense que estamos hablando de aplicaciones que luego terminan siendo concurrentes con miles y miles

177
00:19:45,850 --> 00:19:48,610
y miles de usuarios simultáneamente.

178
00:19:48,610 --> 00:19:53,850
Entonces cómo estamos en el mundo de la alta performance.

179
00:19:54,190 --> 00:20:00,070
Lo que ha creado es esto que es la capacidad de un desliz.

180
00:20:00,100 --> 00:20:07,510
Yo cuando ITD cuando haga un Lain el me va a devolver cinco y cuando quiera iterar por la cantidad de

181
00:20:07,510 --> 00:20:10,930
elementos del vector voy a iterar cinco veces.

182
00:20:10,930 --> 00:20:18,130
Ahora supongamos que nosotros le vamos a ver esto vamos a ver esto muy claro.

183
00:20:18,130 --> 00:20:25,720
Por ejemplo vamos a hacer un vamos a ver por pantalla por consola no voy a usar el F.

184
00:20:27,160 --> 00:20:32,150
Así se los muestro mejor el FC el que me permite mezclar texto con datos.

185
00:20:32,170 --> 00:20:44,320
Entonces yo aquí lo que voy a decir es largo por ciento y voy a poner capacidad por ciento de muy bien.

186
00:20:44,410 --> 00:20:51,930
Ahora nosotros dijimos que con Len Sopó saber el largo de elementos no.

187
00:20:52,510 --> 00:21:00,310
Bueno ahora vamos a ver un nuevo una nueva función que Ska-P que me permite conocer la capacidad de

188
00:21:00,310 --> 00:21:11,260
un desliz y esto es muy importante porque porque yo con mi código voy a saber cuándo voy a estar crítico

189
00:21:11,320 --> 00:21:19,060
con la capacidad y ahí voy a definir y voy a decidir si lo que voy a hacer es agregar ejecutar.

190
00:21:19,060 --> 00:21:24,910
Por ejemplo el comando para agregar elementos a un slice es el Append.

191
00:21:25,420 --> 00:21:28,190
Entonces yo voy a saber si.

192
00:21:28,510 --> 00:21:32,820
Lamentablemente llegué al final y voy a tener que usar el APEN.

193
00:21:32,830 --> 00:21:37,520
Vamos a saber cuál es el comportamiento de Goh ante estas características.

194
00:21:38,020 --> 00:21:46,680
Entonces por ejemplo vamos a ver que vamos a hacer un favor a vamos a primero mostrar esto.

195
00:21:47,820 --> 00:21:53,110
Así ustedes ven qué es lo que me muestra ejecutamos.

196
00:21:53,190 --> 00:21:54,650
Qué pasó que no declare

197
00:21:57,970 --> 00:21:58,450
porque aquí

198
00:22:01,750 --> 00:22:07,970
vamos a sacar esto vamos a correrlo.

199
00:22:09,210 --> 00:22:18,580
Vamos a ver qué es lo que nos muestra bueno me dice que largó el largo del desligue elemento hace cinco

200
00:22:18,580 --> 00:22:20,350
y la capacidad es 20.

201
00:22:20,350 --> 00:22:24,930
Esto que yo les estaba explicando Bueno muy bien entonces qué vamos a hacer.

202
00:22:25,660 --> 00:22:32,720
Vamos a ver una variante cuatro para que entendamos lo del APEN.

203
00:22:32,950 --> 00:22:39,700
Yo estoy haciendo todo con números enteros esto es factible hacerlo con strings booleanos.

204
00:22:39,700 --> 00:22:44,320
Como ya dijimos antes muy bien qué vamos a hacer ahora.

205
00:22:44,330 --> 00:22:48,420
Vamos a crear un vamos a crear otro enlace llamado noms.

206
00:22:48,440 --> 00:22:59,250
Vamos a hacer un MEIC vamos a decirle que es de tipo Luis Lantero y aquí lo que vamos a hacer es decirle

207
00:22:59,250 --> 00:23:04,080
que hay cero elementos y la capacidad es cero.

208
00:23:04,080 --> 00:23:05,030
Esto es factible.

209
00:23:05,040 --> 00:23:11,790
Me crea un vacío y yo ya sé que de movida lo primero que voy a tener que hacer para agregar elementos

210
00:23:11,790 --> 00:23:13,670
son happens.

211
00:23:13,740 --> 00:23:21,030
Si yo hiciera esto aquí arriba voy a estar con un Fornells haciendo asignaciones simples y cuando detecto

212
00:23:21,030 --> 00:23:26,490
que ya no puedo hacer asignaciones simples voy a tener que usar el APEM pero yo quiero que ustedes vean

213
00:23:26,580 --> 00:23:27,390
esto.

214
00:23:27,450 --> 00:23:37,260
Vamos a hacer un favor vamos a crear una variable y que la vamos a inicializar en cero.

215
00:23:37,470 --> 00:23:47,550
Vamos a agregar un 100 y vamos a por ejemplo pero me faltó el más más y aquí lo que vamos a hacer es

216
00:23:47,610 --> 00:23:57,570
que noms porque entonces si yo ya crea enormes bueno pero noms hay que recrearlo constantemente con

217
00:23:57,570 --> 00:23:58,640
una pend.

218
00:23:58,850 --> 00:24:05,230
El Append lo que me va a devolver es un slices el Append recibe una slices y me devuelve un slice.

219
00:24:05,240 --> 00:24:12,930
Entonces voy a tener que constantemente noms crearlo nuevamente o asignarlo nuevamente.

220
00:24:13,070 --> 00:24:26,050
Entonces esto lo que hace es crear un elemento el noms y le va a agravar el valor de Y a ese nuevo elemento

221
00:24:27,460 --> 00:24:28,230
muy bien.

222
00:24:28,270 --> 00:24:38,230
Ahora fíjense una cosa yo creé una capacidad de cero se Akiba iterar 100 veces y va a estar 100 veces

223
00:24:38,230 --> 00:24:46,220
agregando elementos y si yo estoy agregando elementos y va a agregar 100 elementos.

224
00:24:46,230 --> 00:24:54,030
Cuánto creen que va a decir aquí en el largo de la matriz del vector y cuánto va a decir en capacidad.

225
00:24:54,030 --> 00:24:57,060
Se van a llevar una sorpresa vamos a ver esto.

226
00:24:57,550 --> 00:25:09,510
FBT print vamos ahora a usar printed F nuevamente vamos a alegre con un carries retarán porque arriba

227
00:25:09,510 --> 00:25:21,240
ya tengo emprender Efeso y no me los va concatenar el largo y capacidad muy bien y aquí voy a ser un

228
00:25:21,240 --> 00:25:28,000
león de nubes y un cap de nubes.

229
00:25:29,340 --> 00:25:37,680
Muy bien yo creé un vacío vamos repasando un vacío y Terezín veces y le fui grabando en cada elemento

230
00:25:37,800 --> 00:25:45,960
el valor de ello o sea va a grabar 0 1 2 3 y demás me va a ir creando y recreando noms constantemente

231
00:25:46,110 --> 00:25:47,790
y redimensiona.

232
00:25:48,180 --> 00:25:56,130
Aquí en un Redim lo que sea si esto se va agregando elementos y automáticamente se va redimensionado

233
00:25:57,250 --> 00:26:03,610
vamos a ver qué es lo que hace Goh con el tema de la capacidad que es muy interesante vamos a ejecutarlo

234
00:26:04,450 --> 00:26:14,930
muy bien me dice que el largo es 100 como ya previmos pero que la capacidad de 128 qué es lo que hace

235
00:26:14,930 --> 00:26:23,930
GOW GOW me siempre me va a poner una cantidad mayor aquí a no ser que el multi la cantidad de largo

236
00:26:23,930 --> 00:26:28,700
sea múltiplo de 8 de 4 de 2.

237
00:26:28,700 --> 00:26:34,520
Esto en realidad se guía por la numeración binaria que es lo que hace.

238
00:26:34,610 --> 00:26:42,740
Ustedes saben que en las computadoras todo es múltiplo de por ejemplo un un kilobits son 1024 bits y

239
00:26:42,740 --> 00:26:48,770
así todo es no es múltiplo de mil sino que tiene connotación con lo binario.

240
00:26:48,770 --> 00:26:58,280
Entonces la capacidad GOW empieza a reservar espacio lo primero que hace es reservar una u un elemento

241
00:26:58,740 --> 00:27:07,910
lo sobre pacer me reserva dos elementos lo sobrepase me reserva 4 lo sobrepase me reserva 8 me reserva

242
00:27:07,910 --> 00:27:21,510
16 me reserva 32 64 ne reserva 124 ciente perdón 64 128 12:56 y 512.

243
00:27:21,530 --> 00:27:28,670
Todo múltiplo todo múltiplo y de 2 elevado a la potencia.

244
00:27:28,690 --> 00:27:33,200
En definitiva no es múltiplo sino que es el número 2 elevado a una potencia.

245
00:27:33,350 --> 00:27:36,680
Entonces siempre me va a reservar un poco más.

246
00:27:36,710 --> 00:27:46,310
Si yo siguiera agregando elementos aquí diría una capacidad de 12:56 512 1024 2048 ya saben como es

247
00:27:46,370 --> 00:27:54,670
la secuencia entonces son previsiones que hace GOW para que me hace agregando cosas.

248
00:27:54,710 --> 00:27:57,720
Lo ideal no es usar siempre APEN.

249
00:27:57,860 --> 00:28:04,820
Lo ideal es usar APEM cuando ya me quedé sin espacio porque el APEN tiene su costo en el proceso es

250
00:28:04,820 --> 00:28:06,560
lo que yo le decía antes.

251
00:28:06,590 --> 00:28:09,650
Entonces cómo yo voy a tener siempre este número.

252
00:28:09,640 --> 00:28:10,600
La capacidad.

253
00:28:10,910 --> 00:28:19,690
Y siempre voy a tener el largo cuando yo supere el largo y hago una pend para Gouges milésimas de segundo.

254
00:28:19,770 --> 00:28:20,310
Por qué.

255
00:28:20,710 --> 00:28:26,720
Porque mientras no me exceda de la capacidad para GoW es decir bueno yo ya tenía reservado ese espacio

256
00:28:26,990 --> 00:28:34,010
voy agregando voy agregando elementos voy ubicando el dato en los elementos que correspondan porque

257
00:28:34,010 --> 00:28:36,220
yo ya reservé el espacio.

258
00:28:36,260 --> 00:28:41,390
El problema viene cuando yo ya superé mi capacidad que GoW lo resuelve.

259
00:28:41,410 --> 00:28:49,200
Visto que esto no ha demorado tanto GOW lo resuelve el problema es que como vuelvo a repetir esto va

260
00:28:49,200 --> 00:28:56,030
a tener que multiplicarse por miles y miles de usuarios concurrentes GOW tuvo que crear esto que es

261
00:28:56,270 --> 00:28:59,030
la capacidad para manejarlos light.

262
00:28:59,450 --> 00:29:04,340
Bueno espero que les haya gustado este capítulo y no haberlos mareado.

263
00:29:04,430 --> 00:29:10,730
No tiene mucha complejidad tiene características nuevas que son las que yo puse más el acento más que

264
00:29:10,730 --> 00:29:18,380
en explicarles cómo se maneja un vector en GOW porque es muy simple pero el tema de los links sí que

265
00:29:18,470 --> 00:29:24,180
está muy bueno y tiene características nuevas que hay que aprender como el tema de la capacidad.

266
00:29:24,290 --> 00:29:30,740
Así que bueno nos vemos en el próximo capítulo y vamos a seguir aprendiendo sobre el lenguaje.