Algorithmus zum umwandeln einer zahl in 8bit kodierung.

[JackintheBox]

Hi

Also, ich hab für die Uni ne Hausaufgabe bei der ich in nem Programm unteranderem für eine ganze Zahl die Kodierung im 8Bit 2er Kompliment ausgeben muss. Da der vorderste Bit eh nur das Vorzeichen angibt, lass ich den gerade mal außenvor.
Zur Info: Ich darf dazu im Prinzip nur Schleifen verwenden.

 for(zaehler = 1; zaehler <= 140; zaehler++){

      if(e % 2 == 0) y = 0;
                    else y = 1;
      e = e / 2;

      if(zaehler == bit){
        IO.print(y);
        e = exponent;
        bit = bit + (bit - 1);
      }

    }

Der Sinn an der ganzen Sache soll folgender sein:
Das erste if testet, ob ich an der Stelle an der ich gerade bin ne 0 oder ne 1 brauche und speichert das erstmal in y. Danach geh ich mit e / 2 an die nächste Stelle.
Das zweite if testet jetzt, ob ich überhaupt an der richtigen Stelle bin um das y auszugeben, wenn dem so ist soll genau das passieren. Das bit ist mit 7 initialisiert. Danach soll das e wieder auf seinen Urpsrungswert vor der schleife zurück gesetzt werden (der Wert von exponent) und das bit auf 13 erhöht werden, weil ich die obere Schleife jetzt 6mal durchlaufen muss um an die 6te Stelle zu kommen. Das ganze ToHuWaBoHu natürlich nur, weil ich sonst Bits in der falschen Reinfolge ausgegeben bekomme.
Problem ist dann: ich bekomme 6 0en. Egal was ich tue. Und da blockierts grad bei mir

Hat jmd ne Idee wie ich das Problem anders lösen kann oder ich den Code von oben korrigieren muss?

So, ziemlich lang für nen ersten Post, ich hoff das ist in Ordnung so
In jedem Fall schonmal Danke! für die Mühe :applaus:

LG

 

[Der Müde Joe]

>weil ich sonst Bits in der falschen Reinfolge ausgegeben bekomme.

Man kann auch von hinten her beginnen...

for(int i = MAX ; i > 0; i--)

Den Rest hab ich jetzt nicht so ganz verstanden (das mit 13 7 und so.. ist auch noch etwas früh)...

mal als Bsp... (ich hoff es stimmt..sind aber mit 32 Bit...)

public static String toBinary(int b) {
	char[] binary = new char[32];
	// +/-
	if (b < 0) {
		binary[0] = '1';
	} else {
		binary[0] = '0';
	}
	for (int i = 31; i > 0; i--) {
		if ((b & 0x1) == 0) {
			binary[i] = '0';
		} else {
			binary[i] = '1';
		}
		// b/2
		b = b >> 1;
	}
	return new String(binary);
}

 

[energy47]

wie were es mit einer logischen und verknüpfung.. wo man einfach die integer zahl, bit für bit checkt ob es eine 0 oder 1 ist durch vergleich.. um dann die richtige bit folge zu haben lässt man die schleife rückwerts laufen zb sowas:

public static void toBinary(int x) {
		
		//log(x)/log(2) stellt die benötigte bit anzahl deiner zahl fest
		//uns speichert das in variable "bit"		
		byte bit = (byte)(Math.log(x)/Math.log(2));
		
		for(;bit >= 0;bit --) {  			//damit man die richtige reinfolge
											//hat, lässt man die schleife
			if( (x & (1<<bit)) > 0)			//rückwerts laufen und checkt so die zahl
				System.out.print("1");		//von links nach rechts durch
			else
				System.out.print("0");
		}
		
	}

für zweierkomplement muss das natürlich noch erweitert werden..

 

[JackintheBox]

hm.
das problem ist, das ich offiziell aus der vorlesung im prinzip nur die datentypen und schleifen kenne und auch nur das benutzen soll. dazu halt die IO befehle (komische algo tools, einlese ausgebe befehle).

die 7, 13 usw. soll heißen, dass wenn ich den ersten bit (den 7ten) ausgegeben hab, die schleife ab da ja wieder 6x laufen muss um den 6ten bit zu bekommen, also +6 = 13. wenn ich da in der 2ten if klausel den zaehler zurücksetze wird die schleife endlos, darum muss ich die bit variable so anpassen , dass ich immer an der richtigen stelle den wert rausfische.
das ist was ich mir dabei gedacht hab :/.

was hat das mit der char variablen und dem binary da oben auf sich? bin anfänger und lern java grad in der vorlesung. kann damit also grade nicht soviel anfange

trotzdem schonma danke ^^

 

[Der Müde Joe]

>dass wenn ich den ersten bit (den 7ten) ausgegeben hab,

Das versteh ich nicht, den ersten = siebten oder ??

>6x laufen muss um den 6ten bit zu bekommen, also +6 = 13

Jetzt wirds etwas misteriös?

Erklär doch mal ganz einfach was du möchtest. Ich verstehe im Moment: Ich will eine Zahl im binär Format.
Oder in Psydo:
10 = 1010

1010 --> modulo2 = 0
1010 / 2
101 --> modulo2 = 1
101 / 2
10 -----> modulo2 = 0
10 / 2
1 ------> modulo2 = 1

 

[JackintheBox]

richtig soweit. kann auch sein das der gedanke nicht ganz richtig ist.

was ich gedacht habe ist ungefähr:

-der erste bit ist das vorzeichen, ich hab also 7 bit für die kodierung über. fall die zahl negativ ist geb ich einfach als erstes ne
1 aus und addiere dann 128 zu dem wert. da 10000000 ja -128 und 00000000 0. falls positiv geb ich einfach ne 0 aus und mach weiter.
-so wie du das schon aufgeschrieben hast rechne ich die mids mit % 2 und dann durch /2 ja so aus, dass ich sie am ende falschraum herausbekomme.
-wenn ich jetzt mit der ausgabe der ersten zahl solange warte bis ich die schleife 7x durchlaufen habe, dann habe ich den bit der an die erste stelle gehört.
-wenn ich jetzt die die zahl wieder so zurücksetze wie sie vor der schleife war und die schleife jetzt 6x durchlaufe, habe ich den bit der an die 2te stelle gehört.
-jetzt setz ich das e wieder zurück auf den ausgangswert und durchlaufe die schleife 5x und habe dann die 1 oder 0 an der 5ten stelle.

usw.
die variable bit ist dann also die stelle die ich aktuell möchte. da der zaehler aber immer weiter läuft muss ich das dann immer von dem zuletzt aktuellen "bit" aus sehen.
für bit = 7 will ich also die ausgabe nach 7x durchlaufen der schleife, was der ersten stelle in der kodierung nach der vorzeichenkodierung entspricht.
dann will ich nach zurücksetzten des "e"s nochmal 6x durch die schleife, also insgesamt 7+6 mal.
damit müsst ich doch erreichen, dass mein e 6x durchgenudelt wird und am ende ein y=0 gespeichert und dann ausgegeben wird.

so ungefähr hab ich mir das gedacht. ist irgendwie relativ kompliziert, aber ich hab halt kein großes sammelsurium an befehlen zur auswahl

vllt. ist das jetzt etwas klarer

 

[werkuh]

ich vermute mal du studierst auch in osnabrück...

ich häng am selben problem und versuchs mal detailliert darzustellen

wir haben von der uni die äußerst nutzlosen AlgoTools bereitgestellt bekommen und sollen momentan sämtliche aufgaben ohne arrays und ohne die klassenbibliothek von java lösen

die komplette aufgabenstellung sieht so aus, dass wir eine gleitkommazahl einlesen sollen und diese dann in binärdarstellung nach dem schema [vorzeichen exponent mantisse] ausgeben sollen.

die mantisse zu berechnen ist dabei ja verhältnismäßig einfach, das vorzeichen klärt sich ja auch nach der eingabe. das problem ist jedoch, den exponenten ins zweierkomplement zu codieren, da das ja ohne arrays n bisschen knifflig ist, da man für jedes der 8 exponentenbits eine eigene variable bräuche (hier wäre ein array total hilfreich). einen positiven exponenten könnte man ja auch einfach via Integer.toBinaryString() ausgeben, bei negativen exponenten kommt dabei allerdings nur unsinn raus. zusätzlich schmeißt Integer.toBinaryString() den exponenten auf 23 bits aus, man braucht allerdings nur 8 (mal ganz davon ab, dass wir das ding nicht benutzen sollen). in meinen augen ist die aufgabe reine schikane, aber mann kann ja nichts dagegen tun ^^

also das eigentliche problem ist es ne integer auf 8bit 2erkomplement zu bekommen, ohne dabei die klassenbibliothek oder arrays zu benutzen, dadran bin ich auch grad am verzweifeln :/

 

[JackintheBox]

allerdings

falls du die zündende idee hast, oder sonst den exponenten vernünftig ausgegeben bekommst, sag bescheid.

das wir überprüfen sollen, an welcher stelle wir grade sind und dann abhängig davon die 0 bzw 1 ausgeben sollen oder nicht, war ein tipp von nem übungsleiter.
der zweite tipp war nen anderen algorithmus zur erstellung der binär darstellung zu verwenden, davon ausgehen das die stellen ja auch als 2^1 2^2 2^3 usw. gesehen werden können. vllt find ich mit dem ansatz was.

 

[JackintheBox]

Okay, hab ne Lösung.
Nicht besonders schön, ziemlich lang, tut aber was es soll:

public class Achtbit {

  public static void main(String[] argv) {

      int k = IO.readInt("Bitte ein k ");

      if(k >= 64){
        IO.print("1");
        k = k - 64;
      }
      else IO.print("0");
      if(k >= 32){
        IO.print("1");
        k = k - 32;
      }
      else IO.print("0");
      if(k >= 16){
        IO.print("1");
        k = k - 16;
      }
      else IO.print("0");
      if(k >= 8){
        IO.print("1");
        k = k - 8;
      }
      else IO.print("0");
      if(k >= 4){
        IO.print("1");
        k = k - 4;
      }
      else IO.print("0");
      if(k >= 2){
        IO.print("1");
        k = k - 2;
      }
      else IO.print("0");
      if(k >= 1){
        IO.print("1");
      }
      else IO.print("0");
  }
}

dazu noch das vorzeichen und es sollte funktionieren. naja. was anderes fällt mir auch nicht mehr ein.

 

[werkuh]

das geht auch einfacher, habs auch gerade geknackt, nachdem ich auf anraten mal ein paar zahlen per hand umcodiert hab.

du musst wenn du eine negative zahl codierst das ganze einfach in nen string schreiben, die neuen zahlen vorne in den string setzen und damit brauchst du es nicht mehr umdrehen, sondern kriegste die ausgabe richtigrum.

wenn du nen negativen exponenten kodieren willst, musst du den betrag bilden (vorzeichen umkehren), ein addieren und dann einfach 0 und 1 vertauschen und dann wieder in nen string schreiben wie oben.

klingt kompliziert, ist aber reltativ einfach

 

[Michael...]

Zur Info: Ich darf dazu im Prinzip nur Schleifen verwenden.

Wenn Schleifen Bestandteil der Aufgabenstellung war (was ich mal annehme), dann ist das nicht unbedingt die geforderte Lösung.
Diese ganzen if-Prüfungen könnte man in einer Prüfung innerhalb einer Schleife zusammenfassen.

 

[werkuh]

soderle, ich habs auch hinbekommen... in schleifen

    if(exponent >= 0) {

      for(int i = 1; i <= 8; i++) {

        if(exponent % 2 == 0)                                                   // binäre Ausgabe des Exponenten
          expDual = "0" + expDual;                                              // in umgekehrter Reihenfolge
        else                                                                    // (Elemente vorne in den String schreiben)
          expDual = "1" + expDual;

        exponent /= 2;
      }
    }
    else {
                                                                                // bei negativem Exponenten:
      exponent = - exponent + 1;                                                // umkehren und 1 addieren
      for(int i = 1; i <= 8; i++) {                                             // und beim umrechnen in Dual
        if(exponent % 2 == 0)                                                   // 0 und 1 vertauschen, entspricht
          expDual = "1" + expDual;                                              // - exponent + 256 -> codiert
        else                                                                    // = codierung.
          expDual = "0" + expDual;
          
          exponent /= 2;
      }
    }

    for(int i = 1; i <= 23; i++) {                                              // Mantisse codieren

      redmantisse *= 2;

       if(redmantisse >= 1) {
         redmantisse -= 1;
         mantDual = mantDual + "1";
       }
       else
         mantDual = mantDual + "0";
         
    }

schön ist was anderes.... aber wenigstens funzt es ^^