Pascal - Programm zum Umrechnen in die verschiedenen Zahlensysteme -

Ganz einfach:

PROGRAM bla;
USES crt;
VAR choice:INTEGER;
BEGIN
    REPEAT
        clrscr;
        writeln( '[1] Dec2Bin' );
        writeln( '[2] Bin2Dec' );
        writeln( '[3] Arab2Rom' );
        writeln( '[0] Programm beenden' );
        write( 'Ihre Wahl? ' );
        read( choice );

        CASE choice OF
          1: (*hier den jeweiligen Algorithmus aufrufen*)
          2: (*...*)
          3: (*...*)
        END;

    UNTIL choice = 0;
END.
   

hey.

erstmal danke für deine hilfe Lisaa !
Hast mir echt sehr weitergeholfen, nur irgendwie schaff ich es nicht meinen algorithmus einzubauen.

Kannst du mir da vielleicht nochmal helfen ?.
 

Program dez_bin;
Uses Crt;
Var Zahl_dez,i:Integer;
    Zahl_dual:array[1..1000] of Integer;
    Zahl_dual2:String;

Function potenzen(Basis,potenz:Integer):Integer;
var bas:Integer;
Begin
 if (potenz=0) then potenzen:=1;
 if (Potenz=1) then potenzen:=basis else
 Begin
  bas:=Basis;
  Repeat
   Basis:=Basis*Bas;
   dec(potenz);
  Until Potenz=1;
  Potenzen:=Basis;
 end;
End;

Function IntToStr(Zahl:Integer):String;
var wert:String;
Begin
 STR(zahl,wert);
 IntToStr:=wert;
End;

Function StrToInt(Zeichen:String):Integer;
var wert,code:Integer;
Begin
 Val(Zeichen,wert,Code);
 strtoint:=wert;
End;

Procedure umrechnen_dez_dual;
Var Rest,j,x:Integer;
Begin
 i:=1;
 Writeln('Rechnung:');
 Repeat
  x:=Zahl_Dez div 2;
  Rest:=Zahl_Dez mod 2;
  zahl_dual:=rest;
  inc(i);
  GoToXY(1,3+i);  write(Zahl_dez);
  gotoXY(10,3+i); write(' / 2 =  ',x);
  GotoXY(25,3+i); write('Rest:  ',rest);
  Zahl_Dez:=x;
 Until Zahl_dez=0;
 for j:=i-1 downto 1 do
  Begin
   Rest:=Zahl_dual[j];
   Zahl_dual2:=Zahl_dual2+IntToStr(Rest);
  end;
End;

Procedure umrechnen_dual_dez;
var Exp,ypos:Integer;
    z:String;
Begin
 Exp:=0;
 i:=i-1;
 ypos:=i+4;
 writeln;
 Writeln('Rechnung:');
 repeat
  z:=copy(Zahl_dual2,i, 1);
  GotoXY(1,Wherey);  write(Zahl_dez);
  Zahl_dez:=Zahl_Dez+StrToInt(Z)*Potenzen(2,exp);
  GotoXY(5,Wherey); Write(' + ',strtoint(Z));
  GotoXY(10,Wherey); Write(' * 2^',exp);
  GotoXY(17,Wherey); Writeln(' = ',zahl_dez);
  dec(i);
  inc(Exp);
 until i=0;
End;


Begin
 clrscr;
 Writeln('   Dezimal- Und Dualzahlen ');
 write('Bitte geben sie die umzuwandelnde Dezimalzahl ein... ');
 readln(Zahl_dez);
 writeln;
 umrechnen_dez_dual;
 writeln;
 Writeln('==> Bin„rzahl: ',Zahl_dual2);
 writeln;
 writeln;
 Writeln('Die Zahl wird nun zur Dezimalzahl zurckgerechnet...');
 delay(500);
 umrechnen_dual_dez;
 Writeln('==> Dezimalzahl: ',Zahl_dez);
 readln;
End.

Das ist mein Pascal Code für die Umrechnung von Dezimal in Binär. Nur wie muss ich das jetzt umschreiben das es nicht automatisch zurückrechnet sondern nur so wie ich es im Menü auswähle und wie kann ich das dann in das Menü einbauen  ?.


Danke für die hilfe !!

 

Das ist doch jetzt ganz einfach:

[...]
BEGIN
    REPEAT
        clrscr;
        writeln( '[1] Dec2Bin' );
        writeln( '[2] Bin2Dec' );
        writeln( '[3] Arab2Rom' );
        writeln( '[0] Programm beenden' );
        write( 'Ihre Wahl? ' );
        read( choice );

        CASE choice OF
          1: BEGIN
               write( 'Bitte geben sie die umzuwandelnde Dezimalzahl ein... ' );
               readln( Zahl_dez );
               writeln;
               umrechnen_dez_dual;
               Writeln( '==> Binärzahl: ', Zahl_dual2 );
             END;
          2: BEGIN
               write( 'Bitte geben sie die umzuwandelnde Binärzahl ein... ' );
               readln( Zahl_dual2 );
               writeln;
               umrechnen_dual_dez;
               Writeln( '==> Dezimalzahl: ', Zahl_dez );
             END;
          3: (*...*)
        END;

    UNTIL choice = 0;
END.

Ich hätte allerdings die Funktionen zum Umrechnen so gemacht, dass sie als Parameter die umzurechnende Zahl bekommen und als Rückgabewert das Ergebnis zurückliefern. Dann wärst du nicht abhängig von den globalen Variablen - und ist auch noch besserer Stil.
 

irgendwie blicke ich jetzt überhaupt nicht mehr durch.

könntest du mir vielleicht die Procedure zum umrechnen von dezimal zu dual aufschreiben ?.

wenn ich sie einfach so wie aus meinem alten code einbaue dann funktioniert das nicht. 

Nee, das funktioniert schon soweit. Musst natürlich noch etwas aufhübschen, z.B. ein readln; nach der Ausgabe des Ergebnisses, damit das nicht sofort überschrieben wird. Oder ein clrscr; vor der Ausgabe des Rechenweges, weil du an feste Positionen schreibst (wo dann schon das Menü steht).
Die dual zu dec hat aber noch zwei Probleme:
1. Du gehst im Moment davon aus, dass einige Variablen (mindestens das i) vom Hinweg noch initialisiert sind - das musst du natürlich ändern.
2. In der Potenzen-Funktion läufst du in jedem Fall in die Berechnung rein - auch wenn der Exponent 0 ist. Das legt den Rechner ne ganze Weile lahm und das Ergebnis ist auch noch falsch...

ich hab es leider nicht geschafft das programm so zu verändern wie du in deinem letzten post geschrieben hast. @ Lisa

könntest du mir vielleicht das programm überarbeiten das es richtig funktioniert und ins menü einbauen ? - ich schaff das einfach nicht, anscheinend bin ich zu blöd !.

Wäre echt sehr nett von dir !.

Wo genau gab es jetzt Schwierigkeiten? War doch schon fast fertig...

PROGRAM transform;

USES Crt;

(***************************************************)
FUNCTION potenzen( basis, potenz:INTEGER ) :INTEGER;

VAR bas:INTEGER;

BEGIN
    IF( potenz = 0 ) THEN potenzen := 1 ELSE
    BEGIN
        IF( potenz = 1 ) THEN potenzen := basis ELSE
        BEGIN
            bas := basis;
            REPEAT
                basis := basis * bas;
                Dec( potenz );
            UNTIL potenz = 1;
            potenzen := basis;
        END;
    END;
END;

(***************************************************)
FUNCTION IntToStr( zahl:INTEGER ) :STRING;

VAR wert:STRING;

BEGIN
    Str( zahl, wert );
    IntToStr := wert;
END;

(***************************************************)
FUNCTION StrToInt( zeichen:STRING ) :INTEGER;

VAR wert,
    code:INTEGER;

BEGIN
    Val( zeichen, wert, code );
    strtoint := wert;
END;

(***************************************************)
FUNCTION umrechnen_dez_dual( number:INTEGER ) :STRING;

VAR rest,
    i,
    j,
    x:INTEGER;
    rval:STRING;
    zahl_dual:ARRAY[1..1000] of INTEGER;

BEGIN
    Clrscr;
    rval := '';
    i :=1 ;
    Writeln( 'Rechnung:' );
    REPEAT
        x := number DIV 2;
        rest := number MOD 2;
        zahl_dual[i] := rest;
        Inc( i );
        Gotoxy(  1, 3+i ); Write( number );
        Gotoxy( 10, 3+i ); Write( ' / 2 =  ', x );
        Gotoxy( 25, 3+i ); Write( 'Rest:  ', rest );
        number := x;
    UNTIL number = 0;

    FOR j := i-1 DOWNTO 1 DO
    BEGIN
        rest := zahl_dual[ j ];
        rval := rval + IntToStr( rest );
    END;
    umrechnen_dez_dual := rval;
END;

(***************************************************)
FUNCTION umrechnen_dual_dez( number:STRING ) :INTEGER;

VAR exp,
    i,
    rval:INTEGER;
    z:STRING;

BEGIN
    Clrscr;
    exp := 0;
    rval := 0;
    i := length( number );
    Writeln;
    Writeln( 'Rechnung: ' );
    REPEAT
        z := Copy( number, i, 1 );
        Gotoxy( 1, Wherey );  Write( rval );
        rval := rval + StrToInt( z ) * Potenzen( 2, exp );
        Gotoxy( 5, Wherey ); Write( ' + ', StrToInt( z ) );
        Gotoxy( 10, Wherey ); Write( ' * 2^', exp );
        Gotoxy( 17, Wherey ); Writeln( ' = ', rval );
        Dec( i );
        Inc( exp );
    UNTIL i = 0;
    umrechnen_dual_dez := rval;
END;

(***************************************************)

VAR dez,
    choice: INTEGER;
    dual:STRING;

BEGIN
     REPEAT
        Clrscr;
        writeln( '[1] Dec2Bin' );
        writeln( '[2] Bin2Dec' );
        writeln( '[3] Arab2Rom' );
        writeln( '[0] Programm beenden' );
        write( 'Ihre Wahl? ' );
        read( choice );

        CASE choice OF
          1: BEGIN
               Write( 'Bitte geben sie die umzuwandelnde Dezimalzahl ein... ' );
               Readln( dez );
               Writeln;
               dual := umrechnen_dez_dual( dez );
               Writeln;
               Writeln( '==> Binaerzahl: ', dual );
               Writeln( 'Bitte Taste druecken' );
               Readln;
             END;
          2: BEGIN
               Write( 'Bitte geben sie die umzuwandelnde Binaerzahl ein... ' );
               (* Additional readln because program seems to skip one here *)
               (* for some strange reason *)
               Readln;
               Readln( dual );
               Writeln;
               dez := umrechnen_dual_dez( dual );
               Writeln;
               Writeln( '==> Dezimalzahl: ', dez );
               Writeln( 'Bitte Taste druecken' );
               Readln;
             END;
          3: BEGIN
               Writeln( 'Diese Funktion steht nur in der Deluxe-Version zur Verfuegung' );
               Writeln( 'Bitte Taste druecken' );
               (* Additional readln because program seems to skip one here *)
               (* for some strange reason *)
               Readln;
               Readln;
             END;
        END;

    UNTIL choice = 0;
END.


Hey Lisa !

Danke für die Hilfe.

Leider funktioniert es bei mir noch immer nicht. Es kommt der Fehler "compile failed". Was hab ich falsch gemacht ?.

 

Keine Ahnung. Bei mir gehts. Gibt es noch zusätzliche Infos zum Fehler (Zeilennummer, was falsch ist etc.)?
Welchen Compiler verwendest du?

Also das Steht genau da

Zahlensystem2.pas (38,2)Error: Illegal expression
Zahlensystem2.pas (38,6)Error: Illegal expression
Zahlensystem2.pas (38,6)Fatal: Syntax but"<" found Error, ";" expected

ich verwende

Kannst du mal die entsprechende Zeile hier posten (Zeile 38)?

ich hab den fehler schon gefunden. hab mich nur vertippt - jetzt funktioniert es !.

Danke sehr !

ich verwende http://www.freepascal.org/

Hab ich mir gerade mal angesehen - das errinerte mich an meine Schulzeit vor >10 Jahren, da haben wir auch sowas verwendet.
Eine sehr viel komfortablere, modernere Umgebung gibts hier (nur so als kleiner Tipp):
http://www.bloodshed.net/devpascal.html  
Benutzt auch den FreePascal-Compiler, ist also kompatibel zu dem anderen Kram (den ihr wahrscheinlich auch in der Schule verwendet?).

Hallo an alle!

Ich bin gerade dabei so ein ähnliches Programm, das auch verschiedene Zahlen umrechnet zu schreiben.

Könnte mir vielleicht einer erklären was in den folgenden Funktionen genau passiert ??

FUNCTION potenzen( basis, potenz:INTEGER ) :INTEGER;


FUNCTION IntToStr( zahl:INTEGER ) :STRING;


FUNCTION StrToInt( zeichen:STRING ) :INTEGER;

Habe schon versucht den Vorgang zu kapiern aber irgendwie komm ich auf kein ergebnis.

thx for help !

Im Prinzip machen die Funktionen genau das, was der Name sagt. Bei StrToInt/IntToStr ist es einfach, hier wird einfach Str() bzw. Val() aufgerufen - Standardfunktionen, die nämlich genau Integer in Strings und umgekehrt wandeln.
Potenzen berechnet die Potenz aus Basis und Exponent (hier etwas unglücklich Potenz genannt). Da 2^3 = 2*2*2 wird es hier in der Schleife genau so "abgerollt". Die Basis wird mit sich selbst multipliziert und der Exponent danach um 1 verringert - und das solange bis der Exponent nur noch 1 ist. Sicherlich nicht die eleganteste Lösung, wie das hier programmiert ist (vor allem die Variablennamen) aber es funktioniert.

Und für was genau braucht man diese Funktionen ?. Ohnen diesen Funktionen funktioniert das Programm nicht oder ?

Richtig. Die eigentliche Arbeit machen die Funktionen umrechnen_dez_dual und umrechnen_dual_dez. Und wenn du genau hinschaust, wirst du feststellen, dass diese Hilfsfunktionen dort aufgerufen werden.

sorry lisa jetzt muss ich dich nochmal nerven.

Könntest du mir vielleicht noch Schritt für Schritt erklären wie die funktion dez_dual und dual_dez abläuft ?.

Ich bin noch anfänger und wenn ich das programm verstehe dann werd ich mir sicher leichter tun bei meinem programm.
nur zur zeit blick ich noch nicht so durch !.

danke schon im Voraus.

 

Ich hab die Funktionen mal etwas vereinfacht, vielleicht ist es dann besser zu verstehen. Sind im Grunde genommen Implementierungen der hier beschriebenen Algorithmen

FUNCTION umrechnen_dez_dual( number:INTEGER ) :STRING;

VAR rval:STRING;

BEGIN
     ClrScr;
     rval := '';
     REPEAT
           rval := IntToStr( number MOD 2 ) + rval;
           number := number DIV 2;
     UNTIL number = 0;
     umrechnen_dez_dual := rval;
END;

(************************************************************)

FUNCTION umrechnen_dual_dez( number:STRING ) :INTEGER;

VAR rval:INTEGER;
    i:INTEGER;

BEGIN
     ClrScr;
     rval := 0;
     FOR i := 1 TO length( number ) DO
          rval := rval * 2 + StrToInt( number[ i ] );
     umrechnen_dual_dez := rval;
END;


Ok ich versuchs mal in worten zu erklären, sag mir dann bitte ob ich etwas falsch habe.

umrechnen_dez_duau
rval - was ist das genau ?

1) bildschirm wird gelöscht
2) rval bekommt die zeichen ``;

danach wird rval berechnet. die eingebene zahl MOD 2 + nochmal rval;
jetzt wird dividiert durch 2
Solange bis 0 rauskommt.

Versteh ich das so richtig ?. ich hoffe du weißt was ich damit meine .

ich würde das halt gerne in worten erklären können...

danke für die tipps. 

rval - was ist das genau ?

Kurz für return value (Rückgabewert). Das Ergebnis halt.

2) rval bekommt die zeichen ``;

'' steht für den leeren String, d.h. rval wird damit initialisiert. Dadurch stelle ich sicher, dass da nicht schon was drinsteht, weil ich später nur noch anhänge.

danach wird rval berechnet. die eingebene zahl MOD 2 + nochmal rval;

Genau. In jedem Durchgang wird der ganzzahlige Rest (das Ergebnis von zahl MOD 2) *vorne* an den String angefügt. Also jedesmal eine 0 oder eine 1. Danach die Zahl halbiert. Solange bis sie 0 ist. Also wird hier genau das gemacht: http://de.wikipedia.org/wiki/Dualsystem#vom_Dezimalsystem_ins_Dualsystem

 

oke, also die erste hab ich mal verstanden !

jetzt die zweite dual_dez

Bildschirm wird gelöscht.
Und der rückgabewert (rval) wird auf null gesetzt.

Danach i:=0 TO length ( number) Do - > das versteh ich nicht ??

rval:= rval * 2 + StrToInt ( number{i} );
Rückgabewert (rval) wird mit 2 multipliziert und dannach ?.

sorry das ich mich so dumm anstelle aber ich glaube danach sind wir fertig und ich kenne mich aus !

Danach i:=0 TO length ( number) Do - > das versteh ich nicht ??

Die Zahl ist ja eine Folge von 1en und 0en. Das was gleich passiert, muss für jede davon gemacht werden. Also von der ersten bis zur letzten. Die erste hat den Index 1*, die letzte kriege ich mit length( number ) raus, was einfach nur die Anzahl der Zeichen in dem String zurückliefert.

*) In der Funktion ist ein Fehler, es muss heißen FOR i:=1 TO ... in Pascal wird ja ab 1 gezählt, in anderen Programmiersprachen immer ab 0. Ich frage mich nur gerade, warum es trotzdem funktioniert...

rval:= rval * 2 + StrToInt ( number{i} );
Rückgabewert (rval) wird mit 2 multipliziert und dannach ?.

Danach wird die Zahl an der i-ten Position unserer Dualzahl dazuaddiert. Gemäß diesem Algorithmus (2. Tabelle, Prior value ist hier rval und Next Bit entspricht eben number):
http://en.wikipedia.org/wiki/Binary_numeral_system#Decimal
 
Das ist ein etwas anderer Algorithmus als der ursprüngliche, der mit Potenzen gearbeitet hat. Ich finde diesen schöner und man braucht auch die Potenzen-Funktion nicht mehr.

danke sehr. das hab ich jetzt verstanden - hoff ich mal

find ich echt klasse das du mir da so behilflich bist !.

schönen abend noch.