Newsgroup: it.comp.lang.delphi
Titolo: Creazione Calendari Calcio

Salve NG,
Vorrei un consiglio:
Ho N Squadre di calcio dove (per fortuna) N è sempre pari. Dovrei simulare
la creazione di un calendario di calcio con andata e ritorno... E fin qui
tutto ok, o meglio mi blocco ad un punto.
Supponiamo che N valga 4, avrò 4 squadre che giocheranno 3 giornate
all'andata e 3 giornate al ritorno.
Supponiamo che i nomi delle squadre siano "A" "B" "C" "D", le combinazioni
possibili sono:
(andata)
A vs B
B vs C
C vs D
D vs A
A vs C
B vs D
(ritorno)
C vs A
D vs B
A vs D
B vs A
C vs B
D vs C
E fin qui tutto ok, riesco a generare tutte le combinazioni.
Adesso vorrei un consiglio su come generare un algoritmo che mi raggruppi
queste combinazioni in (N-1)*2 gruppi (cioè 6 gruppi in questo caso) in modo
che ogni gruppo contenga tutte le N squadre senza nessuna ripetizione.
Esempio: NON va bene A vs B e B vs C perchè la B gioca due volte nella
stessa giornata ma VA BENE A vs B e C vs D perchè sono tutte diverse.
Ovviamente l'algoritmo non ha una logica ben precisa e quindi vorrei un
consiglio su come formare le combinazioni in modo che si rispecchi il
funzionamento di un calendario di calcio.
Il problema non finisce qui, molto probabilmente riscriverò per la seconda
fase, ma per ora vi chiedo un aiuto sulla prima fase, altrimenti non potrò
procedere alla seconda.
Ciao e GRAZIE.
--
Karletto
chiamac...@tiscalinet.it
http://www.carletto.cjb.net

Karletto wrote:
[CUT]
Una volta avevo scritto un algoritmo del genere. Io avevo fatto le 
associazioni con in numeri, avevo cio' chiamato le squadre 1, 2, ... N e le 
avevo definite integer. Per controllare che tutte giocassero con tutte 
avevo fatto una tabella dove in testa alle colonne c'erano i numeri delle 
squadre e le righe erano le varie giornate. Facevo poi la somma per righe 
(o per colonne) e il risultato doveva sempre essere pari a (N*(N+1))/2.
Il problema che ho trovato il era che lasciando N generico non sempre 
andava bene lo stesso algoritmo. Se N era una potenza di 2 (2, 4, 8...) 
bastava far giocare ogni squadra col primo numero libero. Negli altri casi 
(6, 10, 12...) ottenevo ripetizioni di domeniche uguali. Alla fine per 
avere un algoritmo unico ho messo una generazione casuale del calendario. 
Per ogni squadra avevo la lista delle partita non ancora giocate e ne 
sceglievo una a caso. Se non riuscivo a completare una giornata ripartivo 
con le estrazioni. Lo provato tante volte e mi ha sempre fornito un 
calendario in tempi brevissimi (e il computer su cui girava era gia' 
vecchio).
-- 
Ciao,
   Stefano


Cioè praticamente provavi a prendere le combinazioni casualmente finchè
trovavi una che andava bene?
E se casualmente non dovesse mai uscire una combinazione buona, rimango lì
giorno e notte?
Il mio problema è capire come una combinazione va bene o meno in quanto non
so quali sono i nomi delle squadre a priori e quindi non posso stabilire se
una squadra è già uscita oppure no... O mi sbaglio?
Sono bene accetti altri eventuali suggerimenti, per ora grazie mille,
proverò a ragionare sul tuo metodo...
Grazie...
Ciao

 posso stabilire se una squadra è già uscita oppure no... O mi sbaglio?
Io creavo N elenchi di N-1 elementi. L'elenco dell'i-esima squadra 
conteneva tutti i numeri da 1 a N tranne i. Ogni volta che associavo la 
una (x) squadra ad un'altra (y) toglievo i numeri dall'elenco, cioe' 
dall'elenco di x toglievo y e dall'elenco di y toglievo x. Se non riuscivo 
a chiudere la giornata azzeravo l'estrazione in corso non ricominciavo da 
capo.
-- 
Ciao,
   Stefano

 --
Vedrò cosa riesco a fare così...
Grazie di tutto.
Ciao

noi per il fantacalcio usiamo
non so se va bene?
ciao da mik
procedure TForm1.Button2Click(Sender: TObject);
var i,j,squadre,giornata,progressivo1,progressivo2, indice1, indice2 :
Integer;
    campionato : array of integer;
    matrice : array of array of integer;
    a : array of string; riga:string;
begin
 Memo1.Clear;
 squadre := E_Squadre.AsInteger;
 SetLength(campionato,squadre+1);
 SetLength(matrice,((squadre*(squadre-1)) div 2)+1,3);
 SetLength(a,((squadre*(squadre-1)) div 2)+1);
 for i := 1 to squadre do campionato[i] := i;
 progressivo1 := 1;
 progressivo2 := 1;
 for giornata := 1 to squadre-1 do
  begin
   if giornata mod 2 <> 0 then
    begin
     indice1 := giornata;
     indice2 := giornata-2;
     while indice1 <= squadre-1 do
      begin
       matrice[progressivo1,1] := campionato[indice1];
       progressivo1 := progressivo1 + 1;
       indice1 := indice1 + 2;
      end;
     indice1 := squadre - 2 ;
     while progressivo1 <= squadre / 2 * giornata do
      begin
       matrice[progressivo1,1] := campionato[indice1];
       progressivo1 := progressivo1 + 1;
       indice1 := indice1 - 2;
      end;
     while indice2 >= 1 do
      begin
       matrice[progressivo2, 2] := campionato[indice2];
       indice2 := indice2 - 2;
       progressivo2 := progressivo2 + 1;
      end;
     indice2 := 2;
     while progressivo2 < squadre / 2 * giornata do
      begin
       matrice[progressivo2, 2] := campionato[indice2];
       indice2 := indice2 + 2;
       progressivo2 := progressivo2 + 1;
      end;
     If progressivo2 = squadre / 2 * giornata Then
      begin
        matrice[progressivo2, 2] := campionato[squadre];
        progressivo2 := progressivo2 + 1;
      end;
     end
    else
     begin
      indice1 := squadre - giornata;
      indice2 := squadre - giornata + 2;
      While indice1 >= 2 do
       begin
        matrice[progressivo1, 1] := campionato[indice1];
        progressivo1 := progressivo1 + 1;
        indice1 := indice1 - 2;
       end;
      indice1 := 1;
      While progressivo1 < squadre / 2 * giornata do
       begin
        matrice[progressivo1, 1] := campionato[indice1];
        indice1 := indice1 + 2;
        progressivo1 := progressivo1 + 1;
       end;
      If progressivo1 = squadre / 2 * giornata Then
       begin
        matrice[progressivo1, 1] := campionato[squadre];
        progressivo1 := progressivo1 + 1;
       End;
      While indice2 <= squadre - 2 do
       begin
        matrice[progressivo2, 2] := campionato[indice2];
        progressivo2 := progressivo2 + 1;
        indice2 := indice2 + 2;
        end;
      indice2 := squadre - 1;
      While progressivo2 < squadre / 2 * giornata do
       begin
        matrice[progressivo2, 2] := campionato[indice2];
        indice2 := indice2 - 2;
        progressivo2 := progressivo2 + 1;
       end;
      If progressivo2 = squadre / 2 * giornata Then
       begin
        matrice[progressivo2, 2] := campionato[giornata - 1];
        progressivo2 := progressivo2 + 1;
       End;
      End;
     For i:= 1 To squadre div 2 do
      begin
        a[giornata*(squadre div 2)-(squadre div 2)+i] :=
formatfloat('00',matrice[(giornata - 1) * squadre div 2 + i, 1])+'-'
        + formatfloat('00',matrice[(giornata - 1) * squadre div 2 + i, 2]);
      end;
     end;
     For i:= 1 To (squadre div 2) do
      begin
       riga := '';
       for j := 0 to (squadre-2) do
        riga := riga + a[i+j*(squadre div 2)]+'  ';
       memo1.Lines.Add(riga);
      end;
  end;

 ciao da mik
Č proprio ciň che cercavo...
O meglio: mi serviva una cosa che ordinasse le giornate per colonne...
Appena ho 10 minuti mi studio l'algoritmo e lo integro alla mia
applicazione.
Poi ti faccio sapere.
Grazie 1000 per ora.
Ciao