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);
}

Ähnliche Beiträge:

C-Programm – Schaltjahr Berechnung C-Programm – letzte Ziffer anzeigen C-Programm – eulersche Zahl