{"id":55000468,"date":"2019-12-01T00:00:00","date_gmt":"2020-03-23T18:48:59","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=468"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ligaverwaltung_Teil_3_Spielplaene_generieren","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html","title":{"rendered":"Ligaverwaltung, Teil 3: Spielpl&auml;ne generieren"},"content":{"rendered":"<p class='introduction'>F&uuml;r die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden k&ouml;nnen mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff f&uuml;r eine Datenbankanwendung &#8211; mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpl&auml;ne und Tabellen auszugeben. Im dritten Teil der Artikelreihe entwickeln wir einen Algorithmus, der es uns erlaubt, Spielpl&auml;ne f&uuml;r Ligen mit beliebig vielen Mannschaften zu generieren.<\/p>\n<h2>Beispieldatenbank<\/h2>\n<p>Die Beispiele dieses Artikels finden Sie in der Datenbank <b>1906_Ligaverwaltung.accdb<\/b>.<\/p>\n<h2>Aufgabenstellung<\/h2>\n<p>Die Aufgabe lautet: Wir wollen f&uuml;r eine Anzahl von Mannschaften, egal ob 4, 6 oder 18, programmgesteuert einen Spielplan erstellen. Dieser Spielplan soll folgene Bedingungen erf&uuml;llen:<\/p>\n<ul>\n<li>Jede Mannschaft soll ein Heimspiel gegen jede andere Mannschaft haben. F&uuml;r die Fu&szlig;ball-Bundesliga bedeutet das beispielsweise: Jede Mannschaft macht 17 Heimspiele plus, resultierend aus den 17 Spielen, in denen die anderen Mannschaften ein Heimspiel gegen diese Mannschaft haben, 17 Ausw&auml;rtsspiele. Dementsprechend gibt es 2 mal n-1 Spieltage, wobei n der Anzahl der Mannschaften entspricht.<\/li>\n<li>Jede Mannschaft soll auch nur genau einmal in einem Heimspiel gegen jede andere Mannschaft spielen.<\/li>\n<li>Die Spielpaarungen sind auf Spieltage aufgeteilt, wobei an jedem Spieltag jede Mannschaft einmal spielt.<\/li>\n<li>Die Spiele sollen in zwei Runden ausgetragen werden, wobei die Hin- und die R&uuml;ckrunde identisch zusammengestellt werden &#8211; nur mit umgedrehtem Heimrecht. Es reicht also prinzipiell, nur die Hinrunde zu generieren und daraus die Spielpaarungen der R&uuml;ckrunde abzuleiten.<\/li>\n<li>Um es nicht zu einfach zu machen: Jede Mannschaft soll maximal einmal pro Spielrunde (also bezogen auf Hin- und R&uuml;ckrunde) zwei Heim- oder Ausw&auml;rtsspiele hintereinander bestreiten. Und das soll auch erst ab dem zweiten Spieltag und bis zum vorletzten Spieltag m&ouml;glich sein (also keine zwei Heim- oder Ausw&auml;rtsspiele am ersten und zweiten oder vorletzten und letzten Spieltag).<\/li>\n<li>Die Kr&ouml;nung w&auml;re &#8211; und so ist es in den echten Spielpl&auml;nen der Fu&szlig;ballbundesliga -, wenn die Abfolge der Gegner einer jeden Mannschaft ungef&auml;hrt gleich w&auml;re. Also wenn Mannschaft 1 nacheinander gegen Mannschaft 2, Mannschaft 3 und Mannschaft 4 spielt, dann wird Mannschaft 5 auch irgendwann in dieser Abfolge gegen diese Mannschaften spielen. Das funktioniert nat&uuml;rlich nicht durchgehend, denn wenn man die Abfolge der 17 Spiele der Hinrunde einer Mannschaft auf eine andere Mannschaft &uuml;bertragen wollte, m&uuml;sste diese ja gegen sich selbst spielen &#8211; und sp&auml;testens an dieser Stelle m&uuml;ssten wir die Mannschaft dann austauschen.<\/li>\n<\/ul>\n<h2>Ablauf<\/h2>\n<p>Wie k&ouml;nnte das programmatisch ablaufen Man k&ouml;nnte auf verschiedene Arten vorgehen. Die erste Idee ist, zuerst alle Spiele f&uuml;r Mannschaft 1 festzulegen, dann die verbleibenden Spiele f&uuml;r Mannschaft 2 und so weiter. <\/p>\n<p>Wir k&ouml;nnten auch einfach alle Spiele von Spieltag 1 an komplett durchbesetzen, indem wir immer die Mannschaft mit dem kleinsten Index eintragen, die noch verf&uuml;gbar ist. Am erste Spieltag sieht der Spielplan dann so aus:<\/p>\n<pre>1-2\r\n3-4\r\n5-6\r\n...<\/pre>\n<p>Am zweiten Spieltag beginnen wir dann wieder mit Mannschaft 1 und suchen die Mannschaft mit dem kleinsten Index, gegen den diese Mannschaft noch nicht gespielt hat &#8211; in diesem Fall Mannschaft 3 -, und tauschen das Heimrecht um:<\/p>\n<pre>3-1<\/pre>\n<p>Dann h&auml;tte allerdings Mannschaft 3 direkt an den ersten beiden Spieltagen zwei Heimspiele, was fr&uuml;hestens ab dem zweiten Spieltag m&ouml;glich sein soll. Mannschaft 1 m&uuml;sste dann also bei Mannschaft 4 antreten:<\/p>\n<pre>4-1<\/pre>\n<p>Sie sehen: Es ist nicht einfach. Und das wollen wir gleich auch noch programmieren! Abzusehen ist, dass wir dann irgendwann bei der Ermittlung der Paarungen f&uuml;r die hinteren Spieltage auf das Problem sto&szlig;en werden, dass wir je Spieltag nicht mehr ausreichend Spiele zusammenstellen und gleichzeitig alle Bedingungen erf&uuml;llen k&ouml;nnen.<\/p>\n<p>Das hei&szlig;t, wir k&ouml;nnen keinen starren Ablauf programmieren, sondern m&uuml;ssen die M&ouml;glichkeit der Korrektur vorheriger Spieltage ber&uuml;cksichtigen.<\/p>\n<p>In der Programmierung bekommt man das am besten mit rekursiven Funktionen hin. Das hei&szlig;t, wir legen ein Spiel an, pr&uuml;fen, ob wir das n&auml;chste Spiel nach anlegen k&ouml;nnen, und wenn nicht, l&ouml;schen wir das zuvor angelegte Spiel wieder, um ein anderes Spiel anzulegen. Auf diese Weise arbeiten wir uns durch die Kombinationen, um am Ende einen Spielplan zu erhalten, der alle Bedingungen erf&uuml;llt. Gegebenenfalls m&uuml;ssen wir uns dabei bis zur&uuml;ck zum Anfang bewegen.<\/p>\n<h2>Alternative: Erst Spiele anlegen, dann auf Spieltage aufteilen<\/h2>\n<p>Es gibt allerdings noch andere Herangehensweisen. Eine, die vielleicht etwas anschaulicher ist, sieht so aus: Wir tragen erst einmal alle Paarungen in die Tabelle <b>tblSpielpaarungen <\/b>ein. Das ist einfach: Wir brauchen ja nur zwei Recordsets mit den Mannschaften der Liga\/Spielzeit in zwei verschachtelten <b>Do While<\/b>-Schleifen zu durchlaufen und darin jeweils die Heim- und die Ausw&auml;rtsmannschaft in die Felder der Tabelle <b>tblSpielpaarungen <\/b>einzutragen. Dabei m&uuml;ssen wir nur pr&uuml;fen, ob die Heim- und die Ausw&auml;rtsmannschaft identisch sind und in diesem Fall keinen Datensatz anlegen. <\/p>\n<h2>Programmierung der Spielplangenerierung<\/h2>\n<p>Wir beginnen mit dem Anlegen der Spiele einer Liga. Dazu verwenden wir die Prozedur aus Listing 1. Die Prozedur erwartet die <b>LigaSpieljahrID <\/b>f&uuml;r die Liga, f&uuml;r deren Mannschaften der Spielplan angelegt werden soll. Wir haben zun&auml;chst eine kleine Liga angelegt, die nur vier Mannschaften enth&auml;lt.<\/p>\n<pre>&lt;font color=blue&gt;Public Sub &lt;\/font&gt;PaarungenAnlegen(lngLigaSpieljahrID&lt;font color=blue&gt; As Long&lt;\/font&gt;)\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;db&lt;font color=blue&gt; As &lt;\/font&gt;DAO.Database\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;rstSpielpaarungen&lt;font color=blue&gt; As &lt;\/font&gt;DAO.Recordset\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;rstHeimmannschaften&lt;font color=blue&gt; As &lt;\/font&gt;DAO.Recordset\r\n     &lt;font color=blue&gt;Dim &lt;\/font&gt;rstAuswaertsmannschaften&lt;font color=blue&gt; As &lt;\/font&gt;DAO.Recordset\r\n     &lt;font color=blue&gt;Set&lt;\/font&gt; db = CurrentDb\r\n     &lt;font color=blue&gt;Set&lt;\/font&gt; rstSpielpaarungen = db.OpenRecordset(\"SELECT * FROM tblSpielpaarungen\", dbOpenDynaset)\r\n     &lt;font color=blue&gt;Set&lt;\/font&gt; rstHeimmannschaften = db.OpenRecordset(\"SELECT MannschaftID FROM tblLigenSpieljahreMannschaften \" _\r\n         & \"WHERE LigaSpieljahrID = \" & lngLigaSpieljahrID, dbOpenDynaset)\r\n     &lt;font color=blue&gt;Set&lt;\/font&gt; rstAuswaertsmannschaften = db.OpenRecordset(\"SELECT MannschaftID FROM tblLigenSpieljahreMannschaften \" _\r\n         & \"WHERE LigaSpieljahrID = \" & lngLigaSpieljahrID, dbOpenDynaset)\r\n     &lt;font color=blue&gt;Do While&lt;\/font&gt; &lt;font color=blue&gt;Not&lt;\/font&gt; rstHeimmannschaften.EOF\r\n         &lt;font color=blue&gt;Do While&lt;\/font&gt; &lt;font color=blue&gt;Not&lt;\/font&gt; rstAuswaertsmannschaften.EOF\r\n             &lt;font color=blue&gt;If &lt;\/font&gt;&lt;font color=blue&gt;Not&lt;\/font&gt; rstHeimmannschaften!ID = rstAuswaertsmannschaften!ID&lt;font color=blue&gt; Then&lt;\/font&gt;\r\n                 rstSpielpaarungen.Add&lt;font color=blue&gt;New&lt;\/font&gt;\r\n                 rstSpielpaarungen!HeimmannschaftID = rstHeimmannschaften!ID\r\n                 rstSpielpaarungen!AuswaertsmannschaftID = rstAuswaertsmannschaften!ID\r\n                 rstSpielpaarungen.Update\r\n             &lt;font color=blue&gt;End If&lt;\/font&gt;\r\n             rstAuswaertsmannschaften.Move&lt;font color=blue&gt;Next&lt;\/font&gt;\r\n         &lt;font color=blue&gt;Loop&lt;\/font&gt;\r\n         rstAuswaertsmannschaften.MoveFirst\r\n         rstHeimmannschaften.Move&lt;font color=blue&gt;Next&lt;\/font&gt;\r\n     &lt;font color=blue&gt;Loop&lt;\/font&gt;\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<p class='imagetext'>Listing 1: Anlegen von Spielpaarungen<\/p>\n<p>Die Prozedur verwendet drei Recordset-Objekte: <b>rstSpielpaarungen <\/b>liefert die Daten der Tabelle <b>tblSpielpaarungen <\/b>und <b>rstHeimmannschaften <\/b>und <b>rstAuswaertsmannschaften <\/b>jeweils die Daten des Feldes <b>MannschaftID <\/b>der Tabelle <b>tblLigenSpieljahreMannschaften<\/b>. Dabei werden die Daten dieser beiden Recordsets nach dem Wert des Parameters <b>lngLigaSpieljahrID <\/b>gefiltert.<\/p>\n<p>In einer &auml;u&szlig;eren Schleife durchlaufen wir die Elemente des Recordsets <b>rstHeimmannschaften<\/b>, in einer inneren die Elemente aus <b>rstAuswaertsmannschaften<\/b>. Dabei stellen wir den Datensatzzeiger der inneren Schleife immer wieder mit <b>rst.MoveFirst <\/b>auf den ersten Datensatz zur&uuml;ck, wenn wir alle Ausw&auml;rtsmannschaften f&uuml;r die aktuelle Heimmannschaft durchlaufen haben. Innerhalb der Schleife pr&uuml;fen wir dann, ob die aktuelle Heimmannschaft gleich der aktuellen Ausw&auml;rtsmannschaft ist. In diesem Fall legen wir keine neue Spielpaarung an. Anderenfalls f&uuml;gt die Prozedur einen neuen Datensatz zum Recordset rstSpielpaarungen hinzu und tr&auml;gt die jeweiligen IDs f&uuml;r die Felder <b>HeimmannschaftID <\/b>und <b>AuswaertsmannschaftID <\/b>ein. Danach sieht die Tabelle <b>tblSpielpaarungen <\/b>f&uuml;r vier Mannschaften etwa wie in Bild 1 aus.<\/p>\n<p class=\"image\"><a rel=\"lightbox\" href=\"..\/tl_files\/images\/pic_468_001.png\"><img decoding=\"async\" src=\"..\/tl_files\/images\/pic_468_001.png\" alt=\"Spielpaarungen einer Vierer-Liga\" width=\"325\" \/><\/a><\/p>\n<p class='imagetext'>Bild 1: Spielpaarungen einer Vierer-Liga<\/p>\n<p>Nun brauchen wir hier nur noch die Spieltage einzutragen. Und das wird eine interessante Aufgabe. Die Grundidee ist: Wir beginnen mit dem ersten Spieltag und suchen uns f&uuml;r diesen Paarungen heraus. F&uuml;r das erste Spiel am ersten Spieltag kein Problem: Hier k&ouml;nnen wir einfach das erste Spiel ausw&auml;hlen. Danach wollen wir das erste Spiel aus der Tabelle tblSpielpaarungen suchen, dessen Heimmannschaft und dessen Ausw&auml;rtsmannschaft nicht am ersten Spiel beteiligt sind. Soweit kein Problem &#8211; der erste Spieltag k&ouml;nnte so aussehen:<\/p>\n<pre>FC Bayern M&uuml;nchen - Borussia Dortmund\r\nEintracht Frankfurt - TSG Hoffenheim 1899<\/pre>\n<p>F&uuml;r den zweiten Spieltag k&ouml;nnen wir dann eines der verbleibenden Spiele als Startpunkt nehmen, und zwar das n&auml;chste verf&uuml;gbare in der Tabelle. Hier also:<\/p>\n<pre>FC Bayern M&uuml;nchen - Eintracht Frankfurt<\/pre>\n<p>Dazu passt dann: <\/p>\n<pre>Borussia Dortmund - TSG Hoffenheim 1899<\/pre>\n<p>Damit hat Bayern M&uuml;nchen allerdings direkt zwei Heimspiele und Hoffenheim gleich zwei Ausw&auml;rtsspiele. Aber gut, das l&auml;sst sich bei einer Vierergruppe nicht vermeiden. W&uuml;rden wir eine der beiden Paarungen umdrehen, h&auml;tten die beiden anderen Mannschaften entweder zweimal zuhause oder ausw&auml;rts gespielt. F&uuml;r den dritten Spieltag erhalten wir dann, wenn wir wieder das n&auml;chste noch nicht an einen Spieltag vergebene Spiel holen und dann das n&auml;chste Spiel mit den &uuml;brigen Mannschaften:<\/p>\n<pre>FC Bayern M&uuml;nchen - TSG Hoffenheim 1899\r\nBorussia Dortmund - Eintracht Frankfurt<\/pre>\n<p>Sp&auml;testens hier ist die Verteilung von Heim- und Ausw&auml;rtsspielen auff&auml;llig, denn FC Bayern M&uuml;nchen h&auml;tte nun drei Heimspiele in Folge.<\/p>\n<p>Uns wurde schnell klar, dass es ein sehr aufwendiges Unterfangen werden w&uuml;rde, selbst mit Verfahren wie Rekursion eine programmgesteuerte Methode zum Erstellen eines Spielplans mit beispielsweise 18 Mannschaften zu erstellen.<\/p>\n<h2>Algorithmus nachbauen<\/h2>\n<p>Also haben wir im Internet geschaut, ob es nicht Informationen gibt, wie so ein Bundesligaplan zusammengestellt wird. Und Wikipedia hat unter <b>https:\/\/de.wikipedia.org\/wiki\/Spielplan_(Sport) <\/b>eine passende Erl&auml;uterung pr&auml;sentiert, die wir nun in Form einer Prozedur f&uuml;r unser Datenmodell umsetzen wollen.<\/p>\n<p>Hier lautet es zun&auml;chst: <\/p>\n<p>&#8222;Im ersten Schritt wird dazu jeder der 18 Mannschaften au&szlig;er einer, dem &#8222;Joker&#8220; (in diesem Fall dem Hamburger SV) eine zuf&auml;llige Zahl zwischen 1 und 17 zugeordnet, woraufhin der &#8222;Joker&#8220; selbst die Nummer 18 erh&auml;lt.&#8220;<\/p>\n<p>Das ergibt eine Liste mit 17 Mannschaften: <\/p>\n<pre>1 Bayern M&uuml;nchen\r\n2 Borussia Dortmund\r\n...\r\n17 Union Berlin<\/pre>\n<p>Weiter lautet es:<\/p>\n<p>&#8222;Am Spieltag n (hier: 1 ? n ? 17) tritt der Verein mit der Nummer k gegen genau die gegnerische Mannschaft mit der Nummer l an, so dass der Rest der Summe beider Nummern k + l bei Division durch 17 genau den Rest n ergibt. Der &#8222;Joker&#8220; mit der Nummer 18 (in diesem Fall also der Hamburger SV) tritt schlie&szlig;lich gegen den Verein an, f&uuml;r den sich nach obiger Regel an dem betreffenden Spieltag kein Partner findet.&#8220;<\/p>\n<p>Und schlie&szlig;lich f&uuml;r die Entscheidung, ob eine Mannschaft daheim oder ausw&auml;rts antritt:<\/p>\n<p>&#8222;Um zu ermitteln, welche Mannschaft Heimrecht hat, gilt in der Hinrunde folgendes: Ist die Summe der beiden Nummern k + l eine gerade Zahl, hat die Mannschaft mit der h&ouml;heren Nummer Heimrecht; ist die Summe dagegen eine ungerade Zahl, hat die Mannschaft mit der niedrigeren Nummer Heimrecht. Der &#8222;Joker&#8220; mit der Nummer 18 schlie&szlig;lich hat nur Heimrecht gegen die Mannschaften mit den Nummern 8 bis 16, nicht aber 1 bis 7 und 17.&#8220;<\/p>\n<p>Schauen wir, wie wir das in Programmform umsetzen k&ouml;nnen.<\/p>\n<p>Als Erstes brauchen wir eine Liste der Mannschaften mit dem Index von 1 bis 18. Wir haben kein entsprechendes Feld in der Tabelle <b>tblMannschaften <\/b>vorgesehen, was auch keinen Sinn macht, da die Mannschaften ja in verschiedenen Spieljahren verschiedenen Ligen zugeordnet werden sollen. Viel praktischer w&auml;re es, wenn wir in der Tabelle <b>tblLigenSpieljahreMannschaften <\/b>ein Feld h&auml;tten, wo wir jeder Mannschaft in der Zuordnung zu Liga\/Spieljahr eine Nummer vergeben k&ouml;nnen.<\/p>\n<p>Wir k&ouml;nnten zwar auch einfach die Mannschaften einer Liga einlesen und diesen dann die Zahlen von 1 bis 18 zuweisen, etwa in einer Collection, aber wenn wir die Zahlen direkt in der Tabelle <b>tblLigenSpieljahreMannschaften <\/b>speichern, kann der Benutzer auch die Zahlenzuordnung &auml;ndern und den Spielplan neu generieren, wenn dieser nicht seinen Anforderungen entspricht. Die Tabelle sieht nach dieser &auml;nderung in der Entwurfsansicht wie in Bild 2 aus.<\/p>\n<p class=\"image\"><a rel=\"lightbox\" href=\"..\/tl_files\/images\/pic_468_002.png\"><img decoding=\"async\" src=\"..\/tl_files\/images\/pic_468_002.png\" alt=\"Neues Feld in der Tabelle tblLigenSpieljahreMannschaften\" width=\"325\" \/><\/a><\/p>\n<p class='imagetext'>Bild 2: Neues Feld in der Tabelle tblLigenSpieljahreMannschaften<\/p>\n<p>Das neue Feld f&uuml;gen wir auch zum Formular <b>frmLigenSpieljahreMannschaften<\/b> hinzu (siehe Bild 3).<\/p>\n<p class=\"image\"><a rel=\"lightbox\" href=\"..\/tl_files\/images\/pic_468_003.png\"><img decoding=\"async\" src=\"..\/tl_files\/images\/pic_468_003.png\" alt=\"Neues Feld im Formular frmLigenSpieljahreMannschaften\" width=\"325\" \/><\/a><\/p>\n<p class='imagetext'>Bild 3: Neues Feld im Formular frmLigenSpieljahreMannschaften<\/p>\n<div class=\"rcp_restricted\"><p><span style=\"color: #ff0000;\">M&ouml;chten Sie weiterlesen? Dann l&ouml;sen Sie Ihr Ticket!<\/span><br \/>\n<span style=\"color: #ff0000;\">Hier geht es zur Bestellung des Jahresabonnements des Magazins <strong>Access &#091;basics&#093;<\/strong>:<\/span><br \/>\n<span style=\"color: #ff0000;\"><a style=\"color: #ff0000;\" href=\"https:\/\/shop.minhorst.com\/magazine\/282\/access-basics?c=77\">Zur Bestellung ...<\/a><\/span><br \/>\n<span style=\"color: #ff0000;\">Danach greifen Sie sofort auf <strong>alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span><br \/>\n<span style=\"color: #000000;\">Oder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t<form id=\"rcp_login_form\"  class=\"rcp_form\" method=\"POST\" action=\"https:\/\/access-basics.de\/data\/wp\/v2\/posts\/55000468\/\">\n\n\t\t\n\t\t<fieldset class=\"rcp_login_data\">\n\t\t\t<p>\n\t\t\t\t<label for=\"rcp_user_login\">Username or Email<\/label>\n\t\t\t\t<input name=\"rcp_user_login\" id=\"rcp_user_login\" class=\"required\" type=\"text\"\/>\n\t\t\t<\/p>\n\t\t\t<p>\n\t\t\t\t<label for=\"rcp_user_pass\">Password<\/label>\n\t\t\t\t<input name=\"rcp_user_pass\" id=\"rcp_user_pass\" class=\"required\" type=\"password\"\/>\n\t\t\t<\/p>\n\t\t\t\t\t\t<p>\n\t\t\t\t<input type=\"checkbox\" name=\"rcp_user_remember\" id=\"rcp_user_remember\" value=\"1\"\/>\n\t\t\t\t<label for=\"rcp_user_remember\">Remember me<\/label>\n\t\t\t<\/p>\n\t\t\t<p class=\"rcp_lost_password\"><a href=\"\/index.php\/data\/wp\/v2\/posts\/55000468?rcp_action=lostpassword\"><\/a><\/p>\n\t\t\t<p>\n\t\t\t\t<input type=\"hidden\" name=\"rcp_action\" value=\"login\"\/>\n\t\t\t\t\t\t\t\t\t<input type=\"hidden\" name=\"rcp_redirect\" value=\"https:\/\/access-basics.de\/data\/wp\/v2\/posts\/55000468\/\"\/>\n\t\t\t\t\t\t\t\t<input type=\"hidden\" name=\"rcp_login_nonce\" value=\"8d63f6cbe9\"\/>\n\t\t\t\t<input id=\"rcp_login_submit\" class=\"rcp-button\" type=\"submit\" value=\"Login\"\/>\n\t\t\t<\/p>\n\t\t\t\t\t<\/fieldset>\n\n\t\t\n\t<\/form>\n<\/p>\n","protected":false},"excerpt":{"rendered":"<p>F&uuml;r die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden k&ouml;nnen mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff f&uuml;r eine Datenbankanwendung &#8211; mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpl&auml;ne und Tabellen auszugeben. Im dritten Teil der Artikelreihe entwickeln wir einen Algorithmus, der es uns erlaubt, Spielpl&auml;ne f&uuml;r Ligen mit beliebig vielen Mannschaften zu generieren.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662019,66062019,44000014],"tags":[],"class_list":["post-55000468","post","type-post","status-publish","format-standard","hentry","category-662019","category-66062019","category-Loesungen"],"aioseo_notices":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v15.9.2 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Ligaverwaltung, Teil 3: Spielpl&auml;ne generieren - Access [basics]<\/title>\n<meta name=\"description\" content=\"F\u00fcr die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden k\u00f6nnen mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff f\u00fcr eine Datenbankanwendung \u2013 mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpl\u00e4ne und Tabellen auszugeben. Im dritten Teil der Artikelreihe entwickeln wir einen Algorithmus, der es uns erlaubt, Spielpl\u00e4ne f\u00fcr Ligen mit beliebig vielen Mannschaften zu generieren.\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Ligaverwaltung, Teil 3: Spielpl&auml;ne generieren - Access [basics]\" \/>\n<meta property=\"og:description\" content=\"F\u00fcr die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden k\u00f6nnen mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff f\u00fcr eine Datenbankanwendung \u2013 mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpl\u00e4ne und Tabellen auszugeben. Im dritten Teil der Artikelreihe entwickeln wir einen Algorithmus, der es uns erlaubt, Spielpl\u00e4ne f\u00fcr Ligen mit beliebig vielen Mannschaften zu generieren.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\" \/>\n<meta property=\"og:site_name\" content=\"Access [basics]\" \/>\n<meta property=\"article:published_time\" content=\"2020-03-23T18:48:59+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"-0001-11-30T00:00:00+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/..\/tl_files\/images\/pic_468_001.png\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Gesch\u00e4tzte Lesezeit\">\n\t<meta name=\"twitter:data1\" content=\"30\u00a0Minuten\">\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/access-basics.de\/#website\",\"url\":\"https:\/\/access-basics.de\/\",\"name\":\"Access [basics]\",\"description\":\"DAS ACCESS-MAGAZIN F\\u00dcR ALLE, DIE VON 0 AUF 100 WOLLEN\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":\"https:\/\/access-basics.de\/?s={search_term_string}\",\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"de\"},{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html#primaryimage\",\"inLanguage\":\"de\",\"url\":\"..\/tl_files\/images\/pic_468_001.png\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html#webpage\",\"url\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\",\"name\":\"Ligaverwaltung, Teil 3: Spielpl&auml;ne generieren - Access [basics]\",\"isPartOf\":{\"@id\":\"https:\/\/access-basics.de\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html#primaryimage\"},\"datePublished\":\"2020-03-23T18:48:59+00:00\",\"dateModified\":\"-0001-11-30T00:00:00+00:00\",\"author\":{\"@id\":\"https:\/\/access-basics.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f\"},\"description\":\"F\\u00fcr die meisten Sportarten gibt es Wettbewerbe in Ligen. Oder zumindest Turniere, die ja meist auch als kleine Liga angesehen werden k\\u00f6nnen mit Spielpaarungen und Tabellen. Jedenfalls gibt eine Verwaltung solcher Ligen jede Menge Stoff f\\u00fcr eine Datenbankanwendung \\u2013 mit Datenmodell, Abfragen, Formularen zur Eingabe der Daten und Berichten, um Spielpl\\u00e4ne und Tabellen auszugeben. Im dritten Teil der Artikelreihe entwickeln wir einen Algorithmus, der es uns erlaubt, Spielpl\\u00e4ne f\\u00fcr Ligen mit beliebig vielen Mannschaften zu generieren.\",\"breadcrumb\":{\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/\",\"url\":\"https:\/\/access-basics.de\/\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"position\":2,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\",\"url\":\"https:\/\/access-basics.de\/index.php\/Ligaverwaltung_Teil_3_Spielplaene_generieren.html\",\"name\":\"Ligaverwaltung, Teil 3: Spielpl&auml;ne generieren\"}}]},{\"@type\":\"Person\",\"@id\":\"https:\/\/access-basics.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/access-basics.de\/#personlogo\",\"inLanguage\":\"de\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","_links":{"self":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts\/55000468","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/comments?post=55000468"}],"version-history":[{"count":0,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/posts\/55000468\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/media?parent=55000468"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/categories?post=55000468"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-basics.de\/index.php\/data\/wp\/v2\/tags?post=55000468"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}