Binärcode einer Zahl, allerdings mit Einschränkung...

Herr-Vorragend

hi,

ich ich verzweifel fast: ich suche einen algorithmus, der den binärcode einer zahl erstellt, allerdings auch die länge berücksichtigt...

also sowas:

0       0
1       1
2      00 // und nicht 01 !
3      01
4      10
5      11
6     000
7     001
...

ich hoffe es wurde manchen einigermaßen verständlich und es gibt einen algorthmus für sowas ^^

MfG, Herr-Vorragend

das ist interresant ... aber sicher nicht binär ^^

weil meines wissens ist 0binär = 00binär ??? ... aber man/frau kann mich gerne verbessern ...

naja zur berechnung/umsetzung fällt mir persönlich sponatan nur ein das du das vermutlich irgendwie mir zeichenketten string/char machen werden musst weil somit 00 != 0 ist ... allerdings wie weiß ich auf anhieb nicht ;/ ... ist aber sicherlich interresant

Herr-Vorragend

jo, also binär ist das nicht, ich geb eh das ergebnis als string aus (es handelt sich dabei um RLE-0, falls das jemand etwas sagen sollte...) und da kann man dann auch die länge des strings unterscheiden...

groovemaster

Also so wie ich das sehe, musst du 2 Informationen aus dem Ausgangswert rausholen. Zum einen den "echten" Binärwert, der dem resultierenden Binärstring entspricht und zum anderen die Länge des Strings. Das ist nicht allzu schwer. Man kann sowas vielleicht auch mit Hashwerten oder irgendwelchen Bittricks machen, aber dafür bin ich momentan zu faul. Mir fällt momentan jedenfalls folgender Ansatz ein:

Bsp.

Ausgangswert    Binaerstring    "echter" Binaerwert Laenge Binaerstring
7               001             1                   3

Wenn du erstmal diese 2 Informationen hast, ist es kein Problem mehr, daraus den Binärstring zu machen.
Schaun wir uns also mal die Vorgaben an. Man sieht, dass immer nach einer entsprechenden Anzahl Werte eine neue Binärstelle im String hinzukommt.

2 + 4 + 8 + 16 ...

Das ist eine sehr schöne Reihe aus aufeinanderfolgenden 2er Potenzen. Dh in unserem Ausgangswert ist nicht nur der "echte" Binärwert, sondern sind auch die Anzahl der Binärstellen schön verschlüsselt. Und 2, 4, 8, 16 etc. stehen dabei für jeweils eine weitere Stelle. Alles was wir jetzt noch machen müssen, ist, alle Stellen rauszufiltern. Dabei bekommen wir nicht nur die Anzahl der Stellen raus, der Restwert ist auch noch unser gesuchter "echter" Binärwert. Im Grunde ist das wie modulo rechnen, leider fehlt uns aber der Divisor (oder ich seh ihn zumindest nicht). Ok, hier mal ein bissl Code

// x ist unser Ausgangswert
unsigned int foo(unsigned int x, unsigned int* anzahl_stellen)
{
	// Anzahl der Stellen
	unsigned int n = 1;
	unsigned int wert_stelle = 1 << n;
	// wir durchlaufen alle Stellen, bis der Wert der aktuellen Stelle groesser als unser verbleibender Ausgangswert ist
	// also solange, bis alle Stellen im Ausgangswert rausgefiltert wurden
	while (x >= wert_stelle)
	{
		// kick die aktuelle Stelle aus unserem Ausgangswert
		x -= wert_stelle;
		// naechste Stelle plz
		++n;
		wert_stelle <<= 1;
	}
	*anzahl_stellen = n;
	// "echter" Binaerwert
	return x;
}

Hoffe ich hab nix übersehen (ist halt schon etwas später).

Herr-Vorragend

Danke, funktioniert super, allerdings muss ichs erst noch kapieren

Herr-Vorragend

So, jetzt bräuchte ich noch genau das Gegenteil des Algorithmus', also "001" wird dann 7...

tut mir echt leid, aber ich krieg das allein echt nicht gebacken :-\

groovemaster

// x ist unser "echter" Binaerwert
// n ist die Anzahl der Binaerstellen
unsigned int foo(unsigned int x, unsigned int n)
{
    unsigned int wert_stelle = 2;
    // wir durchlaufen alle Stellen
    while (n > 1)
    {
        x += wert_stelle;
        // naechste Stelle plz
        --n;
        wert_stelle <<= 1;
    }
    return x;
}

*ungetestet*

Herr-Vorragend

jupp, funktioniert wunderbar. tausend dank!