Roulette !

[Murray]

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]

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]

..was verstehst Du unter Standardabweichung?

mfg
DocRandom

 

[Leroy42a]

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]

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]

hat irgendjemand einen Ansatz für mich ?

Grüße

 

[DocRandom]

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

mfg
DocRandom

 

[Gast]

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

MfG

 

[Guest]

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]

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]

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]

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]

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]

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

Viele Grüße

 

[anderer gast]

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]

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());
}

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

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

System.out.printf("%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]

Vielen vielen Dank !

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

 

[Guest]

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]

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]

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]

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


Grüße

 

[Gast]

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]

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.