23 Matrices irregulares o dentadas

C# nos permite crear irregulares o dentadas. Se dice que una matriz es irregular si la cantidad de elementos de cada fila varía. Luego podemos imaginar una matriz irregular:




Como podemos ver la fila cero tiene reservado dos espacios, la fila uno reserva espacios y la última fila reserva espacio para tres componentes.


La sintaxis para declarar una matriz irregular es:

int [][] mat;

Primero creamos la cantidad de dejando vacío el espacio que indica la cantidad de columnas:

mat=new int[3][];

Luego debemos ir creando cada fila de la matriz indicando la cantidad de elementos de la respectiva fila:

mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];

Luego la forma para acceder a sus componentes debe ser utilizando corchetes abiertos y cerrados para cada índice:

mat[0][0]=120;

Dará un error si queremos cargar la tercer componente de la fila cero (esto debido a que no existe):

mat[0][2]=230;

Luego si queremos saber la cantidad de filas que tiene la matriz:

Console.Write(mat.Length);

Si queremos saber la cantidad de elementos de una determinada fila:

Console.Write("Cantidad de elementos de la fila 0:"+mat[0].Length);
Console.Write("Cantidad de elementos de la fila 1:"+mat[1].Length);
Console.Write("Cantidad de elementos de la fila 2:"+mat[2].Length);

Problema 1:

Confeccionaremos un programa que permita crear una matriz irregular y luego imprimir la matriz en .

Programa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MatrizIrregular1
{
    class MatrizIrregular1
    {
        private int[][] mat;
    
        public void Cargar() 
        {
            Console.Write("Cuantas fila tiene la matriz:");
            string linea=Console.ReadLine();
            int filas=int.Parse(linea);
            mat=new int[filas][];
            for(int f = 0; f < mat.Length; f++)
            {
                Console.Write("Cuantas elementos tiene la fila " + f + ":");
                linea = Console.ReadLine();
                int elementos=int.Parse(linea);
                mat[f]=new int[elementos];            
                for(int c = 0; c < mat[f].Length; c++) 
                {
                    Console.Write("Ingrese componente:");
                    linea=Console.ReadLine();
                    mat[f][c]=int.Parse(linea);
                }
            }
        }
    
        public void Imprimir() 
        {
            for(int f = 0; f < mat.Length; f++)
            {
                for(int c = 0; c < mat[f].Length; c++)
                {
                    Console.Write(mat[f][c]+" ");
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    
        static void Main(string[] args)
        {
            MatrizIrregular1 ma = new MatrizIrregular1();
            ma.Cargar();
            ma.Imprimir();
        }
    }
}

Primero creamos la cantidad de filas que tendrá la matriz (en los corchetes columnas no disponemos valor):

            Console.Write("Cuantas fila tiene la matriz:");
            string linea=Console.ReadLine();
            int filas=int.Parse(linea);
            mat=new int[filas][];

Dentro del primer for pedimos que ingrese la cantidad de elementos que tendrá cada fila y utilizamos el operador new nuevamente, pero en este caso se están creando cada fila de la matriz (C# trata a cada fila como un vector):

                Console.Write("Cuantas elementos tiene la fila " + f + ":");
                linea = Console.ReadLine();
                int elementos=int.Parse(linea);
                mat[f]=new int[elementos];            

Dentro del for interno hacemos la carga de las componentes propiamente dicho de la matriz (podemos ir cargando cada fila a medida que las vamos creando):

                for(int c=0;c < mat[f].Length;c++) 
                {
                    Console.Write("Ingrese componente:");
                    linea=Console.ReadLine();
                    mat[f][c]=int.Parse(linea);
                }

Luego imprimimos la matriz en forma teniendo cuidado las condiciones que disponemos en cada for.
El primer for se repite tantas veces como filas tiene la matriz: f<mat.Length y
el for interno se repite tantas veces como elementos tiene la fila que estamos procesando c<mat [f].Length:

            for(int f = 0; f < mat.Length; f++)
            {
                for(int c = 0; c < mat[f].Length; c++)
                {
                    Console.Write(mat[f][c]+" ");
                }
                Console.WriteLine();
            }

Problemas propuestos

1. Confeccionar una clase para administrar una matriz irregular de 5 filas y 1 columna la primer fila, 2 columnas la segunda fila y así sucesivamente hasta 5 columnas la última fila (crearla sin la intervención del operador)
   Realizar la carga por teclado e imprimir posteriormente.
2. Confeccionar una clase para administrar los días que han faltado los 3 empleados de una empresa.
   Definir un vector de 3 elementos de tipo string para cargar los nombres y una matriz irregular para cargar los días que han faltado cada empleado (cargar el número de día que faltó)
   Cada fila de la matriz representan los días de cada empleado.
   Mostrar los empleados con la cantidad de inasistencias.
   Cuál empleado faltó menos días.