Ligaalgorithmus

[Art]

hi,

für mein derzeitiges projekt brauche ich ein kleines codetechnisches schmankerl. es geht darum, einen spielplan z.b. einer fußballliga aus einer mysql-tabelle zu generieren. die mysql-abfragen sind dabei natürlich nicht das problem, sondern der algorithmus, mit dem der spielplan erstellt wird.
habe mir da schon den die haare zerrauft. eine befreundeter mittleiweile pensionierter mathelehrer hat mir dazu folgendes gepostet:



--------------------------------------------------------------------------------
In einer Menge mit n (n gerade) verschiedenen Elementen gibt es
(n-1)(n-3)(n-5)...1 Möglichkeiten, Paare zu bilden.
Bei Deinem Beispiel M = (1, 2, 3, 4, 5, 6) sind das 5 mal 3 mal 1 = 15
Möglichkeiten, ich will sie mit 1*, 2*, 3*,...,15* bezeichen:

1* 2* 3* 4* 5* 6* 7* 8* 9* 10* 11* 12* 13* 14* 15*
12 12 12 13 13 13 14 14 14 15 15 15 16 16 16
34 35 36 24 25 26 23 25 26 23 24 26 23 24 25
56 46 45 56 46 34 56 36 35 46 36 34 45 35 34

nun streiche man alle Möglichkeiten, in denen Paare sind, die schon
vorgekommen sind:

1* ok
2* streichen wegen 12 in 1*
3* streichen wegen 12 in 1*
4* streichen wegen 56 in 1*
5* ok
6* streichen wegen 13 in 5*
7* streichen wegen 56 in 1*
8* streichen wegen 25 in 5*
9* ok
10* streichen wegen 46 in 5*
11* ok
12* streichen wegen 26 in 9*
13* ok
14* streichen wegen 16 in 13*
15* streichen wegen 16 in 13*

Es bleiben also die fünf ( = 6 - 1) Paarbildungen ((Spieltage)): 1*, 5*,
9*, 11* und 13*.
--------------------------------------------------------------------------------



ferner habe ich noch was mit divide und conquer gefunden: http://www.niederma.de/Comp/spielplan.html

kriege das aber mit allem nich hin. auswärtsspiele und so ein schnickschnack können allerdings unberücksichtig bleiben.

hat jemand für das prob eine lösung parat oder habt ihr lust hier gemeinsam einen algorithmus zu entwickeln, den am ende jeder versteht?

[DarkTemplar]

Hi!!

Keine Ahnung, ob es daran liegt, dass ich etwas falsch verstanden habe, aber mir scheint deine hier angewandte Methode zur Errechnung der Anzahl der Begegnungen doch ziemlich kompliziert zu sein!
Wir haben im Ma-Unterricht für solch eine Problematik das geordnete Ziehen ohne Zurücklegen (Stochastik) angewandt!! Meintest du das?

Bye,
DarkTemplar

[Art]

also das da oben ist eigentlich das, was mir bei der suche nach einer lösung des problems zur generierung eines ligaspielplans aus einer n-Anzahl von Teams bisher so untergekommen ist. es geht also darum: ich übergebe eine beliebige anzahl von teams. das programm soll dann einen spielplan für die einzelnen begegnungen erstellen, so wie etwa in der bundesliga mit n-1 spieltagen und die paarung entsprechend ausspucken.
z.B. Spieltag 1 o. Woche 1

1 vs 2
3 vs 4
5 vs 6 ... .... usw.

[Codeq]

hi
also ich hab echt null plan von fussball...
aber das was du von deinem mathe kollegen bekommen hast ist in meinen augen doch vollkommen ok.. ?!

bei n teams gibt es wenn jeder gegen jeden spielen soll gibt es (n * (n-1)) paarungen.. und mit hin und rückspielen...
oder (n^2 - n)..
dein kollege betrachtet die menge der paare, ist auf jedefall korrekt, aber für dieses kleine problem etwas zu über dimensioniert...
und bei den spielplänen musste nurnoch darauf achten das nicht die selbe manschaft an einem tag mehrfach spielt oder??
da nimmste einfach die menge aller paare in ein table rein und bei jedem zustande gekommenen spiel nimmste das paar raus..

hoffe ich hab das alles richtig verstanden.

[Art]

fussball? :( nenene.

das soll später auf einer ligaverwaltung für online gaming (soldier of fortune) laufen.
ich finde das überhaupt nicht einfach. sagen wir ich habe 12 teams, dann gibt es 11 spieltage, in diesem fall 11 wochen in denen die matches absolviert werden müssen. teams usw. werden dem script aus der datenbank übergeben, das jetzt die paarungen in from einer tabelle ausspuckt, in etwa so:

woche | clan1 | vs | clan2
1 | team1 | team2
1 | team3 | team4
. | . | .
. | . | .
. | . | .
2 | team1 | team3
. | . | .
. | . | .
. | . | .
. | . | .
usw. eben.

[Codeq]

jo.. und? 8)

erstell dir doch mal eine tabelle mit n zeilen und n spalten.. dann trägst du in den zellen wo spalte und zeile gleich sind eine 0 ein.. und in den anderen zuerst die spalte, dann die zeilen nummer mit einem : getrennt :]

und schon siehst du alle paarungen.

wenn du nun den spielplan erstellen willst, dann fang beim ersten tag doch einfach oben an.. du weisst es spielen team n-(n-1) und n-(n-2)
weisst also es am selben tag nurnoch spiele stattfinden die nicht diesen wert enthalten und suchst dir entweder geordnet oder durch zufall ein anderes paar heraus... und wenn noch mehr am tag spielen sollen halt nochn paar dessen einzelnes team nirgend wo sonst mitspielt..

wenn du die teams allerdings ungeordnet aus einem "pool" nimmst, dann kanns passieren das du mit den n-1 spieltagen nicht hinkommst... doofer zufall halt :D

ich weiss nicht genau wo dein prob ist an der sache...

[DarkTemplar]

Hi!!

Vielleicht kann ich noch ein bißchen zu der Lösung der Problematik
beihelfen!!

Original von Codeq
bei n teams gibt es wenn jeder gegen jeden spielen soll gibt es (n *(n-1))
paarungen..


Das ist aber wirklich nur der Fall, wenn man mit Hin und Rückrunden rechnet.
Ansonsten müßtest du die so ermittelte Zahl noch durch 2 teilen!

Deine (Codeq) Idee mit der Tabelle hört sich zwar ganz gut an, aber ich sehe nicht, wie damit das größte Problem gelöst wird, nämlich dass so viele Begegnungen wie möglich gleichzeitig abgehalten werden können, ohne dass einer aussetzen muss.

Allerdings habe ich noch eine Idee, wie sich vielleicht ein relativ schneller Algorithmus entwickeln lässt, bei dem jeder Spieler bzw. jedes Team nicht dauernd so lange Aussetzer hat:
Erzeuge einfach ein Feld von 1 bis n, in das du per Zufallsgenerator die Namen der Teilnehmer einträgst. Wenn es dann an die Aufstellung der Paarungen geht, gehst du wie folgt vor:
Bei der ersten Begegnung spielen Nummer (in der Reihenfolge der Spieler):

1 bis (n/2) gegen (n/2+1) bis n
2 bis (n/2)und 1 gegen (n/2+1) bis n
3 bis (n/2)und 1 bis 2 gegen (n/2+1) bis n
4 bis (n/2)und 1 bis 3 gegen (n/2+1) bis n
.
.
.
(n/2) und 1 bis (n/2-1) gegen (n/2+1) bis n

Mit einem solchen Plan hast du schonmal gewährleistet, dass jeder aus der Gruppe 1 bis n/2 gegen jeden aus der Gruppe n/2+1 bis n gespielt hat! Um nun auch jeden der einen Gruppe gegen Jeden seiner Gruppe spielen zu lassen, müßte man das ganze Verfahren wahrscheinlich dann rekursiv gestallten.
Einen kleinen Haken hat die Sache jedoch noch, wie du sicher schon gemerkt hast. Was nämlich ungerade Anzahlen von Spielern betrifft, so wüßte ich nicht, wie man diese mit dem Verfahren auch berücksichtigen könnte und ungerade wird die Spieleranzahl spätestens bei der Rekursion. Hat jemand da irgendwelche Ideen noch für???


Bye,
DarkTemplar

[Steffel]

Hier eine C#-Implementierung:

http://www.stefan-taube.de/liga.htm

[DonVitoni]

Also wenn ich dicch richtig verstanden habe sollen n Amnnschaften gegeneinander spielen.
Und willst alle begenungen haben.

Analogie:

5 Personen sind in einem Raum und jeder soll jedem die Hand schüteln
Nr. 5 fängt an und schütelt Nr. 4,3,2,1 die Hand ist fertig
Nr. 4 => Nr. 3,2,1 => fertig
Nr. 3 => Nr. 2,1 => fertig
..usw..


int n=15;

for(int i=n;i>=1;i--)
for(int j=i-1;j>=1;j--)
System.out.println(j+" "+i);


n ist die Anzahl der Mannschaften
Anzahl der Spiele ist (n*(n-1))/2

[DonVitoni]

Sorry

Anzahl der Spiele (n*(n+1))/2

:D

[Steffel]

Das Problem ist nicht die Menge aller Paarungen zu bestimmen, sondern diese auf n-1 bzw. n Spieltage zu verteilen, so dass an keinem Spieltag eine Mannschaft doppelt spielt.

[DonVitoni]

Hi Steffel
so das hier klappt :)

Aber nur für eine Anzahl ungerader Mannschaften.
sonst giebt es mal 5 mal 4 mal 5 mal4 Spiele pro Tag. (z.B.)

n ist Anzahl der Mannnschaften


int n=6;
boolean[][] array=new boolean[n+1][n+1];

for(int i=0;i<n+1;i++)
for(int j=0;j<n+1;j++)
array[j][i]=false;

for(int i=n;i>=1;i--)
for(int j=i-1;j>=1;j--)
{
System.out.println(j+" "+i);
array[j][i]=true;
}

System.out.println("\n\n");

int a=0,b=0;

for(int i=1;i<=n;i++)
{
a=1;
b=i;
for(int j=1;j<=n;j++)
{
if(array[a][b])System.out.print(a+":"+b+" ");
a++;b--;
if(b==0)b=n;
}
System.out.println();
}


Ach so die Anzahlder Spiele ist doch (n*(n-1))/2 oder (n^2-n)/2
und
Die Spieltage ist gleich der Anzahlder Manschaften.

GRZ DON :D

[Steffel]

Ich habe das jetzt nicht laufen lassen, aber intuitiv würde ich sagen dass das so nicht klappt. Lass das mal mit n=9 oder n=10 laufen und lass Dir die Spieltage ausgeben - ich schätze dann siehst Du die Probleme.

[pille]

Also wenn ich dicch richtig verstanden habe sollen n Amnnschaften gegeneinander spielen.
Und willst alle begenungen haben.

Analogie:

5 Personen sind in einem Raum und jeder soll jedem die Hand schüteln
Nr. 5 fängt an und schütelt Nr. 4,3,2,1 die Hand ist fertig
Nr. 4 => Nr. 3,2,1 => fertig
Nr. 3 => Nr. 2,1 => fertig
..usw..

int n=15;

for(int i=n;i>=1;i--)
for(int j=i-1;j>=1;j--)
System.out.println(j+" "+i);


n ist die Anzahl der Mannschaften
Anzahl der Spiele ist (n*(n-1))/2


Da bei einer ungeraden Anzahl von Mannschaften an einem Spieltag ja immer eine Mannschaft spielfrei hätte, kann man eine erfundene Mannschaft hinzufügen und alle Mannschaften , die gegen diese erfundene Mannschaft spielen, haben spielfrei.

[Steffel]

So ganz verstehe ich die Diskussion hier nicht. Das Problem wird durch den Algorithmus wie ich ihn oben mit dem Link veröffentlicht habe gelöst. Alles was jetzt noch interessant wäre ist ein einfacherer Algorithmus - dann aber bitte mit dem Nachweis dass er auch funktioniert!

[DonVitoni]

Tach ooch!

So hab das auch noch mal laufen lassen.
Hier die Ergebnisse.

n=9:

Tag 1 => 2:9 3:8 4:7 5:6 => Team 1 hat frei
Tag 2 => 1:2 3:9 4:8 5:7 => Team 6 hat frei
Tag 3 => 1:3 4:9 5:8 6:7 => Team 2 hat frei
Tag 4 => 1:4 2:3 5:9 6:8 => Team 7 hat frei
Tag 5 => 1:5 2:4 6:9 7:8 => Team 3 hat frei
Tag 6 => 1:6 2:5 3:4 7:9 => Team 8 hat frei
Tag 7 => 1:7 2:6 3:5 8:9 => Team 4 hat frei
Tag 8 => 1:8 2:7 3:6 4:5 => Team 9 hat frei
Tag 9 => 1:9 2:8 3:7 4:6 => Team 5 hat frei

n=10

Tag 1 => 2:10 3:9 4:8 5:7 => Team 1 und 6 hat frei
Tag 2 => 1:2 3:10 4:9 5:8 6:7 => alle spielen
Tag 3 => 1:3 4:10 5:9 6:8 => Team 2 und 7 hat frei
Tag 4 => 1:4 2:3 5:10 6:9 7:8 => allen spielen
Tag 5 => 1:5 2:4 6:10 7:9 => Team 3 und 8 hat frei
Tag 6 => 1:6 2:5 3:4 7:10 8:9 => allen spielen
Tag 7 => 1:7 2:6 3:5 8:10 => Team 4 und 9 hat frei
Tag 8 => 1:8 2:7 3:6 4:5 9:10 => allen spielen
Tag 9 => 1:9 2:8 3:7 4:6 => Team 5 und 10 hat frei
Tag 10 => 1:10 2:9 3:8 4:7 5:6 => alle spielen

bei n%2<>0 Mannschaften hat immer eine pro tag frei
bei n%2==0 Mannschaften haben immer 2 Teams an jedem zweiten tag frei


Probleme hab ich noch nicht endeckt. :confused:

Jeder spielt gegen jeden, jeder hat ein mal frei und besser verteilen kann man die Spiele auch nicht(oder doch?) + der Algoithmus ist doch nun superkurz.

Gerechter und kürzer geht das glaube ich nicht.

GRZ DON :D

[pille]

hab hier zwei links für dich , die dir helfen könnten:

http://www.hollwitz.de/php/lmo.htm

und

http://www.hollwitz.de/software/lmd-win.htm

da gibts einmal ein GUI Programm für Windows und das ganze noch einmal als PHP-Script. Beides unter der GPL - Lizenz. Mit den Programmen kann man Ligen erstellen und man kann einen Spielplan automatisch erstellen lassen !

[Steffel]

@DonVitoni:
Ok, da lag ich wohl mit meiner Intuition daneben. Scheint zu klappen und ist deutlich einfacher als der rekursive Algorithmus. Hübsch!

[DonVitoni]

Danke für die Blumen. :)

Ist aber bloss der kern der sache.
Es müssen ja noch die Namen integriert werden und die Rückrunden(wenn den erforderlich).

Interesanter aber wäre es doch herauszufinden wieviele Möglichkeiten es insagesamt gibt um mit n Mannschaften einen Spielplan zu erstellen?

GRZ DON :D


p.s. ist dir mal aufgefallen das das Thema vom 17.04.2002 stammt

[Steffel]

Wenn Du noch weitere Herausforderungen suchst:
- Faire Verteilung von Heim- und Gastrecht
- 2 Teams teilen sich ein Stadion, so dass sie nicht gleichzeitig Heimrecht haben dürfen
Auch wenn das Thema von 2002 ist: Es gibt ja sicher immer wieder mal jemanden der nach der Lösung sucht.

[DonVitoni]

Hi Steffel

Wenn ich dich richtig verstanden habe teilen sich bei 6 teams:
team 1 und 2 , 3 und 4 , 5 und 6 ein Stadion.

und jeder soll die gleichen anzahl spiele im eigen Stadion haben.

also bei 6 teams müsste team 1 => 3 mal im eigen Stadion spielen. usw.

mein Ergebnis mit 6 teams:

2:6 3:5
2:1 5:4 6:3
1:3 4:6
3:2 4:1 6:5
1:5 2:4
4:3 5:2 6:1

jeder spielt 3 mal im eigenen Stadion


mein Code:


int n=6;
int a=0,b=0;

boolean[][] array=new boolean[n+1][n+1];

for(int i=0;i<n+1;i++)
for(int j=0;j<n+1;j++)
array[j][i]=true;

for(int i=0;i<=n;i++)
array[i][i]=false;

for(int i=2;i<=n;i+=2)
for(int j=0;j<=n-i;j++)
array[i+j][j]=false;

for(int i=1;i<=n;i+=2)
for(int j=0;j<=n-i;j++)
array[j][j+i]=false;

System.out.println("\n\n");

for(int i=1;i<=n;i++)
{
a=1;
b=i;
for(int j=1;j<=n;j++)
{
if(array[a][b])System.out.print(a+":"+b+" ");
a++;b--;
if(b==0)b=n;
}
System.out.println();
}



Have fun with it ;)


GRZ DON :D

[Steffel]

Die minimale Anzahl an Spieltagen wären das erste Postulat. Und die Randbedingung lautet nur, dass sich Team 1 und Team 2 ein Stadion teilen. Oder, wenn Du es allgemeiner willst: Wieviele Mannschaftspaare können sich maximal bei gegebenem n jeweils ein Stadion teilen?
Bei Deiner Lösung für n=6 gibt's ja jetzt 6 Spieltage, also mehr als nötig. Oder liegt's daran dass n gerade ist? Da versagt ja auch Deine erste Version ohne Randbedingung noch, was die Minimalität der Spieltag-Anzahl angeht.

[DonVitoni]

Hi Steffel :)

Also die Spieltage sind minimal weil schau mal

für n=5;

4:3 5:2
2:1 3:5
1:3 5:4
3:2 4:1
1:5 2:4

alle teams sind vertretten ausser 1 (tag 1)und ein Team doppelt spielen lassen geht ja nicht. und ein spiel pro tag reicht
und die Bundesliga hat auch 36 spieltage (hin-und rückrunde)
36/2 => Mannschaften (hoffe ist richtig)

bei n=6 =>

2:6 3:5
2:1 5:4 6:3
1:3 4:6
3:2 4:1 6:5
1:5 2:4
4:3 5:2 6:1

naja gut sind 15 spiele kann mann auch 3*5 machen (asche auf mein haupt)

vielleicht kannst du ja mal meinen code ändern sodass dass klappt
schreib morgen noch mal
hab feierabend

GRZ DON :D

[Steffel]

So sollte es für alle n>=2 klappen:


using System;
class LigaAlgorithmus
{
// st[i,j] ist der Spieltag an dem i gegen j spielt.
static void Calc(int n)
{
int i=0,j=0,a=0,b=0,s=0,k=(n%2==0?n-1:n);
int [,] st = new int[n+1,n+1];
for(i=1;i<=k;i++)
{
s++; a=1; b=i;
for(j=1;j<=k;j++)
{
if (a<b) st[a,b]=s;
a++; b--;
if (b<1) b=k;
}
}
if (k<n) for (i=1;i<n;i++) st[i,n]=(i==1?1:st[i-1,i]+1);
for (i=1;i<=n;i++) for (j=1;j<i;j++) st[i,j]=st[j,i]+k;
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++) Console.Write(" "+st[i,j].ToString("d2"));
Console.WriteLine();
}
}
[STAThread]
static void Main(string[] args)
{
Calc(8);
}
}

[dsiemers]

und die Bundesliga hat auch 36 spieltage (hin-und rückrunde)
36/2 => Mannschaften (hoffe ist richtig)


Moment ! Die Bundesliga hat nur 34 Spieltage, oder soll noch Bremen gegen Bremen in der Hinrunde und Bremen gegen Bremen in der Rückrunde spielen ?

Ich schreib gerade ein Proseminar über Komplexitätstheorie... in der Bundesliga. Da wird der DFB-Spielplan auch erklärt. Vieleicht hilft wuch das weiter ?

Also, das ganze ist als 1-Faktorisierung des vollständigen Graphen in der Graphentheorie angesiedelt und funktioniert für ein gerades n folgendermassen:

Skizze:

_____ 16 15 14 13 12 11 10 9
17-0 | | | | | | | |
_____ 1 2 3 4 5 6 7 8

Wir teilen die Manschaften von 0,..,n-1 ein. Die Mannschaft n-1 spielt eine Sonderrolle. Sie spielt zuerst gegen 0, dann gegen 1, bis n-2. Sie hat als bei dem ersten Spiel Heimrecht, dann ein Auswärtsspiel, usw.
Die weiteren Paarungen sind dann 1 gegen n-2, 2 gegen n-3, ... , n/2-1 gegen n/2. Danach dreht sich das Diagramm von oben in einem gedachten Kreis eine Position im Uhrzeiger.
So sieht dann der 2te Spieltag aus:

Skizze2:

_____ 0 16 15 14 13 12 11 10
17-1 | | | | | | | |
_____ 2 3 4 5 6 7 8 9

Die Positionen 2,4,6,8,10,12,14,16 von oben haben Heimrecht. Die Heimrechtspositionen bleiben nun auch bei dem 2ten Spieltag so. Daher haben nun folgende Mannschaften Heimrecht: 0,3,5,7,9,11,13,15.
1 würde nun auch zuhause spielen, da 17 ja auswärts spielen muss.

Man muss noch dazusagen, dass der DFB ein paar Spieltage umlegt. z.B. weil es nach dem 15 Spieltag 3mal Heimrecht gibt, oder so ?!? Oder z.B. ist Kirchentag in Frankfurt, und dann sollten die nicht zuhause spielen, oder so :confused:

Hoffe hab euch ein wenig weitergeholfen. Die Algorithmen sind eigentlich schon länger bekannt.

ps. ich krieg das mit den Skizzen hier nicht hin, ansonsten kann ich nochmal ein Bild schicken

[Alhambra]

Hallo Steffen,
Habe das auch erst kürzlich gefunden, klappt auf jeden Fall.
Hoffe du kannst das gebrauchen.
Du sagtest mit ner Anbindung an eine Datenbank wäre kein Problem.
Leider bekomme ich das nicht hin. warum weiss ich allerdings nicht:-(

Alhambra

/*
** Spielplan-Generator / Liga-Planer
**
**
**
** Erweitert von Christian <linker@toter-link.de>
**
** =================================
** Spielmodus: "Jeder gegen Jeden", Hin- und Rückspiele,
** mit spieltäglichem Wechsel zwischen Heim- und Gastspiel.
** Das Programm benötigt ein Array ($teams), welches die Teilnehmer enthält.
**
** Es wird ein Array $plan erzeugt, das alle Hin- und Rückspiele enthält.
** Hierbei werden alle Spielpaarungen fortlaufend durchnummeriert.
** Das Array $plan halt folgenden Aufbau:
** $plan[$spieltag][$spielnummer]['H'|'G' = Heim- oder Gast-Team]
*/




$teams = array("1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18");



// Testen ob die Anzahl der Teams gerade ist
// wenn nicht das Team "frei" hinzufügen.
if(count($teams) % 2 ){
array_push($teams , '[FREI]');
}

// Anzahl der Teams im Array $teams
$paare = $anz/2; // Anzahl der möglichen Spielpaare
$tage = $anz-1; // Anzahl der Spieltage pro Runde
$spiele = $paare*$tage; // Anzahl der Spiele pro Hin-/Rück-Runde
$plan = array(); // Array für den kompletten Spielplan
$xpos = $anz-1; // höchster Key im Array $teams
$tag = 0; // Zähler für Spieltag
$spnr = 0; // Zähler für Spielnummer
$sppaar = 0; // Zähler für Spielpaar
$i = 0; // Schleifenzähler

// ================================================================================

for ($tag=1; $tag<$anz; $tag++) {
array_splice ($teams, 1, 1, array(array_pop($teams),$teams[1]));
for ($sppaar=0; $sppaar<$paare; $sppaar++) {
$spnr++;
// wechseln zwischen G und H -Spiel:
if (($spnr%$anz!=1) and ($sppaar%2==0)) {
$hteam = $teams[$sppaar];
$gteam = $teams[$xpos-$sppaar];
} else {
$gteam = $teams[$sppaar];
$hteam = $teams[$xpos-$sppaar];
}
$plan[$tag][$spnr]["G"] = $gteam; // für Hin-Runde
$plan[$tag][$spnr]["H"] = $hteam; // für Hin-Runde
$plan[$tag+$tage][$spnr+$spiele]["G"] = $hteam; // für Rück-Runde
$plan[$tag+$tage][$spnr+$spiele]["H"] = $gteam; // für Rück-Runde
}
}
ksort($plan); /* nach Spieltagen sortieren */

// ================================================================================



/* Ausgabe des gesamten $plan */
$rueck = count($plan)/2 ;
echo "Spielplan: <br>";
echo "********* Hin-Runde *********<br><br>\n" ;
foreach($plan as $spieltag => $v1) {
foreach($v1 as $spielnummer => $v2) {
echo "SpTag: "; echo $spieltag;
echo ":&nbsp;&nbsp;SpNr: "; echo $spielnummer;
echo ":&nbsp;&nbsp;&nbsp;"; echo $plan[$spieltag][$spielnummer]['H'];
echo " - "; echo $plan[$spieltag][$spielnummer]['G'];


echo "<br>";
}
if ($spieltag == $rueck){
echo "<br>********* Rück-Runde *********<br>\n" ;
}
echo"<br>";
}
echo "**********************************************<br>Ende der Liste <br>";

mysql_close();

?>

[TheX]

Habe das nun wie folgt (analog zu DonVitoni) in Blitz-Basic probiert :

Tabelle(4)
Function Tabelle(anz)
i = (anz + anz Mod 2 - 1)
for a = 1 to i
for b = 1 to i
if a < b then
print "Verein "+a+" gegen Verein "+b+" an Spieltag "+((a+b-2) mod i + 1)
endif
next
next
if anz mod 2 = 0 then
for a = 1 to i
print "Verein "+a+" gegen Verein "+(i+1)+" an Spieltag "+((a-1)*2 mod i + 1)
next
endif
end function


... und es funktioniert ... und das Rückspiel läßt sich bei Bedarf einfach ergänzen ...

Tabelle(4)
Function Tabelle(anz)
i = (anz + anz Mod 2 - 1)
for a = 1 to i
for b = 1 to i
if a < b then
print "Verein "+a+" gegen Verein "+b+" an Spieltag "+((a+b-2) mod i + 1)
print "Verein "+b+" gegen Verein "+a+" an Spieltag "+(((a+b-2) mod i + 1)+i)
endif
next
next
if anz mod 2 = 0 then
for a = 1 to i
print "Verein "+a+" gegen Verein "+(i+1)+" an Spieltag "+((a-1)*2 mod i + 1)
print "Verein "+(i+1)+" gegen Verein "+a+" an Spieltag "+(((a-1)*2 mod i + 1)+i)
next
endif
end function


Gruß,

Nino