tp5

Trabajo Práctico Número 5: Arreglos Bidimensionales

Aquí vas a encontrar algunos ejercicios de Arreglos Bidimensionales o comunmente llamados arrays de dos dimensiones, además de conocer que pueden adoptar la multidimensionalidad.
  • Generar matrices

Diseñar un programa que pida la dimensión n de una matriz cuadrada n*n, y
luego dé a elegir entre las siguientes opciones:

- Generar una matriz en espiral:

1 2 3 4 5 6 7 8 9
32 33 34 35 36 37 38 39 10
31 56 57 58 59 60 61 40 11
30 55 72 73 74 75 62 41 12
29 54 71 80 81 76 63 42 13
28 53 70 79 78 77 64 43 14
27 52 69 68 67 66 65 44 15
26 51 50 49 48 47 46 45 16
25 24 23 22 21 20 19 18 17

-Generar una matriz en ángulo recto:

1 2 3 4 5 6 7 8 9
2 2 3 4 5 6 7 8 9
3 3 3 4 5 6 7 8 9
4 4 4 4 5 6 7 8 9
5 5 5 5 5 6 7 8 9
6 6 6 6 6 6 7 8 9
7 7 7 7 7 7 7 8 9
8 8 8 8 8 8 8 8 9
9 9 9 9 9 9 9 9 9

-Generar una matriz en diagonal:

1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 8
3 4 5 6 7 8 9 8 7
4 5 6 7 8 9 8 7 6
5 6 7 8 9 8 7 6 5
6 7 8 9 8 7 6 5 4
7 8 9 8 7 6 5 4 3
8 9 8 7 6 5 4 3 2
9 8 7 6 5 4 3 2 1

-Generar una matriz en antidiagonal:

1 2 3 4 5 6 7 8 9
2 1 2 3 4 5 6 7 8
3 2 1 2 3 4 5 6 7
4 3 2 1 2 3 4 5 6
5 4 3 2 1 2 3 4 5
6 5 4 3 2 1 2 3 4
7 6 5 4 3 2 1 2 3
8 7 6 5 4 3 2 1 2
9 8 7 6 5 4 3 2 1

/*Programa que genera una matriz cuadrada*/
/*Posibilidades: espiral, angulo recto, diagonal, antidiagonal*/
/*Utiliza las funciones genera_cuadrado, espiral, diag, adiag, lista_matriz*/
#include <stdio.h>
 
/*Maximo tamaño de la matriz: 20*20*/
#define MAXCOL 20
#define MAXFIL 20
 
/*Funcion que genera una vuelta de la espiral*/
int genera_cuadrado(int m[MAXFIL][MAXCOL], int cont, int n, int num)
{
    /*cont es el numero de cuadrados introducidos ya en la matriz*/
    /*n es la longitud del lado del cuadrado*/
    /*num es el numero a introducir en cada momento*/
 
    int i=cont, j=cont;
 
    /*Introduce el lado superior del cuadrado: tiene longitud n*/
    while(j<(cont+n))
    {
        m[i][j]=num;
        num++;
        j++;
    }
    /*j acaba desfasada*/
    j--;
    /*se continuara en la fila inferior: i=cont+1*/
    i++;
 
    /*Introduce el lado derecho del cuadrado: tiene longitud n-1*/
    while(i<(cont+n))
    {
        m[i][j]=num;
        num++;
        i++;
    }
    /*i acaba desfasada*/
    i--;
    /*se continuara en la columna anterior: j=cont+n-2*/
    j--;
 
    /*Introduce el lado inferior del cuadrado: tiene longitud n-1*/
    while(j>=cont)
    {
        m[i][j]=num;
        num++;
        j--;
    }
    /*j acaba desfasada*/
    j++;
    /*se continuara en la fila superior: i=cont+n-2*/
    i--;
 
    /*Introduce el lado izquierdo del cuadrado: tiene longitud n-2*/
    while(i>cont)
    {
        m[i][j]=num;
        num++;
        i--;
    }
    return(num);
}
 
/*Funcion que genera una matriz en espiral*/
void espiral(int m[MAXFIL][MAXCOL], int dim)
{
    /*num es el numero introducido en la casilla inicial del cuadrado*/
    /*cont es el numero de vueltas introducidas*/
    /*n es la longitud del lado del cuadrado*/
    int num=1, cont=0, n=dim;
 
    while(n>1)
    {
        /*Se genera una vuelta de la espiral*/
        num=genera_cuadrado(m,cont,n,num);
        cont++;
 
        /*Se han introducido 2 hileras y 2 columnas, por lo tanto*/
        /*el lado del siguiente cuadrado se reduce en dos unidades*/
        n-=2;
    }
 
    if(n==1)/*solo queda introducir el centro de la espiral*/
        m[dim/2][dim/2]=num;
 
    /*si n==0, ya no queda introducir nada*/
}
 
/*Funcion que genera una matriz en angulo recto*/
void angulo_recto(int m[MAXFIL][MAXCOL], int n)
{
    int i, j;
 
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        {
            /*La casilla esta en la diagonal o en el lado vertical*/
            if(i>=j)
                m[i][j]=i+1;
 
            /*La casilla esta en el lado horizontal*/
            else
                m[i][j]=j+1;
        }
}
 
/*Funcion que genera una matriz paralelamente a la diagonal*/
void diag(int m[MAXFIL][MAXCOL], int n)
{
    int i, j, num;
    /*num es el numero a introducir en la matriz en todo momento*/
 
    /*se introducen los numeros de debajo de la diagonal*/
    for(num=n; num>1; num--)
    {
        j=0;
        for(i=(num-1);i<n;i++)
        {
            m[i][j]=num;
            j++;
        }
    }
    /*se acaba con num==1*/
 
    /*se introducen los numeros de la diagonal y de encima*/
    while(num<=n)
    {
        i=0;
        for(j=(num-1);j<n;j++)
        {
            m[i][j]=num;
            i++;
        }
        num++;
    }
}
 
 
/*Funcion que genera una matriz paralelamente a la antidiagonal*/
void adiag(int m[MAXFIL][MAXCOL], int n)
{
    int i, j;
 
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        {
            /*La casilla esta encima o en la antidiagonal*/
            if((i+j)<n)
                m[i][j]=i+j+1;
 
            /*La casilla esta por debajo de la antidiagonal*/
            else
                m[i][j]=(2*n)-(i+j+1);
        }
}
 
/*Funcion que lista en pantalla una matriz*/
void lista_matriz(int m[MAXFIL][MAXCOL], int n)
{
    int i, j;
 
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            printf("%d\t", m[i][j]);
 
        printf("\n\n");
    }
}
 
 
void main()
{
    char opcion='\0';
    int n, matriz[MAXFIL][MAXCOL];
 
    do{
        /*Pide la dimension*/
        printf("\nIntroduzca la dimension de la matriz:\n");
        scanf("%d%*c",&n);
 
        /*Comprueba que la dimension sea correcta*/
        if(n<1)
        printf("\nDimension no correcta\n");
 
        else if(n>MAXCOL)
            printf("\nDimension demasiado grande\n");
 
        else
        {
            /*Muestra menu y pide la opcion*/
            printf("\nElija opcion generadora:\n");
            printf("\n1. Espiral");
            printf("\n2. Angulo recto");
            printf("\n3. Diagonal");
            printf("\n4. Antidiagonal");
            printf("\n5. Finalizar programa\n\n");
 
            scanf("%c%*c",&opcion);
 
            switch (opcion)
            {
                case '1':/*Espiral*/
                    printf("\nEspiral\n");
                    espiral(matriz,n);
                    lista_matriz(matriz, n);
                    break;
 
                case '2':/*Angulo_recto*/
                    printf("\nAngulo recto\n");
                    angulo_recto(matriz, n);
                    lista_matriz(matriz, n);
                    break;
 
                case '3':/*Diagonal*/
                    printf("\nDiagonal\n");
                    diag(matriz, n);
                    lista_matriz(matriz, n);
                    break;
 
                case '4':/*Antidiagonal*/
                    printf("\nAntidiagonal\n");
                    adiag(matriz, n);
                    lista_matriz(matriz, n);
                    break;
 
                case '5':
                    printf("\nFin del programa\n");
                    break;
 
                default:
                    printf("\nOpcion incorrecta\n");
            }
        }
 
    }while(opcion!='5');
}