# Roulette !



## Guest (15. Nov 2006)

Hallo !


Ich habe mir ein kleines Projekt vorgenommen. Und zwar will ich eine Art Roulette Tisch in Java erstellen.
Und zwar soll das so aussehen dass das Programm auf einmal ca 100 mal "die Kugel rollen" lässt, und dann eine Aufstellung darüber geben, wie oft welche Zahl gekommen ist.

So jetzt meine Fragen:

Was für Literatur, kann ich zu speziellen Lösung dieses Problems, lesen ?! Gibt es darüber etwas auf der Java Insel ?
Mit was für Klassen muss ich mich auseinandersetzten ?


Viele Lg !


----------



## Wildcard (15. Nov 2006)

Du brauchst dir nur eine Zufallszahl (mit Random) aus dem Wertebereich eines Roulettetisches ausgeben lassen und dir die Zahl merken.


----------



## Gast (15. Nov 2006)

naja ich will ja dass 100 ergebnisse aufeinmal in einer Auswertung erscheinen, und ich ablesen kann, welche Zahl wie oft gekommen is ..

Lg


----------



## Wildcard (15. Nov 2006)

Davon rede ich doch  ???:L


----------



## dercheffe (15. Nov 2006)

aber diese werte werden nie "echte" werte sein, weil ein computer den zufall eben nicht simulieren kann.


----------



## Wildcard (15. Nov 2006)

dercheffe hat gesagt.:
			
		

> aber diese werte werden nie "echte" werte sein, weil ein computer den zufall eben nicht simulieren kann.


Das kann ein Roulettetisch aber auch nicht


----------



## dercheffe (15. Nov 2006)

ein Roulette Tisch funktioniert nicht nach dem zufall Prinzip?


----------



## Wildcard (15. Nov 2006)

Wohin die Kugel geht hängt von der Drehgeschwindigkeit des Tisches, der Gravitiation, Luftströmungen,... ab.
Es ist also nicht zufällig sondern schwer zu berechnen.
Insofern sind der Tisch und die Random Klasse hier äquivalent.


----------



## Gast (15. Nov 2006)

ja ich will das ganze natürlich mit Random machen, das ist mir klar ...


----------



## Wildcard (15. Nov 2006)

Dann versuch deine Frage mal neu zu formulieren, da ich das Problem offensichtlich nicht sehe.


----------



## Gast (15. Nov 2006)

naja ich versuchs mal:

ich will ein Programm schreiben dass eine Roulette 100Mal "wirft", die Häufigkeitsverteilung graphisch ausgibt und die Standardabweichung der Häufigkeiten ausgibt ...

lg


----------



## Gast (15. Nov 2006)

Roulette Kugel ...


----------



## Wildcard (15. Nov 2006)

Dann passt's doch was ich dir gesagt habe.
Erzeuge dir 100 Zufallswerte, speicher die in einem Array/einer Liste und werte sie aus.
Für die Visualisierung kannst du dir dann überlegen ob du das selbst zeichnen willst, oder auf Bibliotheken wie zB JFreeChart zurückgreifen willst.


----------



## DocRandom (15. Nov 2006)

..kleine Anleitung:
Array bauen (int [36] )
Schleife aufrufen und 100 mal ...
..Zufallszahlen gennerieren im Wertebereich von 0 - 36..
.. im Array speichern
und was immer Du dann damit machen willst, machen!

mfg
DocRandom


----------



## Gast (15. Nov 2006)

Aber ich will das das Programm gleich nach dem es gestartet wird eine Ausgabe der Werte gibt !


----------



## Wildcard (15. Nov 2006)

Was denkst du denn wie lange es dauert 100 Werte zu erzeugen?  :wink:


----------



## DocRandom (15. Nov 2006)

..und? 
Dann machst ne 2. Schleife wo Du dann das Array ausgibst, allerdings ist das dann nur Console und keine Graphic!

mfg
DocRandom


----------



## Gast (15. Nov 2006)

ja es kann eh in einer Konsole sein ..
ich stell mir das ca so vor:

1 ******
2 *********
3 ****
4 ************
5 **************
5 *****************


usw.


Grüße


----------



## DocRandom (15. Nov 2006)

..jo guter Ansatz, dann programmiere es mal!
Wenn Du nimmer weiter weißt werden wir Dir helfen!

mfg
DocRandom


----------



## Gast (15. Nov 2006)

ok, ich fang mal an !

Vielen Danke !


----------



## Guest (15. Nov 2006)

Hallo !


Ich bin mal so weit dass ich eine Klasse geschrieben habe, die mir 10 Zufallszahlen ausgibt.
Das ganze sieht so aus:



```
import java.util.Random;

          public class Roulette
          {  public static void main(String[] args)
             {  Random generator = new Random();

                // zehn Mal Kugel

                for (int i = 1; i <= 10; i++)
                {  int Kugel = 1 + generator.nextInt(37);
                   System.out.print(Kugel + " ");
                }
                System.out.println();
             }
          }
```

und funktioniert recht gut.

Jetzt muss ich mich daran machen, die Ausgabewerte in ein Array zu bringen.
Hat da irgendjemand nen Tipp oder Denkanstóß für mich ?


Grüße


----------



## Wildcard (15. Nov 2006)

Sagen wir du hast ein Array mit 37 Werten mit allen möglichen Resultaten (sind das 37 beim Roulette?  ???:L )
Dann kannst du einfach in der Schleife sagen:
array[zufallszahl]++;


----------



## Gast (15. Nov 2006)

mit der 0 sind es 37


----------



## Leroy42 (15. Nov 2006)

Wildcard hat gesagt.:
			
		

> (sind das 37 beim Roulette?  ???:L )



Manchmal sogar 38 in den Kasinos, deren Roulettes (Rouletten?  :shock: ) eine
Null *und* eine Doppelnull aufweisen.

Aber auch die einfache Null macht de facto den langfristigen Gewinn der Spielbank aus


----------



## Wildcard (15. Nov 2006)

War mir nur nicht sicher. Bin kein großer Zocker  :wink: 
Verstehst du den Ansatz den ich dir gegeben habe?


----------



## Gast (15. Nov 2006)

naja ich les gerade über Arrays ...
noch kann ich ehrlich gesagt nichts damit anfangen !

Du meinst ich soll eine Zweite Schleife erstellen ?

Grüße


----------



## Wildcard (15. Nov 2006)

Nein, eine reicht um das Array zu füllen


----------



## Gast (15. Nov 2006)

hmm ...

int Zufallszahl [] = { ????? } 


aber wie bekomme ich meine 10 Zufallszahlen in diese Klammern ... Geht das vielleicht mit einem Scanner ?!


----------



## Wildcard (15. Nov 2006)

Diese Art der initialisierung benutzt man wenn die Werte bereits bekannt sind.
In deinem Fall muss das so aussehen (Variablen schreibt man klein): 
int zufallszahl [] = new int[37];


----------



## gast (15. Nov 2006)

```
public class Roulette
          {  public static void main(String[] args)
             {  Random generator = new Random();
                int array[] = new int;
                // zehn Mal Kugel

                for (int i = 1; i <= 37; i++)
                {  array[i] = 1 + generator.nextInt(37);
                   System.out.print(Kugel + " ");
                }
                System.out.println();
             }
          }
```


----------



## Guest (15. Nov 2006)

oops

```
public class Roulette
          {  public static void main(String[] args)
             {  Random generator = new Random();
                int array[] = new int[37];
                // zehn Mal Kugel

                for (int i = 1; i <= 37; i++)
                {  array[i] = 1 + generator.nextInt(37);
                   System.out.print(Kugel + " ");
                }
                System.out.println();
             }
          }
```
[/quote]


----------



## Wildcard (15. Nov 2006)

```
public class Roulette
          {  public static void main(String[] args)
             {  Random generator = new Random();
                int array[] = new int[37];
                // zehn Mal Kugel

                for (int i = 0; i <= 100; i++)
                {  
                   array[generator.nextInt(37)]++;
                }
             }
          }
```


----------



## Gast (15. Nov 2006)

Hallo !

Vielen Dank erstmal. Jetzt werden also die Ergebnisse nicht mehr ausgegeben, sondern in einem Feld angelegt, oder ?

Das heißt jetzt geht es darum, diese Werte irgendwie zu "Ordnen" und zu "zählen"

Lg


----------



## Wildcard (15. Nov 2006)

Die werden bereits gezählt.
Nimm mal an die 5 kam 3 mal vor, dann ist in array[6] eine 3.


----------



## Gast (15. Nov 2006)

und wie komme ich zur Ausgabe meines Feldes, um es in so eine Form zu bringen ?

1 ****
2 *********
3 **


Grüße


----------



## Wildcard (15. Nov 2006)

Mit 2 verschachtelten for-Schleifen.
Mit einer läufst du über das Array, in der anderen schreibst du so viele '*' wie die Zahl in diesem Feld des Arrays.


----------



## Gast (16. Nov 2006)

hm ... hab jetzt ein wenig drüber nachgedacht, bij aber noch zu keinem sinnvollen Ansatz gekommen.

Ich versuchs weiter !


Grüße


----------



## Leroy42a (16. Nov 2006)

Nimm mal das als Grundlage:


```
int anzahlen[37] = new int[37];
// Füllen des Arrays mit anzahlen[randomWert]++
for (int i=0; i < anzahlen.length; ++i) {
  System.out.printf("%2d : ", i);
  for (int j=0; j < anzahlen[i].length; ++j)
    System.out.print('*');
  System.out.println();
}
```


----------



## Gast (16. Nov 2006)

Vielen Dank erstmal Leroy42a !


Zum Teil versteh ich diesen Ansatz, aber eben nur zum Teil ... 
Kannst du mir vielleicht irgendeine Seite empfehlen, wo diese Art von for Schleife genauer erklärt wird ?

Ich habe mir nämlich vorgenommen nicht in mein Programm rein zu schreiben was ich nicht zu hunder Prozent verstehe 

Grüße


----------



## Leroy42a (16. Nov 2006)

Ich gehe mal davon aus daß dir die äußere Schleife
(die mit der Laufvariablen i) klar ist. Sie ist da um die
einzelnen Anzahlen der Roulettewürfe zu durchlaufen.


```
for (int j=0; j < anzahlen[i].length; ++j) 
    System.out.print('*');
  System.out.printnln();
```

Hier werden, für jedes i, soviele Sternchen ausgegeben
wie der Wert des jeweiligen anzahlen_ beträgt.

Beispiel: Sei i=7 und anzahlen = 3 dann steht in der
inneren Schleife einfach nur



		Code:In die Zwischenablage kopieren


for (int j=0; j < 3; ++j) 
    System.out.print('*');


j durchläuft also die Werte [0,1,2] und gibt dementsprechend 3 Sternchen aus.
(print statt println damit die Sternchen in eine Zeile geschrieben werden)
Nach Beendigung der Schleife wird mit System.out.println() die Ausgabezeile beendet.

Ich wüßte nicht, wie ich es noch verständlicher erklären könnte.  ???:L_


----------



## Gast (16. Nov 2006)

Vielen vielen Dank !!

Noch verständlicher gehts eh nicht  Jetzt hab ichs kapiert, vielen Dank !!!


----------



## Guest (16. Nov 2006)

```
import java.util.Random;

           public class Wuerfel 
          {  public static void main(String[] args) 
             {  Random generator = new Random(); 
                int array[] = new int[37]; 
                // zehn Mal Kugel 

                for (int i = 0; i <= 100; i++) 
                {  
                   array[generator.nextInt(37)]++; 
                } 
             } 
            
           {  int anzahlen[37] = new int[37]; 
            
            }

        
              for (int i=0; i < anzahlen.length; ++i) { 
                System.out.print("%2d : ", i); 
 		 for (int j=0; j < anzahlen[i].length; ++j) 
  		  System.out.print('*'); 
 		 System.out.println(); 
		}
              }
```


Jetzt muss ich das ganze mal in eine halbwegs schöne Form bringen ... !


Grüße


----------



## Leroy42a (16. Nov 2006)

Anonymous hat gesagt.:
			
		

> Jetzt muss ich das ganze mal in eine halbwegs schöne Form bringen ... !


... und die Namen der Arrays einander angleichen.


----------



## Leroy42a (16. Nov 2006)

```
import java.util.Random; 

public class Wuerfel {
  public static void main(String[] args) {
    Random generator = new Random(); 
    int array[] = new int[37]; 
    // zehn Mal Kugel 
    for (int i = 0; i <= 100; i++) {  
      array[generator.nextInt(37)]++; 
    } 
    for (int i=0; i < array.length; ++i) { 
      System.out.print("%2d : ", i); 
      for (int j=0; j < array[i].length; ++j) 
        System.out.print('*'); 
      System.out.println(); 
    } 
  }
}
```

Es wäre besser, wenn du dir gleich von Anfang an diesen Stil
der Einrückung angewöhnst:


```
public class Würfel {
  public static void main(String[] args) {
```

Der Stil


```
public class Würfel
  {  public static void main(String[] args)
     {  ...
```

ist ziemlich daneben. :autsch:


----------



## Leroy42a (16. Nov 2006)

Noch ein Fehler


```
for (int j=0; j < array[i].length; ++j)
```
muß heissen

```
for (int j=0; j < array[i]; ++j)
```


----------



## Guest (16. Nov 2006)

dercheffe hat gesagt.:
			
		

> ein Roulette Tisch funktioniert nicht nach dem zufall Prinzip?


es gibt da einen fall, dass zwei physiker, mithilfe einer ins kasino geschmuggelten kamera, die an einen rechner angeschlossen war... vorhergesagt haben, wo di ekugel landet... da es berechnbar ist, da im geschlossenen raum ja kaum luftströme sind... nur ma so ...


----------



## Guest (16. Nov 2006)

```
import java.util.Random; 

public class Roulette { 
  public static void main(String[] args) { 
    Random generator = new Random(); 
    int array[] = new int[37]; 
    // zehn Mal Kugel 
    for (int i = 0; i <= 100; i++) {  
      array[generator.nextInt(37)]++; 
    } 
    for (int i=0; i < array.length; ++i) { 
      System.out.print("%2d : ", i); 
      for (int j=0; j < array[i]; ++j) 
        System.out.print('*'); 
      System.out.println(); 
    } 
  } 
}
```

sollte das ca so aussehen ?


Grüße


----------



## Gast (17. Nov 2006)

irgendwo versteckt sich noch ein Fehler ...


----------



## DocRandom (17. Nov 2006)

Moin!

..gibts ne Fehlermeldung dazu?
Du weißt ja wir sind ganz wild auf diese Meldungen! 

mfg
DOcRandom


----------



## Gast (17. Nov 2006)

Hallo !

beim kompilieren gibts eine:

Roulette.java:12: cannot find symbol
symbol: mehtod print (java.lang.String,int)
location: class java.io.PrintStream
           System.out.print("%2d : " ,i);
1error


mfg und danke


----------



## Murray (17. Nov 2006)

Diese C-artige Ausgabeformatierung gibt es so ähnlich seit JDK 1.5:

```
System.out.format( "%2d : ", i);
```

Für JDK <= 1.4 würde ich diesem Fall lieber auf das Padding bei der Ausgabe der Zahl verzichten:

```
System.out.print( i + " : ");
```


----------



## Gast (17. Nov 2006)

Hallo !


Vielen Dank, jetzt funktioniert es.

Das einzige was ich jetzt noch einbauen will ist, dass mir auch die Standardabweichung angezeigt wird.

Kann mir irgendwer einen Tipp geben, womit ich da weiter komme ?

Grüße


----------



## DocRandom (17. Nov 2006)

..was verstehst Du unter Standardabweichung?

mfg
DocRandom


----------



## Leroy42a (17. Nov 2006)

```
System.out.printf( "%2d : ", i);
```

Das *f* am Ende nicht vergessen.

tippe bei google einfach ein: wiki standardabweichung

Dann bekommst du die Definition, die du dann in Java
nur noch coden mußt. Bei Umsetzungsproblemen, melde
dich wieder.


----------



## Gast (19. Nov 2006)

Hallo !

es klappt ja bis hierhin ganz perfekt, aber das mit der Standradabweichung ist mir doch ein bisschen zu hoch  
Mathematisch versteh ich sie schon, aber das umzusetzen ...


Grüße


----------



## Gast (19. Nov 2006)

hat irgendjemand einen Ansatz für mich ?

Grüße


----------



## DocRandom (19. Nov 2006)

..wenn Du sie mathematisch verstehts, dann verstehe ich nicht wo das Problem der Umsetzung liegt!

mfg
DocRandom


----------



## Gast (20. Nov 2006)

Naja das ist schon eine ziemlich lange Formel, und ich weiß nicht wie ich die da rein bekomme ...

MfG


----------



## Guest (20. Nov 2006)

du berchnest den mittelwert, dann ziehst du jede zahl von dem mittelwert ab, quadrierst das und bildest die summe davon. dannach diviedierst du durch die Anzahl deiner zahlen und bildest die Wurzel. Bis auf die Wurzel sind das alles Aufrufe, die du bis jetzt auch verwendet hast. Deshalb hier der Code für die wurzel:


```
int zahl = 9;
    	Math.sqrt(zahl);
```


PS: Wenn du vorher das ganze mal auf papiermachst, ist es vielleicht so einen Algorithmus zu implementieren.


PPS: Da du die Anzahl der Zahlen ja kennst, kannst du den Algorithmus etwas hübchen.


----------



## Gast (20. Nov 2006)

Hallo !

den Code für die Wurzel kenn ich 

doch auch wenn ich mir das auf Papier zusammenschreibe, kann ich das nicht umsetzen.
Ich weiß nicht wie ich mit den Zahlen aus meinem Array rechnen kann ...


Grüße


----------



## Guest (20. Nov 2006)

Hallo allerseits !


ich bin das ganze jetzt noch mal von vorne bis hinten durchgegangen, um zu schauen ob ich das auch so gut verstanden habe, dass ich sowas auch allein hinkriegen würde.

Ein paar Verständnissfragen habe ich jedoch:


```
int array[] = new int[37];
```

so hiermit erstelle ich also mein Array mit 37 Plätzen.


```
for (int i = 0; i <= 100; i++)
```

und das ist meine for schleife, die bei 0 beginnt, und mir 100 mal die Zufallszahlen gibt


```
array[generator.nextInt(37)]++;
```

hmm ... hier wählt mein random generator die Zahlen zwischen 0 und 37 aus ?!?!?




```
for (int i=0; i < array.length; ++i) {
```

so diese Schleife wird logischerweise nur dann ausgeführt, wenn i kleiner als die Feldgröße ist



So weit bin ich mal !


Wäre nett, wenn mir da jemand ein paar Tipps geben könnte !



Grüße !


----------



## Murray (20. Nov 2006)

Anonymous hat gesagt.:
			
		

> array[generator.nextInt(37)]++;
> 
> [/code]
> 
> hmm ... hier wählt mein random generator die Zahlen zwischen 0 und 37 aus ?!?!?



Hier passieren bereits zwei Dinge: 1. es wird eine Zufallszahl (zwischen 0 und *36*) bestimmt und 2. diese Zahl wird als Array-Index benutzt und das so indizierte Feld um eins erhöht. Man könnte das auch so schreiben:


```
int zufallzahl = generator.nextInt(37); //--- Zufallzahl zwischen 0 und 36
array[zufallszahl] = array[zufallszahl] + 1;  //--- Anzahl der Vorkommen der Zahl <zufallszahl> um 1 erhöhen
```


----------



## Guest (20. Nov 2006)

Hallo !


Vielen Dank, das ist jetzt auch klar.


```
for (int i=0; i < array.length; ++i) { 
      System.out.print("%2d : ", i); 
      for (int j=0; j < array[i]; ++j)
```

Trotz langen Überlegens steh´ ich aber bei diesem Teil des Codes auf der Leitung ...


Viele Grüße


----------



## Gast (20. Nov 2006)

Außerdem komm und komm ich nicht dahinter wie ich die Standardabweichung da rein bekommen ... *grübel*

Viele Grüße


----------



## anderer gast (21. Nov 2006)

Auch wenn man mich jetzt steinigen mag, weil ich die Berechnung und die Ausgabe vermische, hab ich mich entschlossen mal eine Lösungsvariante zu posten:



```
Random generator = new Random();
		int array[] = new int[37];                               // Feld zum Speichern der absoluten Häufigkeit einer Zahl
		// zehn Mal Kugel
		int sum = 0;                                                   // Summe zur Mittelwert Bestimmung
		int currentRandom;                                         // Zwischenspeicher für die aktuell erzeugte Zufallszahl
		for (int i = 0; i <= 100; i++) {                         // 100 mal
			currentRandom = generator.nextInt(37);  // Zufallszahl erzeugen
			array[currentRandom]++;                       // Feldindex der Zufallszahl um 1 erhöhen
			sum += currentRandom;                         // Aktuelle Zahl zur Mittelwertsumme dazu addieren
		}
		double mean = sum / 100.0;                           // Den Mittelwert bestimmen
		double var = 0;                                              // Variable für die Varianz
		for (int i = 0; i < array.length; ++i) {              // Über alle Felder des Arrays
			var += (i-mean)*(i-mean) * array[i];      // (Zahl - Mittelwert)^2 * Anzahl   
			                                                            // <=> (x_i - x_quer) ^2 * n_x_i
			System.out.print(i + " : ");                      // Zahl ausgeben
			for (int j = 0; j < array[i]; ++j){             // Über die Anzahl der Zahl
				System.out.print('*');                     // Einen Stern ausgeben
			}
			System.out.println();                             // Zeilenumbruch ausgeben
		}
		var =Math.sqrt(var / 100.0);                          // Die summierten diverenzen durch die Anzahl der Zahlen  
		                                                                   // teilen und die Wurzel ziehen.
		System.out.println("mean: " + mean + "\n" + // Mittelwert und Varianz ausgeben 
				           "var : " + var);
```

ich hab als Grundlagen "deinen" Code benutzt und dann einfach an passenden Stellen die benötigten Werte geholt und verarbeitet.

Grüße


----------



## Leroy42a (21. Nov 2006)

Anonymous hat gesagt.:
			
		

> ```
> for (int i=0; i < array.length; ++i) {
> System.out.print("%2d : ", i);
> for (int j=0; j < array[i]; ++j) {
> ...



Die äußere Schleife (i) durchläuft jedes Array-Element (0..36)

System.out.print*f*("%2d : ", i);

gibt die Kugelnummer rechtsbündig auf 2 Stellen aus und *verbleibt* in der Zeile

Die innere Schleife (j) gibt (für jede Kugel) soviele Sternchen aus wie
vorher geworfen wurde.

Anschließend wird nach den Sternchenausgaben die Zeile mit println beendet.


----------



## Gast (21. Nov 2006)

Vielen vielen Dank !

auch für die gut verständlichen Erklärungen !


----------



## Guest (21. Nov 2006)

So, das ist jetzt der fertige Code


```
import java.util.Random;

import java.util.Random;

public class Roulette { 
  public static void main(String[] args) {


    Random generator = new Random(); 
      int array[] = new int[37];                                
      // zehn Mal Kugel 
      int sum = 0;                                                    
      int currentRandom;                                           
      for (int i = 0; i <= 340; i++) {                          
         currentRandom = generator.nextInt(37);   
         array[currentRandom]++;                       
         sum += currentRandom;                          
      } 
      double mean = sum / 340.0;                            
      double var = 0;                                               
      for (int i = 0; i < array.length; ++i) {               
         var += (i-mean)*(i-mean) * array[i];          
                                                             
         System.out.print(i + " : ");                       
         for (int j = 0; j < array[i]; ++j){               
            System.out.print('*');                      
         } 
         System.out.println();                              
      } 
      var =Math.sqrt(var / 340.0);                            
                                                                         
      System.out.println("mean: " + mean + "\n" +  
                       "var : " + var); }

      }
```

Wie würde ich es jetzt hinbekommen, wenn ich wollte, dass ohne die Null gespielt wird ?

Muss ich nur in den for Schleifen die 0 durch eine 1 ersetzten ?
anscheinend nicht, denn das funktioniert nicht 



Dank noch mal an alle die mir dabei geholfen haben !


Grüße


----------



## DocRandom (21. Nov 2006)

> Muss ich nur in den for Schleifen die 0 durch eine 1 ersetzten ?
> anscheinend nicht, denn das funktioniert nicht icon_wink.gif



.hmm, man sollte doch schon seinen eigenen Code verstehen!
mit der *for*-Schleife hat das ansich nix zu tun, wenn Du aber statt:

```
currentRandom = generator.nextInt(37);
```
dies:
	
	
	
	





```
currentRandom = (generator.nextInt(36)+1);
```
verwendest, wird 0 nie vorkommen!

mfg
DocRandom


----------



## Guest (21. Nov 2006)

Hallo !

ja vielen Dank, das kling natürlich logisch.


Ich weiß ich stell jetzt schon viel zu viele Fragen, aber mein Programm ist eh schon fast fertig, und das Verständniss wird auch immer größer 


Nur kann mir noch irgendjemand helfen ?

Das Arithmetische Mittel wird leider falsch berechnet ...


Habe das Programm jetzt mal als Wuerfel mit 17 Seiten definiert ...


```
import java.util.Random;

public class Wuerfel { 
  public static void main(String[] args) {


    Random generator = new Random(); 
      int array[] = new int[18];                                
      // zehn Mal Kugel 
      int sum = 0;                                                    
      int currentRandom;                                           
      for (int i = 0; i <= 340; i++) {                          
         currentRandom = (generator.nextInt(17)+1);   
         array[currentRandom]++;                       
         sum += currentRandom;                          
      } 
      double mean = sum / 340.0;                            
      double var = 0;                                               
      for (int i = 0; i < array.length; ++i) {               
         var += (i-mean)*(i-mean) * array[i];          
                                                             
         System.out.print(i + " : ");                       
         for (int j = 0; j < array[i]; ++j){               
            System.out.print('*');                      
         } 
         System.out.println();                              
      } 
      var =Math.sqrt(var / 340.0);                            
                                                                         
      System.out.println("mean: " + mean + "\n" +  
                       "var : " + var); }

      }
```


Folgende Probleme hätte ich noch:

1.) Ich kann mein Array nicht auf 17 setzen, möchte das aber, weil ich sonst in der  Ausgabe immer die null dabei habe

0 
1 ****
2 ******

2.) Desweitern müsste das Arithmetische Mittel der Häfigkeit bei 340 würfen doch 340/17 sein ... also 20 ... nur irgendwie wird das bei mir falsch berechnet, mir fällt aber im code kein Fehler auf  :roll: 



3.) Kommt auch für die Standardabweichung kein richtiger Wert heraus ...




Vielen vielen Dank an jeden der mir noch hilft, oder bis jetzt geholfen hat !



Grüße


usw ...


----------



## Gast (21. Nov 2006)

ohne jetzt unverschät wirken zu wollen 
kann mir da vlt. noch jemand helfen ?


Grüße


----------



## Gast (21. Nov 2006)

ich habe die schleife jetzt einfach bei 1 beginnen lassen, das klappt ja ganz gut, nur die ergebnisse für das mittel und die standardabweichung stimmen nicht 

Grüße


----------



## anderer gast (22. Nov 2006)

So wie ich das sehe ist die Formel richti. Allerdings erzeugst du gerade mal 340 zufallszahlen. Um das von dir scheinbar  gewünschte "exakte" arithmetische Mittel zu erhalten soltest du die Zahl der Zufallszahlen jedoch deutlich erhöhren (ca. 10000) sollten ein näherungsweise gutes ergebnis liefern. Wenn nicht poste mal ein paar Ergebnisse.

Kleine Anmerkung noch die solltest nicht beim arithmetischen Mittel den Mittlerwert der Verteilungsfunktion erwarten. Das arithmetische Mittel beruht auf Stichproben ergebnissen und ist daher von dem Umfang und der Qualität der Stichprobe abhängig. Den "echten" Mittelwert bestimmt man über das Integral der Verteilungsfunktion, aber das ist in deinem Fall ja nicht wirklich interessant.


----------

