Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Kann jemand den Code erklären?
Warum machen wir -1? Wofür steht 0b11? Warum machen wir *2 und ?
warum schieben wir nach rechts? Ich verstehe den Code garnicht
Java:
public int gibBesitzer(int zeile, int spalte) {
int index = zeile*3+spalte;
return (spielInt>>>2*index & 0b11) - 1;
}
public void besetzePosition(int zeile, int spalte, int spieler) {
int index = zeile*3+spalte;
spielInt &= ~(0b11 << 2*index); // clear
spielInt |= (spieler+1) << 2*index;
}
Also so einen Ausschnitt zu zeigen bringt nur Vermutungen. Im Code wird man z.B. sehen, wie man Werte speichert. Wie die Besitzer gespeichert werden und so.
Und was hast Du denn verstanden? Woran scheitert es? Hast Du die einzelnen Operatoren verstanden?
Kannst Du das, was da gemacht wird, denn erläutern? Hast Du das mal einfach mit Stift und Papier durchgespielt?
int index = zeile*3+spalte;
Was wird hier berechnet? Was kommt da raus? Hast Du mal ein Spielfeld aufgemalt und dann die index Werte eines jeden Feldes rein geschrieben?
(spielInt>>>2*index & 0b11) - 1;
Was passiert da bei den Operatoren? Was macht spielInt>>>2*index?
Wenn Du das verstanden hast: Was macht ein & 0b11 - was ist dieses 0b11 überhaupt?
Das -1 wirst Du verstehen, wenn Du anschaust, wie Werte geschrieben werden. Welche Werte werden denn als Besitzer genommen?
Also so einen Ausschnitt zu zeigen bringt nur Vermutungen. Im Code wird man z.B. sehen, wie man Werte speichert. Wie die Besitzer gespeichert werden und so.
Und was hast Du denn verstanden? Woran scheitert es? Hast Du die einzelnen Operatoren verstanden?
Kannst Du das, was da gemacht wird, denn erläutern? Hast Du das mal einfach mit Stift und Papier durchgespielt?
int index = zeile*3+spalte;
Was wird hier berechnet? Was kommt da raus? Hast Du mal ein Spielfeld aufgemalt und dann die index Werte eines jeden Feldes rein geschrieben?
(spielInt>>>2*index & 0b11) - 1;
Was passiert da bei den Operatoren? Was macht spielInt>>>2*index?
Wenn Du das verstanden hast: Was macht ein & 0b11 - was ist dieses 0b11 überhaupt?
Das -1 wirst Du verstehen, wenn Du anschaust, wie Werte geschrieben werden. Welche Werte werden denn als Besitzer genommen?
Damit hast Du das mit dem index verstanden. Was ist mit den übrigen Dingen?
So Code kann man sich nur erarbeiten, in dem man sich genau überlegt, was jeder einzelne Schritt macht. Das dann verständlich formuliert und schon hat man eine Beschreibung an Hand derer man einen Überblick bekommen kann.
Daher wirklich alle Punkte der Reihe nach ganz genau beschreiben!
Damit hast Du das mit dem index verstanden. Was ist mit den übrigen Dingen?
So Code kann man sich nur erarbeiten, in dem man sich genau überlegt, was jeder einzelne Schritt macht. Das dann verständlich formuliert und schon hat man eine Beschreibung an Hand derer man einen Überblick bekommen kann.
Daher wirklich alle Punkte der Reihe nach ganz genau beschreiben!
A binary numeral consists of the leading ASCII characters 0b or 0B followed by one or more of the ASCII digits 0 or 1 interspersed with underscores, and can represent a positive, zero, or negative integer.
Du hast ja bereits erläutert, wie man einen Index für ein mehrdimensionales (Spiel-) Feld in ein eindimensionales Feld umrechnet. Du hast geschrieben Array. Es gibt aber kein Array. Wie wird also das Spielfeld gespeichert. Hilfe: Die Lösung steht bereits im Namen der Klasse.
Lösung: Das Feld wird in einem Integer gespeichert. Du hast also 32 Bit zur Verfügung, um ein Spielfeld mit 9 Feldern unterzubringen. Nebenbei hast du zwei Spieler, ein Feld muss also drei Zustände annehmen können: leer - Spieler 1 - Spieler 2. Wie du bereits erkannt hast, benötigt man dazu 2 Bits. Jeweils zwei Bits der 32 Bit des Integers entsprechen also einem Feld. Und die kann man auch indexieren, ungefähr so:
in der Variablen spielInt (Typ int -> 32bit groß) ist das ganze Spielfeld abgebildet, einschließlich der Besitzer der einzelnen Felder. Für jedes der neun Felder werden zwei benachbarte bits reserviert. Je nachdem, welches der bits gesetzt, also (1) ist, bedeuted es, dass Spieler_0, oder Spieler_1 im Besitz eines Feldes ist.
Also Nur um es noch einmal ganz deutlich zu machen:
Du hast eine binäre Darstellung - es werden immer 2 Bit pro Feld gespeichert.
Ein Bit besagt, ob ein Feld belegt ist oder nicht und das andere bit besagt, welcher Spieler (falls das Feld belegt ist).
Bei den 9 Feldern sind das also 18 Bit, die genutzt werden. Diese 18 Bit betrachten wir jetzt einfach. Am Anfang ist alles 0:
00 00 00 00 00 00 00 00 00
Wenn wir jetzt ein bestimmtes Feld haben wollen, dann müssen wir
a) Die bits so verschieben, dass die gewünschten Bits ganz rechts sind.
b) alle anderen bits wegmachen.
Also wir interessieren uns z.B. für index 2 - das wären dann diese Bits:
?? ?? ?? ?? ?? ?? xx ?? ?? (da wir die anderen Werte nicht kennen, habe ich da mal ?? gesetzt!)
Um diese xx ganz rechts zu haben, müssen wir alles nach rechts schieben. Dazu dient der Operator >>>
Und um wie viele Bits müssen wir schieben? Um 4 Bits - halt 2 * den index.
Somit erhalten wir bei >>> 4 dann folgendes:
?? ?? ?? ?? ?? ?? xx
Nun stören aber noch die ganzen ?? - um die los zu werden können wir nun eine bitweise operation machen.
0 und 0 -> 0
0 und 1 -> 0
1 und 0 -> 0
1 und 1 -> 0
Also 0 und ? ist immer 0.
Also machen wir:
?? ?? ?? ?? ?? ?? xx und
00 00 00 00 00 00 11
und erhalten: 00 00 00 00 00 00 xx
Bei den gannzen 0er und dann 11 kann man die führenden 0er weglassen ... das ist also einfach 11 (also 0b11 in Java)
Somit weisst Du nun, wie die Methode nun den Wert eines Feldes bekommt.
in der Variablen spielInt (Typ int -> 32bit groß) ist das ganze Spielfeld abgebildet, einschließlich der Besitzer der einzelnen Felder. Für jedes der neun Felder werden zwei benachbarte bits reserviert. Je nachdem, welches der bits gesetzt, also (1) ist, bedeuted es, dass Spieler_0, oder Spieler_1 im Besitz eines Feldes ist.
Weil der Wert 1 bzw 2 mit +1 gespeichert wird: setzung = (spieler+1)<<(zeile*3*2)+(spalte*2);
Die Idee ist halt, dass Du hast:
00 -> nicht belegt
1x -> belegt mit x = 0 bzw. 1 für Spieler 1 bzw 2.
Wenn Du so Code hast, den Du nicht verstehst, dann spiel etwas damit:
=> Schreib Dir eine Methode, die diese 18 Bit ausgibt
=> Nutze diverse Methoden um Werte zu setzen / zu lesen um zu sehen, was gespeichert wird.
Darüber kannst Du dann prüfen, ob alle Felder belegt sind: (spielInt&0x2AAAA) == 0x2AAAA
Das wirst Du verstehenm wenn Du 0x2AAAA einmal binär darstellst.
Weil der Wert 1 bzw 2 mit +1 gespeichert wird: setzung = (spieler+1)<<(zeile*3*2)+(spalte*2);
Die Idee ist halt, dass Du hast:
00 -> nicht belegt
1x -> belegt mit x = 0 bzw. 1 für Spieler 1 bzw 2.
Wenn Du so Code hast, den Du nicht verstehst, dann spiel etwas damit:
=> Schreib Dir eine Methode, die diese 18 Bit ausgibt
=> Nutze diverse Methoden um Werte zu setzen / zu lesen um zu sehen, was gespeichert wird.
Darüber kannst Du dann prüfen, ob alle Felder belegt sind: (spielInt&0x2AAAA) == 0x2AAAA
Das wirst Du verstehenm wenn Du 0x2AAAA einmal binär darstellst.
v & 3 bedeutet eine bitweise ver-UND-und von v mit 0b11 (Binärliteral für dezimal 3).
Es "extrahiert" also die beiden niedrigstwertigsten Bits von v, was als Integer interpretiert die Zahlen 0, 1, 2 oder 3 als mögliches Ergebnis bedeuten würde.
in der Variablen spielInt (Typ int -> 32bit groß) ist das ganze Spielfeld abgebildet, einschließlich der Besitzer der einzelnen Felder. Für jedes der neun Felder werden zwei benachbarte bits reserviert. Je nachdem, welches der bits gesetzt, also (1) ist, bedeuted es, dass Spieler_0, oder Spieler_1 im Besitz eines Feldes ist.
in der Variablen spielInt (Typ int -> 32bit groß) ist das ganze Spielfeld abgebildet, einschließlich der Besitzer der einzelnen Felder. Für jedes der neun Felder werden zwei benachbarte bits reserviert. Je nachdem, welches der bits gesetzt, also (1) ist, bedeuted es, dass Spieler_0, oder Spieler_1 im Besitz eines Feldes ist.
Also der Unterschied ist, wie mit dem Vorzeichen umgegangen wird. Einmal wird einfach das Vorzeichen beachtet und das andere Mal kommt einfach eine 0 rein. Da das Vorzeichenbit aber immer 0 ist (wir haben ja nur positive Werte da drin) ist der Verhalten hier also gleich.
Nochmals in korrigierter Fassung, da ich mich in #14 nicht ganz an die Vorgaben gehalten habe.
Code:
Zeile | 2 | 1 | 0 |
Spalte | 2| 1| 0| 2| 1| 0| 2| 1| 0|
spielInt |00| ... |10|11|11|10|00|00|10|00|11| (für das Programm sind nur die rechten 18 bit wichtig)
^ ^ ^
bit-Position 31(MSB) 17 ... 0(LSB)
leer : 0 => binär 00 (linkes bit (=0) -> Feld frei)
Spieler_1 : 2 => binär 10 (linkes bit (=1) -> Feld besetzt, rechtes bit (=0) -> Spieler_1)
Spieler_2 : 3 => binär 11 (linkes bit (=1) -> Feld besetzt, rechtes bit (=1) -> Spieler_2)
gewonnen hat Spieler_1, weil drei mal in Spalte 2 das Bitmuster 10 steht.
Jetzt überlege Dir: Um wieviele bit-Positionen muss das bit-Paar einer bestimmten Zeilen/Spalten-Kombination nach rechts verschoben werden, damit es an Position 0 zu liegen kommt?
Warum will man nun ein bestimmtes bit-Paar ganau an Position 0 haben. Weil nur dann sich Werte vergleichen lassen, wie z.B. das Bitmuster eines Feldes mit dem Bitmuster eines bestimmten Spielers.
Nochmals in korrigierter Fassung, da ich mich in #14 nicht ganz an die Vorgaben gehalten habe.
Code:
Zeile | 2 | 1 | 0 |
Spalte | 2| 1| 0| 2| 1| 0| 2| 1| 0|
spielInt |00| ... |10|11|11|10|00|00|10|00|11| (für das Programm sind nur die rechten 18 bit wichtig)
^ ^ ^
bit-Position 31(MSB) 17 ... 0(LSB)
leer : 0 => binär 00 (linkes bit (=0) -> Feld frei)
Spieler_1 : 2 => binär 10 (linkes bit (=1) -> Feld besetzt, rechtes bit (=0) -> Spieler_1)
Spieler_2 : 3 => binär 11 (linkes bit (=1) -> Feld besetzt, rechtes bit (=1) -> Spieler_2)
gewonnen hat Spieler_1, weil drei mal in Spalte 2 das Bitmuster 10 steht.
Jetzt überlege Dir: Um wieviele bit-Positionen muss das bit-Paar einer bestimmten Zeilen/Spalten-Kombinatiowarum setzen wir hiern nach rechts verschoben werden, damit es an Position 0 zu liegen kommt?
Warum will man nun ein bestimmtes bit-Paar ganau an Position 0 haben. Weil nur dann sich Werte vergleichen lassen, wie z.B. das Bitmuster eines Feldes mit dem Bitmuster eines bestimmten Spielers.
Hast Du dir das bitweise und einmal im Detail angesehen? Die ganzen Erklärungen sind doch schon gekommen.
3 ist binäre 11 - wir wollen nur die letzten 2 Bits betrachten:
Also machen wir:
?? ?? ?? ?? ?? ?? xx und
00 00 00 00 00 00 11 ergibt
00 00 00 00 00 00 xx ==> die letzten zwei Bit bleiben und alles übrige bleibt.
Und das ==2 bzw ==3 ist doch logisch. Es wurde ja die Spielernummer + 1 eingetragen. Also bei Spieler 1 steht da 2 und bei Spieler 2 eine 3.
Mal Dir das mit den Bits richtig auf und spiel es durch. Ich habe das sichere Gefühl, dass Du massive Probleme hast mit den bitweisem Verknüpfungen aber auch mir den ganzen anderen Operatoren, die verwendet wurden. Aber mehr, als die einmal zu erläutern können wir nicht. Die wichtigen Punkte sind jetzt mehrfach beschrieben worden - geh diese durch und versuch die Erläuterungen zu verstehen.
Jetzt möchten wir Spieler 2 auf das Feld 2 eintragen. Hier der erste Teil (spieler + 1) in binärer Darstellung:
Java:
Spieler 2 => 0b10 (2)
+ 1 => 0b11 (3)
Das muss jetzt an die Stelle von Feld 2. Wie der Index berechnet wird, weißt du ja aus Beitrag #3.
Wir verschieben also den berechneten Wert um die entsprechende Anzahl an Bits nach links, das Ergebnis ist (nur 8 von 32 Bits dargestellt)
Java:
0b00110000
Jetzt muss dieser Wert nur noch in das eigentliche Spielfeld übertragen werden. Dazu verwenden wir diesmal die logische ODER Verknüpfung:
Java:
0 oder 0 -> 0
0 oder 1 -> 1
1 oder 0 -> 1
1 oder 1 -> 1
Java:
Spielfeld: 0b???????? ODER
Setzung : 0b00110000
ergibt : 0b??11????
Alle Bits, die in Setzung "1" enthalten, enthalten auch im Spielfeld den Wert "1". Die anderen Bits aus Spielfeld bleiben unverändert erhalten. Genau was erreicht werden sollte.
Diese Technik mit Bitmasken sowie UND/ODER Verknüpfungen gezielt Bits zu manipulieren ist schon sehr alt, Stichworte dafür sind "Bitmaske" oder "Bitmanipulation".
Hast Du dir das bitweise und einmal im Detail angesehen? Die ganzen Erklärungen sind doch schon gekommen.
3 ist binäre 11 - wir wollen nur die letzten 2 Bits betrachten:
Also machen wir:
?? ?? ?? ?? ?? ?? xx und
00 00 00 00 00 00 11 ergibt
00 00 00 00 00 00 xx ==> die letzten zwei Bit bleiben und alles übrige bleibt.
Und das ==2 bzw ==3 ist doch logisch. Es wurde ja die Spielernummer + 1 eingetragen. Also bei Spieler 1 steht da 2 und bei Spieler 2 eine 3.
Mal Dir das mit den Bits richtig auf und spiel es durch. Ich habe das sichere Gefühl, dass Du massive Probleme hast mit den bitweisem Verknüpfungen aber auch mir den ganzen anderen Operatoren, die verwendet wurden. Aber mehr, als die einmal zu erläutern können wir nicht. Die wichtigen Punkte sind jetzt mehrfach beschrieben worden - geh diese durch und versuch die Erläuterungen zu verstehen.
Jetzt möchten wir Spieler 2 auf das Feld 2 eintragen. Hier der erste Teil (spieler + 1) in binärer Darstellung:
Java:
Spieler 2 => 0b10 (2)
+ 1 => 0b11 (3)
Das muss jetzt an die Stelle von Feld 2. Wie der Index berechnet wird, weißt du ja aus Beitrag #3.
Wir verschieben also den berechneten Wert um die entsprechende Anzahl an Bits nach links, das Ergebnis ist (nur 8 von 32 Bits dargestellt)
Java:
0b00110000
Jetzt muss dieser Wert nur noch in das eigentliche Spielfeld übertragen werden. Dazu verwenden wir diesmal die logische ODER Verknüpfung:
Java:
0 oder 0 -> 0
0 oder 1 -> 1
1 oder 0 -> 1
1 oder 1 -> 1
Java:
Spielfeld: 0b???????? ODER
Setzung : 0b00110000
ergibt : 0b??11????
Alle Bits, die in Setzung "1" enthalten, enthalten auch im Spielfeld den Wert "1". Die anderen Bits aus Spielfeld bleiben unverändert erhalten. Genau was erreicht werden sollte.
Diese Technik mit Bitmasken sowie UND/ODER Verknüpfungen gezielt Bits zu manipulieren ist schon sehr alt, Stichworte dafür sind "Bitmaske" oder "Bitmanipulation".
Es sollen binär die Werte 10 und 11 gespeichert werden, denn so lässt sich das höherwertige bit als Flag: belegt / nicht belegt benutzen. (Was dann zu der Möglichkeit führt, dass man dies über das 2AAAA prüfen kann.)
Es sollen binär die Werte 10 und 11 gespeichert werden, denn so lässt sich das höherwertige bit als Flag: belegt / nicht belegt benutzen. (Was dann zu der Möglichkeit führt, dass man dies über das 2AAAA prüfen kann.)
Ich habe meine istVoll Methode geändert, weil ich nicht mit 2AAAAA zurecht komme. Mit dieser Änderung ist mein Code #37 richtig? oder muss trotzdem 10, 11 und dann spieler+1 schreiben?
Hier würde ich empfehlen, einfach einmal den Code selbst zu testen. Du kannst das ja einfach einmal nutzen - halt diverse Felder setzen und immer prüfen, dass genau dieses Feld gesetzt wurde und kein anderes. Da kannst Du dann den ganzen Code intensiv ausprobieren um dann so selbst die Frage zu beantworten.
Hier würde ich empfehlen, einfach einmal den Code selbst zu testen. Du kannst das ja einfach einmal nutzen - halt diverse Felder setzen und immer prüfen, dass genau dieses Feld gesetzt wurde und kein anderes. Da kannst Du dann den ganzen Code intensiv ausprobieren um dann so selbst die Frage zu beantworten.
Such unbedingt nach "Bitmaske" oder "Bitmanipulation". Das sind Techniken, die man nicht oft benötigt, aber dennoch kennen sollte. Die ganze Übung, die du gerade machst, geht nur ganz genau um dieses Thema.
Du weißt, dass ein Spieler zwei Bit belegt. Sobald das Feld besetzt ist, dann ist das höherwertige Bit gesetzt. Welcher Spieler darauf steht ist egal (=> ?).
Java:
2b0? => Feld frei
2b1? => Feld belegt
Wir beschränken uns wieder auf 8 Bit, damit es nicht so lang wird. Das Feld 2 ist durch einen Spieler belegt, sieht also so aus:
Java:
2b001?0000
Möchte ich wissen, ob diese Feld belegt ist, dann kann ich das mit einer Bitmaske herausfinden:
Java:
2b001?0000 (Feld)
2b00100000 (Maske)
------------------ AND
2b00100000 (Ergebnis)
Das Ergebnis entspricht der Maske, wenn das Feld gesetzt war, ansonsten wäre es 0 (in diesem Fall).
Jetzt besetzen wir alle Felder.
Java:
2b1?1?1?1? (Feld)
2b10101010 (Maske)
------------------ AND
2b10101010 (Ergebnis)
Gleicher Ergebnis: Wenn das Ergebnis der Maske entspricht, dann waren alle Felder gesetzt.
Die binäre Darstellung 2b10101010 entspricht einer hexadezimalen Darstellung von 0xAA
Die Verknüpfung mit 0x2AAAA ist das selbe Prinzip nur mit ein paar Bits mehr, um alle 9 Felder abzudecken.
Die hexadezimale Darstellung geht ja von 0 bis F, was dezimal 0 bis 15 und binär 0000 bis 1111 entspricht. Man kann eine binäre Darstellung also ganz gut in Viererblöcke aufteilen und sehr leicht zur hexadezimalen Darstellung gelangen.
