Newsgroup: it.comp.lang.pascal
Titolo: cerco un algoritmo per creare un calendario di calcio

Che crei un calendario date n squadre (andata e ritorno)...
Grazie per l'aiuto..
aki...@hotmail.com

Che crei un calendario date n squadre (andata e ritorno)...
Anzitutto, supponiamo che N sia pari -- se dispari, aggiungi
una squadra chiamata "riposo" (chi in un turno la "incontra",
sta in realta` saltando il turno stesso).  Ciascun girone dura,
chiaramente, N-1 giornate.
Dato un girone di andata, quello di ritorno e` facile: alla
X-esima giornata, per X fra N e 2N-2, ci sono gli stessi
incontri che ci sono stati alla X-(N+1)-esima giornata, ma
con scambio in ogni partita dei ruoli di squadra di casa e
squadra ospite.  Interessa dunque solo determinare il
girone di andata, cioe` le prime N-1 giornate.
Un possibile schema, al netto del problema di chi sia
di casa e chi ospite in ciascuna partita, e` (in C++, il
linguaggio del primo dei tre gruppi su cui hai postato):
spero che sia auto-esplicativo, i "gradi di liberta`"
restando la determinazione della situazione iniziale
(indifferente vista la possibilita` di rinumerare le
squadre) e dell'algoritmo di passaggio da ciascuna
giornata alla successiva:
template<int nPartite> class girone
{   const int nSquadre = nPartite*2;
    int unasquadra[nPartite];
    int quellaltra[nPartite];
    int numero_giornata;
public:
    girone();
    int quale_giornata() const {
        return numero_giornata;
    }
    int max_giornate() const {
        return nSquadre-1;
    }
    void prossima_giornata();
    void quale_partita(
        int numero_partita,
        int& una_squadra,
        int& quell_altra) const
    {    una_squadra=unasquadra[numero_partita-1];
         quell_altra=quellaltra[numero_partita-1];
    }
};
La situazione iniziale e` codificata dal costruttore,
e come dicevamo e` indifferente visto che si
possono sempre rinumerare le squadre, ad es:
template<int nPartite>
girone<nPartite>::girone():
    numero_giornata(1)
{
    for(int i=0; i<nPartite; ++i) {
        unasquadra[i] = i+1;
        quellaltra[i]=i+1+nPartite;
    }
}
L'unico punto interessante dell'algoritmo e`
dunque il metodo prossima_giornata, che da
solo ne determina interamente le caratteristiche.
Ecco un possibile schema, basato su di una
"rotazione a catena" di tutte le squadre meno
una che resta in posizione-ancora:
template<int nPartite>
void girone<nPartite>::prossima_giornata()
{
    int temp = unasquadra[1];
    for(int i=1; i<nPartite-1; ++i)
        unasquadra[i]=unasquadra[i+1];
    unasquadra[nPartite-1]=
        quellaltra[nPartite-1];
    for(int j=nPartite-1; j>0; --j)
        quellaltra[j]=quellaltra[j-1]l
    quellaltra[0]=temp;
    ++numero_giornata;
}
Ecco un esempio d'uso, dato per scontato
l'include di <iostream> e using std::cout:
template<int nPartite>
void torneo()
{
    cout<<"Torneo a "<<2*nPartite<<" squadre:\n";
    girone<nPartite> giro;
    for(;;) {
        int giorno = giro.quale_giornata();
        if(giorno>giro.max_giornate()) break;
        cout<<"Giornata numero "<<giorno<<"\n";
        for(int i=1; i<=nPartite; ++i) {
            int una,laltra;
            giro.quale_partita(i,una,laltra);
            cout<<"Squadra "<<una<<" contro "<<
                laltra<<"\n";
        }
        giro.prossima_giornata();
    }
}
Un problema interessante (ma di matematica
discreta, non di alcuno dei linguaggi cui sono
relativi i gruppi su cui questo e` postato) e` la
determinazione di quali gironi "intrinsecamente
diversi" (non trivialmente riportabili l'uno
all'altro per rinumerazione di squadre e partite)
possano esistere per ogni numero N pari di
squadre.
Alex