Technischer Projektleiter
Java Programmierbeispiele: Erstelle eine nützliche Anwendung, um zufällige Spiele von Doppelteams zu generieren
In diesem Artikel möchte ich zeigen, wie sich reale Probleme mit der Programmiersprache Java leicht lösen lassen.
Auftrag
Gemeinsam werden wir ein Programm erstellen, das aus den N angemeldeten Personen einzigartige Paare bildet. Aus diesen Paaren werden dann nach dem Zufallsprinzip 2 Teams gebildet, die gegeneinander spielen. Das Ziel ist es, alle möglichen Varianten von Spielen zu erstellen, so dass jedes Team gegen die übrigen Teams spielt.
Vorschlag für eine Lösung
Wenn Sie eine komplexere Aufgabe lösen, empfiehlt es sich, sie in kleinere Teile aufzugliedern und diese separat zu lösen. In diesem Fall könnte die Aufgabe in die folgenden Schritte unterteilt werden:
- das Einlesen der angemeldeten Personen und deren Speicherung im Speicher des Programms,
- die Erstellung von Paarvariationen ohne Wiederholungen,
- die Erstellung aller möglichen Spiele von zwei Doppelpaaren,
- das zufällige Mischen der generierten Matches,
- Auflistung der Ergebnisse.
Wir werden uns nun jeden Schritt genauer ansehen.
Das Einlesen der angemeldeten Personen und deren Speicherung im Programmspeicher
In diesem Abschnitt lesen wir die Liste der Namen der angemeldeten Personen aus der Datei und speichern sie in der Personenliste. Eine Person wird durch die Klasse Person repräsentiert.
Erstellung von Paarvariationen ohne Wiederholungen
Wenn wir Personen geladen haben, müssen wir alle möglichen Paare von ihnen erstellen, damit sich die Personen darin nicht wiederholen und natürlich sollte jedes Paar einzigartig sein. Bei einem Paar ist uns die Reihenfolge, wer das erste oder zweite Mitglied ist, egal. Ein solches Zweierteam wird durch die Klasse Pair repräsentiert und wir speichern die Ergebnisse in der Liste UniquePairs.
Erstellung aller möglichen Spiele von zwei Doppelpaaren
Aus den gebildeten Zweierteams erstellen wir alle möglichen Spiele, die jedes Team gegeneinander spielen kann. Wir müssen jedoch sicherstellen, dass ein bestimmtes Paar nur in einem Team in einem Spiel spielen kann, d.h. Paare können nicht in einem Spiel gegeneinander antreten, und gleichzeitig kann kein Spieler in zwei Teams gleichzeitig spielen. Ein Spiel wird durch die Klasse Zapas repräsentiert und wir werden diese in der Liste Zapas für die weitere Verarbeitung speichern.
Zufälliges Mischen der generierten Matches
Um die Sache aufzupeppen, fügen wir ein Element des Zufalls hinzu, indem wir die generierten Spiele zufällig mischen.
Auflistung der Ergebnisse
Für diese Art von Konsolenanwendung reicht es aus, die Ergebnisse auf der Konsole auszugeben.
Implementierung des Entwurfs in der Programmiersprache Java
Sobald wir die wichtigsten Schritte des Programms identifiziert haben, haben wir keine andere Wahl, als das Programm zu programmieren. Wir werden ein Turniersystem für Spiele zwischen Gruppen von Teams (Paaren von Personen) erstellen. Damit Sie eine bessere Vorstellung davon bekommen, was das Programm tut, erkläre ich es Ihnen Schritt für Schritt:
Person.java
package entities;
public class Osoba {
public String meno;
public Osoba(String meno) {
this.meno = meno;
}
}
Definiert eine Klasse Person mit einem Attribut name, das den Namen der Person darstellt.
Ehepaar.java
package entities;
public class Dvojica {
public Osoba osoba1;
public Osoba osoba2;
public Dvojica(Osoba osoba1, Osoba osoba2) {
this.osoba1 = osoba1;
this.osoba2 = osoba2;
}
}
Definiert die Klasse Pair, die zwei Personen (Person1 und Person2) enthält und ein Personenpaar oder ein aus zwei Personen bestehendes Team darstellt.
Zapas.java
package entities;
public class Zapas {
public Dvojica tim1;
public Dvojica tim2;
public Zapas(Dvojica tim1, Dvojica tim2) {
this.tim1 = tim1;
this.tim2 = tim2;
}
}
Die Klasse Zapas repräsentiert ein Spiel zwischen zwei Paaren oder Teams (tim1 und tim2).
Generator.java
package entities;
import entities.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
public class Generator {
private List<Osoba> ludia;
private List<Dvojica> unikatneDvojice;
private List<Zapas> zapasy;
public void Generator() {
ludia = null;
unikatneDvojice = null;
zapasy = null;
}
public void nacitajVstupneData() throws IOException {
ludia = new ArrayList<>();
for(String line : Files.readAllLines(Paths.get("vstupy.txt"))) {
ludia.add(new Osoba(line));
}
}
// Vytvori všetky možné dvojice z ľudí
public void vygenerujUnikatneDvojice() {
unikatneDvojice = new ArrayList<>();
for (int i = 0; i < ludia.size(); i++) {
for (int j = i + 1; j < ludia.size(); j++) {
Dvojica dvojica = new Dvojica(ludia.get(i), ludia.get(j));
unikatneDvojice.add(dvojica);
}
}
}
// Vytvori všetky možné zápasy s danými dvojicami
public void vygenerujUnikatneZapasy() {
zapasy = new ArrayList();
for (int i = 0; i < unikatneDvojice.size(); i++) {
for (int j = i + 1; j < unikatneDvojice.size(); j++) {
Dvojica tim1 = unikatneDvojice.get(i);
Dvojica tim2 = unikatneDvojice.get(j);
if(tim1.osoba1.equals(tim2.osoba1) || tim1.osoba1.equals(tim2.osoba2) || tim1.osoba2.equals(tim2.osoba1) || tim1.osoba2.equals(tim2.osoba2))
continue;
zapasy.add(new Zapas(tim1, tim2));
}
}
}
public List<Osoba> getLudia() {
return ludia;
}
public List<Dvojica> getUnikatneDvojice() {
return unikatneDvojice;
}
public List<Zapas> getZapasy() {
return zapasy;
}
}
Die Klasse Generator ist für das Laden, die Verarbeitung der Daten und die Generierung der Ergebnisse verantwortlich. Verwendet drei Listen (ludia, unikatneDvojice und zapasy) zur Verwaltung von Informationen über Personen, Teams und Matches.
Der Konstruktor Generator() initialisiert die Listen mit dem Wert null.
Die Methode nacitajVstupneData() lädt Daten über Personen aus der Datei vstupy.txt und erstellt daraus Objekte vom Typ Osoba, die in der Liste ludia gespeichert werden.
Die Methode vygenerujUnikatneDvojice() erstellt alle möglichen Paare von Personen und speichert diese in der Liste unikatneDvojice.
Die Methode vygenerujUnikatneZapasy() erstellt alle möglichen Matches zwischen den Paaren und speichert diese in der Liste zapasy. Stellt sicher, dass keine zwei Personen in verschiedenen Paaren wiederholt werden.
Zugriffsmethoden getPeople(), getUniqueDoubles(), getZapasy() – ermöglichen den Zugriff auf einzelne Listen.
Main.java
import java.io.IOException;
import java.util.Collections;
import java.util.Random;
import entities.*;
public class Main {
public static void main(String[] args) throws IOException {
Generator generator = new Generator();
generator.nacitajVstupneData();
System.out.println("Prihlaseni ludia [" + generator.getLudia().size() + "]: ");
for (Osoba osoba : generator.getLudia()) {
System.out.println(osoba.meno);
}
System.out.println();
generator.vygenerujUnikatneDvojice();
System.out.println("Mozne dvojice [" + generator.getUnikatneDvojice().size() + "]: ");
for (Dvojica dvojica : generator.getUnikatneDvojice()) {
System.out.println(dvojica.osoba1.meno + " a " + dvojica.osoba2.meno);
}
System.out.println();
generator.vygenerujUnikatneZapasy();
Collections.shuffle(generator.getZapasy(), new Random());
System.out.println("Zapasy kazdy s kazdym v nahodnom poradi [" + generator.getZapasy().size() + "]: ");
for (Zapas zapas : generator.getZapasy()) {
System.out.println(zapas.tim1.osoba1.meno + " a " + zapas.tim1.osoba2.meno + " vs. " +
zapas.tim2.osoba1.meno + " a " + zapas.tim2.osoba2.meno);
}
}
}
Es enthält die Methode main(), die die Funktionalität des Programms demonstriert. Erstellt eine Instanz der Klasse Generator. Lädt die Eingangsdaten über Personen und gibt die angemeldeten Personen aus. Generiert alle möglichen eindeutigen Paare und listet sie auf. Erzeugt alle möglichen Matches, sortiert diese dann zufällig und gibt sie auf der Konsole aus.
Das Programm ist für beliebig viele Personen geeignet und kann leicht angepasst und für spezifische Anforderungen modifiziert werden.
Programmeintrag:
Programmausgabe:
Übung 1
Erweitern Sie die Klasse Person um das Attribut Geschlecht (männlich, weiblich). Ändern Sie die Methode GenerateUniquePairs(), um alle möglichen Paare aus Personen zu erzeugen, so dass das Team aus einem Mann und einer Frau besteht. Generieren Sie dann die möglichen Übereinstimmungen. Speichern Sie die Ergebnisse in der Ausgabedatei.
Übung 2 (Herausforderung)
Wenn Sie eine Instanz des Generators erstellen, geben Sie eine Zahl an, die bestimmt, wie viele Teams erstellt werden müssen. Ändern Sie dann den Code aus dem Beispiel, damit er für beliebig große Teams funktioniert.
Java Code Beispiel
Wir haben die Dateien mit dem obigen Beispiel in Form von Code vorbereitet, den du direkt in Java ausführen kannst. Laden Sie den Java-Beispielcode hier herunter . Wenn das Erstellen von Code anhand einer Aufgabe kein Problem für Sie ist und Sie ein erfahrener Java-Programmierer sind, sollten Sie sich unsere Unternehmensvorteile ansehen und auf Stellenausschreibungen reagieren .
