matze4all - So 04.12.05 17:40
Titel: Problem mit Turnier-Algorithmus
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:
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:
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:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
| type
spiel = record
first:integer;
second:integer;
resultfirst:byte;
resultsecond:byte;
end;
var
Form1: TForm1;
spieler: integer;
spiele: array[0..100] of spiel;
spielegesamt:integer; |
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 )
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 - Do 08.12.05 19:26
schade das bis her keiner geantwortet hat :/
hier meine Ergebnisse:
Folgendes ist im Deklarations-Teil definiert ( Auszug ):
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... )
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:
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;
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:
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;
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 :D
mfg,
Matze