# Integer in zwei Bits



## lucyyy (15. Jan 2021)

Guten Tag,

folgende Aufgabe habe ich: 
Implementiere das Interface Spielfeld mit einer weiteren Klasse SpielfeldInteger, die intern eine int-Variable zur Darstellung des aktuellen Spielfeldzustandes verwendet. Wieder darf das Interface nicht verändert werden. Verwende die Bit-Operationen von Java, um den Zustand einer Zelle des Spielfeldes in jeweils zwei Bits der int-Variablen abzulegen (warum gerade zwei?). 

Dabei geht es um das Spiel TicTacToe.

Wie genau kann ich hier also einen Integer in 2 Bits umwandeln?


----------



## mihe7 (15. Jan 2021)

Ein int sind 32 Bits, da gibts nichts umzuwandeln. Worum es geht, ist einzelne Bits zu setzen. Das funktioniert, indem man mit dem bitweisen Oder-Operator zwei ints miteinander verknüpft.


----------



## kneitzel (15. Jan 2021)

Also erst einmal die Frage: Wie viele Zustände hat ein Feld bei Tic Tac Toe?
==> Daraus kann man die Anzahl der notwendigen Bits bekommen.

Wie viele Spielfelder hat ein TicTacToe Spiel? ==> Dann kann man sich, zusammen aus der oberen Information, die Anzahl der Bits ausrechnen, die man braucht. Und man kann prüfen, ob es in ein int passt ... (Und wird wohl, da es ja so vorgegeben ist)

Dann muss man nur noch überlegen, wie man auf welches Bits zugreifen kann ... Was für bitweise Zugriffe kennst Du denn in Java?


----------



## kneitzel (15. Jan 2021)

mihe7 hat gesagt.:


> Ein int sind 32 Bits, da gibts nichts umzuwandeln. Worum es geht, ist einzelne Bits zu setzen. Das funktioniert, indem man mit dem bitweisen Oder-Operator zwei ints miteinander verknüpft.


Nunja - ich würde auch noch den shift Operator erwähnen. Der wird sich bei der Aufgabe bestimmt auch als hilfreich erweisen denke ich mal....


----------



## mihe7 (15. Jan 2021)

Nicht alles auf einmal


----------



## mihe7 (15. Jan 2021)

OK, sehen wir uns mal ein TicTacToe-Spielfeld an und tragen dort jeweils zwei Bits ein. Als Ausgangswert verwenden wir einfach mal 0 für jedes Bit.


00​00​00​00​00​00​00​00​00​

Wie viele Zustände kann ein einzelnes Feld nun einnehmen? Wie viele Zustände kann man mit einem Bit darstellen? Wie kann man die verschiedenen Zustände mit zwei Bits kodieren?


----------



## lucyyy (15. Jan 2021)

mihe7 hat gesagt.:


> OK, sehen wir uns mal ein TicTacToe-Spielfeld an und tragen dort jeweils zwei Bits ein. Als Ausgangswert verwenden wir einfach mal 0 für jedes Bit.
> 
> 
> 00​00​00​00​00​00​00​00​00​
> ...


Ein Feld kann ab da ja nur noch einen Zustand annehmen. Also der, dass da jemand drauf ist. Entweder Spieler 1 oder Spieler 2. Heißt er kann aus zwei Zuständen nur einen annehmen. 
Ich weiß aber leider nicht, wie ich es mit zwei Bits kodieren kann. Ich würde aus 00 dann einfach 11 oder 22 machen. 
In meinem Studiengang haben wir aber nie damit gearbeitet, weshalb ich nicht wirklich Ahnung davon habe haha


----------



## thecain (15. Jan 2021)

Ein Bit ist {0,1}... Also eher nicht 22


----------



## mihe7 (15. Jan 2021)

lucyyy hat gesagt.:


> Heißt er kann aus zwei Zuständen nur einen annehmen


Leer, Spieler 1 oder Spieler 2 sind für Dich nur zwei Zustände?



lucyyy hat gesagt.:


> Ich würde aus 00 dann einfach 11 oder 22 machen.


22 ist mit einem Bit, das nur 0 oder 1 annehmen kann, etwas schwierig.


----------



## httpdigest (15. Jan 2021)

mihe7 hat gesagt.:


> 22 ist mit einem Bit, das nur 0 oder 1 annehmen kann, etwas schwierig.


Vielleicht hat er auch zu viel Futurama (Hell Is Other Robots) geguckt.


----------



## kneitzel (15. Jan 2021)

Die Frage wäre evtl. angebracht, in wie weit die Zusammenhänge mit Bit, Byte und Integer verstanden wurden.
Kannst du erläutern, was sich hinter diesen Begriffen verbirgt und wie diese zusammen hängen?


----------



## mihe7 (15. Jan 2021)

httpdigest hat gesagt.:


> Vielleicht hat er auch zu viel Futurama (Hell Is Other Robots) geguckt.


Was war da?


----------



## httpdigest (15. Jan 2021)

mihe7 hat gesagt.:


> Was war da?


----------



## mihe7 (15. Jan 2021)

@httpdigest Move segment register to r/m16?


----------



## White_Fox (15. Jan 2021)

lucyyy hat gesagt.:


> Ein Feld kann ab da ja nur noch einen Zustand annehmen. Also der, dass da jemand drauf ist. Entweder Spieler 1 oder Spieler 2. Heißt er kann aus zwei Zuständen nur einen annehmen.
> Ich weiß aber leider nicht, wie ich es mit zwei Bits kodieren kann. Ich würde aus 00 dann einfach 11 oder 22 machen.
> In meinem Studiengang haben wir aber nie damit gearbeitet, weshalb ich nicht wirklich Ahnung davon habe haha


mihe7 will auf Stellenwertsysteme hinaus. Ein Bit ist in der Computerrechnerei die kleinstmögliche Informationseinheint und kann zwei mögliche Zustände annehmen. Im Computer werden die Zustände eines Bits mit Strom AN/Strom AUS dargestellt, genauso gut könntest du aber z.B. auch eine Leuchte ein- oder ausschalten (das wird in der Elektronik übrigens auch genutzt).

Wenn du jetzt mehrere Bits aneinanderreihst, kannst du damit Zahlen bilden, wobei jedes Bit eine Wertstelle repräsentiert.
Im Dezimalsystem kennst du das: bei einer dreistelligen Zahl, z.B. 231, hast du ganz rechts die Einerstelle, in der Mitte die Zehnerstelle, links die Hunderterstelle, und kannst das Ganze nach links beliebig erweitern.

Bei Bits funktioniert das ganz genauso, der Witz ist, daß du halt nur bis 1 zählen kannst. Willst du bis zwei zählen mußt du um eine Stelle links erweitern. Und das nennt man dann Binär- oder Dualsystem. Wenn du zwei Bits hast, kannst du insgesamt bis drei (also vier Zustände, null gibt es ja auch noch) zählen (0bx = Binärsystem):

0b00 -> 0
0b01 -> 1
0b10 -> 2
0b11 -> 3

Nur aus Interesse: Was studierst du eigentlich?


----------



## mihe7 (15. Jan 2021)

White_Fox hat gesagt.:


> mihe7 will auf Stellenwertsysteme hinaus.


Eigentlich wollte ich hier gerade darauf nicht hinaus, weil man hier keine Zahlen umrechnen muss


----------



## White_Fox (16. Jan 2021)

Sicher mußt du nicht umrechnen. Aber lucyyy muß wissen, wie man zwei Bits in 32 Bits unterbringt, und da finde ich es schon hilfreich zu wissen, wie das mit den Stellen funktioniert.


----------



## Meniskusschaden (16. Jan 2021)

White_Fox hat gesagt.:


> da finde ich es schon hilfreich zu wissen, wie das mit den Stellen funktioniert.


Um das zu vertiefen könnte man dann noch die Implementierung so ändern, dass statt der int- eine short-Variable als Spielfeldspeicher verwendet wird.


----------



## mihe7 (16. Jan 2021)

White_Fox hat gesagt.:


> Sicher mußt du nicht umrechnen. Aber lucyyy muß wissen, wie man zwei Bits in 32 Bits unterbringt, und da finde ich es schon hilfreich zu wissen, wie das mit den Stellen funktioniert.


Das ändert aber nichts daran, dass ich darauf nicht hinaus wollte  

Mir ging es einfach darum, dass ein int 32 Bits speichert und man jedes Bit mit einer Bitmaske und einer Oder-Verknüpfung setzen kann (mit einer Und-Verknüpfung testen kann usw.) Dass sich die 32 Bits auch als Zahl interpretieren lassen, spielt dabei keine Rolle, man könnte den Spaß auch mit einem BitSet nachbilden.


----------



## kneitzel (16. Jan 2021)

Meniskusschaden hat gesagt.:


> Um das zu vertiefen könnte man dann noch die Implementierung so ändern, dass statt der int- eine short-Variable als Spielfeldspeicher verwendet wird.


Naja - die Idee dürfte doch sein, das ganze Spielfeld in nur einem int zu speichern. Da reichen ja 3 Byte aus.

Wobei das Verständnis mit den Zahlen auch gut und wichtig ist. Ich hatte ja erst einmal explizite shift Operationen im Sinn. Aber das braucht man nicht, denn durch die Zahlen geht das ja ebenso gut. (Wobei es auf das Gleiche hinaus läuft. Ein shift um eine Position ist ja auch nur eine Multiplikation oder Division durch zwei.

Aber daher ist halt der erste wichtig Punkte: Ist das Verständnis da, um was es hier denn dann geht. Wie die Daten prinzipiell gehalten werden und so. (Daher schon mein #11!)


----------



## Meniskusschaden (16. Jan 2021)

kneitzel hat gesagt.:


> Naja - die Idee dürfte doch sein, das ganze Spielfeld in nur einem int zu speichern. Da reichen ja 3 Byte aus.


Ja. Ich hatte ich es als Vertiefung (des Themas Stellenwertsysteme) bezeichnet, weil es für die eigentliche Aufgabe nicht erforderlich ist. Damit ist die Implementierung nicht mehr ganz so einfach wie mit den Bitmasken, dafür drückt man den Speicherbedarf auf zwei Byte.


----------



## lucyyy (17. Jan 2021)

An sich verstehe ich generell Bits und so schon. Aber in der Aufgabenstellung wiederum habe ich echt keine Ahnung.
Mein Prof will ja, dass ich dann pro Zelle zwei Bits zur Darstellung verwende. Aber wie kann ich dies überhaupt machen?
Ich habe bis jetzt nur mit integer, long und short gearbeitet zur Zahlendarstellung. 
Deswegen bin ich echt verwirrt von dieser Aufgabe.

Und kurz zu der Frage was ich studiere: Ich studiere European Computer Science xD


----------



## mihe7 (17. Jan 2021)

lucyyy hat gesagt.:


> European Computer Science


Ah, das ist dann der Teilbereich, den keiner braucht und der Rest findet sich dann in American Computer Science  SCNR.



lucyyy hat gesagt.:


> Aber wie kann ich dies überhaupt machen?


Hast Du die Kommentare nicht gelesen?


----------



## lucyyy (17. Jan 2021)

mihe7 hat gesagt.:


> Ah, das ist dann der Teilbereich, den keiner braucht und der Rest findet sich dann in American Computer Science  SCNR.


Naja geht so. Ist schon ganz cool haha


mihe7 hat gesagt.:


> Hast Du die Kommentare nicht gelesen?


Doch, ich habe die Kommentare gelesen. Allerdings verstehe ich immer noch nicht, wie ich dass dann in Java umsetzen kann.


----------



## mihe7 (17. Jan 2021)

a | b liefert in Java die bitweise OR-Verknüpfung von a und b.
a & b liefert in Java die bitweise AND-Verknüpfung von a und b.
a << 1 liefert in Java die Bits von a um ein Bit nach links verschoben.
a >> 1 liefert in Java die Bits von a um ein Bit nach rechts verschoben (das Vorzeichen wird dabei berücksichtigt)
a >>> 1 funktioniert wie a >> 1, nur ohne Berücksichtigung des Vorzeichens.

Mach was draus


----------



## lucyyy (17. Jan 2021)

mihe7 hat gesagt.:


> a | b liefert in Java die bitweise OR-Verknüpfung von a und b.
> a & b liefert in Java die bitweise AND-Verknüpfung von a und b.
> a << 1 liefert in Java die Bits von a um ein Bit nach links verschoben.
> a >> 1 liefert in Java die Bits von a um ein Bit nach rechts verschoben (das Vorzeichen wird dabei berücksichtigt)
> ...


Ich verstehe nicht, wie mir das zur Aufgabe weiterhilft. 
Ich hab doch einen Integer der pro 2 Bits mir eine Zelle darstellt. Wie kann ich aber diesen Integer in 18 Bits umwandeln. Und kann ich das dann als einen normalen Integer verwenden um Zahlen darzustellen.
Also dass ich dann sage, dass wenn die erste Zelle besetzt ist, der Integer folgendermaßen aussieht: 110000000000000000?


----------



## httpdigest (17. Jan 2021)

Hier mal etwas ausführlicher, weil es ganz offensichtlich den Anschein hat, als fehlten dir hier noch einige wichtige Konzepte:

Ihr sollt als primitiven Datentyp `int` zur Modellierung des Spielfeldes verwenden.
Ein `int` in Java hat 32 Bits. Das Spielfeld hat 9 Zellen und pro Zelle habt ihr jeweils 3 verschiedene Zustände, die die Zelle annehmen _kann_. Oben wurde ja schon erläutert, dass man aufgerundet 2 Bits benötigt, um 3 Zustände zu speichern (ceil(log2(3)) == 2). Also musst du jede Zelle mit zwei Bits darstellen, wofür du für ein Feld mit 9 Zellen also 9*2 = 18 Bits benötigst. Das sind gerade 2 Bits mehr als der nächstkleinere Datentyp `short` besitzt. Somit sollt ihr wohl also `int` nehmen.

Man kann in Java ein int nicht in "kleine" Bits umwandeln, weil es ein "Bit" als Datentyp nicht gibt. Du musst also Bitoperationen wie @mihe7 schon sagte, jeweils immer auf das ganze 32-bit `int` anwenden, wenn du eine "Zelle" aktualisieren willst. Du hast als "Wortbreite" für alle möglichen Operationen also immer "ganze 32-bits".

Jetzt musst du die logischen, bitweisen Operationen verwenden (deren Wahrheitstabellen du ja sicherlich kennst - zumindest bei OR), um gezielt nur einzelne Bits in dem ganzen `int` zu setzen.


----------



## lucyyy (17. Jan 2021)

httpdigest hat gesagt.:


> Hier mal etwas ausführlicher, weil es ganz offensichtlich den Anschein hat, als fehlten dir hier noch einige wichtige Konzepte:
> 
> Ihr sollt als primitiven Datentyp `int` zur Modellierung des Spielfeldes verwenden.
> Ein `int` in Java hat 32 Bits. Das Spielfeld hat 9 Zellen und pro Zelle habt ihr jeweils 3 verschiedene Zustände, die die Zelle annehmen _kann_. Oben wurde ja schon erläutert, dass man aufgerundet 2 Bits benötigt, um 3 Zustände zu speichern (ceil(log2(3)) == 2). Also musst du jede Zelle mit zwei Bits darstellen, wofür du für ein Feld mit 9 Zellen also 9*2 = 18 Bits benötigst. Das sind gerade 2 Bits mehr als der nächstkleinere Datentyp `short` besitzt. Somit sollt ihr wohl also `int` nehmen.
> ...


Ah okay, jetzt habe ich es schon etwas besser verstanden. 
Wenn ich zum Beispiel die erste Zelle mit den Spieler 1 besetzen möchte. Muss ich dann a>>b verwenden, damit die ersten beiden Bits auf 1 gesetzt werden?


----------



## httpdigest (17. Jan 2021)

lucyyy hat gesagt.:


> Wenn ich zum Beispiel die erste Zelle mit den Spieler 1 besetzen möchte. Muss ich dann a>>b verwenden, damit die ersten beiden Bits auf 1 gesetzt werden?


Warum willst du denn die ersten *beiden *Bits auf 1 setzen? Und was genau sind für dich die *ersten* Bits? Also: Du hast 3 verschiedene Zustände und 2 Bits pro Zelle.
Wie genau planst du, mit den jeweils zwei Bits pro Zelle die drei Zustände abzubilden?


----------



## kneitzel (17. Jan 2021)

Das wichtige sind die Zusammenhänge.

Bit -> Byte: Ein Byte besteht aus 8 Bit. Diese kann man hintereinander weg schreiben, also z.B. 00000000.
Wenn man da nun die Stellen durchgeht, dann haben die eine gewisse Wertigkeit. So wie im Dezimalsystem auch.

Wertigkeit im Dezimalsystem:
- Erste Ziffer sind die Einer. (mal 10^0 = 1)
- zweite Ziffer sind die Zehner (mal 10^1 = 10)
- dritte Ziffer sind die Hunderter (mal 10^2 = 100)
- ...

Im Dualen System ist es auch so, nur eben ist die Basis jetzt 2 und nicht zehn, also haben wie 2^0, 2^1, 2^2, .... sprich: Wertigkeiten sind 1, 2, 4, 8, 10, .... (Also immer mal 2 statt mal 10 im 10er-System)

Integer -> sind sind nun 4 Byte, also kann man schreiben:
00000000 00000000 00000000 00000000
==> 32 Bit.

Wenn Du nun 2 Bit für eine Darstellung brauchst, dann kannst Du das natürlich nehmen ... bei 9 Feldern brauchst du also 18 Bit. Von den 32 bleiben also 14 unbenutzt:
00000000 000000xx xxxxxxxx xxxxxxxx
0er sind unbenutzte Bits, x benutzte.

Nun ist die Frage, wie kommst Du an die zwei Bit, die Dich interessieren?
Da kann man nun mit bitweisen Operationen hantieren ... also z.B. mittels UND.

00000000 000000xx xxxxxxxx xxxxxxxx und
00000000 00000000 00000000 00000011
== 00000000 00000000 00000000 000000xx --> Wir haben nur noch die letzten beiden Bits...

Aber ebenso kann man sich anschauen, das da für Wertigkeiten sind. 1, 2, 4!! Ab der 4 wollen wir nichts mehr. Also nehmen wir einfach die Zahl und Rechnen modulo 4!
Kann man sich ja gut aufschreiben: x*1 + y*2 -> modulo 4 bleiben die, wenn da ein x 1 sein soll.
x*4 + x*8 + x*16 + ... --> Das wird bei modulo 4 immer 0 geben.

Wenn ich nun binär eine Zahl xxyy habe (mal nur 4 Bits dargestellt) und mich interessieren nur die xx: Wie bekommt man diese xx?
a) logisch und: yyxx UND 1100 -> yy00 - aber der Wert ist halt noch hoch...
b) shift Operation: Ich kann bits verschieben. Ich verschiebe zwei Stellen und schon ist xx entfallen und ich habe nur yy.
c) eine shift Operation ist auch ein geteilt durch 2. Also einfach / 4 rechnen und ich habe auch yy.

Also wenn ich xxxxyyxx habe, dann kann ich diese binäre Zahl durch 4 Teilen (dann verschiebe ich diese so dass yy am Ende steht) und dann modulo rechnen. Und schon habe ich den Wert des Feldes ...

Nun musst Du nur überlegen, wie Du an jedes einzelne Felde kommen kannst. Wie sieht da die Berechnung aus?
Also mich interessiert jeweils das yy:
Feld 1: 00000000 000000xx xxxxxxxx xxxxxxyy
Feld 2: 00000000 000000xx xxxxxxxx xxxxyyxx
Feld 3: 00000000 000000xx xxxxxxxx xxyyxxxx
Feld 4: 00000000 000000xx xxxxxxxx yyxxxxxx
Feld 5: 00000000 000000xx xxxxxxyy xxxxxxxx
Feld 6: 00000000 000000xx xxxxyyxx xxxxxxxx
Feld 7: 00000000 000000xx xxyyxxxx xxxxxxxx
Feld 8: 00000000 000000xx yyxxxxxx xxxxxxxx
Feld 9: 00000000 000000yy xxxxxxxx xxxxxxxx

Mit den Informationen oben sollte es also möglich sein den jeweiligen Wert von yy zu lesen.

Wenn Du das hast, dann bleibt nur noch die Frage, wie Du die einzelnen Bits setzen kannst...


----------



## lucyyy (17. Jan 2021)

kneitzel hat gesagt.:


> Nun musst Du nur überlegen, wie Du an jedes einzelne Felde kommen kannst. Wie sieht da die Berechnung aus?
> Also mich interessiert jeweils das yy:
> Feld 1: 00000000 000000xx xxxxxxxx xxxxxxyy
> Feld 2: 00000000 000000xx xxxxxxxx xxxxyyxx
> ...


Kann ich dann hier einfach durch 4 rechnen und dann modulo?
Also das bei jedem Feld machen?


----------



## lucyyy (17. Jan 2021)

httpdigest hat gesagt.:


> Warum willst du denn die ersten *beiden *Bits auf 1 setzen? Und was genau sind für dich die *ersten* Bits? Also: Du hast 3 verschiedene Zustände und 2 Bits pro Zelle.
> Wie genau planst du, mit den jeweils zwei Bits pro Zelle die drei Zustände abzubilden?


Ich dachte dass wenn ich beide auf 1 setze, ich somit zeige, dass dort jemand drauf ist


----------



## httpdigest (17. Jan 2021)

lucyyy hat gesagt.:


> Ich dachte dass wenn ich beide auf 1 setze, ich somit zeige, dass dort jemand drauf ist


Naja, kann man ja so machen. Mir war nur wichtig, dass du dir bewusst wirst, was "beide auf 1" denn ganz genau bedeutet? Bzw. was ist, wenn eben nur "einer auf 1 ist"?


----------



## thecain (17. Jan 2021)

Wie würdest du es denn z.B für Feld 1.lösen? Welche Werte gibt es, wie stellst du sie dar?


----------



## lucyyy (17. Jan 2021)

thecain hat gesagt.:


> Wie würdest du es denn z.B für Feld 1.lösen? Welche Werte gibt es, wie stellst du sie dar?


Ich würde beim 1.Feld Und 00000000 00000000 00000000 00000011 machen und dann habe ich die letzten beiden Bits.
Ich weiß aber nicht, ob dort Diese dann direkt verändert werden, oder ob ich die irgendwie noch ändern muss und wie weiß ich auch nicht.


----------



## thecain (17. Jan 2021)

Welcher int wäre das? Und welcher Zustand? X,O odwr nichts?


----------



## lucyyy (17. Jan 2021)

thecain hat gesagt.:


> Welcher int wäre das? Und welcher Zustand? X,O odwr nichts?


Ich weiß nicht wie ich es erkennen kann.


----------



## mihe7 (17. Jan 2021)

```
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 000000ab ERGIBT
00000000 00000000 00000000 000000ab
```


```
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 0000ab00 ERGIBT
00000000 00000000 00000000 0000ab00
```


```
00000000 00000000 00000000 00001100 ODER
00000000 00000000 00000000 ab000000 ERGIBT
00000000 00000000 00000000 ab001100
```
Damit hätten wir z. B. mal die Felder 1, 2, und 4 durch.

Wenn man einen Spieler mit

```
00000000 00000000 00000000 000000ab
```
darstellt und das n-te Feld besetzen möchte, muss man die Bitfolge um 2*(n-1) Bits nach links verschieben. Zum Beispiel Feld 5 -> Verschiebung um 8 nach links:


```
00000000 00000000 000000ab 00000000
```

Verknüpft man damit das Feld, erhält man eben ein Spielfeld, in dem Feld 5 mit ab besetzt ist - vorausgesetzt, das Feld war vorher leer!

Jetzt ist die Frage: was ist a und was ist b? Für Spieler 1 könnte man a=0, b=1 wählen und für Spieler 2 könnte man a=1 und  b=0 wählen. Dann gibt es je Feld zwei Bit: 00 = leer, 01 = Spieler 1 und 10 = Spieler 2.


----------



## lucyyy (17. Jan 2021)

mihe7 hat gesagt.:


> ```
> 00000000 00000000 00000000 00000000 ODER
> 00000000 00000000 00000000 000000ab ERGIBT
> 00000000 00000000 00000000 000000ab
> ...


Und wie kann ich dass dann um n*(n-1) nach links verschieben?
Und muss ich dann am Anfang den integer mit 32 Nullen initialisieren?
Meine Idee wäre es dann bei den Cases einfach immer anzugeben, dass wenn er auf dem Feld... ist, soll er es verschieben und mit den Benutzer füllen sozusagen.


----------



## mihe7 (17. Jan 2021)

lucyyy hat gesagt.:


> Und wie kann ich dass dann um n*(n-1) nach links verschieben?
> Und muss ich dann am Anfang den integer mit 32 Nullen initialisieren?
> Meine Idee wäre es dann bei den Cases einfach immer anzugeben, dass wenn er auf dem Feld... ist, soll er es verschieben und mit den Benutzer füllen sozusagen.


Wie oben geschrieben: mit dem <<-Operator 

OK, ich mach mal Code, vielleicht wird es dann leichter:

```
class Test {
    // Konstante für die Bitmaske des Spielers, wir könnten auch einfach = 1 schreiben,
    // hier nur zur Verdeutlichung der Bits.
    public static final int SPIELER1 = 0b00000000_00000000_00000000_00000001; 

    // Unser Spielfeld, das wird automatisch mit 0 initialisiert -> alle 32 Bits sind also 0.
    private int spielfeld; 

    // Beispiel, wie man ein gegebenes Feld mit Spieler 1 besetzt.
    public void besetzeFeldMitSpieler1(int feldIndex) {
        int verschiebung = 2*feldIndex; // feldIndex für das erste Feld ist 0, will man das n-te Feld, rechnet man 2*(n-1) wie oben
        int bitmaske = SPIELER1 << verschiebung; // verschieben der Bits von SPIELER1 um verschiebung Bits nach links, das Ergebnis wird in bitmaske abgelegt
        spiefeld = spielfeld | bitmaske; // hier verknüpfen wir das Spielfeld mit der Bitmaske per ODER-Verknüpfung (wie oben) und speichern das Ergebnis in Spielfeld.
    }
    ...
}
```


----------



## lucyyy (17. Jan 2021)

mihe7 hat gesagt.:


> Wie oben geschrieben: mit dem <<-Operator
> 
> OK, ich mach mal Code, vielleicht wird es dann leichter:
> 
> ...


Das macht es auf jeden Fall schon mal viel leichter, dankeschön!
Ich werde es mal versuchen und falls ich Schwierigkeiten oder Fragen habe werde ich nochmal schreiben


----------

