Newsgroup: it.scienza.informatica
Titolo: Algoritmo creazione calendario-campionato

Salve a tutti,
sto disperatamente cercando una fonte che mi possa spiegare come funzioni
l'algoritmo che crea calendari-campionato (o come dir si voglia) tra un
numero N di squadre.
Voglio realizzare una specie di fantacalcio online visto che quelli presenti
sono a pagamento.
Il difficile è creare un calendario per cui:
-tutte le squadre incontrino tutte le altre (come è naturale)
-ogni squadra alternativamente deve giocare in casa e poi fuori o viceversa
(con una eccezione di un massimo di 2 volte consecutive "casa-casa",
"fuori-fuori")
Credo sia tutto.
Ringrazio anticipatamente chi darà una mano.

Io ho il tuo stesso problema, sei riuscito a trovare qualche informazione ??
ciao,
Ivan

--------------------------------
Inviato via 
http://usenet.libero.it

Ho studiato un po' il problema, cercando di ricostruire l'algoritmo da
zero.
Per ora ho notato che se il numero di squadre è una potenza di due il
problema si risolve abbastanza facilmente.
Per gli altri casi ancora nn ci sono arrivato, e per ora devo
accantonare il problema causa esami, cmq suppongo che il calendario
non sia speculare, cioè non è possibile dividerlo esattamente in
girone d'andata e girone di ritorno.
Piuttosto ci saranno delle giornate (una o due) in cui si accavallano
partire di andata  e di ritorno.
Siete pregati di smentire o confermare, considerando che nn seguo il
calcio.
Cmq tu a che conclusioni sei arrivato?

 partire di andata  e di ritorno.
Perchè??? Io, seguendo il calcio, non ho mai visto accadere una cosa del
genere. Non avevo nemmeno mai visto una squadra neo-promossa in C1 essere
ripescata in B, ma questo è un altro discorso... :)
Ste

 problema si risolve abbastanza facilmente.
Già. L'algoritmo qua sotto funziona, ma mi sono appena accorto che va
solo quando le squadre sono potenze di due...
In pratica: per ogni squadra conto con chi ha giocato e quante volte ha
giocato. Scelgo ogni volta, tre le squadre contro cui non ho giocato,
una di quelle che ha il minor numero di partite giocate. Tengo anche un
vettore per indicare quali squadre giocano questa giornata.
Esempio a 4 squadre:
giornata = [ false, false, false, false ]
giocate = [ 0, 0, 0, 0 ]
giocatocon = [ 
        [ 1, 0, 0, 0 ], 
        [ 0, 1, 0, 0 ], 
        [ 0, 0, 1, 0 ], 
        [ 0, 0, 0, 1 ] ]
La 1 deve giocare: scelgo la due (non ci ho ancora giocato, ed ha il
numero minimo di partite giocate. Aggiorno:
giornata = [ true, true, false, false ]
giocate = [ 1, 1, 0, 0 ]
giocatocon = [ 
        [ 1, 1, 0, 0 ], 
        [ 1, 1, 0, 0 ], 
        [ 0, 0, 1, 0 ], 
        [ 0, 0, 0, 1 ] ]
Prossimo passo: la due sta già giocando per questa giornata, quindi
passo alla tre. Tra le squadre con cui non ha ancora giocato, quella
col minore numero di partite giocate è la 4, quindi la prossima partita
è 3 - 4
giornata = [ true, true, true, true ]
giocate = [ 1, 1, 1, 1 ]
giocatocon = [ 
        [ 1, 1, 0, 0 ], 
        [ 1, 1, 0, 0 ], 
        [ 0, 0, 1, 1 ], 
        [ 0, 0, 1, 1 ] ]
Tutta la giornata si è conclusa, quindi passo alla prossima e riazzero
il vettore giornata:
giornata = [ false, false, false, false ]
giocate = [ 1, 1, 1, 1 ]
giocatocon = [ 
        [ 1, 1, 0, 0 ], 
        [ 1, 1, 0, 0 ], 
        [ 0, 0, 1, 1 ], 
        [ 0, 0, 1, 1 ] ]
Scelgo la 1: con la due ha già giocato, e quindi guardo la 3.
giornata = [ true, false, true, false ]
giocate = [ 2, 1, 2, 1 ]
giocatocon = [ 
        [ 1, 1, 1, 0 ], 
        [ 1, 1, 0, 0 ], 
        [ 1, 0, 1, 1 ], 
        [ 0, 0, 1, 1 ] ]
E così via la prossima partita sarà 2 - 4, poi 1 - 4 e 2 - 3 la giornata
dopo.
-- 
Andrea Bergia - studente              Linux Registered User #281550

L'algoritmo che proponi è diverso da quello che ho pensato io.
Forse facendo un merging si arriva a qualcosa.
Purtroppo ho gli esami in tempi stretti e per ora nn psosso seguire
questa interessante questione.  :-(