Umwandlung von Zahlen mit Restwertmethode

tonirakete

Hallo Community,

folgendes:

Ich bin dabei, ein Programm zu schreiben welches es ermöglichen soll, Dezimalzahlen in andere Zahlensysteme umzurechnen.

Und zwar in Dual-, Oktal-, und Hexadezimalzahlen. Die Umrechnung muss mittels der Restwertmethode passieren.

Die Restwertmethode funktioniert so:

Die Dezimalzahl 12 wird ins 2er-System umgewandelt

12 : 2 = 6 Rest: 0
6 : 2 = 3 Rest: 0
3 : 2 = 1 Rest: 1
1 : 2 = 0 Rest: 1

Resultat: 1100

Jetzt hänge ich am Algorithmus, der für die Rechnung zuständig ist.
In der Schleife müssten gespeichert werden die Dividierte Zahl(6,3,1,0) und der "Restwert". Zudem muss dem Compiler vorgeschrieben werden, dass bei glatten Divisionen der Rest 0 bleibt und bei ungeraden Ergebnissen der Rest 1.

Hier mein bisheriger Code:
[code="c"]

#include <stdio.h>
#include <conio.h>
#include <math.h>

//-------------------RESTWERTMETHODE--------------------------------------------------------------
//Konve rtierung von Binär,Oktal und Hexadezimalzahlen in das Dezimalsystem mit der Restwertmethode

double eingabe; //komplette eingabe
int base; //Basis des Zahlensystems
double vk; //Vorkommastellen
double nk; //Nachkommastellen

int rest; //restwert

int a;

int main (){
printf("Bitte geben Sie eine Zahl ein:");
scanf("%lf",&eingabe);

printf("Bitte geben Sie die Basis des Zielzahlensystems ein:");
scanf("%d",&base);

nk=modf(eingabe,&vk); //trenne Vor- und Nachkommastellen

printf("\nVorkommastelle:%lf\n",vk); //TEST
printf("Nachkommastelle:%lf\n",nk); //TEST
printf("Basis des Zahlensystems:%d\n",base); //TEST

if(base=2)
{
do{
a++;
vk=vk/base;

printf("%lf\n",vk);

}while(a<7); //a bisher nur als Hilfsvariable bis die richtige
//Abbruchbedingung feststeht(rechne bis Quotient=0)
}

getch();
}

Ich hoffe jemand kann mir weiterhelfen. Danke schonmal

MfG

Toni

Nimm mal lieber ein unsigned int Typ für deine Zahlen.
Der Modulooperator dafür ist %

Die Abbruchbedingung hast du dann, wenn Zahl/Basis 0 ergibt. 12->6->3->1->0
Diese Zahlen musst du aber gar nicht speichern.
Wichtig ist nur der Rest für die Ausgabe.

Was genau ist aber deine Frage?
Schon mal die (Unter-)Forensuche befragt?

tonirakete

Vielen Dank für die Antwort!

Ich habe deine Erklärung erst nach kurzer Denkpause verstanden^^

Jetzt wäre meine Frage. Wie lege ich fest, dass der Kompiler im falle einer glatten Division(zum Beispiel 8:2=4) eine 0 als Restwert bestimmt und bei einer ungeraden Division(7:2=3.5) als Rest eine 1 bestimmt und die Zahlen danach in der richtigen Reihenfolge zusammenfassen.

Und weil es gerade mal fünf Tage her ist: Dezimal- in Trinärdarstellung umwandeln

tonirakete

while (x!=0)
{
    ziffer = x%3;
    x=x/3;
    printf("%lu", ziffer);
}

könntest du mir vielleicht erklären was das % in der Zeile: Ziffer = x%3 bewirkt?

void ultocon (unsigned long x, int base) /* unsigned log to console */
{  
    if(base<2 || base > 10) return;
    if(x>=base)
      ltocon (x/base,base);
    putchar(x%base+'0');  // Ausgabe der Ziffer Wert + Zeichen für Null
}

und was du in deinem Vorschlag gemacht hast? ^^

Vielen Dank schonmal

tonirakete schrieb:

könntest du mir vielleicht erklären was das % in der Zeile: Ziffer = x%3 bewirkt?

Steht in meiner ersten Antwort.

tonirakete schrieb:

und was du in deinem Vorschlag gemacht hast?

Da ist leider ein Zeichen verloren gegangen.
Das soll ein rekursiver Aufruf sein:

void ultocon (unsigned long x, int base) /* unsigned log to console */
{  
    if(base<2 || base > 10) return; // Wenn die Basis zu klein oder zu groß ist, zurück.

    if(x>=base)                     // Wenn die Zahl nicht kleiner als die Basis ist
      ultocon (x/base,base);        // Funktion mit dem neuem Wert aufrufen

    putchar(x%base+'0');  // Ausgabe vom Rest  (Zifferwert + Zeichen für Null)
}

Bedenke das beim rekursiven Aufruf die Funktion mit neuen Werten aufgerufen wird und komplett bis zur } abgearbeitet wird.

Durch die Zeichenausgabe (mit putchar) nach dem rekursiven Aufruf wird die Zahl in der richtigen Reihenfolge ausgegeben.