Binär zu Dezimal

[multihamster]

Hey Leute,

ich will eine Methode schreiben dir mir ein Binäres Integer Array in einen Dezimalen Integer umwandelt.
Ohne Array war es kein Problem, aber wie würdet ihr das mit einem Array als Eingabe lösen?
Würde mich über eine Antwort sehr freuen, danke

 

[Jw456]

1,0,1,1

8 4 2 1

1*1 = 1
2*1 = 2
4*0 = 0
8*1 = 8
    +
     = 11

 

[MarvinsDepression]

-ein Array (int[]) erstellen und mit Einsen und Nullen füllen.
-ergebnis = 0
-beginnend beim höchstwertigen 'Bit' durch das Array iterieren:
dabei jedes mal ergebnis = 2*ergebnis + Bit-Wert (1 oder 0)rechnen.

 

[KonradN]

Wenn man es rein mathematisch betrachtet: Einfach das Array durchgehen und aufsummieren: Wert * 2 ^ index

Das * 2 entspricht einen shift um eine Stelle im dualen System. Und da wir immer nur neue Stellen hinzu addieren würde auch ein einfaches bitweises ODER reichen. Dann wäre es also etwas wie (Pseudocode):
Ergebnis := 0
Wertigkeit := 1
index von 0 ... höchster Index:
--> Wenn array[index] == 1 dann Ergebnis := Ergebnis | Wertigkeit
--> Wertigkeit := Wertigkeit << 1

 

[MarvinsDepression]

Der Witz an der Sache ist ja, dass der Inhalt des ursprünglichen Arrays in ein identisches Bitmuster in 'Ergebnis' kopiert wird. Erst bei der Visualisierung (Konsolenausgabe, etc.) wird von der JVM ein 'dezimale' Darstellung erzeugt.😆
Interessant wird die Aufgabe ja erst, wenn man diesen Schritt auch zufuß geht.

 

[Jw456]

wenn man diesen Schritt auch zufuß geht.

Genau diesen Schritt will oder soll er ja machen. Wird wohl eine Aufgabe sein.

 

[berndoa]

Mathematisch alternativ kann man auch die Formel von irgendwem benutzen, wo du von der größten zur kleinsten Binärziffer geht und immer zwischenddition und Multiplikation abwechselst. Musst du keine Potenzen benutzen.
In etwa so:
Binärzahl: 101100111
Dezimalzahl((((((((1)*2+0)*2+1)*2+1)*2+0)*2+0)*2+1)*2+1)*2+1)
Also sowas wie:

int[] array={1,0,1,1,0,0,1,1,1}
int dezimal=array[0];

for (int i=1;i<array.length-1;i++){
    dezimal=dezimal*2+array[i];
}

Also dezimal=erste ziffer ganz vorne.
und danach dezimal immer mal 2 plus folgestelle.
bsi man alle ziffern durch hat.

 

[Jw456]

Mathematisch alternativ kann man auch die Formel von irgendwem benutzen, wo du von der größten zur kleinsten Binärziffer geht und immer zwischenddition und Multiplikation abwechselst. Musst du keine Potenzen benutzen.
In etwa so:
Binärzahl: 101100111
Dezimalzahl((((((((1)*2+0)*2+1)*2+1)*2+0)*2+0)*2+1)*2+1)*2+1)
Also sowas wie:

int[] array={1,0,1,1,0,0,1,1,1}
int dezimal=array[0];

for (int i=1;i<array.length-1;i++){
    dezimal=dezimal*2+array[i];
}

Also dezimal=erste ziffer ganz vorne.
und danach dezimal immer mal 2 plus folgestelle.
bsi man alle ziffern durch hat.

int dezimal=array[0]
Am Anfang sollte dezimal 0 sein.
Die for Schleife sollt somit auch von 0 anfangem.
Dann benutze doch mal eine foreach.

 

[MarvinsDepression]

Mathematisch alternativ kann man auch die Formel von irgendwem benutzen, wo du von der größten zur kleinsten Binärziffer geht und immer zwischenddition und Multiplikation abwechselst. Musst du keine Potenzen benutzen.
In etwa so:
Binärzahl: 101100111
Dezimalzahl((((((((1)*2+0)*2+1)*2+1)*2+0)*2+0)*2+1)*2+1)*2+1)
Also sowas wie:

int[] array={1,0,1,1,0,0,1,1,1}
int dezimal=array[0];

for (int i=1;i<array.length-1;i++){
    dezimal=dezimal*2+array[i];
}

Also dezimal=erste ziffer ganz vorne.
und danach dezimal immer mal 2 plus folgestelle.
bsi man alle ziffern durch hat.

Vorsicht! Üblicherweise befindet sich das 'least significant digit' bei Index 0 und bei diesem Algorithmus ist es wichtig beim 'most significant digit' zu beginnen. Die for-Schleife müsste also rückwärts laufen.
Das Array wird von links nach rechts initialisiert und somit als erstes der Index 0 eingetragen. Man könnte sagen, die binäre Zahl steht rückwärts geschrieben im Code.
Andererseits, wenn die Zahl als String codiert übergeben würde, wäre nach meiner unmaßgeblichen Meinug das MSD wieder links, weil wir beim lesen von zahlen es so erwarten. Ein toArray() liefert dann aber die faschen Indizes...
Was ist jetzt richtig(er) ? Diskussion folgt?

 

[Jw456]

Ich denke das LSB ist auf Pos [0].
Aber genauso wissen wir es nicht das weis nur der TE. Wie die genaue Aufgabe ist.

 

[berndoa]

Vorsicht! Üblicherweise befindet sich das 'least significant digit' bei Index 0 und bei diesem Algorithmus ist es wichtig beim 'most significant digit' zu beginnen. Die for-Schleife müsste also rückwärts laufen.
Das Array wird von links nach rechts initialisiert und somit als erstes der Index 0 eingetragen. Man könnte sagen, die binäre Zahl steht rückwärts geschrieben im Code.
Andererseits, wenn die Zahl als String codiert übergeben würde, wäre nach meiner unmaßgeblichen Meinug das MSD wieder links, weil wir beim lesen von zahlen es so erwarten. Ein toArray() liefert dann aber die faschen Indizes...
Was ist jetzt richtig(er) ? Diskussion folgt?

Das häng thalt davon ab wie die binärzahl ins Array gepackt wird,
Ich würde sie normal so eintragen wie sie da steht, also von links nahc rechts mit index 0,1,2,3,4,etc.

Klar, mathematisch gesehen (Stellenwertsystem und so) steht da

Binärzahl: 101100111
=1*2^8+0*2^7+1*2^6+1*2^5+...

die 1 vorne das msot significant bit und da 1 hinten das least significant bit.

Für die formel müsste man wie gesagt eigentlich vom most bis zum least significant bit gehen wobei ich annehme dass die ziffern von most zu least SB ins Array gepackt sind.

Aber gut, das hängt halt von der AUfgabe ab.
Falls sie Ziffern andersrum im Array sind, zählt man halt nicht von oben nahc unten sondern umgekehrt.

 

[berndoa]

int dezimal=array[0]
Am Anfang sollte dezimal 0 sein.
Die for Schleife sollt somit auch von 0 anfangem.
Dann benutze doch mal eine foreach.

das hatte ich am Anfang auch so vor aber wird dann nicht das MSB (die ziffer ganz links in der zahl) einmal zu oft mit 2 multipliziert?
Man fngt doch(wie oben dargelegt, erst mal mit der 1 ganz links an.
dann *2+0.
dann *2+1.
also für jede weitere ziffer nach der index=0ten ein *2+folgeziffer. oder? :O

Vielleicht habe ich die Formel auch nur falsch in erinnerung.
Aber rein logisch , wenn ich hinten eine ziffer dazu mache, werden ja alle vorherigen ziffdern mit 2 multipliziert, also "um eine stelle erhöht".

keine AHnung, müsste meiner Meinung nahc eigentlich so passen.

 

[KonradN]

aber wird dann nicht das MSB (die ziffer ganz links in der zahl) einmal zu oft mit 2 multipliziert?

So lange Du nur mit 2 multiplizierst, wenn Du auch eine Ziffer anfügst, dann passt es.

Und dann ist es auch genau das, was @MarvinsDepression in #3 schon beschrieben hatte in Pseudocode:

-ein Array (int[]) erstellen und mit Einsen und Nullen füllen.
-ergebnis = 0
-beginnend beim höchstwertigen 'Bit' durch das Array iterieren:
dabei jedes mal ergebnis = 2*ergebnis + Bit-Wert (1 oder 0)rechnen.

Daher passt das so und Du hast das richtig in Erinnerung gehabt.

 

[Jw456]

das hatte ich am Anfang auch so vor aber wird dann nicht das MSB (die ziffer ganz links in der zahl) einmal zu oft mit 2 multipliziert?
Man fngt doch(wie oben dargelegt, erst mal mit der 1 ganz links an.
dann *2+0.
dann *2+1.
also für jede weitere ziffer nach der index=0ten ein *2+folgeziffer. oder? :O

Vielleicht habe ich die Formel auch nur falsch in erinnerung.
Aber rein logisch , wenn ich hinten eine ziffer dazu mache, werden ja alle vorherigen ziffdern mit 2 multipliziert, also "um eine stelle erhöht".

keine AHnung, müsste meiner Meinung nahc eigentlich so passen.

wenn das MSB auf Pos[0] im Array ist Passt dein Code.

wenn du eine ForEach benutzt musst du mit 0 anfangen

int[] array={1,0,1,1,0,0,1,1,1}
int dezimal=0;

for (int bit  : array ){
    dezimal=dezimal*2+array[bit];
}
// 0*2 = 0 + 1 = 1
// 1*2 = 2 + 0 = 2
// 2*2 = 4 + 1 = 5
....

 

[KonradN]

// 0*2 = 0 + 1 = 1
// 1*2 = 2 + 0 = 2
// 2*2 = 4 + 1 = 5

Da hast Du das Richtige gemeint, aber das, was Du da aufgeschrieben hast, ist mathematisch so nicht korrekt: 0*2 ist nicht 1 und 2*2 ist nicht 5

 

[Jw456]

Damit der Herr es auch versteht
0 * 2 = 0
0 + 1 = 1


päpstlicher als der Papst selst der Mathe Lehrer

 

[berndoa]

Am Ende vom Lied meinen wir ALle Dasselbe und je nachdem wie die Binärziffern wie herum im Array abgelegt sind, ändert sich halt geringfügig der Code.

Ging mir ja eigentlich auch nur durm dass es die Variante gibt bei der man nicht dauernd Potenzen berechnen lassen muss.
Ist vor Allem auch praktisch falls man bspw. nicht alle Ziffern als Array da liegen hat sondern die Binärzahl (most significant bit first, also links nach rechts) ziffernweise eingelesen bekommt.

Praktishc für Streams und so (Obgleich ich noch nie Streams benutzt habe, nur immer drüber gelesen ). Oder auch die Standardeingabe mit dem klassischen

while(Eingabeteil.getNext()!=null){
    //hier Ziffer verarbeiten
}