Java-Programmieraufgabe in Informatik: Wie kann ich die ersten drei Gewinner ermitteln?
In dem Skript geht es um einen Wettlauf und acht Läufer. Ich habe jeweils schon Methoden mit for-Schleifen programmiert, dass die Läufer losrennen sollen und das ihre Zeit gemessen werden soll.
Ich muss nun ermitteln, wer die ersten drei Gewinner sind (auch for-Schleife), weiß aber nicht weiter. Kann mir jemand helfen? Codes findet ihr unten.
Losrennen:
public void rennenLaufen() {
double zeit;
for (int i = 0; i < starterfeld.length; i++) {
zeit = Math.round((Math.random() * 10 + 10) * 100) / 100;
starterfeld[i].setZeit(zeit);
}
}
Zeit messen:
public void zeitMessen() {
for (int i = 0; i < starterfeld.length; i++) {
System.out.println(starterfeld[i].getName() + " " + starterfeld[i].getZeit());
}
}
Und nun muss ich die drei Gewinner (definiert anhand der Zeitwerte) bestimmen. Dort habe ich bisher nur das hier:
public void ermittleSieger() {
for (int i = 0; i < starterfeld.length; i++) {
System.out.println(
Kann mir jemand helfen, wie ich weiter machen soll?
Das wäre super.
4 Antworten
Erstmal vorweg: Gibt's einen Grund, warum du die Zufallszahlen für die Zeiten so kompliziert ermittelst? Wenn du für jeden einen int zwischen 10 und 19 haben willst, würde ich dir eher
starterFeld[i].setZeit(new Random().nextInt(10)+10);
empfehlen.
Außerdem ist es empfehlenswert, eine foreach-Schleife oder einen Stream anstatt einer normalen for-Schleife zu benutzen, wenn du etwas für jedes Element eines Arrays machen willst. Also
for (Starter starter: starterFeld) {
starter.setZeit(new Random().nextInt(10)+10);
}
oder
Arrays.stream(starterFeld).forEach(starter -> starter.setZeit(new Random().nextInt(10)+10));
Das gleiche gilt natürlich auch für die zeitMessen-Methode.
Optimalerweise überschreibst du die toString() Methode in der Klasse Starter (oder wie du die Klasse genannt hast). Dann kannst du nämlich einfach ein Objekt an System.out.println() schicken und brauchst dich nicht drum zu kümmern, wie es dargestellt werden soll.
// In Klasse Starter
@Override
public String toString() {
return this.getName() + ": " + this.getZeit();
}
// In zeitMessen()
for (Starter starter: starterFeld) {
System.out.println(starter);
}
// oder
Arrays.stream(starterFeld).forEach(System.out::println);
Um zu deiner eigentlichen Frage zurückzukehren:
Die besten drei ermittelst du am einfachsten, indem du das Array nach Zeiten sortierst und dann die ersten drei ausgibst. Also:
Arrays.sort(starterFeld, Comparator.comparingInt(starter -> starter.getZeit()));
for (int i = 0; i < Math.min(starterFeld.length, 3); i++) {
System.out.println(starterFeld[i]); // falls du die toString()-methode in Starter überschrieben hast.
}
oder
Arrays.stream(starterFeld).sorted(Comparator.comparing(starter -> starter.getZeit())).limit(3).forEach(System.out::println);
Wenn du deinen Lehrer ein bisschen beeindrucken willst, kannst du in der Klasse Starter noch das Interface Comparable<Starter> implementieren. Dann brauchst du der sort()-Methode keinen Comparator übergeben, sondern sie kann automatisch sortiert werden.
class Starter implements Comparable<Starter> {
@Override
public int compareTo(Starter otherStarter) {
return Integer.compare(this.getZeit(), otherStarter.getZeit());
}
...
// Zum sortieren:
Arrays.sort(starterFeld);
// oder
Arrays.stream(starterFeld).sorted()...
Ich hoffe ich konnte dir ein bisschen weiterhelfen. Ich weiß aus eigener Erfahrung, dass Java am Anfang ziemlich kompliziert ist, weil es für alles, was man machen will eigene Klassen gibt, bei denen man erstmal den Durchblick behalten muss.
der simpelste fall weil genau 3 ist ,,, nimm ein array mit 3 werten 0,0,0
dann nimmst du ein for loop über das gesammte array
myarray = {0,0,0}
hoechsterwert = 0;
array = {...deine werte}
for i=0; i< array.length {
if hoechsterWert <= array[i] {
hoechsterWert = array[i];
myarray[1] = myarray[0];
myarray[2] = myarray[1];
myarray[0] = hoechsterWert;
}
}
simpler gehts nicht und brauch nur ein durchlauf, schneller als jeder sortier algorythmus .
danach ist myarray[0] der hoechste und die anderen 1 und 2 folgen
fghdgf
okay danke, hab ich verstanden, eine frage hab ich noch. Schreib ich das alles da dann einfach in meine neue Methode rein?
irgendwo vor der ausgabe auf jedenfall und du musst da natürlich irgendwie dein wert bekommen von dem was du da als höchsten wert willst . und dann danach die ausgabe mit entweder einer for schleife oder oder , wenn man das noch perfektionieren will kann man das array auch einfach per push etc manipulieren so das die werte auch wandern im array und vorne ein neues element reingeschoben wird und hitnen eins entfernt wird wenn mehr als 3 :)
das oben ist reiner pseudocode :)
Ich würde sowas in die richtung machen:
public void ermittleSieger() {
int[] sieger = [-1, -1, -1];
int[] zeiten = [Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE];
for(int i=0; i<starterfeld.length; i++) {
for(int j=0; j<sieger.length; j++) {
if(zeiten[j] > starterfeld[i].getZeit()) sieger[j] = i;
}
}
System.out.printf("Die Sieger sind %d, %d und %d.\n", sieger[0], sieger[1], sieger[2]);
}
Wobei, da fehlt was wichtiges.
Muss bei dem if sowas sein wie:
if(zeiten[j] > starterfeld[i].getZeit()) {
sieger[j] = i;
zeiten[j] = starterfeld[i].getZeit()
}
Sonst updatet er die zeiten nicht.
Ah, in java war das so
int[] sieger = {-1, -1, -1};
In python z.B. ist es [-1, -1, -1].
Kennst du Sortieralgorithmen?
Du könntest BubbleSort auf das Array bzgl. getZeit() machen.
und was würde mir das denn bringen für das was ich brauche?
ja, wie mache ich das denn, hab es nicht richtig verstanden mit dem BubbleSort
wäre lieb wenn du's mir nochmal genauer erklären könntest
Schau mal
https://javabeginners.de/Algorithmen/Sortieralgorithmen/Bubblesort.php
starterfeld[0].getZeit() = 1.23
starterfeld[1].getZeit() = 10.47
starterfeld[2].getZeit() = 13.23
starterfeld[3].getZeit() = 14.87
genau die willst du nun sortieren .. und dann kannst du die For-Schleife einfach auf die ersten 0-2 Durchläufe reduzieren für die Ausgabe
Beim sortieren werden die Zeiten sortiert, entweder auf oder absteigend, jenachdem wie du das möchtest. Bedeutet also du könntest einfach die ersten 3 Läufer ausgeben lassen und hast dann dabei die 3 schnellsten. Entweder könntest du dir selber den Sortieralgorythmus schreiben oder die vorgeferigte Sortiermethode von Arrays nehmen.
Ich würde eher z.B. Heapsort lernen, anstelle von Bubblesort.
Heapsort hat eine geringere Zeitkomplexität, nämlich O(n*log n) anstelle von O(n^2) für Bubblesort.
Das Video erklärt die Grundlagen ziemlich gut:
Es ging ja nur allgemein um eine Sortierung, welchen Alg. er nutzt ist seine Sache 😉
Klar gibt deutlich bessere
Wow Dankeschön, bin zwar bisschen später, aber die Pluspunkte werd ich mir trotzdem noch abholen ;) Vielen Dank