Tag Archives: MAX

C-Programm – Matrix-Addition

Mit diesen kleinen Programmen kann man Matrix-Addition durchführen, indem die Werte der Matrizen jeweils zusammengerechnet werden. In dem zweiten Programm habe ich mit Funktionen und Pointeren gearbeitet.

/*
 ============================================================================
 Name        : matrix-addition_1.c
 Author      : Voku
 Version     : 1.0
 Description : Matrix-Addition
 ============================================================================
 */

#include <stdio.h>
#define MAX_ZEILEN 10
#define MAX_SPALTEN 10

int main (void) {
	int index_zeile, zeile, index_spalte, spalte;
	double array_a[MAX_ZEILEN][MAX_SPALTEN], array_b[MAX_ZEILEN][MAX_SPALTEN], array_c[MAX_ZEILEN][MAX_SPALTEN];

	// Anzahl der Zeilen einlesen
	do {
		printf("Anzahl der Zeilen (1-%i): ",MAX_ZEILEN);
		scanf("%i",&zeile);
		if (zeile > MAX_ZEILEN ) {
			printf("\n zu viel Zeilen...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Zeilen...\n\n");
		}
	} while (zeile > MAX_ZEILEN || zeile < 1);
	printf("\n");
	// Anzahl der Spalten einlesen
	do {
		printf("Anzahl der Spalten (1-%i): ",MAX_SPALTEN);
		scanf("%i",&spalte);
		if (spalte > MAX_SPALTEN ) {
			printf("\n zu viel Spalten...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Spalten...\n\n");
		}
	} while (spalte > MAX_SPALTEN || spalte < 1);
	printf("\n");

	// Werte fuer Matrize 1 einlesen
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
  			printf("Wert fuer Zeile %i und Spalte %i (Matrize 1) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_a[index_zeile][index_spalte]);
    		}
    	}
	printf("\n");
    	// Werte fuer Matrize 2 einlesen
    	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 2) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_b[index_zeile][index_spalte]);
    		}
    	}

	// Array A und B addieren und in Array C schreiben
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
        		array_c[index_zeile][index_spalte]=array_a[index_zeile][index_spalte]+array_b[index_zeile][index_spalte];
    		}
	}

	// Ausgabe
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
        		printf(" %.2lf", array_a[index_zeile][index_spalte]);
        	}
		printf(" ) ");
	}
	printf("\n\n +\n");
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", array_b[index_zeile][index_spalte]);
		}
		printf(" ) ");
	}
	printf("\n\n =\n");
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", array_c[index_zeile][index_spalte]);
    		}
		printf(" ) ");
	}

	return 0;
}
/*
 ============================================================================
 Name        : matrix-addition_2.c
 Author      : Voku
 Version     : 1.0
 Description : Matrix-Addition mit Funktionen (+Pointer)
 ============================================================================
 */

#include <stdio.h>
#define MAX_ZEILEN 10
#define MAX_SPALTEN 10

void matrix_addition (double *array_a, double *array_b, double *array_c, int zeile, int spalte) {
	int index_zeile, index_spalte;
	// printf("*array_a %lf\n*array_b %lf\n*array_c %lf\n", *array_a, *array_b, *array_c); // TEST-Ausgabe
	for(index_zeile=0; index_zeile < zeile; index_zeile++) {
		for(index_spalte=0; index_spalte < spalte; index_spalte++) {
			*(array_c + (index_zeile * spalte) + index_spalte) = *(array_a + (index_zeile * spalte) + index_spalte) + *(array_b + (index_zeile * spalte) + index_spalte);
		}
		printf("\n");
	}
}

void matrix_ausgabe (double *matrix, int zeile, int spalte) {
	int index_zeile, index_spalte;
	// printf("*matrix %lf", *matrix); // TEST-Ausgabe
	printf("\n\n");
	for(index_zeile=0; index_zeile < zeile; index_zeile++) {
		for(index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", *(matrix + (index_zeile * spalte) + index_spalte));
		}
		printf("\n");
	}
}

int main (void) {
	int index_zeile, zeile, index_spalte, spalte;

	// Anzahl der Zeilen einlesen
	do {
		printf("Anzahl der Zeilen (1-%i): ",MAX_ZEILEN);
		scanf("%i",&zeile);
		if (zeile > MAX_ZEILEN ) {
			printf("\n zu viel Zeilen...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Zeilen...\n\n");
		}
	} while (zeile > MAX_ZEILEN || zeile < 1);
	printf("\n");
	// Anzahl der Spalten einlesen
	do {
		printf("Anzahl der Spalten (1-%i): ",MAX_SPALTEN);
		scanf("%i",&spalte);
		if (spalte > MAX_SPALTEN ) {
			printf("\n zu viel Spalten...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Spalten...\n\n");
		}
	} while (spalte > MAX_SPALTEN || spalte < 1);
	printf("\n");

	double array_a[zeile][spalte], array_b[zeile][spalte], array_c[zeile][spalte];

	// Werte fuer Matrize 1 einlesen
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 1) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_a[index_zeile][index_spalte]);
    		}
	}
    	printf("\n");
    	// Werte fuer Matrize 2 einlesen
    	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 2) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_b[index_zeile][index_spalte]);
    		}
	}

	// printf("zeile + spalta: %i, %i", zeile, spalte); // TEST-Ausgabe

	// Array A und B addieren und in Array C schreiben
	matrix_addition(&array_a[0][0], &array_b[0][0], &array_c[0][0], zeile, spalte);

	// Ausgabe
	matrix_ausgabe(&array_a[0][0], zeile, spalte);
	printf("\n +");
	matrix_ausgabe(&array_b[0][0], zeile, spalte);
	printf("\n =");
	matrix_ausgabe(&array_c[0][0], zeile, spalte);

	return 0;
}

C-Programm – Skalarprodukt

Hier ein kleines Programm, welches das Skalarprodukt von zwei Vektoren berechnet…

/*
 ============================================================================
 Name        : Skalarprodukt.c
 Author      : Voku
 Version     : 1.0
 Description : Skalarprodukt zweier Vektoren
 ============================================================================
 */

#include <stdio.h>
#define MAX 10

int main(void) {
    double vektor1[MAX],vektor2[MAX];  	// Arrays fuer Vektoren (1 und 2)
    int anzahl;      			// Anzahl der Vektoren
    int index;       			// Wert im Array
    double produkt;     		// einzelnes Produkt
    double ergebnis=0.0;  		// Gesamtwert aller Produkte

    printf("Skalarprodukt (innere Produkt) zweier beliebiger Vektoren berechnen:\n\n");

    do {
    	printf("Anzahl der Elemente pro Vektordimension (1-%i):" ,MAX);
        scanf("%i",&anzahl);
        if (anzahl > MAX ) {
        	printf("\n zu viel Dimension...\n\n");
        } else if (anzahl < 1) {
        	printf("\n zu wenig Dimension...\n\n");
        }
    } while (anzahl > MAX || anzahl < 1);

    // Vektorwerte fuer Vektor 1 einlesen
    for (index=0; index < anzahl; index++) {
    	printf("Wert %i fuer Vektor 1 eingeben: ",index+1);
    	scanf("%lf",&vektor1[index]);
    }
    // Vektorwerte fuer Vektor 2 einlesen
    for (index=0; index < anzahl; index++) {
    	printf("Wert %i fuer Vektor 2 eingeben: ",index+1);
    	scanf("%lf",&vektor2[index]);
    }

    // Berechnung des Skalarproduktes
    for(index=0; index < anzahl; index++) {
    	produkt = vektor1[index] * vektor2[index];
    	ergebnis += produkt;
    }

    // Ausgabe
    printf("Skalarprodukt: %.4lf\n",ergebnis);

    return 0;
}

C-Programm – Funktionen

Dies kurze Beispiel zeigt das Prinzip von Funktionen… und wie man das Maximum von drei Zahlen ausgibt. ;-)

#include <stdio.h>

// Funktion_1: max_1 (Maximum) mit drei Eingaengen
int max_1 (int a, int b, int c) {
	if(a>b && a>c)
		return a;
	else if(b>a && b>c)
		return b;
	else
		return c;
}

// Funktion_2: max_2 (Maximum) mit zwei Eingaengen
int max_2 (int a, int b) {
	if(a>b)
		return a;
	else
		return b;
}

int main (void){

	int a,b,c,max_3;

	printf("a");
	scanf("%d",&a);
	printf("b");
	scanf("%d",&b);
	printf("c");
	scanf("%d",&c);

	// Funktion_1
	printf ("%d", max_1(a,b,c));

	// Funktion_2 (wird 2-mal ineinander ausgefuehrt)
	printf ( "%d", max_2(max_2(a,b),c) );

	// alles in einer Zeile :-)
	max_3 = (a>b) ? ((a>c) ? a : c) : ((b>c) ? b : c);
	printf("%d", max_3);

	return (0);
}

C-Programm – Größe von Variablen

Mit diesem kleinem Programm kannst du dir die minimale und maximale Größe von Variablen ausgeben lassen. :-)

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
        printf("min. char-Wert          : %d\n", SCHAR_MIN);
        printf("max. char-Wert          : +%d\n", SCHAR_MAX);
        printf("min. unsigned-char      : 0\n");
        printf("max. unsigned-char      : %u\n\n", UCHAR_MAX);

        printf("min. short-Wert         : %d\n", SHRT_MIN);
        printf("max. short-Wert         : +%d\n", SHRT_MAX);
        printf("min. unsigned-short     : 0\n");
        printf("max. unsigned-short     : %u\n\n", USHRT_MAX);

        printf("min. int-Wert           : %d\n", INT_MIN);
        printf("max. int-Wert           : +%d\n", INT_MAX);
        printf("min. unsigned-int       : 0\n");
        printf("max. unsigned-int       : %u\n\n", UINT_MAX);

        printf("min. long-Wert          : %ld\n", LONG_MIN);
        printf("max. long-Wert          : +%ld\n", LONG_MAX);
        printf("min. unsigned-long      : 0\n");
        printf("max. unsigned-long      : %lu\n\n", ULONG_MAX);

        printf("min. long long-Wert     : %lld\n", LLONG_MIN);
        printf("max. long long-Wert     : +%lld\n", LLONG_MAX);
        printf("min. unsigned-llong     : 0\n");
        printf("max. unsigned-llong     : %llu\n\n", ULLONG_MAX);


        printf("min. float-Wert         : %f\n", FLT_MIN);
        printf("max. float-Wert         : +%f\n", FLT_MAX);
        printf("float Genauigkeit       : %d\n\n", FLT_DIG);

        printf("min. double-Wert        : %lf\n", DBL_MIN);
        printf("max. double-Wert        : +%lf\n", DBL_MAX);
        printf("double Genauigkeit      : %d\n\n", DBL_DIG);

        printf("min. long double        : %Lf\n", LDBL_MIN);
        printf("max. long double        : +%Lf\n", LDBL_MAX);
        printf("long double Genu.       : %d\n\n", LDBL_DIG);

        return 0;
}


Ausgabe:

min. char-Wert : -128
max. char-Wert : +127
min. unsigned-char : 0
max. unsigned-char : 255

min. short-Wert : -32768
max. short-Wert : +32767
min. unsigned-short : 0
max. unsigned-short : 65535

min. int-Wert : -2147483648
max. int-Wert : +2147483647
min. unsigned-int : 0
max. unsigned-int : 4294967295

min. long-Wert : -2147483648
max. long-Wert : +2147483647
min. unsigned-long : 0
max. unsigned-long : 4294967295

min. long long-Wert : -9223372036854775808
max. long long-Wert : +9223372036854775807
min. unsigned-llong : 0
max. unsigned-llong : 18446744073709551615

min. float-Wert : 0.000000
max. float-Wert : +340282346638528859811704183484516925440.000000
float Genauigkeit : 6

min. double-Wert : 0.000000
max. double-Wert : +179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889[...]

min. long double : 0.000000
max. long double : +1189731495357231765021263853030970205169063322294624200440323733891737005522970722616410290336528882853545697807495577314427443153670[...]


Wenn du das nächste C-Programm einmal kompiliert hast und es mehrere male nacheinander ausführst siehst du, dass die Variable ggf. an einer anderen Stelle im Speicher abgelegt wurde.

#include <stdio.h>

int main(void) {
        int var=0;
        printf("Die Adresse von var lautet: %p\n", &var);
        return 0;
}