Oppure

Loading
19/02/16 11:28
luibo
Postato originariamente da torn24:

Ciao, secondo me la funzione passo_casuale() è totalmente da rivedere, non rispetta la traccia, nella traccia è specificato che si deve eseguire una mossa alla volta "prima pedina uno, segue pedina due, poi pedina uno ecc...", la funzione cammino() non ha motivo di esistere, è il main() secondo la traccia che deve provvedere al "ciclo", quindi quello che è inserito nella funzione cammino() andrebbe fatto nel main(), la funzione passo_causale() non tiene conto dei 4 possibili movimenti, e non fa nessun controllo sulla possibilità che la mossa è sui bordi della scacchira.

Per passatempo, ho fatto l'esercizio, e magari con qualche BUG :D sembra funzioni, non so se è il caso di mostrarti una possibile soluzione, bisognerebbe sapere se l'esercizio è un passatempo o altro ??


Ciao, la traccia mi chiede esplicitamente di organizzare l’algoritmo come una function che restituisce il numero di passi del cammino, e il main deve limitarsi a richiamare questa function per 100 volte. Nella function passo_casuale() i controlli in caso la pedina vada ai bordi della scacchiera ci sono, sono quegli if annidati dove ad esempio
if (*y1==29)
        {
                *y1=0;
                *p1=scacchiera[*x1][*y1];
        }

prevede il caso in cui la pedina si trovi sul bordo in basso della scacchiera e pass1 sia = 0 (cioè il passo della pedina sia verso il basso)
aaa
19/02/16 11:42
luibo
Postato originariamente da Template:

Attento: nel main, usi x1, y1, x2 e y2 come indici senza averli inizializzati (perchè l'inizializzazione l'hai messa nella funzione cammino)!
Inoltre, nella funzione passo_casuale, effettui tutti gli incrementi senza premettere l'opportuno operatore: tu scrivi y1++, ma avendo passato il parametro by reference dovresti scrivere (*y1)++ ;)

Detto questo, è normale che ti escano passi uguali, visto che il tuo programma viene eseguito dal calcolatore in pochissimo tempo e dunque ad ogni ripetizione passa ad srand() un valore di tempo sostanzialmente uguale a quello passatogli prima.
Una semplice soluzione a scopo didattico sarebbe quella di passare alla funzione cammino anche l'indice del for, e ri-scrivere la riga 59 così:

srand((((int)time(NULL)) / 314) + i * 27183);


(Notare che i due numeri che ho scelto sono assolutamente arbitrari: io ho preso multipli di pi-greco e del valore di Nepero, ma tu puoi usare quelli che vuoi :k: )

E inoltre potresti riscrivere le due righe 71-72 così:

        pass1 = (rand() + *x1) % 4;
	pass2 = (rand() + 314 * (*x2)) % 4;



Non è una soluzione perfetta (avrai ancora delle ripetizioni, ineluttabilmente), ma almeno ti garantirà dei risultati un po' più interessanti :D


Detto questo, per la gestione grafica della scacchiera ti basta, in sede di determinazione del prossimo passo, nell'ordine:

- Svuotare la casella dove prima si trovava la pedina
- Determinare la sua nuova posizione
- Inserire il suo segnaposto (un trattino, se ben ricordo) nella nuova posizione

Non è difficile: sono tre-quattro righe di codice implementabili nella funzione passo_casuale ;)


Ho seguito i tuoi suggerimenti sulla sistemazione delle srand(), e effettivamente qualcosa è cambiato ma rimane sempre strano: ora le 10 esecuzioni restituiscono diversi numeri totali di passi eseguiti, ma quando eseguo nuovamente l'intero algoritmo i risultati sono identici a prima (praticamente le 10 esecuzioni restituiscono sempre gli stessi numeri di passi totali, sempre nello stesso ordine); poi, il numero di passi totali prima che le due pedine si incontrino è sempre un numero basso, tra l'1 e il 10, anche questo mi pare un po' improbabile dato che le due pedina si muovono su una scacchiera di 30 caselle x 30, tecnicamente ce ne vorrebbero di passi prima di farle incontrare.. Infine scusami se posso sembrare un po' tardo, ma questo "aggiornamento" delle posizioni delle pedine non riesco proprio a implementarlo :d
aaa
19/02/16 12:46
Template
Purtroppo, dei risultati veramente casuali non li avrai mai (almeno, non ponendo come seme della randomizzazione qualcosa di legato all'orario)... per quanto riguarda il numero di passi, il problema principale è un errore nel tuo codice che non avevo visto prima (*), ma considera che molto dipende anche da dove hai posto le due pedine: le hai infatti sistemate in due caselle che sfruttando il comportamento del tuo programma rispetto ai movimenti "oltre i bordi" sono reciprocamente facili da raggiungere, quindi è molto probabile che qualche ripetizione riporti un numero di passi molto basso.


(*) Il while nella funzione cammino ha una condizione che non va bene: ponendo (x1 != x2 && y1 != y2) sostanzialmente il ciclo si ferma non appena le due pedine sono sulla stessa riga o sulla stessa colonna, anche se magari su due caselle diverse. La condizione che serve a te è, a parole, "finchè non è vero contemporaneamente che x1 = x2 e y1 = y2", la quale in codice C si traduce in

while(!(x1 == x2 && y1 == y2))


O, applicando il teorema di De Morgan:

while(x1 != x2 || y1 != y2)




Andiamo ora all'aggiornamento della posizione delle pedine: onestamente, che tu non riesca ad implementarlo non ci credo, perchè è veramente semplice... più probabile piuttosto che tu non abbia capito la mia proposta (che ho in effetti esposto un po' maccheronicamente) :rofl:
Quello che ti proponevo io è di sostituire alle righe

(*y1) = 0;
p1 = scacchiera[*x1][*y1];



Ed affini, le righe:

scacchiera[*x1][*y1] = ' ';
(*y1) = 0;
scacchiera[*x1][*y1] = '_';
p1 = scacchiera[*x1][*y1];


Così da spostare opportunamente il "segnaposto" ;)
Nel tuo programma non è essenziale, perchè di fatto tu quella matrice non la stampi mai... ma, nel caso ti venisse voglia di stamparla, questo sarebbe un metodo semplice per aggiornarla ;)
Ultima modifica effettuata da Template 19/02/16 12:47
aaa
19/02/16 13:21
luibo
Postato originariamente da Template:

Purtroppo, dei risultati veramente casuali non li avrai mai (almeno, non ponendo come seme della randomizzazione qualcosa di legato all'orario)... per quanto riguarda il numero di passi, il problema principale è un errore nel tuo codice che non avevo visto prima (*), ma considera che molto dipende anche da dove hai posto le due pedine: le hai infatti sistemate in due caselle che sfruttando il comportamento del tuo programma rispetto ai movimenti "oltre i bordi" sono reciprocamente facili da raggiungere, quindi è molto probabile che qualche ripetizione riporti un numero di passi molto basso.


(*) Il while nella funzione cammino ha una condizione che non va bene: ponendo (x1 != x2 && y1 != y2) sostanzialmente il ciclo si ferma non appena le due pedine sono sulla stessa riga o sulla stessa colonna, anche se magari su due caselle diverse. La condizione che serve a te è, a parole, "finchè non è vero contemporaneamente che x1 = x2 e y1 = y2", la quale in codice C si traduce in

while(!(x1 == x2 && y1 == y2))


O, applicando il teorema di De Morgan:

while(x1 != x2 || y1 != y2)




Andiamo ora all'aggiornamento della posizione delle pedine: onestamente, che tu non riesca ad implementarlo non ci credo, perchè è veramente semplice... più probabile piuttosto che tu non abbia capito la mia proposta (che ho in effetti esposto un po' maccheronicamente) :rofl:
Quello che ti proponevo io è di sostituire alle righe

(*y1) = 0;
p1 = scacchiera[*x1][*y1];



Ed affini, le righe:

scacchiera[*x1][*y1] = ' ';
(*y1) = 0;
scacchiera[*x1][*y1] = '_';
p1 = scacchiera[*x1][*y1];


Così da spostare opportunamente il "segnaposto" ;)
Nel tuo programma non è essenziale, perchè di fatto tu quella matrice non la stampi mai... ma, nel caso ti venisse voglia di stamparla, questo sarebbe un metodo semplice per aggiornarla ;)


Non so come ho fatto a non rendermi conto dell'errore del while.. sono pessimo! Non giudicarmi per questo :-|
Dopo averlo corretto i risultati sono decisamente più adeguati allo scopo dell'algoritmo, ora non mi resta che rendere più efficienti le funzioni di randomizzazione (perché come hai detto tu se il seed è in base all'orario per ottenere risultati diversi devo eseguire il programma ogni tot minuti) e magari ottimizzare un po', alleggerendo un po' il codice. Riguardo l'aggiornamento delle posizioni, effettivamente non avevo capito molto bene.. mea culpa! Dopo il tuo ultimo post ho afferrato il concetto per bene. Detto questo, ti ringrazio tanto perché mi hai dato un enorme aiuto e te ne sono infinitamente grato! :hail:
Se per caso avessi qualche altro suggerimento per ottimizzare, sarò felice di ascoltarti (tranquillo non ti sto chiedendo nient altro, hai già fatto tanto :k: )
aaa
19/02/16 13:43
torn24
Vorrei postare la mia versione dell'esercizio, non so se sia etico, possa sembrare scortese, o addirittura è fuori dal regolamento del forum, solo stamani, leggendo il problema alle sette del mattino, ho pasticciato col codice per vedere il problema e capire come funzionasse, quindi mi dispiace che si stato tempo perso.

Se la cosa sembra scortese, basta accennarlo e provvederò a eliminare il codice da questo messaggio.


Come ho interpretato io le richieste della traccia, mi soffermo sul punto TENTARE di eseguire una mossa, perché lo preso come essenziale.


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
 /* Per visuallizzare la scacchiera impostare le dimensione della finestra
    del prompt a 200 x 200 e massimizzatela */

 
     
int passo_casuale(char [][30],int*,int*,int*,int*);

void stampa_scacchiera(char scacchiera[][30]);

void inizializza_scacchiera(char scacchiera[][30]);
 
int main()
{
    int i,x1=0,y1=0,x2=29,y2=29,cammino_totale=0;
    int contatore=0;
    srand(time(NULL));    
    char scacchiera[30][30]=
                      {{'X','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                       {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                       {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                       {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                       {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                           {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','Y'}};

  /* DA test possono servire 2000 interazioni perchè casualmente le due pedine si trovino sulla stessa casella*/

    while( contatore<10){
        cammino_totale=passo_casuale(scacchiera,&x1,&y1,&x2,&y2);
        printf("Cammino terminato\nNumero di passi eseguiti: %d\n",cammino_totale);

        //Stampo i valori delle posizioni, al termine delle mosse, altrimenti sarebbe del tutto inutile
        // usare puntatori e passare le varibili per indirizzo, ma si potrebbero usare semplici variabili locali
        printf(" posizione pedina uno %d - %d posizione pedina due %d - %d \n",x1,y1,x2,y2);
        puts("_______________________________________________________");
        contatore++; 
        x1=0;y1=0;x2=29;y2=29; // riposiziono la scacchiera in condizioni iniziali
        inizializza_scacchiera(scacchiera);  
    }          
        

    
    getchar();
}
 
 

 
int passo_casuale(char scacchiera[][30],int *x1,int *y1,int *x2,int *y2)
{
     /* Funzione da modificare radicalmente, non esegue il corretto svolgimento delle richeste della traccia */
    int p=0; //numero casuale
    int ciclo=1;
    int passi=0;
    char selettore_pedina=0;
    char Tentativo_mossa_finale=1;
    while(Tentativo_mossa_finale){// Ripete mosse, fino a condizione inposta dalla traccia
    
        /* Implementata la visualizzazione della scacchiera 
           non è richiesta nella traccia.
           L'esecuzione della stampa scacchiera, rallenta 
           l'esecuzione del codice, rendendo il tempo di esecuzione
           estremamente lungo, si parla di molte ore.
           Bello però provare l'effetto grafico per qualche minuto */
        //stampa_scacchiera(scacchiera); 
        ciclo=1;  
        
        selettore_pedina=selettore_pedina^1; 
        if(selettore_pedina){// Se ha valore uno pedina X 
    
    
            while(ciclo){//ripete fino a quanto non si genera una mossa valida
    
                p=rand()%4;
                switch(p){
        
                    case 0:// spostamento pedina destra
                        if( (*y1)+1<=29 && scacchiera[*x1][(*y1)+1]!='Y' ){
                            scacchiera[*x1][(*y1)+1]= 'X';
                            scacchiera[*x1][*y1]= '-';
                            (*y1)++;
                            ciclo=0;
                            passi++;  
                        }
                        else{
                             if(scacchiera[*x1][(*y1)+1]=='Y'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }       
                        break;
        
                    case 1:// spostamento pedina sinistra
                        if( (*y1)-1>=0 && scacchiera[*x1][(*y1)-1]!='Y' ){
                            scacchiera[*x1][(*y1)-1]= 'X';
                            scacchiera[*x1][*y1]= '-';
                            (*y1)--;
                            ciclo=0; 
                            passi++; 
                        }
                        else{
                             if(scacchiera[*x1][(*y1)-1]=='Y'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }    
                        break;
                    case 2:// spostamento pedina alto 
                        if( (*x1)-1>=0 && scacchiera[(*x1)-1][*y1]!='Y'){
                            scacchiera[(*x1)-1][*y1]= 'X';
                            scacchiera[*x1][*y1]= '-';
                            (*x1)--;
                            ciclo=0;
                            passi++;  
                        }
                        else{
                             if(scacchiera[(*x1)-1][*y1]=='Y'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }    
                        break;
                    case 3:// spostamento pedina basso
                        if( (*x1)+1<=29 && scacchiera[(*x1)+1][*y1]!='Y'){
                             scacchiera[(*x1)+1][*y1]= 'X';
                             scacchiera[*x1][*y1]='-';
                             (*x1)++;
                             ciclo=0;
                             passi++;  
                        }
                        else{
                             if(scacchiera[(*x1)+1][*y1]=='Y'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }   
                        break;
                }  //end switch  
    
            }   //end while 
        }// end if
        else if(selettore_pedina==0){// Se ha valore uno pedina Y 
    
    
            while(ciclo){//ripete fino a quanto non si genera una mossa valida
    
                p=rand()%4;
                switch(p){
        
                    case 0:// spostamento pedina destra
                        if( (*y2)+1<=29 && scacchiera[*x2][(*y2)+1]!='X'){
                            scacchiera[*x2][(*y2)+1]= 'Y';
                            scacchiera[*x2][*y2]= '-';
                            (*y2)++;
                            ciclo=0; 
                            passi++; 
                        }
                        else{
                             if(scacchiera[*x2][(*y2)+1]=='X'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }   
                            
                        break;
        
                    case 1:// spostamento pedina sinistra
                        if( (*y2)-1>=0 && scacchiera[*x2][(*y2)-1]!='X'){
                            scacchiera[*x2][(*y2)-1]= 'Y';
                            scacchiera[*x2][*y2]= '-';
                            (*y2)--;
                            ciclo=0;
                            passi++;  
                        }
                        else{
                             if(scacchiera[*x2][(*y2)-1]=='X'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }   
                        
                        break;
                    case 2:// spostamento pedina alto 
                        if( (*x2)-1>=0 && scacchiera[(*x2)-1][*y2]!='X'){
                            scacchiera[(*x2)-1][*y2]= 'Y';
                            scacchiera[*x2][*y2]= '-';
                            (*x2)--;
                            ciclo=0;
                            passi++;  
                        }
                        else{
                             if(scacchiera[(*x2)-1][*y2]=='X'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }   
                        break;
                    case 3:// spostamento pedina basso
                        if( (*x2)+1<=29 && scacchiera[(*x2)+1][*y2]!='X'){
                            scacchiera[(*x2)+1][*y2]= 'Y';
                            scacchiera[*x2][*y2]='-';
                            (*x2)++;
                            ciclo=0; 
                            passi++; 
                        }
                        else{
                             if(scacchiera[(*x2)+1][*y2]=='X'){
                                 Tentativo_mossa_finale=0;
                                 ciclo=0;
                             }       
                        }   
                        break;
                } // end switch   
    
            } //end while   
        }// end else if
   
    }// end while 
      
    return passi;
}// end function 


void stampa_scacchiera(char scacchiera[][30]){
    
    int i=0, j=0;
    for(i=0;i<30;i++){
        for(j=0;j<30;j++){
            
            printf(" %c ",scacchiera[i][j]);
            
        }    
        printf("\n");
        
    }    
    sleep(200);
    system("CLS");
    
}  



void inizializza_scacchiera(char scacchiera[][30]){
    
     int i=0, j=0;
    for(i=0;i<30;i++){
        for(j=0;j<30;j++){
            
            scacchiera[i][j]='-';
            
        }    
        
        
    }
    scacchiera[0][0] ='X';
    scacchiera[29][29]='Y';     
}         








Ultima modifica effettuata da torn24 19/02/16 13:45
aaa
19/02/16 13:55
Template
Mi fa piacere che tu non intenda fermarti solo perchè "il programma fa il suo lavoro": è un atteggiamento che, secondo me, nel tempo può portare a capire veramente come si programma bene :k:

Detto questo, per prima cosa - visto che lo chiedi - fossi in te toglierei quell'orribile definizione della matrice, sostituendola con la molto più ordinata versione:

char scacchiera[30][30];
	for (i = 0; i < 30; i++)
		for (j = 0; j < 30; j++)	
			scacchiera[i][j] = ' ';
	scacchiera[0][0] = '_';
	scacchiera[29][29] = '-';


Inoltre, se proprio vuoi continuare a utilizzare il tempo del sistema come seme per srand(), ne effettuerei un casting esplicito al tipo int, che per correttezza ci starebbe proprio (e che, se ci fai caso, silenziosamente ti ho già "proposto" nel codice di un post precedente) ;)


Per il resto, non è che ci sia molto da dire: in termini di correttezza, il codice va bene, e di fatto il suo lavoro lo fa in maniera abbastanza pulita... per curiosità, sei autodidatta?
Chiedo perchè l'attenzione alla leggibilità del codice ed una sua scrittura in generale così pulita (se eccettuiamo i pochi errori che ti ho segnalato - che in generale possono capitare - il codice in sè era già buono in partenza) sono caratteri che quasi mai ho ritrovato negli autodidatti :D
aaa
19/02/16 14:04
luibo
Postato originariamente da Template:


Per il resto, non è che ci sia molto da dire: in termini di correttezza, il codice va bene, e di fatto il suo lavoro lo fa in maniera abbastanza pulita... per curiosità, sei autodidatta?
Chiedo perchè l'attenzione alla leggibilità del codice ed una sua scrittura in generale così pulita (se eccettuiamo i pochi errori che ti ho segnalato - che in generale possono capitare - il codice in sè era già buono in partenza) sono caratteri che quasi mai ho ritrovato negli autodidatti :D


Ti ringrazio, ricevere belle parole da un esperto fa sempre piacere ;)
Comunque no, non sono autodidatta, sto seguendo un corso universitario di scienze informatiche, sono al primo anno e per ora sono solo un modesto aspirante programmatore
aaa
19/02/16 14:08
Template
"Esperto", suvvia... diciamo più che altro un "cugino un po' più grande": sono al secondo anno di ingegneria informatica (anche se in effetti quando sono entrato all'università programmavo già da 5-6 anni :D).

Comunque, complimenti anche al tuo professore: non tutti si premurano di insegnare all'allievo l'importanza di un codice pulito ed efficace ;)
Ultima modifica effettuata da Template 19/02/16 14:09
aaa