1.07 Zufall & Spiel

Zufällige int-Werte

Manchmal kann es nützlich sein, Zufallszahlen in einem Programm zu erstellen. Zum Beispiel, wenn man ein Spiel simulieren möchte.

In dem folgenden kleinen Programm wird ein zufälliger Integer-Wert erzeugt und anschließend ausgegeben.

import java.util.Random;

public class Zufallsdemo {
  
  public static void main(String[] args) {
    
    Random generator = new Random();
    
    int meineZufallszahl;    
    meineZufallszahl = generator.nextInt(10);
    
    System.out.println(meineZufallszahl);
    
  }
}

Gehen wir dies einmal Schritt für Schritt durch.

Zunächst müssen wir, um Zufallszahlen erzeugen zu können, mittels  import java.util.Random; die dafür nötigen Hilfsmittel importieren. In der Zeile Random generator = new Random(); wird dann – bildlich gesprochen – ein Zufallsgenerator erzeugt, der von uns den Namen „generator“ erhält. Den Namen können wir dabei frei wählen. Dieser Zufallsgenerator steht uns von nun an bereit, um uns Zufallszahlen zu liefern. In der Zeile int meineZufallszahl; passiert nichts weiter, als dass eine int-Variable eingeführt wird.

Interessanter ist die folgende Zeile. meineZufallszahl = generator.nextInt(10); Hier geben wir dem Zufallsgenerator die Anweisung, eine Zufallszahl zu erzeugen. Genauer gesagt, erzeugt er nun einen zufälligen int-Wert, der zwischen 0 und 9 liegt. Das sind zwar zehn verschiedene mögliche Werte, aber das Zählen beginnt – typisch Informatik – bei 0 statt bei 1.

Wenn wir eine Zufallszahl zwischen 1 und 10 haben wollen, dann können wir eine solche so erhalten: meineZufallszahl = 1 + generator.nextInt(10);

In der Zeile System.out.println(meineZufallszahl); geben wir die Zufallszahl dann schließlich aus.

Zufällige double-Werte

Mit nur wenigen Veränderungen erhalten wir zufällige double-Werte:

import java.util.Random;

public class Zufallsdemo {
  
  public static void main(String[] args) {
    
    Random generator = new Random();       
    
    double meineZufallskommazahl;    
    meineZufallskommazahl = generator.nextDouble();
    
    System.out.println(meineZufallskommazahl);  
    
  }
}

Dies liefert uns eine zufällige Kommazahl zwischen 0 und 1. Allerdings können wir bei der nextDouble()-Methode keine Obergrenze in den Klammern angeben. Möchten wir gerne eine zufällige Kommazahl zwischen 0 und 100 haben, so erreichen wir dies durch meineZufallskommazahl = generator.nextDouble()*100;.

Zufällige boolean-Werte

Wir können unserem Zufallsgenerator noch weitere zufällige Werte entlocken. Beispielsweise können wir auch einen zufälligen boolean-Wert erzeugen:

import java.util.Random;

public class Zufallsdemo {	
  public static void main(String[] args) {
    
    Random generator = new Random();
        
    boolean meinZufallsBoolean;		
    meinZufallsBoolean = generator.nextBoolean();
    
    System.out.println(meinZufallsBoolean);
    
  }
}

Dies sind für uns erst einmal die drei wichtigsten Möglichkeiten, um an zufällige Werte zu kommen.

Ratespiel

Wir haben nun genug Werkzeuge kennengelernt, um ein kleines Spiel zu programmieren. Diese soll natürlich auch als Anregung für Dich dienen, selbst weiter zu experimentieren!

Hier ist zunächst einmal der Programmtext des Spiels. Du kannst es selbst ausprobieren und dann versuchen, den Text nachzuvollziehen. Umgekehrt kannst Du auch zuerst den Text genau untersuchen, um Dir vorher zu überlegen, wie das Spiel wohl funktioniert. Unten gehen wir den Programmtext dann zusammen Schritt für Schritt durch.

import java.util.Random;
import java.util.Scanner;

public class Zahlensuche {

  public static void main(String[] args) {

    // Zufallsgenerator und Scanner werden erstellt.
    Random generator = new Random();
    Scanner meinScanner = new Scanner(System.in);

    // Diese Zahl muss gefunden werden.
    int zahl;
    zahl = generator.nextInt(100);

    // Der Tipp des Spielers.
    int tipp;

    // Versuche werden gezählt.
    int versuche;
    versuche = 0;

    // Spielschleife
    do{
      
      // Tipp wird abgegeben.
      System.out.print("Tippe eine Zahl von 0 bis 99! ");
      tipp = meinScanner.nextInt();
      versuche = versuche + 1;
      
      // Prüfung des Tipps.
      if(tipp == zahl){
        System.out.println("Du hast die Zahl in "+versuche+" Versuchen gefunden!");
      }else{
        if (tipp < zahl){
          System.out.println("Die gesuchte Zahl ist größer als "+tipp+".");
        }else{
          System.out.println("Die gesuchte Zahl ist kleiner als "+tipp+".");
        }
      }
      
    }while(tipp != zahl);
    // Ende der Spielschleife
    
    meinScanner.close();

  }

}

Das Ziel dieses Spiels ist es, in möglichst wenigen Versuchen, eine geheime Zahl von 0 bis 99 zu finden.

Für diese Spiel werden ein Zufallsgenerator und ein Scanner benötigt, die ganz am Anfang erstellt werden. Die gesuchte Zahl wird mit dem Zufallsgenerator erstellt und unter tipp gespeichert. Die Anzahl der Versuche wird in der Variablen versuche mitgezählt. Diese muss zunächst auf 0 gesetzt werden.

Kommen wir nun zur Spielschleife. Hier wird über den Scanner der Tipp des Spielers abgefragt. Direkt danach wird der Versuch gezählt, d.h., versuche wird um 1 erhöht. Ist die getippte Zahl gleich der geheimen Zahl, wird eine entsprechende Meldung ausgegeben. Ist dies nicht der Fall, wird geprüft, ob der Tipp zu klein war. Danach wird ausgegeben, ob der tatsächlich zu klein oder aber zu groß war. Solange der Tipp noch nicht richtig ist, wird diese Schleife wiederholt.

Hier wurde ein fußgesteuerte Schleife verwendet, weil erst beim ersten Durchlauf der Schleife die Variable tipp ihren ersten Wert zugewiesen bekommt.


Hintergrundinfo

Das systematische Suchen (wie hier einer geheimen Zahl) ist ein wichtiges Thema in der Informatik. Mit einer guten Strategie, kannst Du hier tatsächlich meist mit sehr wenigen Versuchen die richtige Zahl finden.


 

Ein Gedanke zu „1.07 Zufall & Spiel“

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.