Cuando tenemos que resolver un ejercicio en c# con matrices lo primero es definir la estructura general, es decir sabemos que vamos a tener al menos dos métodos, una sección para ir declarando variables, una sección para realizar cálculos y una sección donde devolveremos los resultados a mostrar por pantalla.

El siguiente paso es practicar diferentes operaciones por ejemplo:

  1. Seleccionar el vector de la fila n de la matriz.
  2. Hacer algún calculo con esa fila (vector), por ej.:
    1. Suma de las filas, sin ordenar
    2. Suma de las filas, ordenadas.
    3. Contar los números pares que tienen el vector.
    4. Seleccionar todos los valores del vector, sin ordenar.
    5. Seleccionar todos los valores del vector, ordenados.
  3. Realizar cálculos con la matriz completa, por ej.:
    1. Sumar todos sus elementos, excepto la primera columna.
    2. Los elementos de la primera columna, almacenarlos en un vector que declare.
    3. Seleccionar la cantidad de elementos sumados de la matriz.
    4. Calcular el promedio de la matriz sin la primera columna.
    5. Seleccionar el número mayor de la matriz.
    6. Seleccionar la posición dentro de la matriz del número mayor.
    7. Seleccionar el número menor de la matriz.
    8. Seleccionar la posición dentro de la matriz del número menor.
    9. Seleccionar el promedio de la matriz.
  4. Mostrar todos los resultados por pantalla

Una vez que tenemos la estructura general y los cálculos por separado, es importante conocer las estructuras de bucle ya que van a ser necesarias para recorrer nuestra matriz de una forma más óptima (ojo pueda que ya los hayas utilizado en el paso anterior y eso es justo lo queremos).

Finalmente es el momento de «juntar todo» y dejar un mini programita funcionando al cual luego le podemos dar «alma» por ejemplo supongamos que somos un meteorólogo y queremos guardar en el ordenador la temperatura que ha hecho cada
hora del día de hoy.

Ahora bien, ¿Cómo lo hacemos? Veamos…

Array en C#

¿Qué es un array?
La definición sería algo así:
Un array es un conjunto de variables del mismo tipo que tienen el mismo nombre y se diferencian en el índice. Es decir un array se corresponde con un vector matemática, en el cuál el índice es la posición dentro del array.

Luego sabemos que una matriz es un conjunto de vectores, lo que en programación llamamos array multidimensional que es realmente lo que vamos a declarar y manipular en estos ejemplos.

Declaración de un Array

La forma general de declarar un array es la siguiente: tipo_de_dato nombre_del_array[ dimensión ];
El tipo_de_dato es uno de los tipos de datos conocidos (int, char, float…) o de los definidos por el usuario con typdef. Por ej. int
El nombre_del_array es el nombre que damos al array, por ejemplo temp.
La dimensión es el número de elementos que tiene el array, que podemos definirlo o bien tomarlo desde una caja de texto por pantalla.
Al declarar un array reservamos en memoria tantas variables del tipo_de_dato como las indicadas en dimensión.

Sobre la dimensión de un Array

Es una buena práctica usar una constante con nombre para definir la dimensión ya que en el desarrollo de la solución puede que necesitemos modificar la dimensión y asignándole una constante resulta más cómodo y menos tedioso el cambio. Por ejemplo usemos la constante ELEMENTOS: int temp[ELEMENTOS];

También será útil al querer calcular el promedio de mi vector, veamos como quedaría un programa inicial «completo» para este caso:

int main()
{
int temp[ELEMENTOS];
float media;
int hora;
/* Ahora tenemos que dar el valor de cada una */
for( hora=0; hora<ELEMENTOS; hora++ )
{
printf( «Temperatura de las %i: «, hora );
scanf( «%i», &temp[hora] );
media += temp[hora];
}
media = media / ELEMENTOS;
printf( «\nLa temperatura media es %f\n», media );
}

Inicializar un array

En C se pueden inicializar los arrays al declararlos igual que hacíamos con las variables. Por ej int hojas = 34;
Pues con arrays se puede hacer:
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24,22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 14, 13, 12 };
Ahora el elemento 0 (que será el primero), es decir temperaturas[0] valdrá 15. El elemento 1 (el segundo) valdrá 18 y así con todos.

Vamos a ver un ejemplo:
#include <stdio.h>
int main()
{
int hora;
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 14, 13, 12 };
for (hora=0 ; hora<24 ; hora++ )
{
printf( «La temperatura a las %i era de %i grados.\n», hora,
temperaturas[hora] );
}
}

¿Qué pasa si metemos menos de los reservados? No pasa nada, sólo que los elementos que falten valdrán cero, y el compilador no nos avisará que hemos metido menos datos de los reservados.

¿Qué pasa si metemos más datos de los reservados? Si hacemos esto dependiendo del compilador obtendremos un error o al menos un warning (aviso). En unos compiladores el programa se creará y en otros no, pero aún así nos avisa del fallo. Nos indicará que estamos intentando guardar un dato de más y no hemos reservado memoria para él.

Si sucede el caso que no sabemos la dimensión podemos usar un método alternativo y dejar al ordenador que cuente los elementos que hemos metido y nos reserve espacio para ellos:

#include <stdio.h>
int main()
{
int hora;
/* Faltan los tres últimos elementos */
int temperaturas[] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14 };
for ( hora=0 ; hora<24 ; hora++ )
{
printf( «La temperatura a las %i era de %i grados.\n», hora,
temperaturas[hora] );
}
}

Vemos que no hemos especificado la dimensión del array temperaturas. Hemos dejado los corchetes en blanco. El ordenador contará los elementos que hemos puesto entre llaves y reservará espacio para ellos. De esta forma siempre habrá el  espacio necesario.
Para saber cuantos elementos tiene la matriz podemos usar el operador sizeof. Dividimos el tamaño de la matriz entre el tamaño de sus elementos y tenemos el número de elementos.

#include <stdio.h>
int main()
{
int hora;
int elementos;
int temperaturas[] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24, 22, 21, 20, 18, 17, 16, 17, 15, 14, 14 };

elementos = sizeof temperaturas / sizeof(int);
for ( hora=0 ; hora<elementos ; hora++ )
{
printf( «La temperatura a las %i era de %i grados.\n»,
hora, temperas[hora] );
}
printf( «Han sido %i elementos.\n» , elementos );
}

Recorrer un array

Podemos recorrer un vector con el bucle FOR como hemos visto, tenemos que tener mucho cuidado con el valor de la constante elementos, es decir asegurarnos de que sea exactamente la dimensión de nuestro array (no pasarnos) y tampoco meter datos en elementos que no existen ya que en este último caso se bloqueará el sistema.

Vectores multidimensionales

Podemos declarar vectores de más de una dimensión muy fácilmente:
int a[10][5];
float b[3][2][4];

En este ejemplo, a es una matriz de 10 × 5 enteros y b es un vector de tres dimensiones con 3 × 2 × 4 números en coma flotante.
Puedes acceder a un elemento cualquiera de los vectores a o b utilizando tantos índices como dimensiones tiene el vector: a[4][2] y b[1][0][3], por ejemplo, son elementos de a y b, respectivamente.

La inicialización de los vectores multidimensionales necesita tantos bucles anidados como dimensiones tengan éstos:

int main(void)
{

int a[10][5];
float b[3][2][4];
int i, j, k;

for (i=0; i<10; i++)
for (j=0; j<5; j++)
a[i][j] = 0;

for (i=0; i<3; i++)
for (j=0; j<2; j++)
for (k=0; k<4; k++)
b[i][j][k] = 0.0;

return 0;

}

También podes inicializar explícitamente un vector multidimensional:
int c[3][3] = { {1, 0, 0},
{0, 1, 0},
{0, 0, 1} };

Disposicion de los vectores multidimensionales en memoria

Cuando el compilador de C detecta la declaración de un vector multidimensional, reserva tantas posiciones contiguas de memoria como sea preciso para albergar todas sus celdas. Cuando accedemos a un elemento a[i][j], C sabe a qué celda de memoria acceder sumando a la dirección de a el valor (i*3+j)*4 (el 4 es el tamaño de un int y el 3 es el número de columnas).

Aun siendo conscientes de cómo representa C la memoria, nosotros trabajaremos con una representación de una matriz de 3 × 3 como ésta:

Como podes ver, lo relevante es que a es asimilable a un puntero a la zona de memoria en la que están dispuestos los elementos de la matriz.

Un ejemplo: cálculo matricial

Para ilustrar el manejo de vectores multidimensionales construiremos ahora un programa que lee de teclado dos matrices de números en coma flotante y muestra por pantalla su suma y su producto. Las matrices leídas serán de 3 × 3 y se denominarán a y b. El resultado de la suma se almacenará en una matriz s y el del producto en otra p.
Este es el programa completo:

#include <stdio.h>
#define TALLA 3

int main(void)
{
float a[TALLA][TALLA], b[TALLA][TALLA];
float s[TALLA][TALLA], p[TALLA][TALLA];
int i, j, k;

/* Lectura de la matriz a */
for (i=0; i<TALLA; i++)
for (j=0; j<TALLA; j++) {
printf («Elemento (%d, %d): «, i, j); scanf («%f», &a[i][j]);
}

/* Lectura de la matriz b */
for (i=0; i<TALLA; i++)
for (j=0; j<TALLA; j++) {
printf («Elemento (%d, %d): «, i, j); scanf («%f», &b[i][j]);
}

/* Cálculo de la suma */
for (i=0; i<TALLA; i++)
for (j=0; j<TALLA; j++)
s[i][j] = a[i][j] + b[i][j];

/* Cálculo del producto */

for (i=0; i<TALLA; i++)
for (j=0; j<TALLA; j++) {
p[i][j] = 0.0;
for (k=0; k<TALLA; k++)
p[i][j] += a[i][k] * b[k][j];
}

/* Impresión del resultado de la suma */
printf («Suma\n»);
for (i=0; i<TALLA; i++) {
for (j=0; j<TALLA; j++)
printf («%8.3f», s[i][j]);
printf («\n»);
}

/* Impresión del resultado del producto */
printf («Producto\n»);
for (i=0; i<TALLA; i++) {
for (j=0; j<TALLA; j++)
printf («%8.3f», p[i][j]);
printf («\n»);
}

return 0;
}

Este ejercicio es muy básico, sin tener en cuenta la creación de métodos para optimizar nuestro programa, pero nos sirve para enfocarnos en el cálculo.

Ejercicios resueltos de matrices con C#:

https://algoritmosyalgomas.com/ejercicios-con-matrices-en-c/

ejercicios-resueltos-con-matrices1

https://www.larebelion.com/2019/01/gestion-de-matrices-en-c.html

https://informatikosrd.blogspot.com/2011/10/ejercicios-con-matrices-en-c.html