Hola y bienvenidos.
Vamos a realizar a continuación el ejercicio para introducir datos de manera dinámica en una matriz.
Están listos?
Vamos.
Bien.
Vamos a crear entonces el siguiente ejercicio introducir datos.
En una matriz.
Todo esto va a ser de manera dinámica, así que le vamos a pedir al usuario que proporcione cuántos
renglones y cuántas columnas va a utilizar para crear la matriz.
Y una vez que haya proporcionado estos valores, entonces de manera dinámica también le vamos a pedir
que vaya proporcionando cada uno de los valores para llenar la matriz.
Así que vamos a hacer lo siguiente En primer lugar, vamos a definir dos variables la variable de renglones
y la variable de columnas.
De momento los valores no los vamos a especificar ya que los va a proporcionar directamente el usuario.
Entonces le pedimos al usuario proporciona.
El número de renglones para la matriz y una vez que proporcione este valor utilizando la función esca
nf, lo asignamos a la variable de renglones.
Ya sabemos que como es un valor de tipo primitivo, un valor simple, un tipo simple de tipo entero,
entonces tenemos que especificar la dirección de memoria.
Por ello ponemos en primer lugar el ampersand.
Bien, vamos a hacer ahora lo mismo, pero para solicitar la cantidad de columnas.
Así que le pedimos en primer lugar un salto de línea proporciona.
El número.
De columnas.
Dos puntos.
Espacio.
Y utilizando la función escáner le vamos a proporcionar el valor.
Vamos a asignar el valor de columnas.
Y posteriormente vamos a crear la matriz con los valores que el usuario haya proporcionado.
Así que definimos nuestra matriz.
En este caso la variable se va a llamar matriz, pero se va a crear de la cantidad de renglones y la
cantidad de columnas que haya especificado el usuario.
Y como siguiente paso, una vez que ya hemos creado la matriz, vamos a introducir los valores.
Así que también de manera dinámica vamos a pedirle al usuario que llene la matriz.
Para ello vamos a tener que utilizar también un ciclo for anidado para poder iterar en primer lugar
cada uno de los renglones y de manera interna, por cada renglón, cada una de las columnas asociadas
a cada renglón que estamos iterando.
Por lo tanto, integramos nuestra matriz utilizando un ciclo for más externo y de manera interna también
agregamos otro ciclo for para controlar cada una de las columnas.
Así que el ciclo for más externo vamos a iterar.
Cada renglón inicia en cero y la condición es que vamos a iterar este ciclo for mientras la variable
de renglón sea menor que la cantidad de renglones que tenemos en nuestra matriz y posteriormente incrementamos
nuestra variable de renglón.
Ahora, de manera interna, el ciclo más interno controla las columnas.
Todo esto ya lo vimos en las lecciones anteriores, así que cualquier duda pueden revisar las lecciones
anteriores.
Con eso simplemente ya estamos recorriendo cada uno de los elementos de nuestra matriz.
Bien, aquí si ya es un poco diferente, ya que en primer lugar le vamos a pedir al usuario que proporcione
un valor respectivo según el renglón y columna que deseemos que proporcione el valor.
Así que utilizamos la función printf y entonces le pedimos al usuario el siguiente dato asignado en
el siguiente renglón y también en la columna respectiva según el valor que estemos iterando.
Así que proporcionamos las variables de renglón y también la variable de columna.
Bien y una vez que le hemos pedido al usuario este valor, cuando lo proporcione en la consola, entonces
utilizamos la función escaneo para poder leer.
Este valor es un valor de tipo entero, ya que la matriz que hemos definido también son únicamente valores
de tipo entero y debido a que vamos a acceder a un valor de tipo entero dentro de la matriz, cada una
de las celdas también es un valor de tipo entero.
Por lo tanto, debido a que es un tipo primitivo, un tipo entero, entonces también tenemos que especificar
la dirección de memoria de la celda que queremos acceder de la matriz.
Así que primero ponemos ampersand y posteriormente el identificador de nuestra matriz y de manera interna,
tanto el renglón y la columna que queremos modificar según el valor que vamos a modificar, ya que recordemos
que el usuario ha proporcionado cierto valor y entonces se va a asignar en el renglón y la columna que
estamos indicando.
Bien, hasta aquí es el código para poder introducir cada uno de los valores a nuestra matriz.
Ahora, por último, vamos a mandar a imprimir cada uno de los valores.
Así que por último, imprimimos.
Los valores de la matriz para asegurarnos que cada uno de los valores y almacenado correctamente.
De manera muy similar, vamos a utilizar dos ciclos for el ciclo for más externo para poder iterar cada
renglón y el ciclo for más interno para cada columna, como ya sabemos, así que es prácticamente el
mismo código, pero el código interno es diferente, ya que vamos a mandar a imprimir cada uno de los
valores que estamos iterando.
Así que este código es prácticamente el mismo.
Tenemos nuestro ciclo más externo para iterar cada renglón.
Posteriormente, el ciclo más interno para iterar cada columna.
Y por último, entonces mandamos a imprimir.
El valor que estamos recuperando es un valor también de tipo entero.
De momento solamente vamos a mandar a imprimir este valor, el cual se encuentra en el renglón y columna
que estamos iterando en este momento.
Bien, vamos a dar un poco más de formato a esta salida, pero de momento vamos a ver si todo está funcionando
correctamente.
Vamos a ejecutar y entonces nos pide proporcional el número de renglones.
Vamos a trabajar con los valores que hemos visto ya en nuestro ejemplo anterior, pero obviamente ustedes
pueden proporcionar cualquier cantidad de valores bien proporcionado, el valor de dos renglones, posteriormente
dos columnas, y entonces nos empieza a solicitar cada uno de los datos.
Por ejemplo, en este caso, si proporcionamos dos renglones y tres columnas, entonces en memoria se
crea esta matriz de dos renglones por tres columnas y para el renglón cero, columna cero.
Si asignamos el valor de 100 y damos enter, entonces podemos llevar en nuestra animación que se asigna
el valor de 100 en el renglón cero, columna cero.
Y así continuamos.
Como hemos comentado, ustedes pueden proporcionar cualquier otro valor, pero simplemente es para que
tengamos una referencia según el ejemplo que ya hemos venido trabajando.
Así que para el renglón cero, columna uno, asignamos el valor de 200.
Posteriormente el valor de 300.
Y termina la primera iteración del ciclo más interno.
Ya se recorrieron todas las columnas.
Cambiamos ahora de renglón.
Es decir que ya continuamos con la siguiente iteración del ciclo for más externo.
Y ahora, si asignamos el valor de 400, observamos que para el renglón uno columna cero se asigna el
valor de 400 y así continuamos con los demás elementos, se asigna el valor de 500 y por último el valor
de 600.
Y entonces observamos que en memoria ya se creó nuestra matriz correctamente.
Bien, por último, como hemos comentado, simplemente se está mandando a imprimir cada uno de los valores
que hemos almacenado en nuestra matriz, simplemente para comprobar que la información sea almacenado
correctamente en memoria.
Y vamos a dar un formato aquí para saber qué es lo que se está imprimiendo.
En primer lugar.
Agregamos un pequeño texto.
Impresión de la matriz.
Con tres guiones y posteriormente nuestra impresión de manera más interna.
Vamos a llegar a un salto de línea.
Vamos a imprimir cada valor.
En primer lugar ponemos el nombre de matriz y posteriormente especificamos cuál es el renglón y también
cuál es la columna que vamos a mandar a imprimir y posteriormente recordemos que esto simplemente es
una cadena.
Mandamos a imprimir el valor que estamos recuperando, pero nos falta proporcionar las variables de
renglón y columna.
Así que simplemente estamos mandando imprimir el renglón, posteriormente la columna y finalmente el
valor que estamos recuperando del renglón y columna almacenado en nuestra matriz.
Así que ya estamos agregando este pequeño formato.
Y por último, recordemos que si queremos que cada renglón se imprima en una línea distinta, entonces
al terminar el ciclo for más interno, simplemente mandamos a imprimir también un salto de línea.
Bien, con esto prácticamente ya tenemos toda nuestra información.
Y por último, agregamos un salto de línea al inicio para que cada uno de esos elementos se imprima
en una nueva línea.
Bien, ya tenemos todo nuestro código.
Vamos a volver a ejecutar y vamos a comprobar el número de renglones es dos, el número de columnas
tres y empezamos a proporcionar los valores según lo que ya hemos visto anteriormente.
Y entonces podemos observar que hemos proporcionado todos estos valores dinámicamente, incluyendo los
renglones y las columnas.
Obviamente, ustedes pueden proporcionar cualquier otro valor, y para la impresión de la matriz leemos
cada valor.
Así que para el renglón cero y cada una de las columnas, estamos recuperando todos los valores relacionados
a este renglón con cada columna.
Y por otro lado, cambiamos de pivote el renglón uno.
Con cada una de sus columnas obtenemos también los valores respectivos 400, 500 y 600.
Así que con esto ya estamos terminando nuestro ejercicio para poder proporcionar todos los valores de
manera dinámica en la creación y llenado de nuestra matriz.
Este ejercicio es muy importante ya que con eso tienen la base para el trabajo con matrices, pero sobre
todo la creación de matrices de manera dinámica.
Así que con eso pueden crear ya cualquier matriz de cualquier tamaño que necesiten.
Bien, eso es todo por esta lección.
Pónganlo en práctica y nos vemos en el siguiente vídeo.
Saludos.