Methoden Algorithmus zur Gegnerfindung (Turnier)

[fl_ex]

Hey Leute,

ich bin grad dabei ein Tool zu schreiben wo man Teams eingeben kann.
Diese Teams sollen dann jeder gegen jeden antreten...(Zuerst nur Hinrunde) Später evtl. Rückrunde (sollte die selbe Methode benutzt werden können...)

Nun habe ich eine Methode die Hin- und Rückrunde erstellt und auflistet:
(und die Anzahl an Spielen auflistet)

public void showConfrontations(ArrayList<Team> list) {

		ArrayList<Team> teams = new ArrayList<Team>();

		int count = 0;
		for (int i = 0; i < list.size(); i++) {

			Team teamOne = list.get(i);
			for (Team team : list) {
				if (teamOne == team) {

				} else {
					count++;
					teams.add(teamOne);
					teams.add(team);
				}
			}
		}
		for (int j = 0; j < teams.size(); j = j + 2) {
			System.out.println(teams.get(j).getName() + "-"
					+ teams.get(j + 1).getName());
		}
		System.out.println("(" + count + ")");
	}

Erläuterung:
Die eingegebenen Teams werden in eine ArrayList geschrieben, die dieser Methode übergeben wird.
Dann wird bei Team1 begonnen und erstmal alle mit Team1 (außer sich selbst) in die Liste geschrieben...
Aufbau sieht dann ca. so aus:

Team1,Team2,Team1,Team3,...Team2,Team1,Team2,Team3,...

Dann werden bei der Ausgabe(Schleife) immer get(j) +"-"+ get(j+1) ausgegeben und j um 2 erhöht...
--------
Das Problem was ich nun habe ist, dass ich gerne zunächst nur die Hinrunde haben möchte...Kann mir jemand vllt nen Denkstoß geben...? Dazu möchte ich auch noch das natürlich nicht Team1 erstmal alle Runden spielt und dann Team2....

Dazu hier nochjmal die "Team-Klasse":

public class Team {

	public String name;
	public int score;

	public Team() {
		super();
	}

	public Team(String name, int score) {
		this();
		this.name = name;
		this.score = score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	public int getScore() {
		return score;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void win() {
		this.score++;
	}
}

Bin für jede Hilfe dankbar! 🙂

 

[eRaaaa]

Hilft folgendes: http://www.java-forum.org/607910-post2.html (auch in Bezug auf die verlinkte Seite!!!) ?

 

[fl_ex]

Danke schonmal dafür! 🙂 ... Allein der Hinweis eine Klasse "Spielpahrung" zu erstellen (woran ich eigentlich hätte denken müssen^^) hilft ja schonmal abzufragen ob eine Spielpahrung schon vorliegt oder nicht ... Um das Hinrundenproblem zu lösen! 🙂

 

[fl_ex]

Dazu habe ich nochmal eine Anregung nötig...Vllt sogar nen konkreten Vorschlag...

Habe jetzt das Klasse "Team" Die besitzt einen Namen- sowie eine Scorevariable.

Dazu kommt die Klasse "Game" die beinhaltet immer 2 Teams (teamA,teamB)

Nun ist die momentane ausgabe der der Arraylist "games" wie folgt:

Team1 - Team2
Team1 - Team3
Team1 - Team4
Team2 - Team1
Team2 - Team3
Team2 - Team4
Team3 - Team1
Team3 - Team2
Team3 - Team4
Team4 - Team1
Team4 - Team2
Team4 - Team3

Da will ich nun die doppelten Paare
( Team1 - Team 2 UND Team 2 -Team 1 )
davon das zweite löschen...d.h es sollen keine Rückrundenbegegnungen vorkommen...

Momentan:

		for (Game game : games) {
			Team teamA = game.getTeamA();
			Team teamB = game.getTeamB();

			for (int i = 0; i < games.size(); i++) {
				Game currentGame = games.get(i);
				if (currentGame.getTeamA() == teamB
						&& currentGame.getTeamB() == teamA) {
						System.out.println(i);
				}
			}
		}

		for (Game item : removersList) {
			games.remove(item);
		}

aber da habe ich wohl einen Fehler drin...Er soll mir die position rausgeben und bei der letzten For-Schleife soll er dann die elemente löschen...Jedoch gibt er mir ALLE Positionen aus... bzw. löscht ALLE items!^^

 

[Gast2]

Ich würde die equals Methode von Game überschreiben und dann beim schon Hinzufügen prüfen ob die Begegnung schon existiert.

 

[fl_ex]

hättest vllt n Codeschnipsel dafür?^^

 

[Gast2]

So ungefähr könntest du das machen:

public class Team {
	private String name;

	public Team(final String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return name;
	}
}

public class Game {
	private Team teamA;
	private Team teamB;

	public Game(final Team teamA, final Team teamB) {
		this.teamA = teamA;
		this.teamB = teamB;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((teamA == null) ? 0 : (teamA.hashCode() + teamB.hashCode()));
		return result;
	}

	@Override
	public boolean equals(final Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Game other = (Game) obj;

                // teamA vs. teamB und teamB vs. teamA soll gleich sein
		return (teamA == other.teamA && teamB == other.teamB)
				|| (teamA == other.teamB && teamB == other.teamA);
	}

	public Team getTeamA() {
		return teamA;
	}

	public Team getTeamB() {
		return teamB;
	}

	@Override
	public String toString() {
		return teamA + " vs. " + teamB;
	}
}

public class MatchMaker {
	private List<Team> teams;

	public MatchMaker(final List<Team> teams) {
		this.teams = teams;
	}

	public List<Game> getMatches() {
		List<Game> games = new ArrayList<Game>();

		for (Team teamA : teams) {
			for (Team teamB : teams) {
				if (teamA == teamB) continue;

				Game game = new Game(teamA, teamB);
				if (!games.contains(game)) {
					games.add(game);
				}
			}
		}

		return games;
	}

	public static void main(final String[] args) {
		List<Team> teams = new ArrayList<Team>();
		teams.add(new Team("Team 1"));
		teams.add(new Team("Team 2"));
		teams.add(new Team("Team 3"));
		teams.add(new Team("Team 4"));

		List<Game> games = new MatchMaker(teams).getMatches();

		for (Game game : games) {
			System.out.println(game);
		}
	}
}

 

[fl_ex]

Uff...^^ Danke für deine Mühe! 🙂
Könntest mir vllt die ein oder andere Erläuterung noch geben zum Code? Will ihn ja nicht komplett übernehmen sondern auch verstehen...

Dazu:
- public boolean equals(final Object obj)
- public int hashCode()

Nochmal vielen Dank für die Mühe die du dir gemacht hast 🙂

 

[r.w.]

[strike]
Mal abgesehen davon, dass ich davon ausgehe, dass an dieser Stelle...

//...
                Game game = new Game(teamA, teamB);
                if (!games.contains(game)) {
                    games.add(game);
                }
//...

... games.contains(game) immer false liefern wird, weil hier immer wieder ein neues game-Objekt erzeugt wird.
[/strike]

Was spricht in diesem Fall gegen eine einfache verschachtelte Zählschleife?

//...
   public List<Game> getMatches() {
      List<Game> games = new ArrayList<Game>();

      for (int idxTeamA=0; idxTeamA < teams.size()-1; idxTeamA++) {
         for (int idxTeamB=idxTeamA+1; idxTeamB < teams.size(); idxTeamB++) {
            Game game = new Game( teams.get(idxTeamA), teams.get(idxTeamB));
            games.add(game);
         }
      }
      return games;
   }
//...

Nur noch notwendige Schleifendurchläufe und 0 Prüfungen.

Hier die Ausgabe meines TestProgramms für 4 Teams:

teamcount = 4
Anzahl Spiele: 6
Team_0 : Team_1
Team_0 : Team_2
Team_0 : Team_3
Team_1 : Team_2
Team_1 : Team_3
Team_2 : Team_3

Über die Reihenfolge der zu spielenden Matches, müsste man sich natürlich auch hier noch Gedanken machen.

[EDIT]
Teilweise gestrichen:
Hab grad gesehen, dass die equals-Methode der Game-Klasse überschrieben wurde.
So könnte .contains() natürlich funktionieren. Der ganze Aufwand wäre allerdings
bei meinem Vorschlag gar nicht nötig.
[/EDIT]

Gruß,
ROlf

 

[fl_ex]

Danke euch beiden! 🙂

Top dieses Forum! =)