Umwandeln von Dezimalzahl in Binärrzahl

[Luna.jva]

Hallo zusammen,
ich lerne gerade erst programmieren (Java in Intellij) und tu mir etwas schwer bei dieser Aufgabe wo man einen Dezimalzahl in eine Binärzahl umrechnen soll und alle Zahlen zwischen 0-15 ausgeben soll. Wie das an sich geht ist mir klar- dividieren mit Rest und unter Verwendung von Modulo, jedoch ist hier schon ein Methodenkopf gegeben, den man verwenden soll.
Die Binärzahl ist in einem booleschen Feld zu speichern, wobei die Länge des Feldes so zu wählen ist, dass die Binärzahl genau hineinpasst:

public static boolean[] dec2bin(int dec) {
return new boolean[0];
}

ich hätte jetzt mal so angefangen, ich weiß es ist bei weitem nicht vollständig:

public static boolean[] dec2bin(int dec) {

while (decDigit >= 0 && decDigit <= 15) {
int[] binDigits = new int[counter];
for (int i = 0; i < binDigit.length; i++)
binDigit = dezDigit % 2+binDigit;
dezDigit = dezDigit / 2;
}
return new boolean[0];
}

Danke für eure Hilfe

 

[Tokolosh]

Poste den Code doch bitte in entsprechenden Code-Blocks.

Wo passiert etwas mit decDigit in der while-Schleife? Was machst du mit der dec-Variable als Übergrabeparameter? Dein Code ist unvollständig. Wo wird denn decDigit überhaupt initialisiert?

 

[IBISXI]

Falls das hilft:

https://www.programiz.com/javascrip...t() method is,decimal number to binary number.

 

[djerunX]

Wieso denn

return new boolean[0];

in der Methode. Ist das auch vorgegeben?

edit: Hab mal was gebastelt. Ich weiß nicht wie weit genau du bist. Ist dir der ternäre ? Operator ein Begriff?
edit: und nochmal bearbeitet, weil ich das, was mkossmann gesagt hat nicht beachtet hatte (;

Spoiler: Code

public class Main {
  
    public static boolean[] dec2bin(int dec) {
      
        if(dec == 0) {
            boolean[] arr = {false};
            return arr;
        }
      
        boolean[] array = new boolean[32];
        int counter = 0;
      
        while(dec != 0) {
            array[counter] = dec%2 == 1;
            dec = dec/2;
            counter++;
        }
      
        boolean[] array2 = new boolean[counter];
        for(int i = 0; i < array2.length; i++) {
            array2[array2.length-1-i] = array[i];
        }
        return array2;
    }
  
    public static void printBin(boolean[] array) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] == true) {
                System.out.print("1");
            } else {
                System.out.print("0");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        for(int i = 0; i <= 15; i++) {          
            printBin(dec2bin(i));
        }

    }
}

 

[mkossmann]

wobei die Länge des Feldes so zu wählen ist, dass die Binärzahl genau hineinpasst

Das erfordert das du entweder zuerst bestimmst , wieviel binäre Stellen du brauchst, dann das binäre Feld allozierst und dann mit der bekannten Methode mit Werten füllst und dann zurück gibst
Oder du du allozierts zunächst ein Hilfs-Binärfeld in maximal notwendiger Größe, füllst das mit der bekannten Methode mit Werten und bestimmst dabei gleichzeitig die Anzahl der Binärstellen, allozierts dann das Feld in der Richtigen Größe, kopierst die Werte rüber und gibst es zurück.

 

[mkossmann]

@djerunX
Den ? Oprerator braucht man nicht . Denn der der Vergleich dec%2 == 1 liefert ja schon ein Boolean als Ergebnis zurück .
Zum Vergleich mal die erste Variante

public static boolean[] dec2bin(int dec) {
      
    int numBits=0;
    int help=dec;
      
    do {
        numBits++;
        help=help/2;
    } while (help>0);
    
        
    boolean[] array = new boolean[numBits];
        
      
      
    for(int i = 0; i < numBits; i++) {
            array[numBits-1 -i]=( dec%2 == 1 ); // big endean bit order 
            dec=dec/2;
        }
        return array;
    }

 

[djerunX]

Stimmt das ist ja noch kompakter dann. Hab ich nochmal editiert. Mit der fußgesteuerten Schleife + Hilfsvariable zum ermitteln der Feldlänge ersparst du dir auch nochmal den check auf 0 als übergebenen Parameter. Find ich viel schicker so wie du es gemacht hast, wenn ich darüber nachdenke.

 

[Luna.jva]

sorry wegen den fehlenden Einrückungen.. hatte es eigentlich so reinkopiert, denke durch den Post ist die Formatierung verloren gegangen

@djerunX - vielen Dank! Du hast mir echt weiter geholfen.. habs jetzt hinbekommen
Eine Frage noch zu deinem Code:
Wie kann ich folgende Zeile auch anders schreiben? Das ?true:false versteh ich nicht ganz:

array[counter] = dec % 2 == 1 ? true : false;

Danke!

 

[Tokolosh]

Du musst schon die Code-Tags verwenden, sonst wird das nichts mit der Formatierung, das hab ich auch geschrieben!

Das ist ein Ternary Operator. Du kannst diesen mit einem if-else ersetzen. Aber bevor wir dir hier alles vorkauen, solltest du dir das mal selber angucken.

 

[djerunX]

Wie kann ich folgende Zeile auch anders schreiben? Das ?true:false versteh ich nicht ganz:

array[counter] = dec % 2 == 1 ? true : false;

das ist das Gleiche wie

if(dec%2 == 1) {
   array[counter] = true;
} else {
   array[counter] = false;

}

Den braucht man in dem Fall aber gar nicht, weil sich der Ausdruck ja so oder so zu true/false auswertet. Das war überflüssig von mir.

@Tokolosh hat natürlich Recht. Man sollte immer zuerst selbst nachgucken bevor man sich die Lösung anschaut (;

 

[RalphS]

Zwei Vorschläge:
1: Logarithmus zur Basis 2 => log(2) 16 = 4.
2: Bitshift. Das spart die Division - und den Modulo gleich mit.

Sinngemäß bestimmt man log(2) n und hat damit die Feldbreite. Danach kann man von 0 bis Feldbreite iterierien und hat nach jedem Bitshift einen Wert 0 oder 1 jeweils vom Anfang (oder Ende, je nach Richtung) seiner eingegebenen Zahl (welche selbst Integer sein muß).
Jene 0 (1) interpretiert man dann als Boolean.