C :: Aufgabe #44

3 Lösungen Lösungen öffentlich

Matrizen um 90 Grad drehen

Anfänger - C von pocki - 11.11.2013 um 16:38 Uhr
Erstelle ein Programm, welches als Eingabe eine Matrix beliebiger Größe entgegennimmt und diese dann um 90 Grad dreht.

Beispiel an einer 4x4 Matrix:
Eingabematrix mit den Elementen:
a11 a12 a13 a14
a21 a22 a23 a24
a31 a32 a33 a34
a41 a42 a43 a44

sollte diese Ausgabematrix erzeugen:
a41 a31 a21 a11
a42 a32 a22 a12
a43 a33 a23 a13
a44 a34 a24 a14

Das Programm sollte für unterschiedlich großen und auch mit nicht quadratischen Matrizen funktionieren.

Lösungen:

vote_ok
von devnull (8870 Punkte) - 24.11.2013 um 17:56 Uhr
Quellcode ausblenden C-Code
/****************************************
  * matrot.c   Matrix rotieren
  * devnull    23-11-2013
  ****************************************/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

/*
   Originalmatrix : M x N
   rotierte Matrix: N x M
*/ 
#define ARRAY_SIZE 10  
#define M 4            
#define N 5

void mtx_print(int a[][ARRAY_SIZE], int m, int n)
{
	int i,j;

	for (i=0; i<m; i++) {
		for (j=0; j<n; j++)
			printf("%4d", a[i][j]);
		printf("\n");
	}
    printf("\n");	
}

void mtx_fill(int a[][ARRAY_SIZE], int m, int n)
{
	int i,j;

    srand(time(NULL));	
	for (i=0; i<m; i++)
		for (j=0; j<n; j++)
			a[i][j] = rand() & 0777;
}

void mtx_rotate(int a[][ARRAY_SIZE], int b[][ARRAY_SIZE], int m, int n)
{
	int i,j;

	for (i=0; i<m; i++)
		for (j=0; j<n; j++)
			b[j][m-i-1] = a[i][j];
}
 
int main( int argc, char **argv )
{
	int a[ARRAY_SIZE][ARRAY_SIZE];
	int b[ARRAY_SIZE][ARRAY_SIZE];
	
	mtx_fill(a, M, N);
	mtx_print(a, M, N);
	mtx_rotate(a, b, M, N);
	mtx_print(b, N, M);
    return 0;
}
vote_ok
von 0.bit.0 (50 Punkte) - 07.03.2014 um 15:09 Uhr
Quellcode ausblenden C-Code
/*
 * Dieses kleine Programm soll als erstes zwei Parameter entgegen nehmen, die die Dimension der 
 * Matrix festlegen. Anschliessend sollen die Zahlen in der Reihenfolge: Zeile 1, Spalte 1,
 * Zeile 1,Spalte 2, ...Zeile m, Spalte n eingelesen werden. Dann wird einmal zur Kontrolle
 * die Ursprungsmatrix ausgegeben. Dann wird die Matrix um 90 Grad (nach rechts) gedreht und ausgegeben.
 */

#include <stdio.h>

// Diese Funktion gibt einfach einen als zweidimensionales Array uebergebenen Wert in Matrixform aus.
void return_matrix (int *p, int z, int s){
	int i, j;
	for (i = 0; i < z; i++){
		for (j = 0; j < s; j++){
			printf ("%d ",*p++);
		}
		printf ("\n");
	}
}

// Diese Funktion dreht ein zweidimensionales Array und gibt es aus
void drehe_matrix (int *g, int z, int s){
	int tmp_array [s][z];
	int i,j;
	for (i = 0; i < z; i++){
		for (j = 0; j < s; j++){
			tmp_array[j][z-(i+1)] = *g++;
		}
	}
	return_matrix (tmp_array[0],s,z);
}


/* Mit dieser Funktion wird das zweidimensionale Array mit Werten (durch Benutzereingaben) gefuellt.
 * Anschliessend werden die Funktionen zur Ausgabe und die zum Drehen des Array aufgerufen.
 */
void mach_array (int z, int s){
	int gesamt [z][s];
	int i;
	for (i = 0; i < z; i++){
		int j;
		for (j = 0; j < s; j++){
			printf ("Bitte geben Sie nun den Wert fuer die %d Zeile und die %d Spalte ein\n", (i+1), (j+1));
			scanf ("%i", &gesamt [i][j]);
			getchar();
		}
	}
	printf ("Matrix im Urzustand: \n");
	return_matrix (gesamt[0],z,s);
	printf ("\nUnd die Matrix in dem um 90 Grad nach rechts gedrehten Zustand:\n");
	drehe_matrix (gesamt[0],z,s);
}

/*Diese Funktion nimmt zwei Benutzereingaben zur Dimensionierung entgegen und 
*ruft dann die Funktion mach_Array auf
*/

void mk_array (){
	int zeile, spalte;
	printf ("Geben Sie bitte die Zeilenanzahl ein: \n");
	scanf ("%i",&zeile);
	getchar();
	printf ("Die Zeilenanzahl ist: %i\n",zeile);
	printf ("\nGeben Sie nun bitte die Spaltenanzahl ein: \n");
	scanf ("%i", &spalte);
	getchar();
	printf ("Die Spaltenanzahl ist: %i\n\n", spalte);
	mach_array (zeile,spalte);
}

int main (){
	mk_array();
	return 0;
}
vote_ok
von zefcat (290 Punkte) - 15.12.2016 um 16:20 Uhr
Quellcode ausblenden C-Code
#include <stdio.h>

int main ()
{

    char matrix_1 [4][4] = {"----","-o--","ooo-","----"};
    char matrix_2 [4][4] = {"----","-oo-","oo--","----"};
    char matrix_3 [4][4] = {"----","-o--","-o--","-oo-"};
    char matrix_4 [4][4] = {"--o-","--o-","--o-","--o-"};

    char matrixsafe_1 [4][4];
    char matrixsafe_2 [4][4];
    char matrixsafe_3 [4][4];
    char matrixsafe_4 [4][4];

    int turn_counter = 0;
    int rotate_counter = 0;
    int first;
    int second;




    for(turn_counter=0; turn_counter<5; turn_counter++)
    {

        for(first = 0; first < 4; first++)
        {

        for(second = 0; second < 4; second++)
            {
                printf("%c ",matrix_1[first][second]);
            }
            printf(" ");

            for (second = 0; second < 4; second++)
            {
                printf("%c ",matrix_2[first][second]);
            }printf(" ");

            for (second = 0; second < 4; second++)
            {
                printf("%c",matrix_4[first][second]);
                if (second<3)
                {
                    printf(" ");
                }
            }
            printf("\n");
        }
            if (turn_counter >= 4)
            {
                break;
            }
        printf("\n");

        for (first = 0; first < 4; first++)
        {

            for (second = 0; second < 4; second++)
            {
                matrixsafe_1[first][second] = matrix_1[first][second];
                matrixsafe_2[first][second] = matrix_2[first][second];
                matrixsafe_3[first][second] = matrix_3[first][second];
                matrixsafe_4[first][second] = matrix_4[first][second];
            }
        }

        for (first = 0; first < 4; first++)
        {
            rotate_counter = 3;
            for (second = 0; second < 4; second++)
            {
                matrix_1[first][second] = matrixsafe_1[rotate_counter][first];
                matrix_2[first][second] = matrixsafe_2[rotate_counter][first];
                matrix_3[first][second] = matrixsafe_3[rotate_counter][first];
                matrix_4[first][second] = matrixsafe_4[rotate_counter][first];
                rotate_counter--;
            }
        }
    }

    return 0;
}