1
00:00:01,190 --> 00:00:02,130
Hola y bienvenidos.

2
00:00:02,180 --> 00:00:06,250
Vamos a ver a continuación cómo introducir valores de manera dinámica a un arreglo.

3
00:00:06,380 --> 00:00:07,130
Están listos?

4
00:00:07,340 --> 00:00:07,790
Vamos.

5
00:00:09,150 --> 00:00:10,680
Bien, vamos a quitar todo este código.

6
00:00:10,680 --> 00:00:16,890
Vamos a limpiarlo, ya que vamos a hacer un ejercicio para ver cómo introducir valores de manera dinámica

7
00:00:16,890 --> 00:00:17,730
a nuestro arreglo.

8
00:00:18,240 --> 00:00:19,470
Así que vamos a hacer lo siguiente.

9
00:00:20,530 --> 00:00:24,910
Vamos a hacer un ejemplo para introducir valores de manera dinámica.

10
00:00:26,560 --> 00:00:31,390
A nuestro arreglo y vamos a pedirle al usuario que proporcione la cantidad de elementos.

11
00:00:32,630 --> 00:00:34,010
Que va a tener nuestro arreglo.

12
00:00:34,190 --> 00:00:38,180
Así que definimos esta variable número de elementos que va a tener nuestro arreglo.

13
00:00:38,360 --> 00:00:40,250
Posteriormente le pedimos al usuario.

14
00:00:41,450 --> 00:00:46,130
Que proporcione este valor numérico, así que proporciona el tamaño.

15
00:00:47,270 --> 00:00:51,320
Del arreglo la cantidad de elementos que va a tener nuestro arreglo.

16
00:00:51,650 --> 00:00:57,170
Posteriormente, con la función escaneé le asignamos el valor que proporcione el usuario a nuestra variable.

17
00:00:58,310 --> 00:00:59,720
Es un valor de tipo entero.

18
00:01:00,700 --> 00:01:05,450
E indicamos la dirección de memoria donde se encuentra nuestra variable número elementos.

19
00:01:05,870 --> 00:01:08,300
Así que con esto asignamos el valor a nuestra variable.

20
00:01:08,540 --> 00:01:13,670
Posteriormente, una vez que ya tenemos la cantidad de elementos que va a tener nuestro arreglo, vamos

21
00:01:13,670 --> 00:01:14,210
a crear.

22
00:01:15,780 --> 00:01:16,470
El arreglo.

23
00:01:16,770 --> 00:01:21,180
Así que la cantidad de elementos que va a tener este arreglo fue proporcionada por el usuario de manera

24
00:01:21,180 --> 00:01:21,750
dinámica.

25
00:01:22,020 --> 00:01:29,610
Así que vamos a crear un arreglo llamado números de tipo entero y especificamos la variable del número

26
00:01:29,610 --> 00:01:30,330
de elementos.

27
00:01:31,950 --> 00:01:37,320
Para indicar cuántos elementos va a tener este arreglo y el ejemplo que vamos a crear, vamos a proporcionar

28
00:01:37,320 --> 00:01:38,100
cinco valores.

29
00:01:38,250 --> 00:01:42,480
Por ello ya tenemos lista nuestra animación, pero obviamente ustedes podrían proporcionar cualquier

30
00:01:42,480 --> 00:01:46,890
cantidad de elementos en este caso simplemente para que ya tengamos lista nuestra animación.

31
00:01:46,890 --> 00:01:51,480
Pero ustedes podrían proporcionar cualquier otra cantidad de elementos para crear su arreglo.

32
00:01:52,040 --> 00:01:56,400
Bien, Posteriormente solicitamos al usuario.

33
00:01:57,730 --> 00:02:00,160
Cada uno de los valores que vamos a agregar a nuestro arreglo.

34
00:02:00,280 --> 00:02:04,870
Para ello vamos a utilizar un ciclo for de manera muy similar a lo que vimos anteriormente.

35
00:02:05,140 --> 00:02:10,780
Especificamos en primer lugar nuestra variable que va a ir incrementando para acceder a cada uno de

36
00:02:10,780 --> 00:02:12,550
los índices de nuestro arreglo.

37
00:02:12,760 --> 00:02:20,260
Posteriormente vamos a iterar la variable y hasta la cantidad de elementos que tenga nuestro arreglo,

38
00:02:20,260 --> 00:02:21,850
pero sin incluir este valor.

39
00:02:22,150 --> 00:02:27,370
Por ello, este operador no es menor o igual que simplemente el operador menor que para que no incluya

40
00:02:27,370 --> 00:02:34,060
el valor proporcionado y posteriormente incrementamos nuestra variable de índice para ir recorriendo

41
00:02:34,060 --> 00:02:35,290
cada uno de los elementos.

42
00:02:35,680 --> 00:02:40,480
Así que ahora, una vez que ya estamos dentro del ciclo FOR, le vamos a pedir al usuario que proporcione

43
00:02:40,510 --> 00:02:42,880
el valor del elemento que queremos acceder.

44
00:02:43,150 --> 00:02:46,470
Así que por ello le indicamos de nuestro arreglo.

45
00:02:46,630 --> 00:02:52,630
Queremos que proporcione el valor del índice respectivo y el valor que proporcione lo vamos a asignar

46
00:02:52,630 --> 00:02:53,500
a nuestra variable.

47
00:02:53,710 --> 00:02:58,840
Pero en primer lugar, le pedimos que proporcione el valor del índice respectivo de nuestro arreglo.

48
00:02:59,200 --> 00:03:04,510
Y una vez que proporciona el valor, entonces vamos a utilizar la función F para leer este valor de

49
00:03:04,510 --> 00:03:05,170
la consola.

50
00:03:05,500 --> 00:03:10,450
Y debido a que es un arreglo que almacena valores de tipo numérico, el valor que vamos a leer también

51
00:03:10,450 --> 00:03:16,210
es de tipo numérico y lo asignamos en el índice de nuestro arreglo que estamos iterando en este momento.

52
00:03:16,570 --> 00:03:21,820
Así que es como si le diéramos a una variable, pero podemos observar que es un índice de nuestro arreglo.

53
00:03:21,940 --> 00:03:27,490
Por lo tanto, especificamos la dirección de memoria del índice que queremos modificar de nuestro arreglo.

54
00:03:27,820 --> 00:03:33,070
En este caso, por ejemplo, si es el índice cero, entonces estamos proporcionando esta dirección de

55
00:03:33,070 --> 00:03:33,580
memoria.

56
00:03:34,270 --> 00:03:39,040
Pero para que vayamos avanzando en cada uno de los elementos, no se proporciona directamente en código

57
00:03:39,280 --> 00:03:45,520
el valor de cero, sino proporcionamos la variable I para que se vaya moviendo en cada uno de los índices.

58
00:03:45,730 --> 00:03:50,320
Así que según el índice que se vaya moviendo es la dirección de memoria que se proporciona.

59
00:03:50,560 --> 00:03:55,200
Y en esa dirección de memoria de cada celda es donde se va a almacenar el valor que el usuario vaya

60
00:03:55,210 --> 00:03:55,830
proporcionar.

61
00:03:56,350 --> 00:04:01,390
Así que en cada una de las celdas, conforme vayamos iterando nuestro ciclo FOR, vamos a ir almacenando

62
00:04:01,390 --> 00:04:02,770
cada uno de estos valores.

63
00:04:03,850 --> 00:04:08,440
Así que con esto ya estamos solicitando cada uno de los valores de nuestro arreglo y el usuario va a

64
00:04:08,440 --> 00:04:10,150
ir llenando cada una de estas casillas.

65
00:04:10,480 --> 00:04:15,490
Así que con esa sintaxis, en primer lugar, le pedimos al usuario que proporcione el valor del índice

66
00:04:15,490 --> 00:04:21,370
respectivo de nuestro arreglo y posteriormente leemos el valor de la consola con esta sintaxis, indicando

67
00:04:21,370 --> 00:04:26,200
la dirección de memoria y posteriormente el índice que estamos iterando de nuestro arreglo.

68
00:04:26,680 --> 00:04:32,980
Ahora por último, mandamos a imprimir para asegurarnos de que ya los elementos se almacenaron correctamente

69
00:04:32,980 --> 00:04:33,730
en este arreglo.

70
00:04:33,970 --> 00:04:36,010
Para ello volvemos a utilizar un ciclo for.

71
00:04:37,500 --> 00:04:42,030
Definimos de nueva cuenta nuestra variable, ya que esta variable es local a este ciclo for.

72
00:04:42,390 --> 00:04:44,910
Así que esta variable también es local a este ciclo for.

73
00:04:45,120 --> 00:04:47,910
Se crea y se destruye al terminar este ciclo for.

74
00:04:48,180 --> 00:04:48,630
Por lo tanto.

75
00:04:48,630 --> 00:04:51,720
En este momento Esta es otra variable nueva que es local.

76
00:04:51,720 --> 00:04:52,650
A este ciclo for.

77
00:04:52,890 --> 00:04:55,680
Se crea y se destruye cuando termina este ciclo.

78
00:04:55,680 --> 00:04:55,980
For.

79
00:04:56,820 --> 00:04:58,920
Y para iterar nuestro ciclo for.

80
00:04:58,920 --> 00:05:04,410
Cada uno de los elementos de nuestro arreglo es prácticamente el mismo código y tenemos desde cero hasta

81
00:05:04,410 --> 00:05:07,260
la cantidad de elementos que tengamos en nuestro arreglo.

82
00:05:07,470 --> 00:05:08,880
Recordemos que no incluye el valor.

83
00:05:08,880 --> 00:05:11,250
Por lo tanto es el número de elementos -1.

84
00:05:11,460 --> 00:05:17,160
Posteriormente incrementamos nuestra variable de índice y finalmente vamos a mandar a imprimir cada

85
00:05:17,160 --> 00:05:19,350
uno de los elementos de nuestro arreglo.

86
00:05:19,890 --> 00:05:25,170
Así que simplemente especificamos que en nuestro arreglo estamos accediendo al índice respectivo.

87
00:05:27,680 --> 00:05:33,860
Así que mostramos por un lado el índice y por otro lado el valor de este índice y por otro lado el valor

88
00:05:33,860 --> 00:05:36,320
del índice que estamos accediendo de nuestro arreglo.

89
00:05:36,710 --> 00:05:39,860
Y entonces proporcionamos en primer lugar el valor del índice.

90
00:05:40,340 --> 00:05:41,090
La variable y.

91
00:05:41,390 --> 00:05:47,630
Y posteriormente accedemos a nuestro arreglo y recuperamos el valor del índice que queremos mostrar.

92
00:05:48,120 --> 00:05:50,680
Bien, con esto ya tenemos prácticamente todo nuestro código.

93
00:05:50,930 --> 00:05:51,950
Vamos a comprobar.

94
00:05:53,620 --> 00:05:56,320
Y entonces podemos observar proporciona el tamaño del arreglo.

95
00:05:56,560 --> 00:06:01,690
Voy a proporcionar el valor de cinco y me pide en primer lugar, el valor del índice cero.

96
00:06:02,020 --> 00:06:04,270
Así que en este caso voy a proporcionar el valor de 100.

97
00:06:04,570 --> 00:06:08,770
Obviamente, puede ser cualquier otro valor, pero para que sea similar a lo que ya hemos visto, voy

98
00:06:08,770 --> 00:06:11,320
a proporcionar los valores del 100 al 500.

99
00:06:11,620 --> 00:06:13,150
Así que proporciono el valor de 100.

100
00:06:13,450 --> 00:06:18,090
Y entonces, en este momento, en esta animación, podemos observar que en memoria para el índice cero

101
00:06:18,100 --> 00:06:22,780
que estamos iterando de nuestro arreglo, se está asignando el valor de 100 en esta celda.

102
00:06:23,110 --> 00:06:28,030
Así que para el índice cero, que es la primera vez que estamos recorriendo nuestro arreglo, le estamos

103
00:06:28,030 --> 00:06:32,380
solicitando al usuario este valor y una vez que lo suelo, proporciona.

104
00:06:32,680 --> 00:06:38,470
Entonces, utilizando esta sintaxis, estamos accediendo a la celda del índice cero y entonces se almacena

105
00:06:38,470 --> 00:06:44,410
el valor de 100 en esa celda, ya que de momento estamos en la celda con el índice cero y así continuamos

106
00:06:44,410 --> 00:06:45,840
con cada uno de los elementos.

107
00:06:45,850 --> 00:06:51,280
Para el índice uno proporcionamos el valor de 200, así que nuestro arreglo se estaría almacenando.

108
00:06:51,280 --> 00:06:57,880
Este valor para el índice dos o tercer elemento proporcionamos el valor de 300, así que en memoria

109
00:06:57,880 --> 00:07:00,520
tendríamos asignado el valor de 300 en el índice dos.

110
00:07:01,240 --> 00:07:04,120
Posteriormente asignamos el valor de 400.

111
00:07:04,420 --> 00:07:09,170
Por lo tanto es el valor que se almacenará en memoria y finalmente el valor de 500.

112
00:07:09,220 --> 00:07:13,210
Ya que hemos indicado que el tamaño del arreglo solamente es de cinco elementos.

113
00:07:13,390 --> 00:07:20,290
Así que va de los índices de 0 a 4 y por lo tanto en memoria tendremos lo siguiente el valor de 500.

114
00:07:20,770 --> 00:07:22,930
Aquí al final me faltó agregar un salto de línea.

115
00:07:23,500 --> 00:07:24,250
Voy a agregarlo.

116
00:07:25,310 --> 00:07:26,330
Y vuelvo a ejecutar.

117
00:07:26,690 --> 00:07:27,860
Los valores son los mismos.

118
00:07:27,860 --> 00:07:34,340
Proporciono el valor de cinco, posteriormente 100, 200 300 400 y 500.

119
00:07:34,710 --> 00:07:39,590
Y entonces podemos observar que se manda a imprimir cada uno de los valores en el índice cero de nuestro

120
00:07:39,590 --> 00:07:42,140
arreglo estamos recuperando el valor de 100.

121
00:07:42,290 --> 00:07:44,180
Por lo tanto este es el valor que se imprime.

122
00:07:44,390 --> 00:07:48,620
Y así con los demás índices para el índice uno recuperamos el valor de 200.

123
00:07:49,040 --> 00:07:50,060
Para el índice dos.

124
00:07:50,420 --> 00:07:54,450
El valor de 300 es el valor que se recupera para el índice tres.

125
00:07:54,470 --> 00:07:57,830
El valor de 400 y finalmente para el índice cuatro.

126
00:07:58,190 --> 00:08:01,050
Estamos recuperando el valor de 500.

127
00:08:01,070 --> 00:08:03,320
Por ello se manda a imprimir este valor a consola.

128
00:08:03,650 --> 00:08:08,270
Y básicamente con esto ya tenemos entonces todo nuestro código para crear nuestro arreglo de manera

129
00:08:08,270 --> 00:08:12,860
dinámica y también asignar cada uno de los valores a nuestro arreglo de manera dinámica.

130
00:08:13,220 --> 00:08:16,400
Bien, pongo en práctica lo que hemos visto y continuamos en la siguiente lección.

131
00:08:16,580 --> 00:08:17,150
Saludos.
