# Problem mit Roulette-Spiel



## FranzM (29. Mai 2004)

bin gerade in einer sackgasse was mein roulette spiel angeht und hoffe das ihr mir hier ein paar ansatzpunkte geben könnt

habe alle möglichen zahlenreihen auf die gesetzt werden kann in arrays abgelegt... eine random methode implementiert die eine zahl zwischen 0 - 36 zurückgibt...

mein problem ist: wie kann ich diese zahl durch alle arrays laufen lassen um übereinstimmungen auszulesen?

auf hilfe hoffend

Franz

hier mein popeliger code so far:

```
public class Roulette extends Bet  
{
    int rot[] = {1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36};
    int schwarz[] = {2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35};
    int bank[] = {0};
    int dozen1[] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int dozen2[] = {13,14,15,16,17,18,19,20,21,22,23,24};
    int dozen3[] = {25,26,27,28,29,30,31,32,33,34,35,36};
    int pair[] = {2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36};
    int impair[] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35};
    int half1[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
    int half2[] = {19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36};
        
    void zahl()
    {
        Random r1 = new Random();
        int number = (int) (r1.nextDouble() * 37);
        System.out.print("Ergebnis: "+number+"\n");
        }
```


----------



## Beni (29. Mai 2004)

Wie wäre es mit einer Schlaufe?


```
public boolean inArray( int[] array, int search ){
  for( int i = array.length-1; i>=0; i-- )
    if( array[i] == search )
      return true;

  return false;
}
```

mfg Beni


----------



## FranzM (29. Mai 2004)

omg wenn dummheit schmerzen würde hätte ich jetzt gerade echte probleme...  

kennt ihr dass, wenn man schon lange an einem programm arbeitet und nicht aufhören will
und dann is man plötzlich zu blöde das einfachste vom einfachen zu implementieren...   

danke für die rasche heilung beni  :toll: 

 :wink:


----------



## FranzM (29. Mai 2004)

naja moment so einfach is die sache dann doch nicht abgetan...

schließlich habe ich 10 verschiedene arrays die schlimmstenfalls (je nach setzweise des spielers) alle gecheckt werden müssen, daher meine nächste frage:

gibt es einen platzhalter für arraynamen? sprich wie kann ich die schleife für unterschiedliche arrays aufrufen?

dein- 

```
int[] array
```
 sollte doch ein platzhalter für eingabe eines meiner arrays sein oder? aber beim aufruf klappt das dann irgendwie net so wirklich.... omg denkblockade heute


----------



## der Pate (29. Mai 2004)

ich weiß nicht ob ich deine frage richtig verstanden hab, aber du kannst doch die methode einfach 10x aufrufen und dann  jedesmal ein anderes array mitschicken


----------



## FranzM (29. Mai 2004)

wie ruf ich jetzt meine arrays in der check methode auf ? 


```
public class Roulette extends Bet  
{
    int nummer;

    static int rot[] = {1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36};
    static int schwarz[] = {2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35};
    static int bank[] = {0};
    static int dozen1[] = {1,2,3,4,5,6,7,8,9,10,11,12};
    static int dozen2[] = {13,14,15,16,17,18,19,20,21,22,23,24};
    static int dozen3[] = {25,26,27,28,29,30,31,32,33,34,35,36};
    static int pair[] = {2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36};
    static int impair[] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35};
    static int half1[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
    static int half2[] = {19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36};
        
    public void zahl()
    {
        Random r1 = new Random();
        nummer = (int) (r1.nextDouble() * 37);
        System.out.print("Ergebnis: "+nummer+"\n");
        }
    
    
    public boolean check(int[] array)
    {
         for( int i = array.length-1; i>=0; i-- ) 
         if( array[i] == nummer ) 
         return true; 
         
    return false; 
    }
       
}
```
[/code]


----------



## Beni (29. Mai 2004)

```
boolean isRed = check( rot );
boolean isBlack = check( schwarz );

...
```

Du könntest auch einen 2dimensionalen Array verwenden, und die Indices als Konstanten speichern.

```
int[][] values = {{1, 2, 3}, {4, 5, 6, 7}};

public static final int INDEX_RED = 0;
public static final int INDEX_BLACK = 1;

public void xyz{
  boolean[] fields = new boolean[ values.length ];
  for( int i = fields.length-1; i>=0; i-- )
    fields[i] = check( values[i] );
}
```

Ist halt ein anderer Ansatz.

mfg Beni


----------



## Maks (30. Mai 2004)

muß nochmal nachdenken, vielleicht gibts noch eine bessere Methode.

Grundsätzlich wollte ich nur sagen, daß ich seit einiger Zeit auch an einen Roulette Programm arbeite, vielleicht können wir im Forum ein wenig an dem Thema dran bleiben und zwar nicht weil ICH dran arbeite, sondern weil bei dieser Art von Programm wirklich viel zu lernen ist!

Man braucht eine Zufallsgenerator (den besten habe ich versucht über Google ausfindig zu machen)

man braucht Wahrscheinlichkeitsberechnung

eine Eingabe-Ausgabe Funktion für die getippte Zahl(en) des Spielers und evtl. eine Speicherung der letzten 10 gefallenen Zahlen in einem Textfile.
Will man die echten Casino-Listen einlesen zum herausfinden einer Strategie (Vergleich der letzten 1000 Würfe)
dann braucht man sowieso eine Lesemöglichkeit aus einem Textfile.

FranzM, was bei Deinem Programm noch fehlt ist die Auflistung ALLER möglichen Setzungsmöglichkeiten, z.B. kann man ja auch auf zweier Dreier und sechser Kombinationen setzen.

Zu den Themen habe ich teilweise schon angefangen, jetzt gehts hauptsächlich um die Optimierung.

Wahrscheinlichkeitsberechnung:
Das ist ein Auszug aus dem, was ich bis jetzt habe:


```
import java.io.*; 
import java.util.*; 
import java.awt.*; 

public class RV
{
public static void main(String[ ] args) throws IOException 
	{ 
int a, b, c;

// Eingabe der Zahl auf die gesetzt wird

	BufferedReader din = new BufferedReader( 
	new InputStreamReader(System.in));
	System.out.println("Auf welche Zahl soll gesetzt werden: "); 
	a = Integer.parseInt(din.readLine()); 
	System.out.println(a);

// hier ein S U P E R zufälliger Zufallsgenerator
// Durch Zufallsgenerator ermittelte Zahl

      BitSet bitt = new BitSet();
      Random r = new Random();

      System.out.print("Die gefallene Zahl: ");
      int cnt = 0;
      while (cnt < 1) {
         int num = 0 + Math.abs(r.nextInt()) %36 ;
         if (!bitt.get(num)) {
            bitt.set(num);
            ++cnt;
         }
      }
      for (int i = 0; i <= 36; ++i) {
         if (bitt.get(i)) {
            System.out.print(i + " ");
         }
      }
      System.out.println("");


// Zuordnung der einzelnen Zahlen zu den Setz-Möglichkeiten

	int Schwarz	[] = {1,3,5,7,9,12,14,16,18,19,21,23,25, 27,30,32,34,36};
	int Rot		[] = {2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35};
	int Gerade	                [] = {2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36};
	int Ungerade	[] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35};
	int Manque	                [] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
	int Passe	                [] = {19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36};
	int Dutzend1              [] = {1,2,3,4,5,6,7,8,9,10,11,12};
	int Dutzend2	[] = {13,14,15,16,1718,19,20,21,22,23,24};
	int Dutzend3	[] = {25,26,27,28,29,30,31,32,33,34,35,36};

// Bruch Deklaration für Wahrscheinlichkeiten

	float Gesamtzahlen=37;	
	float Anzahl_rot=18, 		                BruchWrot;	
	float Anzahl_schwarz=18,  		BruchWschwarz;
	float Anzahl_gerade=18,		BruchWgerade;
	float Anzahl_ungerade=18, 	                BruchWungerade;
	float Anzahl_1bis18=18, 		BruchW1bis18;	
	float Anzahl_19bis36=18, 		BruchW19bis36;
	float Anzahl_erstesDutzend=12, 	                BruchWerstesDutzend;
	float Anzahl_zweitesDutzend=12, 	BruchWzweitesDutzend;
	float Anzahl_drittesDutzend=12, 	                BruchWdrittesDutzend;
	float Anzahl_ersteReihe=12, 	                BruchWersteReihe;
	float Anzahl_zweiteReihe=12, 	                BruchWzweiteReihe;
	float Anzahl_dritteReihe=12, 	                BruchWdritteReihe;

// Ausrechnen der Wahrscheinlichkeiten für die einzelnen Chancen

	BruchWrot		=(Anzahl_rot		/ Gesamtzahlen)*100;
	BruchWschwarz	=(Anzahl_schwarz	                / Gesamtzahlen)*100;
	BruchWgerade	=(Anzahl_gerade		/ Gesamtzahlen)*100;
	BruchWungerade	=(Anzahl_ungerade	                / Gesamtzahlen)*100;
	BruchW1bis18            =(Anzahl_1bis18		/ Gesamtzahlen)*100;
	BruchW19bis36	=(Anzahl_19bis36	                / Gesamtzahlen)*100;
	BruchWerstesDutzend	=(Anzahl_erstesDutzend	/ Gesamtzahlen)*100;
	BruchWzweitesDutzend=(Anzahl_zweitesDutzend	/ Gesamtzahlen)*100;
	BruchWdrittesDutzend	=(Anzahl_drittesDutzend	/ Gesamtzahlen)*100;
	BruchWersteReihe	=(Anzahl_ersteReihe	                / Gesamtzahlen)*100;
	BruchWzweiteReihe	=(Anzahl_zweiteReihe	                / Gesamtzahlen)*100;
	BruchWdritteReihe	=(Anzahl_dritteReihe	                / Gesamtzahlen)*100;

// Ausdrucken der ausgerechneten Wahrscheinlichkeiten

	System.out.println("Die Wahrscheinlichkeit fuer");
 	System.out.println("Farbe rot:		"+BruchWrot		+" Prozent");
	System.out.println("Farbe schwarz:	"+BruchWschwarz	                +" Prozent");
	System.out.println("gerade Zahlen:	"+BruchWgerade	    	+" Prozent");
	System.out.println("ungerade Zahlen:	"+BruchWungerade	                +" Prozent");
	System.out.println("Zahlen 1 bis 18:	"+BruchW1bis18	                +" Prozent");
	System.out.println("Zahlen 19 bis 36:	"+BruchW19bis36	                +" Prozent");
	System.out.println("das erste Dutzend:	"+BruchWerstesDutzend	+" Prozent");	
	System.out.println("das zweite Dutzend:	"+BruchWzweitesDutzend	+" Prozent");
	System.out.println("das dritte Dutzend:	"+BruchWdrittesDutzend	+" Prozent");
	System.out.println("erste Reihe:		"+BruchWersteReihe	                +" Prozent");
	System.out.println("zweite Reihe:	"+BruchWzweiteReihe	                +" Prozent");
	System.out.println("dritte Reihe:		"+BruchWdritteReihe	                +" Prozent");


Als Anregung hier auch noch das Durchzählen der möglichen Dreier Kombinationen
// Berechnung der Zahlen für "Dreier"


int Dreier [ ] [ ];
Dreier = new int [ 13 ]  [ 4 ];
int DreierZahlen=0;

for (int du = 1; du <= 12; du=du+1) {
System.out.print ( " du:" + du  );

      for (int dr = 1; dr <= 3; dr=dr+1) { 
      System.out.print ( " dr:" + dr  );

      DreierZahlen=DreierZahlen+1;

      Dreier  [du]  [dr] = DreierZahlen;  
System.out.print ( " Dreier [du] [dr]:" + Dreier  [du]  [dr]  );

     }

}
```

Für die Zweier also Pairs habe ich das auch noch gemacht (das wurde ein 50 Zeiler)
was ich aber hier noch nicht posten möchte, denn eine Lösung würde ja keinen mehr zum Denken anregen.

wichtiger wäre jetzt aber die Optimierung des hier geposteten Codes.
Natürlich wären erst mal alle Bereiche in eigene Methoden zu stecken, damits das Programm kein Bandwurm wird, was ich bisher noch nicht gemacht habe.

Das Durchsuchen der Schwarzen, Roten, geraden und sonstigen Zahlen war natürlich auch bloß eine riesen Schleife in der alle einzeln aufgelistet waren (gleiches Problem wie FranzM)

Nachdem das jetzt durch Beni fast gelöst ist, erst mal die Frage: wie kann man obenstehendes verkürzen/optimieren?
Und für welche Möglichkeiten (Gerade, ungerade, rot, schwarz) besteht die größte Wahrscheinlichkeit, wenn in den ersten 3 Würfen die Zahlen 4, 26 und 32 dran waren? Müssen dabei alle Einzelwahrscheinlichkeiten mit den anderen addiert werden?

Ich hoffe, damit wird jetzt keiner "erschlagen"


----------



## FranzM (30. Mai 2004)

ui das is ja toll das sich noch einer am roulette versucht...

schreib mir mal ne mail maks, ich denke es kann nicht schaden wenn wir in dem fall etwas zusammenarbeiten!

mail an: kumbaijaa@gmx.net

gruß


----------



## Maks (6. Jun 2004)

Ich glaube, jetzt muß ich doch nochmal fragen, sonst grüble ich noch ein paar Tage.
Hatte jetzt endlich mal wieder Zeit um mich mit euren Lösungsansätzen auseinanderzusetzen, aber ich glaube mit Arrays fehlt mir die Erfahrung.

Das hier wäre ein funktionstüchtiger Code, wenn man die Zeile Index...
richtig schreiben würde.
Das Durchsuchen von Schwarz, Rot oder sonstoges nach der gefallenen Zufallszahl funktioniert wunderbar.
Jetzt fehlt allerdings der "Index" um nicht 6 For next-Schleifen schreiben zu müssen im SInne von:


```
for (int ch = 1; ch < Schwarz.length; ch=ch+1) 
{

            System.out.print(Schwarz[ch] + ", ");
         
}
```

das Schwarz, Rot und sonstwas muß doch irgendwie durch ein Index-Feld in dem sowas wie {Schwarz, Rot, ungerade.....} aufgelistet ist ersetzbar sein?

in dem Fall möchte ich die Lösung von Beni vermeiden, daß ich zeilenweise schreibe schwarz = 0, Rot = 1 usw. um einen einfachen "Index" zu bekommen. Schwarz, Rot usw. soll direkt ausgelesen und als Index benutzt werden


```
import java.io.*; 
import java.util.*; 
import java.awt.*; 

public class Roul
{
public static void main(String[ ] args) throws IOException 
	{  

// Zuordnung der einzelnen Zahlen zu den Setz Möglichkeiten

	int Schwarz	[] = {1,3,5,7,9,12,14,16,18,19,21,23,25, 27,30,32,34,36};
	int Rot		[] = {2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35};
	int Gerade	[] = {2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36};
	int Ungerade	[] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35};
	int Manque	[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
	int Passe	[] = {19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36};

int Index = new int [30] [30];
int Setzmöglichkeiten = 6;
int ch = 1;


Index [Setzmoeglichkeiten] [ch] = {Schwarz, Rot, Gerade, Ungerade, Manque, Passe};
//ch = Zähler, der durch z.B. scharz alle Zahlen durchzählt.

for (int IndexSchleife=1; IndexSchleife < Setzmoeglichkeiten; IndexSchleife=IndexSchleife+1)
{
  for (int ch = 1; ch < Index.length; ch=ch+1) 
  {
    if (Zufallszahl=Index [Indexschleife] [ch]) 
    {
      //übernehme die Zufallszahl in ein Array
      //damit wenn mehrere Treffer auftauchen, ALLE Treffer
      //aufgelistet werden können
    }
  
     System.out.print(Index[Indesschleife][ch] + " ");
     //alle Index Zahlen werden aufgelistet
  }
}
```


----------



## FranzM (7. Jun 2004)

so hab mein roulette jetzt wieder einen kräftigen schritt nach vorne gebracht
ich kann bereits munter auf zahlenreihen setzen und gewinne bzw. abzüge werden
einwandfrei berechnet...

sorgen macht mir nur das einzelzahlen setzen:

ich bräuchte ein paar ansätze wie ich das bewerkstelligen soll!
problem dabei ist nämlich das die einzelzahlen in ein array müssen und zusätzlich noch der betrag
der pro zahl gesetzt wird (schließlich kann nicht nur eine zahl gesetzt werden sondern auch mehrere)

und weiters wie ich dieses array wieder auslese, bzw auf übereinstimmung überprüfe...

ein mehrdimensionales array kam mir in den sinn, das hat jedoch seine tücken...


hat jemand schon erfahrungen damit die er weitergeben würde?

gruß


----------

