Appendice 1
1.1 Il programma “matrice-simultaneità.cpp”
Il programma prende come input il file voli.txt e inizialmente va ad individuare con un puntatore i 2 elementi di ogni riga i-esima della tabella identificando per ogni volo qual è lo slot time in cui si inizia ad occupare almeno un operatore (con la variabile sta), e sapendo dal tipo di volo quanto è lungo ogni turnaround (con la variabile trn), possiamo ricavare quanto almeno un operatore sarà occupato (sta+trn). Acquisiti i dati, per ogni riga i-esima, va a confrontare ogni i-esimo intervallo [sta,sta+trn] con tutti gli (i-g)-esimi intervalli precedenti. Nel caso in cui l’intersezione tra i due intervalli non è vuota (cioè si sovrappongono e coincidono almeno per uno slot time) l’elemento della matrice che relaziona i due voli vale 1, altrimenti 0.
Il file di output che si ottiene si chiama “simultaneità.txt”.
#include<iostream.h> #include<stdio.h> main() { int i,j,g; int sta,trn; int imp[46][2]; int sim[46][46]; FILE *in; FILE *outsim; in=fopen("volirighe.txt","r"); for (i=0;i<46;i++) {
fscanf(in,"%d %d",&sta,&trn);//legge le colonne di voli.txt /*la tabella imp indica:
*nella prima colonna il tempo di inizio d'impegno degli operatori *nella seconda colonna il tempo di fine d'impegno degli operatori */
if (trn==20) //il volo ha sostato nella notte in aeroporto {imp[i][0]=sta-4; //(alfa)
imp[i][1]=sta+2; //(beta) }
else if (trn==15) //il volo sosterà nella notte in aeroporto {imp[i][0]=sta-1; //(alfa)
imp[i][1]=sta+3; //(beta) }
else {imp[i][0]=sta-1;//inizio impegno operatori per turnaroud (alfa)
imp[i][1]=sta+(trn/5)+2;//fine impegno operatori per turnaround (beta) }
}
/*si riempie la matrice sim:
*confronta le partenze e gli arrivi di due voli 1 e 2: *(alfa i-1 <= beta i) and (beta i-1 > alfa i)
*/
for (i=0;i<46;i++)
{for (g=1;g<i+1;g++)
{if (imp[i][0]>=imp[i-g][0] && imp[i][0]<imp[i-g][1])
{sim[i][i-g]=1; sim[i-g][i]=1; } else {sim[i][i-g]=0; sim[i-g][i]=0; } }
sim[i][i]=1;//ogni volo è simultaneo a se stesso } outsim=fopen("simultaneità.txt","w"); for (i=0;i<46;i++) {for (j=0;j<46;j++) fprintf(outsim,"%d ",sim[i][j]); fprintf(outsim,"\n"); } return 0; }
1.2 Il programma “accoglienza-stand.cpp”
Il programma prende come input il file “voli.txt”, va ad individuare con il puntatore i 2 elementi di ogni riga della tabella (che rappresenta ogni volo) identificando le due varabili sta e trn. In funzione del valore identificato da trn, si classifica il tipo di volo. A questo punto si crea una matrice, chiamata accoglienza-stand, che ha come righe tutti i voli della giornata e 14 colonne che identificano nell’ordine i seguenti stand: 1, 2, 3, 4, 5, 6, 7, 8, 21, 22, 44, 45, 46, 47.
Ogni elemento accvs vale 1 se il volo v può sostare nello stand s, 0 altrimenti, con il
seguente criterio:
tutti gli elementi accvs sono uguali a 1, eccetto i seguenti casi:
accv8=1 solo per v∈ (lo stand 8 è in grado di accettare solo aeromobili di
piccole dimensioni tipo );
accv21=1 e av22=1solo per v∈ ∪ (gli stand 21 e 22 possono accettare solo
voli di tipo e ). #include<iostream.h> #include<stdio.h> main() { int i,j;
int sta,trn; int acc[46][14]; FILE *in; FILE *outacc; in=fopen("volirighe.txt","r"); for (i=0;i<46;i++) {
fscanf(in,"%d %d",&sta,&trn); //legge le colonne di voli.txt /*
*Costruisco la matrice d'accoglienza degli stand: *ogni riga i identifica un volo,
*per ognuno indica su quali stand può essere parcheggiato */
if ((trn==20)||(trn==15)||(trn==257)||(trn==45))//il volo ha sostato {for (j=0;j<14;j++) //o sosterà nella notte,
acc[i][j]=1; //o è un 737ryan,o 737br
acc[i][7]=0; acc[i][8]=0; acc[i][9]=0; }
else if (trn==25) //il volo è ATR {for (j=0;j<14;j++)
acc[i][j]=1; }
else //il volo è CRJ
{for (j=0;j<14;j++) acc[i][j]=1; acc[i][8]=0; acc[i][9]=0; } } outacc=fopen("accoglienza-stand.txt","w"); for (i=0;i<46;i++) {for (j=0;j<14;j++) fprintf(outacc,"%d ",acc[i][j]); fprintf(outacc,"\n"); } return 0; }
1.3 Il programma “matrici-num-operai.cpp”
Il programma prende come input il file voli.txt e, tramite un puntatore, individua le 2 variabili intere sta e trn di ogni i-esima riga della tabella, identificando quindi il tipo di volo e l’orario di inizio delle attività per lo stesso volo. A questo punto genera la matrice “insieme Tv” scrivendo dalla prima colonna tutti gli slot time in cui l’aeromobile sosta (+ 1 prima dell’arrivo e 2 dopo la partenza), e poi finendo di
riempire la riga con tutti 0. Tale matrice ha 18(16) colonne e ogni riga indica l’insieme Tv di ogni volo.
Dopo aver creato la matrice Tv, il programma genera nell’ordine le seguenti matrici:
- La matrice “domanda-comuni”:
tale matrice ha dimensione (numero voli x 222), ed ogni elemento è composto da 1 in tutti quegli slot time di ogni volo in cui serve un operatore comune, 2 in tutti quegli slot time di ogni volo in cui servono due operatori comuni (per i voli di tipo British Airways), 0 per i rimanenti slot time della giornata in cui per ogni volo non sono necessari operatori.
- La matrice “domanda-specializzati”:
tale matrice ha dimensione (numero voli x 222), ed ogni elemento è composto da 1 in tutti quegli slot time iniziali e finali del turnaround di ogni volo in cui serve un operatore specializzato, 0 per i rimanenti slot time della giornata in cui non è necessaria la presenza di operatori specializzati sotto il volo.
- La matrice “operai-bus-sbarco”:
tale matrice ha dimensione (numero voli x 222), ed ogni elemento è composto da 1 in tutti quegli slot time del turnaround di ogni volo in cui serve un operatore specializzato per la guida del bus per far sbarcare i passeggeri, 0 per i rimanenti slot time in cui non è necessaria la presenza sotto il volo.
- La matrice “operai-bus-imbarco”:
tale matrice ha dimensione (numero voli x 222), ed ogni elemento è composto da 1 in tutti quegli slot time del turnaround di ogni volo in cui serve un operatore specializzato per la guida del bus per far imbarcare i passeggeri, 0 per i rimanenti slot time in cui non è necessaria la presenza sotto il volo.
#include<iostream.h> #include<stdio.h> main() { int i,j,a; int sta,trn; int Tv[46][18]; int DC[46][222]; int DS[46][222];
(16) Con le ipotesi precedentemente fatte sarebbe bastata una matrice di (numero voli x 10) poiché al massimo si può avere un turnaround di 10 time slot per il tipo di voli più lungo (il 737 di British airways). Si è preferito impostare la matrice con più colonne per far fronte al caso in cui, in futuro, le ipotesi venissero cambiate e si considerassero dei voli che hanno una sosta più lunga.
int BA[46][222]; int BP[46][222]; FILE *in;
FILE *outtv, *outdc, *outds, *outbs, *outbi; in=fopen("volirighe-diffATR737.txt","r"); for (i=0;i<46;i++)
{
fscanf(in,"%d %d",&sta,&trn); //legge le colonne di voli.txt /*
*Costruisco la matrice Tv:ogni riga i identifica un volo,
*per ognuno indica tutti i time slot in cui si richiede almeno un operatore */
if (trn==20) //il volo ha sostato nella notte in aeroporto: deve partire {for (j=0;j<6;j++)
Tv[i][j]=sta-3+j; for (j=6;j<18;j++)
Tv[i][j]=0; }
else if (trn==15) //il volo sosterà nella notte in aeroporto {for (j=0;j<4;j++)
Tv[i][j]=sta-1+j; for (j=4;j<18;j++)
Tv[i][j]=0; }
else if ((trn==25)||(trn==257)) //il volo ha turnaround 25 min: è ATR o 737 {for (j=0;j<8;j++)
Tv[i][j]=sta-1+j; for (j=8;j<18;j++)
Tv[i][j]=0; }
else if (trn==35) //il volo ha turnaround 35 min: è CRJ {for (j=0;j<10;j++)
Tv[i][j]=sta-1+j; for (j=10;j<18;j++)
Tv[i][j]=0; }
else //il volo ha turnaround 45 min:è 737br
{for (j=0;j<12;j++) Tv[i][j]=sta-1+j; for (j=12;j<18;j++) Tv[i][j]=0; } } outtv=fopen("insiemeTv.txt","w"); for (i=0;i<46;i++) {for (j=0;j<18;j++) fprintf(outtv,"%d ",Tv[i][j]); fprintf(outtv,"\n"); } /*
*Costruisco la matrice DC:ogni riga i identifica un volo; *per ognuna si indica:
*DC=0,1,2 se in un time slot sono richiesti 0,1,o 2 *operatori almeno comuni,
*/
for (i=0; i<46; i++)
{if (Tv[i][4]!=0&&Tv[i][6]==0) //ha sostato nella notte: deve partire {for (j=0; j<222; j++) DC[i][j]=0; a=Tv[i][0]; DC[i][a-1]=1; DC[i][a]=1; DC[i][a+2]=1; }
else if (Tv[i][4]==0)//il volo sosterà nella notte in aeroporto {for (j=0; j<222; j++) DC[i][j]=0; a=Tv[i][0]; DC[i][a-1]=1; DC[i][a]=1; DC[i][a+2]=1; }
else if (Tv[i][6]!=0&&Tv[i][8]==0)//la riga identifica un ATR o 737 {for (j=0; j<222; j++) DC[i][j]=0; a=Tv[i][0]; DC[i][a-1]=1; DC[i][a]=1; DC[i][a+4]=1; }
else if (Tv[i][8]!=0&&Tv[i][10]==0)//operatori impegnati per 10 ts:è CRJ {for (j=0; j<222; j++) DC[i][j]=0; a=Tv[i][0]; DC[i][a-1]=1; DC[i][a]=1; DC[i][a+6]=1; } else
{for (j=0; j<222; j++) //altrimenti è un 737 british DC[i][j]=0; a=Tv[i][0]; DC[i][a-1]=2; DC[i][a]=2; DC[i][a+8]=2; } } outdc=fopen("domanda-comuni.txt","w"); for (i=0;i<46;i++) {for (j=0;j<222;j++) fprintf(outdc,"%d ",DC[i][j]); fprintf(outdc,"\n"); } /*
*Costruisco la matrice DS:ogni riga i identifica un volo; *per ognuna si indica:
*DS=0,1 se in un time slot sono richiesti 0 o 1 operatore specializzato *e su quali time slot.
*/
{if (Tv[i][4]!=0&&Tv[i][6]==0) //ha sostato nella notte: deve partire {for (j=0; j<222; j++) DS[i][j]=0; a=Tv[i][0]; DS[i][a-1]=1; DS[i][a+2]=1; DS[i][a+3]=1; DS[i][a+4]=1; }
else if (Tv[i][4]==0)//il volo sosterà nella notte in aeroporto {for (j=0; j<222; j++) DS[i][j]=0; a=Tv[i][0]; DS[i][a-1]=1; DS[i][a]=1; DS[i][a+2]=1; }
else if (Tv[i][6]!=0&&Tv[i][8]==0)//la riga identifica un ATR o 737 {for (j=0; j<222; j++) DS[i][j]=0; a=Tv[i][0]; DS[i][a-1]=1; DS[i][a]=1; DS[i][a+4]=1; DS[i][a+5]=1; DS[i][a+6]=1; }
else if (Tv[i][8]!=0&&Tv[i][10]==0)//operatori impegnati per 10 ts:è CRJ {for (j=0; j<222; j++) DS[i][j]=0; a=Tv[i][0]; DS[i][a-1]=1; DS[i][a]=1; DS[i][a+6]=1; DS[i][a+7]=1; DS[i][a+8]=1; } else
{for (j=0; j<222; j++) //altrimenti è un 737 british DS[i][j]=0; a=Tv[i][0]; DS[i][a-1]=1; DS[i][a]=1; DS[i][a+8]=1; DS[i][a+9]=1; DS[i][a+10]=1; } } outds=fopen("domanda-specializzati.txt","w"); for (i=0;i<46;i++) {for (j=0;j<222;j++) fprintf(outds,"%d ",DS[i][j]); fprintf(outds,"\n"); } /*
*per ognuna si indica:
*BA=0,1 se in un time slot sono richiesti 0,o 1
*operatore specializzato per l'uso del bus per lo sbarco passeggeri, *e su quali time slot.
*/
for (i=0; i<46; i++)
{if (Tv[i][4]!=0&&Tv[i][6]==0)//ha sostato nella notte: non devo sbarcare {for (j=0; j<222; j++) BA[i][j]=0; } else {for (j=0; j<222; j++) BA[i][j]=0; a=Tv[i][0]; BA[i][a]=1; BA[i][a+1]=1; } } outbs=fopen("operai-bus-sbarco.txt","w"); for (i=0;i<46;i++) {for (j=0;j<222;j++) fprintf(outbs,"%d ",BA[i][j]); fprintf(outbs,"\n"); } /* *Costruisco la matrice BP: *ogni riga i identifica un volo;
*per ognuna si indica BP=0,1 se in un time slot sono richiesti 0,o 1 *operatore specializzato per l'uso del bus per l'imbarco passeggeri, *e su quali time slot.
*/
for (i=0; i<46; i++)
{if (Tv[i][4]!=0&&Tv[i][6]==0) //ha sostato nella notte:deve partire {for (j=0; j<222; j++) BP[i][j]=0; a=Tv[i][0]; BP[i][a]=1; BP[i][a+1]=1; BP[i][a+2]=1; }
else if (Tv[i][4]==0)//il volo sosterà nella notte in aeroporto:non devo imbarcare {for (j=0; j<222; j++)
BP[i][j]=0; }
else if (Tv[i][6]!=0&&Tv[i][8]==0)//la riga identifica un ATR o 737 {for (j=0; j<222; j++) BP[i][j]=0; a=Tv[i][0]; BP[i][a+2]=1; BP[i][a+3]=1; BP[i][a+4]=1; }
else if (Tv[i][8]!=0&&Tv[i][10]==0)//operatori impegnati per 10 ts:è CRJ {for (j=0; j<222; j++)
BP[i][j]=0; a=Tv[i][0]; BP[i][a+4]=1;
BP[i][a+5]=1; BP[i][a+6]=1; }
else
{for (j=0; j<222; j++) //altrimenti è un 737 british BP[i][j]=0; a=Tv[i][0]; BP[i][a+5]=1; BP[i][a+6]=1; BP[i][a+7]=1; BP[i][a+8]=1; } } outbi=fopen("operai-bus-imbarco.txt","w"); for (i=0;i<46;i++) {for (j=0;j<222;j++) fprintf(outbi,"%d ",BP[i][j]); fprintf(outbi,"\n"); } return 0; }
1.4 Il programma “insieme-teta.cpp”
Il programma, chiamato “insieme-teta.cpp”, prende come input il file voli.txt e tramite un puntatore individua le 2 variabili intere sta e trn di ogni i-esima riga della tabella, identificando quindi il tipo di volo e l’orario di inizio delle attività per lo stesso volo. A questo punto scrive dalla prima colonna tutti gli slot time (1, 3, o 5 a seconda del tipo di volo) a partire dal time slot (sta+2), che rappresentano per ogni volo le fasce temporali in cui l’operatore specializzato può fare le operazioni e i controlli.
In output si ottiene una matrice chiamata “insieme-teta” di tante righe quante sono i voli e di 18(17) colonne.
Successivamente il programma crea la matrice “time slot per controlli” dove per ogni volo indica il numero di slot time (1 o 2 a secondadel tipo di volo) in cui devono essere effettualti dei controlli dall’operatore specializzato. La matrice ha quindi un numero di righe pari al numero di voli della giornata e una colonna.
Infine il programma genera la matrice chiamata “matrice-CNTR” di tante righe quanti sono i voli della giornata e 222 colonne che rappresentano ognuna un time
(17) Con le ipotesi precedentemente fatte sarebbe bastata una matrice di (numero voli x 5) poiché al massimo si può fare controlli su 5 time slot per il tipo di voli più lungo (il 737 di British airways). Si è preferito impostare la matrice con più colonne per far fronte al caso in cui, in futuro, le ipotesi venissero cambiate e si considerassero dei voli che hanno una sosta più lunga.
slot della giornata e indica tutti i time slot in cui l’operatore specializzato può effettuare i controlli. #include<iostream.h> #include<stdio.h> main() { int i,,j,a; int sta,trn; int cnt[46][18]; int tscnt[46][1]; int CNTR[46][222]; FILE *in;
FILE *outcnt, *outtscnt, *outCNTR; in=fopen("volirighe-diffATR737.txt","r"); for (i=0;i<46;i++)
{
fscanf(in,"%d %d",&sta,&trn); //legge le colonne di voli.txt /*
*Costruisco la matrice teta:ogni riga i identifica un volo, *per ognuno indica tutti i time slot in cui si richiede *almeno un operatore specializzato per controlli */
if (trn==20) //il volo ha sostato nella notte in aeroporto:deve partire {for (j=0;j<18;j++)
cnt[i][j]=0; cnt[i][0]=sta-1; }
else if (trn==15) //il volo sosterà nella notte in aeroporto {for (j=0;j<18;j++)
cnt[i][j]=0; cnt[i][0]=sta+1; }
else if ((trn==25)||(trn==257)) //il volo ha turnaround 25 min:è ATR o 737 {for (j=0;j<18;j++)
cnt[i][j]=0; cnt[i][0]=sta+2; }
else if (trn==35) //il volo ha turnaround 35 min:è CRJ {for (j=0;j<3;j++)
cnt[i][j]=sta+j+2; for (j=3;j<18;j++)
cnt[i][j]=0; }
else //il volo ha turnaround 45 min:è 737br
{for (j=0;j<5;j++) cnt[i][j]=sta+j+2; for (j=5;j<18;j++) cnt[i][j]=0; } } outcnt=fopen("insieme-teta.txt","w"); for (i=0;i<46;i++) {for (j=0;j<18;j++) fprintf(outcnt,"%d ",cnt[i][j]);
fprintf(outcnt,"\n"); }
/*
*Costruisco la matrice tscnt:ogni riga i identifica un volo, *per ognuno indica in quanti time slot è necessario *un operatore specializzato per controlli
*/
for (i=0; i<46; i++)
{if (cnt[i][2]==0) //il volo ha sostato o sosterà nella notte, {tscnt[i][0]=1;//o è un ATR, o è un 737
}
else if (cnt[i][2]!=0&&cnt[i][3]==0)//il volo è CRJ {tscnt[i][0]=1;
}
else {tscnt[i][0]=2;//è un volo 737british } } outtscnt=fopen("timeslot-per-controlli.txt","w"); for (i=0;i<46;i++) {for (j=0;j<1;j++) fprintf(outtscnt,"%d ",tscnt[i][j]); fprintf(outtscnt,"\n"); } /*
*Costruisco la matrice CNTR:ogni riga i identifica un volo, *per ognuno indica su quale intervallo di time slot è necessario
*al minimo che un operatore specializzato sia presente in un time slot *per effettuare dei controlli
*/
for (i=0; i<46; i++)
{if (cnt[i][1]==0) //l'insieme dei time slot in cui si può fare il controllo
{for (j=0;j<222;j++) //è un solo time slot
CNTR[i][j]=0; a=cnt[i][0];
CNTR[i][a-1]=1; }
else if ((cnt[i][1]!=0)&&(cnt[i][3]==0)) //l'insieme dei time slot in cui si può
{for (j=0; j<222; j++) //fare il controllo è di 3
time slot CNTR[i][j]=0; a=cnt[i][0]; CNTR[i][a-1]=1; CNTR[i][a]=1; CNTR[i][a+1]=1; }
else //l'insieme dei time slot in cui si può fare il controllo è di 5 time slot {for (j=0; j<222; j++) CNTR[i][j]=0; a=cnt[i][0]; CNTR[i][a-1]=1; CNTR[i][a]=1; CNTR[i][a+1]=1; CNTR[i][a+2]=1; CNTR[i][a+3]=1;
} } outCNTR=fopen("matrice CNTR.txt","w"); for (i=0;i<46;i++) {for (j=0;j<222;j++) fprintf(outCNTR,"%d ",CNTR[i][j]); fprintf(outCNTR,"\n"); } return 0; }
1.5 I programmi “busimbarco.cpp” e “bussbarco.cpp”
I due programmi indicano quali stand hanno bisogno di far imbarcare e sbarcare i passeggeri con l’autobus. Le due matrici che si ottengono hanno 14 colonne che indicano gli stand disponibili e una colonna; gli elementi della matrice assumono valori uguali a 1 o a 0 a seconda della necessità o meno del bus per l’imbarco e lo sbarco. In particolare sappiamo che tutti gli stand hanno bisogno del bus per imbarcare e sbarcare facendo le seguenti eccezioni(18):
gli stand 3 e 4 non necessitano di imbarcare né di sbarcare passeggeri con l’autobus;
lo stand 2 fa sbarcare i passeggeri a piedi, ma necessita di imbarcarli tramite autobus. #include<iostream.h> #include<stdio.h> main() { int busimb[14][1]; int i,j; FILE *out;
/*matrice che indica quali stand *hanno bisogno del bus per l'imbarco */ for (i=0;i<14;i++) {for (j=0;j<1;j++) busimb[i][j]=1; } busimb[2][0]=0; busimb[3][0]=0; out=fopen("bus-imbarco.txt","w"); for (i=0;i<14;i++) {for (j=0;j<1;j++) fprintf(out,"%d",busimb[i][j]); fprintf(out,"\n");
(18)Si trascura il caso in cui i passeggeri vengano imbarcarti tramite l’unico gate si trova al piano superiore dell’aera landside, poichè permette di imbarcare a piedi i passeggeri per lo stand 5.
} return 0; } #include<iostream.h> #include<stdio.h> main() { int bussb[14][1]; int i,j; FILE *out;
/*matrice che indica quali stand *hanno bisogno del bus per lo sbarco */ for (i=0;i<14;i++) {for (j=0;j<1;j++) bussb[i][j]=1; } bussb[1][0]=0; bussb[2][0]=0; bussb[3][0]=0; out=fopen("bus-sbarco.txt","w"); for (i=0;i<14;i++) {for (j=0;j<1;j++) fprintf(out,"%d",bussb[i][j]); fprintf(out,"\n"); } return 0; }
1.6 Il programma “cond.cpp”
Il programma genera la matrice di condivisione degli stand che indica quali sono gli stand che possono condividere uno stesso operatore nel caso in cui vengano allocati aeromobili di voli simultanei.
Ha 14 righe e 14 colonne che mettono in relazione ogni stand con tutti gli altri.
#include<iostream.h> #include<stdio.h> main() { int cond[14][14]; int i,j; FILE *out;
/*matrice che indica quali stand possono essere condivisibili *da uno stesso operatore
*/
for (i=0;i<14;i++)
{for (j=0;j<14;j++) cond[i][j]=0; }
cond[2][1]=1; cond[1][2]=1; cond[3][2]=1; cond[2][3]=1; cond[4][5]=1; cond[5][4]=1; cond[6][5]=1; cond[5][6]=1; cond[7][6]=1; cond[6][7]=1; cond[8][0]=1; cond[0][8]=1; cond[9][0]=1; cond[0][9]=1; cond[9][8]=1; cond[8][9]=1; cond[10][11]=1; cond[11][10]=1; cond[12][11]=1; cond[11][12]=1; cond[13][12]=1; cond[12][13]=1; out=fopen("condivisione.txt","w"); for (i=0;i<14;i++) {for (j=0;j<14;j++) fprintf(out,"%d ",cond[i][j]); fprintf(out,"\n"); } return 0; }
1.7 Il programma “copertura.cpp”
Questa matrice indica quali slot time sono coperti da ognuno degli otto turni lavorativi considerati. La matrice ha ha otto righe, ognuna delle quali rappresenta un turno e 222 colonne ognuna delle quali rappresenta uno slot time della giornata.
#include<iostream.h> #include<stdio.h> main() { int cop[8][222]; int i,j; FILE *out;
/*matrice che indica quali time slot copre ogni turno */
for (i=0;i<1;i++)//la prima riga rappresenta il turno 52 {for (j=0;j<96;j++)
cop[i][j]=1; for (j=96;j<222;j++)
cop[i][j]=0; }
for (i=1;i<2;i++)//la seconda riga rappresenta il turno 22 {for (j=0;j<6;j++) cop[i][j]=0; for (j=6;j<102;j++) cop[i][j]=1; for (j=102;j<222;j++) cop[i][j]=0; }
for (i=2;i<3;i++)//la terza riga rappresenta il turno 37 {for (j=0;j<48;j++) cop[i][j]=0; for (j=48;j<144;j++) cop[i][j]=1; for (j=144;j<222;j++) cop[i][j]=0; }
for (i=3;i<4;i++)//la quarta riga rappresenta il turno 10 {for (j=0;j<66;j++) cop[i][j]=0; for (j=66;j<162;j++) cop[i][j]=1; for (j=162;j<222;j++) cop[i][j]=0; }
for (i=4;i<5;i++)//la quinta riga rappresenta il turno 11 {for (j=0;j<102;j++) cop[i][j]=0; for (j=102;j<198;j++) cop[i][j]=1; for (j=198;j<222;j++) cop[i][j]=0; }
for (i=5;i<6;i++)//la sesta riga rappresenta il turno 2 {for (j=0;j<108;j++) cop[i][j]=0; for (j=108;j<204;j++) cop[i][j]=1; for (j=204;j<222;j++) cop[i][j]=0; }
for (i=6;i<7;i++)//la settima riga rappresenta il turno 41 {for (j=0;j<120;j++) cop[i][j]=0; for (j=120;j<216;j++) cop[i][j]=1; for (j=216;j<222;j++) cop[i][j]=0; }
for (i=7;i<8;i++)//l'ottava riga rappresenta il turno 14 {for (j=0;j<126;j++) cop[i][j]=0; for (j=126;j<222;j++) cop[i][j]=1; } out=fopen("coperture.txt","w"); for (i=0;i<8;i++)
{for (j=0;j<222;j++) fprintf(out,"%d ",cop[i][j]); fprintf(out,"\n"); } return 0; }
