1
00:00:01,080 --> 00:00:01,950
Hola y bienvenidos.

2
00:00:02,130 --> 00:00:07,080
Vamos a realizar a continuación el ejercicio para introducir datos de manera dinámica en una matriz.

3
00:00:07,320 --> 00:00:08,070
Están listos?

4
00:00:08,250 --> 00:00:08,730
Vamos.

5
00:00:10,220 --> 00:00:10,400
Bien.

6
00:00:10,400 --> 00:00:13,670
Vamos a crear entonces el siguiente ejercicio introducir datos.

7
00:00:16,410 --> 00:00:17,250
En una matriz.

8
00:00:17,760 --> 00:00:21,750
Todo esto va a ser de manera dinámica, así que le vamos a pedir al usuario que proporcione cuántos

9
00:00:21,750 --> 00:00:24,930
renglones y cuántas columnas va a utilizar para crear la matriz.

10
00:00:25,170 --> 00:00:29,610
Y una vez que haya proporcionado estos valores, entonces de manera dinámica también le vamos a pedir

11
00:00:29,610 --> 00:00:33,370
que vaya proporcionando cada uno de los valores para llenar la matriz.

12
00:00:33,660 --> 00:00:38,640
Así que vamos a hacer lo siguiente En primer lugar, vamos a definir dos variables la variable de renglones

13
00:00:38,910 --> 00:00:40,380
y la variable de columnas.

14
00:00:40,650 --> 00:00:45,750
De momento los valores no los vamos a especificar ya que los va a proporcionar directamente el usuario.

15
00:00:46,170 --> 00:00:49,920
Entonces le pedimos al usuario proporciona.

16
00:00:52,550 --> 00:00:59,480
El número de renglones para la matriz y una vez que proporcione este valor utilizando la función esca

17
00:00:59,480 --> 00:01:02,570
nf, lo asignamos a la variable de renglones.

18
00:01:03,380 --> 00:01:08,420
Ya sabemos que como es un valor de tipo primitivo, un valor simple, un tipo simple de tipo entero,

19
00:01:08,660 --> 00:01:11,510
entonces tenemos que especificar la dirección de memoria.

20
00:01:11,720 --> 00:01:13,820
Por ello ponemos en primer lugar el ampersand.

21
00:01:14,300 --> 00:01:18,530
Bien, vamos a hacer ahora lo mismo, pero para solicitar la cantidad de columnas.

22
00:01:18,830 --> 00:01:22,460
Así que le pedimos en primer lugar un salto de línea proporciona.

23
00:01:23,650 --> 00:01:24,250
El número.

24
00:01:25,750 --> 00:01:26,500
De columnas.

25
00:01:26,980 --> 00:01:27,730
Dos puntos.

26
00:01:27,730 --> 00:01:28,390
Espacio.

27
00:01:29,460 --> 00:01:33,600
Y utilizando la función escáner le vamos a proporcionar el valor.

28
00:01:33,600 --> 00:01:36,000
Vamos a asignar el valor de columnas.

29
00:01:37,220 --> 00:01:41,330
Y posteriormente vamos a crear la matriz con los valores que el usuario haya proporcionado.

30
00:01:41,600 --> 00:01:43,310
Así que definimos nuestra matriz.

31
00:01:43,580 --> 00:01:48,980
En este caso la variable se va a llamar matriz, pero se va a crear de la cantidad de renglones y la

32
00:01:48,980 --> 00:01:52,160
cantidad de columnas que haya especificado el usuario.

33
00:01:52,910 --> 00:01:57,410
Y como siguiente paso, una vez que ya hemos creado la matriz, vamos a introducir los valores.

34
00:01:57,800 --> 00:02:02,090
Así que también de manera dinámica vamos a pedirle al usuario que llene la matriz.

35
00:02:02,240 --> 00:02:07,580
Para ello vamos a tener que utilizar también un ciclo for anidado para poder iterar en primer lugar

36
00:02:07,580 --> 00:02:13,250
cada uno de los renglones y de manera interna, por cada renglón, cada una de las columnas asociadas

37
00:02:13,250 --> 00:02:14,900
a cada renglón que estamos iterando.

38
00:02:15,200 --> 00:02:22,150
Por lo tanto, integramos nuestra matriz utilizando un ciclo for más externo y de manera interna también

39
00:02:22,160 --> 00:02:25,490
agregamos otro ciclo for para controlar cada una de las columnas.

40
00:02:25,700 --> 00:02:28,280
Así que el ciclo for más externo vamos a iterar.

41
00:02:28,280 --> 00:02:35,900
Cada renglón inicia en cero y la condición es que vamos a iterar este ciclo for mientras la variable

42
00:02:35,900 --> 00:02:42,590
de renglón sea menor que la cantidad de renglones que tenemos en nuestra matriz y posteriormente incrementamos

43
00:02:43,040 --> 00:02:44,300
nuestra variable de renglón.

44
00:02:44,930 --> 00:02:48,770
Ahora, de manera interna, el ciclo más interno controla las columnas.

45
00:02:49,040 --> 00:02:53,960
Todo esto ya lo vimos en las lecciones anteriores, así que cualquier duda pueden revisar las lecciones

46
00:02:53,960 --> 00:02:54,620
anteriores.

47
00:02:55,100 --> 00:02:59,180
Con eso simplemente ya estamos recorriendo cada uno de los elementos de nuestra matriz.

48
00:02:59,630 --> 00:03:04,130
Bien, aquí si ya es un poco diferente, ya que en primer lugar le vamos a pedir al usuario que proporcione

49
00:03:04,130 --> 00:03:09,170
un valor respectivo según el renglón y columna que deseemos que proporcione el valor.

50
00:03:09,440 --> 00:03:16,730
Así que utilizamos la función printf y entonces le pedimos al usuario el siguiente dato asignado en

51
00:03:16,730 --> 00:03:22,460
el siguiente renglón y también en la columna respectiva según el valor que estemos iterando.

52
00:03:22,970 --> 00:03:28,100
Así que proporcionamos las variables de renglón y también la variable de columna.

53
00:03:29,060 --> 00:03:33,800
Bien y una vez que le hemos pedido al usuario este valor, cuando lo proporcione en la consola, entonces

54
00:03:33,800 --> 00:03:36,890
utilizamos la función escaneo para poder leer.

55
00:03:36,890 --> 00:03:43,010
Este valor es un valor de tipo entero, ya que la matriz que hemos definido también son únicamente valores

56
00:03:43,010 --> 00:03:48,230
de tipo entero y debido a que vamos a acceder a un valor de tipo entero dentro de la matriz, cada una

57
00:03:48,230 --> 00:03:50,630
de las celdas también es un valor de tipo entero.

58
00:03:50,810 --> 00:03:55,640
Por lo tanto, debido a que es un tipo primitivo, un tipo entero, entonces también tenemos que especificar

59
00:03:55,640 --> 00:03:59,210
la dirección de memoria de la celda que queremos acceder de la matriz.

60
00:03:59,570 --> 00:04:05,480
Así que primero ponemos ampersand y posteriormente el identificador de nuestra matriz y de manera interna,

61
00:04:05,660 --> 00:04:12,560
tanto el renglón y la columna que queremos modificar según el valor que vamos a modificar, ya que recordemos

62
00:04:12,560 --> 00:04:17,180
que el usuario ha proporcionado cierto valor y entonces se va a asignar en el renglón y la columna que

63
00:04:17,180 --> 00:04:18,290
estamos indicando.

64
00:04:18,610 --> 00:04:23,090
Bien, hasta aquí es el código para poder introducir cada uno de los valores a nuestra matriz.

65
00:04:23,300 --> 00:04:26,420
Ahora, por último, vamos a mandar a imprimir cada uno de los valores.

66
00:04:26,840 --> 00:04:28,460
Así que por último, imprimimos.

67
00:04:30,050 --> 00:04:34,850
Los valores de la matriz para asegurarnos que cada uno de los valores y almacenado correctamente.

68
00:04:35,720 --> 00:04:42,170
De manera muy similar, vamos a utilizar dos ciclos for el ciclo for más externo para poder iterar cada

69
00:04:42,170 --> 00:04:47,240
renglón y el ciclo for más interno para cada columna, como ya sabemos, así que es prácticamente el

70
00:04:47,240 --> 00:04:52,220
mismo código, pero el código interno es diferente, ya que vamos a mandar a imprimir cada uno de los

71
00:04:52,220 --> 00:04:53,750
valores que estamos iterando.

72
00:04:54,110 --> 00:04:56,450
Así que este código es prácticamente el mismo.

73
00:04:56,930 --> 00:05:00,390
Tenemos nuestro ciclo más externo para iterar cada renglón.

74
00:05:00,440 --> 00:05:04,040
Posteriormente, el ciclo más interno para iterar cada columna.

75
00:05:09,220 --> 00:05:11,170
Y por último, entonces mandamos a imprimir.

76
00:05:11,500 --> 00:05:15,370
El valor que estamos recuperando es un valor también de tipo entero.

77
00:05:15,940 --> 00:05:21,400
De momento solamente vamos a mandar a imprimir este valor, el cual se encuentra en el renglón y columna

78
00:05:21,400 --> 00:05:23,350
que estamos iterando en este momento.

79
00:05:23,620 --> 00:05:28,270
Bien, vamos a dar un poco más de formato a esta salida, pero de momento vamos a ver si todo está funcionando

80
00:05:28,270 --> 00:05:29,050
correctamente.

81
00:05:29,350 --> 00:05:33,670
Vamos a ejecutar y entonces nos pide proporcional el número de renglones.

82
00:05:33,970 --> 00:05:37,900
Vamos a trabajar con los valores que hemos visto ya en nuestro ejemplo anterior, pero obviamente ustedes

83
00:05:37,900 --> 00:05:43,840
pueden proporcionar cualquier cantidad de valores bien proporcionado, el valor de dos renglones, posteriormente

84
00:05:43,840 --> 00:05:48,130
dos columnas, y entonces nos empieza a solicitar cada uno de los datos.

85
00:05:48,370 --> 00:05:52,780
Por ejemplo, en este caso, si proporcionamos dos renglones y tres columnas, entonces en memoria se

86
00:05:52,780 --> 00:05:58,090
crea esta matriz de dos renglones por tres columnas y para el renglón cero, columna cero.

87
00:05:58,240 --> 00:06:03,910
Si asignamos el valor de 100 y damos enter, entonces podemos llevar en nuestra animación que se asigna

88
00:06:03,910 --> 00:06:06,670
el valor de 100 en el renglón cero, columna cero.

89
00:06:06,970 --> 00:06:08,040
Y así continuamos.

90
00:06:08,140 --> 00:06:12,130
Como hemos comentado, ustedes pueden proporcionar cualquier otro valor, pero simplemente es para que

91
00:06:12,130 --> 00:06:15,730
tengamos una referencia según el ejemplo que ya hemos venido trabajando.

92
00:06:16,360 --> 00:06:20,200
Así que para el renglón cero, columna uno, asignamos el valor de 200.

93
00:06:20,620 --> 00:06:22,480
Posteriormente el valor de 300.

94
00:06:22,780 --> 00:06:25,750
Y termina la primera iteración del ciclo más interno.

95
00:06:26,020 --> 00:06:27,670
Ya se recorrieron todas las columnas.

96
00:06:27,820 --> 00:06:29,560
Cambiamos ahora de renglón.

97
00:06:29,830 --> 00:06:33,790
Es decir que ya continuamos con la siguiente iteración del ciclo for más externo.

98
00:06:34,810 --> 00:06:40,390
Y ahora, si asignamos el valor de 400, observamos que para el renglón uno columna cero se asigna el

99
00:06:40,390 --> 00:06:48,190
valor de 400 y así continuamos con los demás elementos, se asigna el valor de 500 y por último el valor

100
00:06:48,190 --> 00:06:49,120
de 600.

101
00:06:49,900 --> 00:06:52,990
Y entonces observamos que en memoria ya se creó nuestra matriz correctamente.

102
00:06:53,300 --> 00:06:58,090
Bien, por último, como hemos comentado, simplemente se está mandando a imprimir cada uno de los valores

103
00:06:58,090 --> 00:07:02,860
que hemos almacenado en nuestra matriz, simplemente para comprobar que la información sea almacenado

104
00:07:02,860 --> 00:07:04,330
correctamente en memoria.

105
00:07:05,020 --> 00:07:08,200
Y vamos a dar un formato aquí para saber qué es lo que se está imprimiendo.

106
00:07:08,410 --> 00:07:09,280
En primer lugar.

107
00:07:10,990 --> 00:07:13,630
Agregamos un pequeño texto.

108
00:07:15,640 --> 00:07:18,160
Impresión de la matriz.

109
00:07:19,140 --> 00:07:23,190
Con tres guiones y posteriormente nuestra impresión de manera más interna.

110
00:07:23,880 --> 00:07:25,290
Vamos a llegar a un salto de línea.

111
00:07:25,830 --> 00:07:27,540
Vamos a imprimir cada valor.

112
00:07:29,710 --> 00:07:34,960
En primer lugar ponemos el nombre de matriz y posteriormente especificamos cuál es el renglón y también

113
00:07:34,990 --> 00:07:39,940
cuál es la columna que vamos a mandar a imprimir y posteriormente recordemos que esto simplemente es

114
00:07:39,940 --> 00:07:40,540
una cadena.

115
00:07:40,810 --> 00:07:45,940
Mandamos a imprimir el valor que estamos recuperando, pero nos falta proporcionar las variables de

116
00:07:45,940 --> 00:07:46,930
renglón y columna.

117
00:07:48,630 --> 00:07:54,060
Así que simplemente estamos mandando imprimir el renglón, posteriormente la columna y finalmente el

118
00:07:54,060 --> 00:07:58,830
valor que estamos recuperando del renglón y columna almacenado en nuestra matriz.

119
00:07:59,310 --> 00:08:01,440
Así que ya estamos agregando este pequeño formato.

120
00:08:01,710 --> 00:08:07,140
Y por último, recordemos que si queremos que cada renglón se imprima en una línea distinta, entonces

121
00:08:07,140 --> 00:08:12,480
al terminar el ciclo for más interno, simplemente mandamos a imprimir también un salto de línea.

122
00:08:12,870 --> 00:08:15,480
Bien, con esto prácticamente ya tenemos toda nuestra información.

123
00:08:15,900 --> 00:08:20,340
Y por último, agregamos un salto de línea al inicio para que cada uno de esos elementos se imprima

124
00:08:20,340 --> 00:08:21,270
en una nueva línea.

125
00:08:21,600 --> 00:08:23,250
Bien, ya tenemos todo nuestro código.

126
00:08:23,400 --> 00:08:29,220
Vamos a volver a ejecutar y vamos a comprobar el número de renglones es dos, el número de columnas

127
00:08:29,220 --> 00:08:33,990
tres y empezamos a proporcionar los valores según lo que ya hemos visto anteriormente.

128
00:08:38,240 --> 00:08:43,100
Y entonces podemos observar que hemos proporcionado todos estos valores dinámicamente, incluyendo los

129
00:08:43,100 --> 00:08:44,300
renglones y las columnas.

130
00:08:44,510 --> 00:08:49,040
Obviamente, ustedes pueden proporcionar cualquier otro valor, y para la impresión de la matriz leemos

131
00:08:49,040 --> 00:08:49,730
cada valor.

132
00:08:50,000 --> 00:08:55,700
Así que para el renglón cero y cada una de las columnas, estamos recuperando todos los valores relacionados

133
00:08:55,700 --> 00:08:57,500
a este renglón con cada columna.

134
00:08:57,770 --> 00:09:00,950
Y por otro lado, cambiamos de pivote el renglón uno.

135
00:09:01,190 --> 00:09:07,160
Con cada una de sus columnas obtenemos también los valores respectivos 400, 500 y 600.

136
00:09:07,460 --> 00:09:11,510
Así que con esto ya estamos terminando nuestro ejercicio para poder proporcionar todos los valores de

137
00:09:11,510 --> 00:09:15,080
manera dinámica en la creación y llenado de nuestra matriz.

138
00:09:15,380 --> 00:09:20,180
Este ejercicio es muy importante ya que con eso tienen la base para el trabajo con matrices, pero sobre

139
00:09:20,180 --> 00:09:22,700
todo la creación de matrices de manera dinámica.

140
00:09:22,910 --> 00:09:26,600
Así que con eso pueden crear ya cualquier matriz de cualquier tamaño que necesiten.

141
00:09:27,110 --> 00:09:28,430
Bien, eso es todo por esta lección.

142
00:09:28,430 --> 00:09:30,800
Pónganlo en práctica y nos vemos en el siguiente vídeo.

143
00:09:30,980 --> 00:09:31,580
Saludos.
