Tag Archives: scanf

C-Programm – eulersche Zahl

Hier noch ein Beipspiel für eine Funktion, in welcher die “eulersche Zahl” zu einem bestimmten Exponenten berechnet wird…

#include <stdio.h>

/* 

Die Exponentialfunktion e^x kann als eine unendliche Reihe geschrieben werden, um sich dem Ergebnis anzunaehern!!!

------
e^x = 1 + x + x²/2! + x³/3! + x⁴/4! + ... = 1 + x + 1/2*x² + 1/6*x³ + 1/24*x⁴ + ...  
------

i! ist hier die Fakultaet von i und ist definiert als

------
i! = 1*2*3* ... *(i-1)*i
------

- 1.) die Fakultaet ist fortlaufend mit den aufsteigenden ganzen Zahlen zu multiplizieren
- 2.) die Potenz ist fortlaufend mit Exponenten zu multiplizieren
- 3.) die Summanden koennen aus Fakultaet & Potenz berechnet werden
- 4.) die Summenbildung wird abgebrochen, wenn die Summanden kleiner als eine bestimmte Genauigkeit (Epsilon) werden

*/

double exp_fkt( double exponent) {
	int fakultaet=1; /* i! */
	double potenz=1.0; /* x^i */
	double resultat=1.0, summanden;
	int n=1;

	do {
		fakultaet *= n; // 1.)
		potenz *= exponent; // 2.)
		summanden = potenz/fakultaet; // 3.)
		resultat = resultat + summanden;
		printf("%3d %12d %12.6f %12.6f\n", n, fakultaet, summanden, resultat); // test - Ausgabe
		n++;
	} while (summanden >= 0.0001); // 4.)

	return resultat;
}

int main(void) {
	double exponent;

	printf("Berechnung von e^x\n\n");
	printf("Exponent = "); scanf("%lf", &exponent);

	printf("\nDurchlauf Fakultaet Summanden Resultat\n");
	printf("----------------------------------------\n");
	printf("\nexp(%.1lf) = %.16lf\n", exponent, exp_fkt(exponent));

	return 0;
} 

C-Programm – Umrechnung von Zahlensystemen

Das Programm kann dezimale Zahlen in andere Zahlensysteme umrechnen… sowohl Vorkomma- als auch Nachkommastellen.

#include <stdio.h>

int main(void) {
	float kommazahl, kommazahl_darstellung;
	float array_kommazahl[32], array_kommazahl_ergebnis[32];
	char array_rest[32];
	int y=0, zahl, rest, ergebnis;
	int i=0, j=0, loop=0, basis, genauigkeit=30;

	/* mache etwas (min. 1-mal) ... */
	do { 
		printf("Bitte eine positive Kommazahl eingeben:");
		scanf("%f", &kommazahl);
	/* ... solange die Eingabe kleiner 0 */
	} while (kommazahl < 0);

	/* mache etwas (min 1-mal) ... */
	do {
		printf("Bitte eine Basis >=2 ein:");
		scanf("%d", &basis);
	/* ... solange die Eingabe kleiner 2 */ 
	} while (basis < 2 );

/*
	z.B.: die Dezimalzahl 8 soll ins 2er-System umgewandelt werden

	Verfahren:
	(1) Teile die Zahl mit Rest durch 2.
	(2) Der Divisionsrest ist die naechste Ziffer (von rechts nach links).
	(3) Falls der (ganzzahlige) Quotient = 0 ist, bist du fertig,
		andernfalls nimm den (ganzzahligen) Quotienten als neue Zahl 
		und wiederhole ab (1).

	8 : 2 = 4  Rest: 0
	4 : 2 = 2  Rest: 0
	2 : 2 = 1  Rest: 0
	1 : 2 = 0  Rest: 1

	-> Resultat: 1000
*/

	printf ("\nV O R K O M M A S T E L L E N:\n\n");

	/* nur die Vorkommastellen (Integer = ganze Zahl) in die Variable 'zahl' schreiben */
    zahl = (int) kommazahl;

	while (zahl > 0) { // (3)
		rest = zahl % basis; // (1)
		array_rest[y++] = rest; // Array fuer die umgekehrte Reihenfolge der Ausgabe
		ergebnis = zahl / basis;
		printf("%d : %d = %d  Rest: %d\n", zahl, basis, ergebnis, rest); // Ausgabe 
		zahl = zahl / basis; // (2)
	}

	printf("\n-> Resultat: ");
	while (--y >= 0) { // umgekehrte Reihenfolge der Ausgabe
 		printf("%d", array_rest[y]);
	}


/* 
	z.B: der Dezimalbruch  0,8  soll ins 2er System umgewandelt werden

	Verfahren fuer Nachkommaziffern:
	(1) Multipliziere die Zahl mit der Basis 2
	(2) Die Zahl vor dem Komma ist die naechste Ziffer des Ergebnisses
	(3) Schneide die Zahl vor dem Komma weg.
	(4) Wiederhole ab (1), bis der Rest 0 ist, sich ein Rest wiederholt
		oder die gewuenschte Genauigkeit erreicht ist.

	2 · 0,8 = 1,6    --> Ziffer: 1
	2 · 0,6 = 1,2    --> Ziffer: 1
	2 · 0,2 = 0,4    --> Ziffer: 0
	2 · 0,4 = 0,8    --> Ziffer: 0
	2 · 0,8 = 1,6    --> Ziffer: 1

	Der "Rest" 1,6 trat im 1. Schritt bereits auf.
	Ab dort wiederholen sich die Nachkommaziffern periodisch.

	-> Resultat: 0,1100110011001100110011001100110011001100110011001100...
*/

	printf ("\n\n\nN A C H K O M M A S T E L L E N:\n\n");

	kommazahl = kommazahl - (int) kommazahl; // z.B. kommazahl = 2,5 - 2 = 0,5
	kommazahl_darstellung = kommazahl; // nur zur Veranschaulichung in der Ausgabe

	do {
		kommazahl *= basis; // (1)
		kommazahl = ( (int) (kommazahl * 1000.0 + 0.5)) / 1000.0; // Runden auf 4 Nachkommastellen
		array_kommazahl[j] = kommazahl; // Restwert in ein Array schreiben

		for ( j=0; j < i; j++ ) { 
			// printf("\ntest - [%d][%d] - %f\n", i, j, array_kommazahl[j]); // test - Ausgabe
			if ( array_kommazahl[j] == kommazahl ) { // (4) - Wiederholung feststellen
				loop = j;
			}
		}

		if ( (int) kommazahl == 0 && loop == 0) { // (2)
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
		} else if ( (int) kommazahl != 0 && loop == 0) { // (2) 
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
			kommazahl -= (int) kommazahl; // (3)
		}

		if ( loop >= 1 ) {
			printf ("\nDer \"Rest\" von %f trat im %d. Schritt bereits auf.\nAb dort wiederholen sich die Nachkommaziffern periodisch.\n", array_kommazahl[j-1], loop); 
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( kommazahl == 0.0 ) {
			printf ("\nEs ist kein Rest mehr uebrig... :-)");
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( i >= genauigkeit ) {
			printf ("\nDie Genauigkeit sollte nun ausreichen... (%d Bit)", genauigkeit);
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
			break;
		}

		kommazahl_darstellung *= basis; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung = ( (int) (kommazahl_darstellung * 1000.0 + 0.5)) / 1000.0; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung -= (int) kommazahl_darstellung; // nur zur Veranschaulichung in der Ausgabe

		i++;
		j++;
//	} while ( ( i < genauigkeit ) || !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR
	} while ( !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR

	return(0);
}

C-Programm – Schaltjahr Berechnung

ALGORITHMUS Schaltjahr


Beschreibung:

  • das Programm soll testen, ob eine Folge von Jahren jeweills ein Schaltjahr ist
  • wenn das Jahr größer 1582 ist
  • wenn das Jahr durch 4, aber nicht durch 100 teilbar ist, handelt es sich um ein Schaltjahr
  • ist das Jahr durch 400 teilbar, handelt es sich ebenfalls um ein Schaltjahr


Daten:

  • Jahr (Startwert)
  • Jahr (Endwert)
  • Schrittweite


Kern-(Algorithmus):

Einlesen von "Startwert" + "Endwert" + "Schrittweite"
WENN "Startwert" < 1582 ODER "Startwert" >= "Endwert" ODER Schrittweite <= 0
	DANN Fehler-Meldung
ANSONSTEN
	FÜR "Startwert" BIS "Endwert"
		WENN ("Startwert" / 4 ohne Rest UND "Startwert / 100 mit Rest) ODER ("Startwert" / 400 ohne Rest)
			DANN Ausgabe: "Ja"
		ANSONSTEN
			Ausgabe: "Nein"
		ENDE WENN
	ENDE FÜR
ENDE WENN


C-Programm:

#include "stdio.h"

int main(void) {
	int jahr_startwert,jahr_endwert,schrittweite;

	printf("\n\tK a l e n d e r\n");

	printf("\nBitte den Startwert (Jahrszahl) eingeben: ");
	scanf("%d", &jahr_startwert);

	printf("Bitte den Endwert (Jahreszahl) eingeben: ");
	scanf("%d", &jahr_endwert);

	printf("Bitte die Schrittweite (Jahre) eingeben: ");
	scanf("%d", &schrittweite);

	/* Beginn des gregorianischen Kalerndes - 1582*/
	if (jahr_startwert < 1582 || jahr_startwert >= jahr_endwert || schrittweite <= 0) {
		printf("\nFalsche Angabe!");
	} else {
		printf("\nJahr | Schaltjahr?");
		printf("\n------------------");

		for (jahr_startwert; jahr_startwert <= jahr_endwert; jahr_startwert=jahr_startwert+schrittweite) {
			if ((jahr_startwert % 4 == 0) && (jahr_startwert % 100 != 0) || (jahr_startwert % 400 == 0)) {
				printf("\n%d | Ja",jahr_startwert);
			}
			else {
				printf("\n%d | Nein",jahr_startwert);
			}
		}
	printf("\n\n");
	}
	return (0);
}