# Spielplan Algorithmus



## mavinatic (22. Jun 2010)

Hallo ich möchte einfach zur Übung eine algorithmische Aufgabe lösen, aber trotz Zeichnungen auf dem Papier und vieler Versuche bekomme ich nicht mal die Spielpaarungen in einer einfachen Version zusammen.

Mein Anfang ist momentan so:


```
String[] teams = new String[] { "Team 1", "Team 2", "Team 3", "Team 4", "Team 5", "Team 6" };
	
	public Generator()
	{
		for(int i=1;i<(teams.length/2) ;i++)
		{
			System.out.println(teams[i]+":"+teams[i*2]);
		}
	}
```

Aber irgendwie funktioniert das nicht wirklich, ich möchte nicht das ihr mir irgendeinen fertigen Algorithmus vorlegt, sondern mir eher Hinweise oder Tipps gebt. Just hints  Ich habe schon seiten im Internet gefunden, aber momentan hänge ich eher an den simpelsten Aufgaben.

So far george


----------



## diggaa1984 (22. Jun 2010)

i sollte bei 0 beginnen, da der erste array-index immer bei [0] liegt


----------



## mavinatic (22. Jun 2010)

ich idiot^^ jah du hast recht bei 0 sollte es beginnen, damit ich auch schonmal alle teams drin hab 
das problem ist nur:

wenn ich bei 0 anfange dann spielt die gleiche mannscahft quasi gegen sich selbst!?

for(int i=0; i<Anzahl der Mannschaften n-1; i++)
{
   team_ : team[i*2]
}

bei i=0 wäre das team[0] : team[0*2] also gegen sich selber :O das ist etwas komisch_


----------



## diggaa1984 (22. Jun 2010)

stimmt .. dann mach aus dem *2 ein +3 und schon klappts .. so einfach kann mathe sein


----------



## mavinatic (22. Jun 2010)

wie bist du denn darauf gekommen? ist es nun allgemeingültig für die anzahl der teams N?
Bei 8 Teams sieht zumbeispiel der spielplan so aus:

Team 1 - Team 4
Team 2 - Team 5
Team 3 - Team 6
Team 4 - Team 7


----------



## eRaaaa (23. Jun 2010)

Die Frage ist ja, wie genau soll der Spielplan aussehen? So was kann ganz schnell nicht so ganz trivial werden 
Ich hatte hier schon mal eine Seite gepostet, wo so etwas sehr gut erklärt ist meiner Meinung nach!

Vllt. hilft dir das ja? Ansonsten erkläre doch mal, wie genau deine Paarungen aussehen sollen: jeder gegen jeden? Abwechselnd heim-auswärts usw. ?


----------



## diggaa1984 (23. Jun 2010)

nein passt genau auf dein beispiel  .. der summand hinter dem + entspricht der hälfte der gesamten teamanzahl .. also bei 8 teams +4 bei 4 teams +2 ... deine schleife läuft ja nur bis zur hälfte, entsprechend musst du den summanden setzen, dass du die erste paarung auch mit der 1. mannschaft und der ((N/2) +1). mannschaft hast 

das is aber einfache mathematik .. da müsstest selbst drauf kommen

edit: und was mein vorredner anspricht ist dann schon nicht mehr ganz sooo simpel


----------



## mavinatic (23. Jun 2010)

jah die seiten hatte ich schon aber ich komme einfach nicht dahinter...ich verstehe das bei 6 Teams quasi dieses 5Eck(ich komme nicht auf die bezeichnung) ist und es immer ne "runde" weiter dreht...das hab ich verstanden aber ich bekomme es nicht hin den 1.Spieltag zugestalten das jeder gegen jeden spielt.

Am Ende soll es mit hin und rückrunde sein...


----------



## mavinatic (23. Jun 2010)

also so:


```
for(int i=0;i<teams.length/2 ;i++)
		{
			System.out.println(teams[i]+ " - " +teams[i+teams.length/2]);
		}
```

dann kommt folgener Plan bei raus, welcher auch stimmt 

Team 1 - Team 5
Team 2 - Team 6
Team 3 - Team 7
Team 4 - Team 8

Ich bin echt schlecht in Mathe und so deswegen mach ich ja solche algorithmischen Übungen damit ich das auf die Reihe bekomme versteht ihr?

Sorry für den DOPPELPOST!

___________________________________________________
Das kommende Problem ist jetzt die Paarungen durchzuspielen :O Ich habe noch nicht ganz so die idee :O


----------



## eRaaaa (23. Jun 2010)

mavinatic hat gesagt.:


> Das kommende Problem ist jetzt die Paarungen durchzuspielen :O Ich habe noch nicht ganz so die idee :O



Was möchtest du denn jetzt von uns hören? Seiten wo Algos vorgestellt werden helfen dir anscheinend nicht, Beispiele/einen Algo wie man es machen könnte willst du nicht sehen, eine konkrete Frage stellen tust du auch nicht ?! Wie sollen wir dir jetzt helfen ?


----------



## mavinatic (23. Jun 2010)

Verdammt. Ja ich habe mir überlegt:


```
for(int i=0; i<2; i++)
		{
			System.out.println((i+1)+". Spieltag");
			for(int j=0;j<teams.length/2 ;j++)
			{
				System.out.println(teams[j+i]+ " - " +teams[j+teams.length/2+i]);
			}
		}
```

aber da ich out of bounds bin beim array?! argh  Welchen Tipp könntet ihr mir geben?


----------



## Appleleptiker (23. Jun 2010)

Was ist Dein Plan? Eine Erstellung von einer Tabelle für Hin- und Rückspiel?


----------



## mavinatic (23. Jun 2010)

Spielplan generierung ist mein Plan  für n-1 spieltage


----------



## ARadauer (23. Jun 2010)

wie soll jetzt das fertige Ergebnis aussehen?


----------



## lumo (23. Jun 2010)

mavinatic hat gesagt.:


> Spielplan generierung ist mein Plan  für n-1 spieltage



dabei solltest du aber bedenken dass die spiele so eingeteilt werden, dass möglichst viel zeit zwischen den spielen der mannschaften ist (nicht dass eine mannschaft zwei spiele gleich hintereinander hat...)

zum schluss sollte ja ein baum rauskommen oder??


```
[
	Round #1
[[Team 1] Vs [Team 6], [Team 2] Vs [Team 5], [Team 3] Vs [Team 4]], 
	Round #2
[[Team 6] Vs [Team 3], [Team 2]], 
	Round #2
[[Team 6] Vs [Team 2]]]
and the winner is: [Team 6]
```


```
package tt.at.lumo.matchmaker;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class MatchingAlgorithmus {

	List<Team> teams = new LinkedList<Team>();
	List<Round> rounds = new LinkedList<Round>();
	public final static Random r = new Random(System.currentTimeMillis());

	public MatchingAlgorithmus() {
	}

	public MatchingAlgorithmus(int numberOfTeams) {
		for (int i = 1; i < numberOfTeams + 1; i++) {
			teams.add(new Team(i));
		}

		Round r = new Round(teams);
		rounds.add(r);
		while (!r.isFinalRound()) {
			r = r.getNextRound();
			rounds.add(r);
		}
	}

	@Override
	public String toString() {
		return rounds.toString() + "\nand the winner is: "
				+ rounds.get(rounds.size() - 1).teams.get(0);
	}

	public static void main(String[] args) {
		System.out.println(new MatchingAlgorithmus(6));
	}

	public static <E> List<E> reverseList(List<E> list) {
		List<E> reverted = new LinkedList<E>();
		for (int i = 0; i < list.size(); i++) {
			reverted.add(list.get(list.size() - i));
		}
		return reverted;
	}
}

class Team {
	int number = -1;

	public Team(int name) {
		super();
		this.number = name;
	}

	@Override
	public String toString() {
		return "[Team " + number + "]";
	}
}

class Vs {
	public Team team1;
	public Team team2;

	public Vs(Team team1, Team team2) {
		super();
		this.team1 = team1;
		this.team2 = team2;
	}

	public Team getWinner() {
		if (MatchingAlgorithmus.r.nextBoolean())
			return team1;
		else
			return team2;
	}

	@Override
	public String toString() {
		if (team1.equals(team2)) {
			return team1.toString();
		} else {
			return team1 + " Vs " + team2;
		}
	}
}

class Round {
	int number;
	List<Team> teams;
	List<Vs> vss = new LinkedList<Vs>();

	public Round(List<Team> teams) {
		super();
		this.number = 0;
		this.teams = teams;
		int max = (teams.size() % 2 == 0 ? (int) teams.size() / 2 : (int) Math
				.floor(teams.size() / 2) + 1);
		max--;
		for (int i = 0; i <= max; i++) {
			vss.add(new Vs(teams.get(i), teams.get(teams.size() - 1 - i)));
		}
	}

	public Round(int number, List<Team> teams) {
		super();
		this.number = number;
		this.teams = teams;
		int max = (teams.size() % 2 == 0 ? (int) teams.size() / 2 : (int) Math
				.floor(teams.size() / 2) + 1);
		max--;
		for (int i = 0; i <= max; i++) {
			vss.add(new Vs(teams.get(i), teams.get(teams.size() - 1 - i)));
		}
	}

	public boolean isFinalRound() {
		if (vss.size() == 1)
			return true;
		else
			return false;
	}

	public Round getNextRound() {
		List<Team> winners = new LinkedList<Team>();

		for (int i = 0; i < vss.size(); i++) {
			winners.add(vss.get(i).getWinner());
		}
		number++;
		return new Round(number, winners);
	}

	@Override
	public String toString() {
		return "\n\tRound #" + number + "\n" + vss.toString();
	}
}
```


----------



## mavinatic (23. Jun 2010)

Ne warum sollte ein Baum dabei rauskommen?

1.Spieltag
Team A - Team B
Team C - Team D
Team E - Team F

und am ende der spieltage sollen alle ALLE TEAMS gegen ALLE TEAMS gespielt haben.


----------



## faetzminator (23. Jun 2010)

mavinatic hat gesagt.:


> und am ende der spieltage sollen alle ALLE TEAMS gegen ALLE TEAMS gespielt haben.



So spielen alle gegen alle:

```
for (int i = 0; i < list.size(); i++) {
    for (int j = i + 1; j < list.size(); j++) {
        System.out.println(list.get(i) + " gegen " + list.get(j));
    }
}
```


----------



## mavinatic (23. Jun 2010)

natürlich hatte ich die lösung auch schon  aber!! es geht ja darum das alle an spieltagen spielen wie in der bundesliga da spielen die ja auch nicht alle spiele Team1 und dann Team2 etc...


----------



## lumo (23. Jun 2010)

so wie ich fussballer kenne machen die das sicher per hand *sfg*


----------



## Gast2 (23. Jun 2010)

mavinatic hat gesagt.:


> natürlich hatte ich die lösung auch schon  aber!! es geht ja darum das alle an spieltagen spielen wie in der bundesliga da spielen die ja auch nicht alle spiele Team1 und dann Team2 etc...



In dem obigen Link ist genau das doch beschrieben mit heim und auswärtsspiel...


----------



## eRaaaa (23. Jun 2010)

```
public static void main(String[] args) throws Exception {
		String[] teams = new String[18];
		for (int i = 0; i < teams.length; i++) {
			teams[i] = "Team " + (i+1);
		}
		int n = teams.length - 1;
		System.out.println("----HINRUNDE----");
		for (int i = 1; i < (n + 1); i++) {
			System.out.println("---" + i + ".Spieltag---");
			if (i % 2 == 0) {
				printMatch(teams[i - 1], teams[n]);
			} else {
				printMatch(teams[n], teams[i - 1]);
			}
			for (int k = 1; k < (n + 1) / 2; k++) {
				int tmp = (i + k) % n;
				int teamA = tmp == 0 ? n : tmp;
				tmp = ((i - k % n) + n) % n;
				int teamB = tmp == 0 ? n : tmp;
				if (k % 2 != 0) {
					printMatch(teams[teamA - 1], teams[teamB - 1]);
				} else {
					printMatch(teams[teamB - 1], teams[teamA - 1]);
				}
			}
		}
	}

	private static void printMatch(String teamA, String teamB) {
		System.out.println(teamA + " : " + teamB);
	}
```

das noch schön in Klassen verpacken und die Rückrunde ist auch kein Problem mehr


----------



## Rudi77 (21. Mai 2015)

Hallo zusammen,

ich brauche eure Hilfe!

Es tut mir leid, dass ich diesen uralten Thread wieder herauskrame, allerdings komme ich alleine nicht weiter.

Es geht um den Code den eRaaaa zuvor gepostet hat.

In dem Code werden alle Spielpaarungen aufgeführt, die genannte Anzahl an Teams eintreten können.
Soweit funktioniert der Code auch gut. Jedoch ist die Menge der Spielpaarungen bei einer ungeraden Anzahl an Teams nicht korrekt.
Wenn bspw. 5,7,9 etc. Teams gewählt werden, ergeben sich nicht alle Spielpaarungen.

Ich komme an dieser Stelle leider nicht weiter. Ich kann den entsprechenden "Fehler" im Code nicht finden.

Es wäre nett, wenn sich das mal jemand ansehen könnte.

Danke!

Rudi77


----------



## stg (21. Mai 2015)

Dann füge einfach ein weiteres Team als Dummy hinzu und streiche anschließend alle Spielpaarungen, in denen der Dummy vorkommt.


----------



## Rudi77 (21. Mai 2015)

Danke! Das ist schon mal ein guter Ansatz! Hätte ich auch selber drauf kommen sollen... 

Hat denn noch jemand eine Idee ohne die Dummy-Variante?


----------

