CRC Prüfung

[µngbd]

xX Dany Xx schrieb:

dann p modulo q = rest ... in unserem Beispiel 101110011001 modulo 10011 = 0

Da bin ich ausgestiegen. Du hast doch oben schon nachgewiesen, dass da 5 als Rest bleibt. Und der Rest beim Dividieren ist natürlich in jedem Zahlensystem der gleiche, wie kommst du auf 0?

[xX Dany Xx]

Ja offenbar nicht..

101110011001 : 10011 = irgendwas (unwichtig)
10011
-----
0010000
  10011
  -----
  00011110
     10011
     -----
     011010
      10011
      -----
      010011
       10011
       -----
       00000 <- Rest = 0

Aber 2969 : 19 = 156 Rest 5 bzw. 2969 modulo 19 = 5

Und jetzt?

[µngbd]

xX Dany Xx schrieb:

Und jetzt?

irgendwas (unwichtig) bestimmen, die Probe machen, den Fehler finden, Weihnachten feiern.

[xX Dany Xx]

Was?

Da ist kein Fehler man... das ist richtig.. das ist en Beispiel von nem Prof .. also das mit den Dualzahlen, ich hab das dann in Dezimal umgerechnet, weil rüdiger gemeint hat ich soll das in ein anderes Zahlensystem umwandeln, aber wie ihr seht kommt nicht das gleiche raus..

Das Programm muss das so mit den Dualzahlen rechnen... vielleicht irgenwas mit shiften oder so???

Ich muss das bis Silvester abgeben..

[µngbd]

xX Dany Xx schrieb:

Das Programm muss das so mit den Dualzahlen rechnen... vielleicht irgenwas mit shiften oder so???

More question marks than sanity dictates? Überleg mal: Prozessoren arbeiten mit Worten, die beim Zahlenrechnen sowieso schon als Binärzahlen interpretiert werden müssen. Ein Computer kann deshalb nur mit Dualzahlen rechnen. Alles andere ist eine Illusion, die durch Ein- und Ausgabe zustande kommt.

Wenn du eine Zahl aus einem String machen willst, der eine binäre Zahl darstellt, geht das btw am einfachsten so:

#include <stdlib.h>

long zahl;
zahl = strtol("1010101", NULL, 2);

xX Dany Xx schrieb:

das ist richtig.. das ist en Beispiel von nem Prof

Nego consequentiam.

Ich kann mich auch irren, aber solange du zu faul bist, auch nur die Probe zu machen, rechne ich das sicher nicht nach.

[Genmutant]

Nachdem es völlig egal ist, in welchem Zahlensystem man rechnet, solange man es *richtig* macht, stimmt als Ergebnis für den Rest natürlich 5. Dein schriftliches Teilen ist einfach völlig falsch. Hast du schonmal schriftlich geteilt...?

[noopLolo]

denke das sind xor ops und dann ist da beim flüchtigen überlesen kein fehler?

[µngbd]

Ich kann mich auch irren, aber solange du zu faul bist, auch nur die Probe zu machen, rechne ich das sicher nicht nach.

Ach was soll's, es ist Weihnachten:

10011100 * 10011
        ---------
   10011100
    10011100
-----------------
101110010100

Das Ergebnis der Probe ist 101110010100, also 2964, das sind genau 5 zuwenig, und 5 ist der Rest. Was zu beweisen war.

Glaubst du uns jetzt?

[noobLolo]

also so komm ich auch auf 0

#include <stdio.h>
#include <stdlib.h>

int findFirstBitSet(int i){
	int x = 32;
	while(x--){
		if(i & 1<<x)
			return x;
	}
	return -1;
}

int main(void) {
	unsigned int a = 0xB99;//101110011001
	unsigned int b = 0x13;//10011
	unsigned int firstBit = 0x80000000;
	int dataBits = 12;
	unsigned int c = 0;

	a<<=31-findFirstBitSet(a);
	b<<=31-findFirstBitSet(b);

	c=a^b;
	while(dataBits--){
		if(c&firstBit){
			c^=b;
		}else
			c<<=1;
	}
	printf("%x",c);

	return 0;
}

endlich mal was ums durch den compiler zu jagen...

lg lolo

[µngbd]

noobLolo schrieb:

endlich mal was ums durch den compiler zu jagen...

Ich bin ein schwacher Hacker, weil mir manche Dinge mit Stift und Papier am leichtesten fallen. Nachdem ich aber im Vorraus bewiesen habe, dass dein Programm fehlerhaft ist, wirst du mir wohl verzeihen, dass ich den Fehler nicht suche, oder?

[noopLolo]

1101100101
110101
------
    110101
    110101
    ------
    000000

wäre also laut deiner rechnung

869%53=21

richtig?

[xX Dany Xx]

Cool cool noobLolo

Also ich hab das noch mit nem anderen Beispiel probiert mit 1010011 modulo 1011 = 0 ... also ich hab für a = 0x53; b = 0xB; dataBits = 7 ... und es kam auch 0 raus

Das war die Gute Nachricht... dann wollte ich 1010111 modulo 1011 = 100 rechnen..
also habe ich für a = 0x57; b = 0xB; dataBits = 7 und da kommt dann aber raus 60000000 .. okay gut das scheint falsch zu sein, aber das ist mir egal..

Es geht nur darum kannst du mir garantieren, dass wenn 0 rauskommen soll, kommt auch 0 raus? Weil sonst wenn was falsches rauskommt, ich mach eh if (rest!=0) return (0) .. weißt du was ich mein?

Aber du hast auf jeden schon Mal begriffen was ich will..

[µngbd]

noopLolo schrieb:

wäre also laut deiner rechnung

869%53=21

richtig?

Wenn du mir die Operationen sagst, für die die Striche stehen, kann ich mal drüber nachdenken.

[xX Dany Xx]

XOR

[noobLolo]

z. 17

int dataBits = findFirstBitSet(a)-1;
statt
int dataBits = 12;

machts etwas besser... ob das dann save ist kann ich nicht sagen...

[xX Dany Xx]

Ich glaube wenn du nicht int dataBits = findFirstBitSet(a)-1 machst,
sonder int dataBits = findFirstBitSet(a)-2 dann stimmts .. dann kommt nämlich auch die 4 raus bzw. 100 (binär)

Bei dem Beispiel 1010111 modulo 1011 = 100 ... a = 0x57; b = 0xB;

Kann das sein?

Edit 1:
Ne aber egal... kannst du das nun irgendwie auch so schreiben, dass der Benutzer das a und b als Dualzahl eingibt?

[noobLolo]

nee das ergebnis ist eigentlich immer "falsch" also wenn normal ne 0x1 rauskommt bekommst ne 0x80000000 oder so ähnlich

normal 0b0000000000000000000000000000001
anders 0b1000000000000000000000000000000

das sind so viele nullen aber ich denke das passt scho weiteres beispiel

normal 0b0000000000000000000000000001101
anders 0b1101000000000000000000000000000

denk ich zumindest kannst es ja mal checken und uns bescheid geben obs so ist.

[xX Dany Xx]

Ne is beides falsch.. also weder -1 oder -2 weil... mit dem ursprünglichen beispiel funzt es dann nicht....

Bei a = 0xB99; b = 0x13; int dataBits = findFirstBitSet(a)-1

kommt dann raus 98000000 ... müsste ja aber 0 sein ..

Edit 1
Dass die Reste umgedreht waren war mir schon klar... aber wie gesagt, das ist eigentlich auch egal. WICHTIG ist nur, dass 0 rauskommt, wenn sie rauskommen soll...

Edit 2
Wieso eigentlich -1? Es muss einfach nur int dataBits = findFirstBitSet(a) heißen und dann kommt in beiden Fällen wieder richtigerweise 0 als Rest raus...
Dann kommt sogar bei dem Beispiel a = 0xB90; b = 0x13 als Rest 48000000 das ist doch ne Hexzahl oder? Wenn man nun 48 (Hex) in binär umrechnet erhält man 1001000, richtig wäre aber 1001 also ohne die letzten bzw. ersten 3 Nullen. Ist das nur Zufall?

[noobLolo]

also bei mir stimmen die zwischen ergebnisse schon nur dass die schleife entweder zu früh oder zu spät abbricht und damit das end ergebnis verfälscht wird such da noch nach ner lösung wenn ich sie hab kommt sie natürlich wo sonst hier rein;)

[noobLolo]

Dann kommt sogar bei dem Beispiel a = 0xB90; b = 0x13 als Rest 48000000 das ist doch ne Hexzahl oder? Wenn man nun 48 (Hex) in binär umrechnet erhält man 1001000, richtig wäre aber 1001 also ohne die letzten bzw. ersten 3 Nullen. Ist das nur Zufall?

naja das hab ich im vorletzten post beschrieben und sollte normal sein allerdings steht da nicht umsonst ein noop bzw noob vor dem lolo