Problem mit Turnier-Algorithmus

matze4all · Hält's aus hier Beiträge: 6

Hallo,

ein paar Kumpels von mir und ich haben uns einen Kickertisch zusammen gekauft, um 1on1 Turniere auszutragen.

Es gilt also jeder gegen jeden und wenn möglich dieselbe Person nicht zweimal hintereinander.

Die Anzahl der Person ist dabei unbekannt, kann also gerade oder ungerade sein.

Wieviel Spiele gespielt werden müssen bekommt man mit folgender Bildungsvorschrift raus ( hoffe ich zumindest... ist mir nebenbei eingefallen ) :
spiele := (spieler*spieler-spieler)/2

Nun zum Problem...

Ich hab ein bisschen im Board hier schon gelesen und bin zu folgenden Schluß gekommen:

Bei gerader Anzahl von Spielern:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

1. Runde
 1 2 3
 - - -
 6 5 4
2. Runde
 1 6 2
 - - -
 5 4 3
3. Runde
 1 5 6
 - - - 
 4 3 2 
usw.

der erste Spieler bleibt fest und der Rest dreht im Urzeigersinn

Bei ungerader Anzahl von Spielern:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

1. Runde
 1 2 
 - - 3
 5 4
2. Runde
 5 1 
 - - 2
 4 3 
3. Runde
 4 5 
 - - 1 
 3 2
usw.

alle Spieler drehen sich im URzeigersinn....

soweit so gut, jetzt kommt ja der schwierigste Teil es in Code umzuwandeln :/

erstmal der Anfang:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

type
  spiel = record
   first:integer; { Spieler 1 }
   second:integer;{ Spieler 2 }
   resultfirst:byte; { Ergebnis von Spieler 1 }
   resultsecond:byte;{ Ergebnis von Spieler 2 }
  end;
var
  Form1: TForm1;
  spieler: integer; { Spieleranzahl }
  spiele: array[0..100] of spiel; { spiele besteht aus allen einzelnen Spielen }
  spielegesamt:integer; { Anzahl der Spiele }

sooo... jetzt zum Problem... ich weiß nicht, wie man es am einfachsten in Code umwandelt :/
ich hab folgendes Ergebnis, dass allerdings nicht klappt, weil da irgendwie ein Denkfehler drin ist...
( Turnierplan für eine gerade Anzahl von Spielern )

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

procedure TForm1.gerade(spieler:integer);
var i,count,k,l:integer; weiter:boolean;
begin
count := 0;
 for i:=spieler downto 2 do
 begin
  weiter := true;
  k:=1; l:=i;
  repeat
   if k = 1 then
    begin
    spiele[count].first := 1;
    spiele[count].second := l;
    if (l+1) > spieler then k:=spieler else k:= i+1;
    end
   else
    begin
    if (i+1-k)< 2 then l:= spieler;
    spiele[count].first := k;
    spiele[count].second := l;
    if (k+1) > spieler then k:=spieler else k:= k+1;
    end;
   dec(l);
   if l < 2 then l:=spieler;

   if (spiele[count].second = k) then
    weiter:= false;

   count := count+1;
  until not weiter;
 end;
end;

Kann mir jemand helfen, ich bin total am verzweifeln :cry:

oder hat vielleicht jemand eine bessere Idee, wie man das umsetzten kann?

Mfg,
Matze

matze4all · Hält's aus hier Beiträge: 6

schade das bis her keiner geantwortet hat :/

hier meine Ergebnisse:

Folgendes ist im Deklarations-Teil definiert ( Auszug ):

markieren

Delphi-Quelltext

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

var
  spieler: integer;
  spiele: array[1..189] of spiel;
  spielegesamt:integer;
  zahlen: array[0..20] of integer;
  spielernamen: array[1..20] of string[15];

Damit der Algorithmus klappt, wird überprüft, ob die Spieleranzahl gerade oder ungerade ist:
( Spieler wird bei ButtonClick definiert... )

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

...
 if spieler < 2 then
  showmessage('Es müssen mindestens 2 Spieler am Turnier teilnehmen!')
 else
 begin
   spielegesamt:= round((spieler*spieler-spieler)/2);
   if spieler mod 2 = 0 then
   begin
    for i:=1 to spieler do
     zahlen[i] := i;
    gerade;
   end
   else
    begin
     for i:=1 to spieler do
     zahlen[i] := i;
     ungerade;
    end;
...

Der Algorithmus für eine gerade Anzahl von Spielern:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

procedure TForm1.gerade;
var i,count,gamesperround:integer; weiter:boolean;
begin
count := 0;
weiter:=true;
gamesperround := round(spieler/2);

 repeat
  for i:= 1 to gamesperround do
  begin
  spiele[count].first := zahlen[i];
  spiele[count].second := zahlen[spieler-i+1];
  count := count+1;
  end;
  gerade_drehen;
  if count > (spielegesamt-1) then weiter:=false;
 until not weiter;
end;

{ Prozedur um die Reihenfolge einmal zu drehen, wobei Platz 1 immer gleich bleibt }
procedure TForm1.gerade_drehen;
var i,b,letzter:integer;
begin
zahlen[1]:=1;
letzter := zahlen[spieler];
 for i:=spieler downto 2 do
 begin
  if (i-1) = 0 then b:=letzter else b := zahlen[i-1];
  if zahlen[i-1] = 1 then b:=letzter;
  zahlen[i]:= b;
 end;
end;

und jetzt noch einmal fast dasselbe für ungerade Zahlen:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

procedure TForm1.ungerade;
var i,count,gamesperround:integer; weiter:boolean;
begin
count := 0;
weiter:=true;
gamesperround := round((spieler-1)/2);

 repeat
  for i:= 1 to gamesperround do
  begin
  spiele[count].first := zahlen[i];
  spiele[count].second := zahlen[spieler-i+1];
  count := count+1;
  end;
  ungerade_drehen;
  if count > (spielegesamt-1) then weiter:=false;
 until not weiter;
end;

{ Prozedur um die Reihenfolge einmal zu drehen }
procedure TForm1.ungerade_drehen;
var i,b,letzter:integer;
begin
letzter := zahlen[spieler];
 for i:=spieler downto 1 do
 begin
  if (i-1) = 0 then b:=letzter else b := zahlen[i-1];
  zahlen[i]:= b;
 end;
end;

Falls einen von euch noch eine schnellere/bessere Möglichkeit hat, dann bitte posten

mfg,
Matze

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme