Aufgaben

Schreibe das Programm Noten, das 5 zufällige Noten zwischen 1 und 15 erzeugt. Von diesen Noten soll erst die größte und dann die kleinste Note ausgegeben werden, dann der Durchschnitt und schließlich die Noten selbst. Lösung

Schreibe das Programm Eratosthenes, das die Primzahlen von 2 bis 1000 nach dem Verfahren des Sieb des Eratosthenes bestimmt. Lösung

Schreibe das Programm ZweiWürfel, das zwei Würfel 1000 Mal wirft und am Ende ausgibt, wie oft welche Summe geworfen wurde. Lösung

Erweitere das Programm ZweiWürfel zu NWürfel dahingehend, dass du im Programm die Anzahl der Würfel, die Anzahl der Würfelseiten und die Anzahl der Würfe einstellen kannst. Gib wieder aus, wie oft jede Summe vorkam. Lösung

Zusatzaufgaben

Schon fertig? Dann gibt es hier noch Zusatzaufgaben ohne Lösungen:

Schreibe das Programm Lottoziehung, das 6 aus 49 Zahlen zieht, ohne dass Doppelungen vorkommen. Du darfst dazu keine while-Schleife verwenden, diese kommt erst im nächsten Kapitel.
Schreibe das Programm Regentropfen, das zufällig Regentropfen auf den Boden fallen lässt. Stelle dir nun vor, auf dem Boden sei ein in einem Quadrat einbeschriebener Kreis aufgemalt.

Berechne aus der Anzahl der Tropfen, die im Kreis bzw. Quadrat landen eine Näherung für $\pi$ .
Schreibe das Programm Barcode, das nach der Beschreibung auf Wikipedia einen EAN-13-Code erstellt. Dieser soll in unserem Fall aus einer Abfolge von Nullen und Einsen bestehen.

Noten

int[] note = new int[5]; (1)
for (int i = 0; i < note.length; i++) {
    note[i] = (int) (Math.random() * 15 + 1); (2)
}

// Maximum und Minimum suchen, Summe für Durchschnitt
int maximum = note[0], minimum = note[0], summe = 0; (3)
for (int i = 0; i < note.length; i++) {
    summe += note[i]; (4)
    if (note[i]>maximum) maximum=note[i]; (5)
    if (note[i]<minimum) minimum=note[i];
}
System.out.println("Größte Note: " + maximum + ", kleinste Note: " + minimum);
System.out.println("Durchschnitt: " + ((double) summe / note.length));
for (int i = 0; i < note.length; i++) {
    System.out.println(note[i]); (6)
}

1	Erstelle eine neue Feldvariable `note` mit 5 von 0 bis 4 durchnummerierten "Plätzen"
2	Belege jeden Eintrag der Feldvariable mit einem zufälligen Wert zwischen 1 und 15 (jeweils einschließlich)
3	Setze `minimum` und `maximum` jeweils auf den ersten Eintrag der Feldvariable (erster Eintrag bedeutet, dass der Index 0 sein muss)
4	Zähle zur aktuellen Summe den i-ten Notenwert hinzu
5	Falls die aktuelle Note größer als das bisherige Maximum ist, dann setze das neue Maximum auf den aktuellen Notenwert
6	Gib alle Noten der Reihe nach aus

note.length liefert die Anzahl der "Plätze", also der "Schublade" der Feldvariable note zurück.

Eratosthenes

int anzahl = 1000;
int[] zahlen = new int[anzahl]; (1)
for (int i = 2; i <= anzahl / 2; i++) { (2)
    if (zahlen[i] == 0) { (3)
        for (int j = i * 2; j < anzahl; j += i) { (4)
            zahlen[j] = 1; // entspricht dem Streichen (5)
        }
    }
}
for (int i = 2; i < anzahl; i++) {
    if (zahlen[i] == 0) { // noch nicht gestrichen
        System.out.println(i); (6)
    }
}

1	Erstelle eine neue Feldvariable mit 1000 Plätzen, die von 0 bis 999 durchnummeriert sind. Standardmäßig werden beim Typ `int[]` alle Einträge auf 0 gesetzt
2	Durchlaufe mit `i` alle Werte von 2 bis zur halben Anzahl. Darüber hinaus muss man nicht gehen, da Vielfache der halben Anzahl außerhalb des zu untersuchenden Bereichs liegen.
3	Trete bei der aktuelle Zahl nur in Aktion, wenn dort noch eine 0 steht, d. h. sie ist noch nicht gestrichen
4	Durchlaufe alle Vielfache einer Zahl, also beispielsweise für die 2 die Werte 4, 6, 8, 10 …, solange das Vielfache größer der halben Anzahl kleiner als die maximale zu untersuchende Zahl `anzahl` ist
5	"Streiche" das entsprechende Vielfache. Das gelingt, indem wir den zum aktuellen Vielfachen gehörigen Eintrag der Feldvariable auf "1" setzen (zur Erinnerung: der Eintrag "0" bedeutet, dass die Zahl noch nicht gestrichen wurde)
6	Gehe am Ende alle Einträge durch und gib nur die Werte aus, die noch nicht gestrichen wurden, also in deren zugehörigen Einträgen der Feldvariable noch eine "0" steht

ZweiWürfel

int anzahl = 1000, zz1, zz2;
int[] summen = new int[11]; (1)

for (int i = 0; i < anzahl; i++) {
    zz1 = (int) (Math.random() * 6 + 1); (2)
    zz2 = (int) (Math.random() * 6 + 1);
    summen[zz1 + zz2 - 2]++; (3)
}
for (int i = 0; i < summen.length; i++) {
    System.out.println((i + 2) + ": " + summen[i]); (4)
}

1	Lege eine Feldvariable `summen` an, die so viele Plätze enthält, wie es mögliche Augensummen bei zwei Würfeln gibt (von 2 bis 12 sind es 11 Werte)
2	Erstelle für jeden Wurf zwei zufällige ganze Zahlen zwischen 1 und 6 (jeweils einschließlich)
3	Erhöhe den für die aktuelle Augenzahl zuständigen Eintrag um 1. `zz1+zz2-1` garantiert, dass die Anzahl, wie oft die Augensumme 2 geworfen wurde im Eintrag 2-2=0 landet, die Anzahl der Summe 12 in 12-2=10. Das passt genau zur Feldvariable `summen`, die 11 Einträge von 0 bis 10 zur Verfügung hat.
4	Gib alle Summen aus. Beachte, dass das `i` alle Werte von 0 bis 10 durchläuft, um alle Einträge abzudecken, für die Ausgabe aber immer 2 dazu gezählt werden muss, damit die Zahlen von 2 bis 12 erscheinen.

NWürfel

int anzahlWürfe = 10000;
int anzahlSeiten = 6;
int anzahlWürfel = 5;
int[] summen = new int[anzahlSeiten * anzahlWürfel - anzahlWürfel + 1]; (1)

for (int i = 0; i < anzahlWürfe; i++) {
    int summeAugenzahlen = 0; (2)
    for (int j = 0; j < anzahlWürfel; j++) {
        summeAugenzahlen += (int) (Math.random() * anzahlSeiten + 1); (3)
    }
    summen[summeAugenzahlen - anzahlWürfel]++; (4)
}
for (int i = 0; i < summen.length; i++) {
    System.out.println((i + anzahlWürfel) + ": " + summen[i]); (5)
}

1	Erstelle die Feldvariable `summe` mit der notwendigen Anzahl von möglichen Einträgen. Die höchst Summe ergibt sich aus der Anzahl der Seiten multipliziert mit der Anzahl der Würfel. Die kleineste Summe liegt vor, wenn jeder Würfel die "1" anzeigt, also "Anzahl der Würfel x 1 = Anzahl der Würfel". Zieht man die beiden Werte voneinander ab und zählt 1 dazu, so erhält man die Anzahl der nötigen Plätze. (Beispiel: 2 Würfel mit je 6 Seiten, 12-2+1=11, siehe Programm ZweiWürfel)
2	Für jeden Wurf wird die Summe der Augenzahlen in `summeAugenzahlen` bestimmt. Zu Beginn eines jeden Wurfes wird der Wert auf 0 zurückgesetzt.
3	Zähle zu `summeAugenzahlen` jeweils den Wert der nächsten zufälligen Augenzahl dazu und …
4	… erhöhe den entsprechenden Häufigkeitszähler der erhaltenen Summe um 1.
5	Gib, ähnlich wie im Programm ZweiWürfel, die Häufigkeiten der geworfenen Augensummen aus.

Zurück zu den Aufgaben