JavaCode: Dezimal nach Binär umwandeln

[r0b0t]

@e-Laurin: Da hast du die Formel etwas zu sehr gekürzt. Bei der letzen Stelle ergibt sich nach deinem Schema etwa bei 100 = 2^2 + 0^1 + 0^0 = 5, da irgendetwas hoch 0 immer 1 ergibt. Das betrifft aber wirklich nur die letzte Stelle. Dummerweise sind das aber gerade Probleme, die sehr häufig auftreten, dass man sich genau um 1 verrechnet und eventuelle Randbereiche von Puffern, Funktionswerten, etc. nicht berücksichtigt.

richtig wäre:
11111 = 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 31
10101 = 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 21
00100 = 0*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 0*2^0 = 4

 

[Krik]

Ja stimmt, mein Fehler. Ich hab das irgendwie übersehen.

 

[DTHDdorf]

public class Binear{
public static void main (String [] args) {
int binaer = 11111;
int zehner = 0;
int ergebnis = 0;
int i = 0;
if (zehner == 0) { // Guckt ob er von Binär in Dezimal rechnen soll oder umgekehrt.
int speicher = 1;
int binaerzwei = binaer; /* Deklariert eine zweite Binaerzahl, die "kaputt" gerechnet werden kann*/
while (binaerzwei >= 1) {
binaerzwei = binaerzwei / 10; /* 1. While. Er rechnet aus wieviele Stellen unsere Binaerzahl hat. In dem Fall 5. i ist nun 5 */
i++; }
while (i > 1) { /* Er rechnet i wieder runter während er den Speicher verdoppelt.
Bei dem Schritt fällt mir auf, dass diese While zu viel ist, sieh schadet aber auch nicht. */
i = i - 1;
speicher = speicher * 2;
}
while (speicher >= 1) {
ergebnis = speicher * binaer % 10 + ergebnis; /* Sinn der ersten beiden Whiles wird hoffentlich jetzt klar. Ich Nehme Speicher (16) und multipliziere dies mit der letzten Ziffer von der Binaerzahl ( "1101 % 10; sprich 1101 durch 10 == Rest 1 und diese 1 wird mit 16 multipliziert. Das ganze dann noch mit Ergebnis addiert, da es ja mehrer Durchgänge gibt und die ersten nicht überschireven werden sollen.
Der Trick hierbei ist (und soweit ich es verstanden habe bei deinem Lösungsvorschlag auch), dass wenn die letzte Ziffer 0 ist er mit 0 multipliziert und auch nichts addiert wird.*/
speicher = speicher / 2; /* Am Ende der while wird speicher halbiert, weil bei der 2. Stelle ja nur noch mit 8 multipliziert werden soll. */
binaer = binaer / 10; /* Durch 10 damit ich an die nächste Ziffer rankomme. Da binaer == int wird komma nicht beachtet ( 1101 / 10 == 110 <> 110,1 )

}
System.out.println (ergebnis);
}
else {
for (int speicher = 0; zehner > 0; zehner = zehner / 2) {
ergebnis = 0;
ergebnis = zehner % 2;
System.out.print (ergebnis);
}

}
}
}




Hoffe du verstehst mein Prog / Prob jetzt und kannst mir vorallem bei meinem Lösungsvorschlag helfen und mir nicht einfach die Musterlösung geben

Wäre echt Super

MfG
DTHDdorf

 

[Denara]

Man könnte das ganze vielleicht verstehen, wenns richtig eingerückt und in code-Tags ist. Wofür gibts die denn sonst?

Sei mir nicht böse, wenn ich deine Kommentare direkt wieder rausgeschmissen habe. Habe dafür selbst die Sachen mal kommentiert:

public class Binear{
    public static void main (String [] args) {
        int binaer = 11111;
        int zehner = 0;
        int ergebnis = 0;
        int i = 0; // variablenname suboptimal, anzahlStellen wäre besser
        
        if (zehner == 0) { 
            int speicher = 1; // blöder variablen-name, besser faktor o.ä.
            int binaerzwei = binaer; // variable um Stellen zu zählen
            
            // Solange die zahl noch mehr als eine Stelle hat erhöhe i um 1
            // hier besser prüfen auf binaerzwei > 0 
            while (binaerzwei >= 1) {
                binaerzwei = binaerzwei / 10; 
                i++; 
            }
            // berechne den Wert der höchsten Stelle 2^(i-1). 
            // d.h. bei z.B. 4 stellen 2^3 = 8
            // nicht notwendig, siehe weiter unten
            while (i > 1) { 
                i = i - 1;
                speicher = speicher * 2;
            }
            
            // Soweit ist eigentlich alles Ok, folgendes Problem aber:
            // Du gehst in deiner Berechnung falsch herum vor. Die niedrigste
            // Stelle befindet sich rechts. Mit binaer % 10 erhälst du die 
            // ganz rechte Stelle, welche du dann mit deinem hohen Faktor
            // multiplizierst, der Faktor muss bei der rechten Stelle aber
            // gleich 1 sein. Du drehst sozusagen deine Binärzahl ungewollt um.
            // Wenn du deine Logik beibehalten willst, musst du mit der Stelle
            // ganz LINKS anfangen, die ist aber schwerer zu erhalten.
            while (speicher >= 1) {
                // Hier kommt ein falsches Ergebnis raus, da von links nach
                // rechts gerechnet wird. Du multiplizierst erst binaer und 
                // berechnest dann den Rest: 
                // Deins wäre geklammert: (speicher * binaer) % 10 was aber nicht 
                // mit dem gewünschten: speicher * (binaer % 10)   übereinstimmt
                // Also KLAMMERN SETZEN
                ergebnis = speicher * binaer % 10 + ergebnis; 
                speicher = speicher / 2;
                binaer = binaer / 10;
            }
            // Du musst also quasi umgekehrt denken. Du musst die Schleife so
            // oft wiederholen wie du Stellen hast (dein i von oben) und deine
            // variable speicher in jedem durchlauf verdoppeln - dann aber bei 1 anfangen
            // denn du betrachtest erst die ganz rechte Stelle und multiplizierst
            // diese mit ihrem Wert, dann die nächste usw.
            
            System.out.println (ergebnis);
        }
        else {
            for (int speicher = 0; zehner > 0; zehner = zehner / 2) {
                ergebnis = 0;
                ergebnis = zehner % 2;
                System.out.print (ergebnis);
            }
        }
    }
}

 

[Green Mamba]

https://www.computerbase.de/forum/threads/188124/
An der Tatsache, dass du deine Hausaufgaben selbst erledigen sollst, hat sich bislang nichts geändert.