Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Cammino casuale di una pedina su scacchiera
Forum - C/C++ - Cammino casuale di una pedina su scacchiera - Pagina 2

Pagine: [ 1 2 3 ] Precedente | Prossimo
Avatar
eclix (Normal User)
Newbie


Messaggi: 13
Iscritto: 20/05/2012

Segnala al moderatore
Postato alle 11:42
Martedì, 29/05/2012
Comunque sono andato in panico dicendomi che la matrice non serve . Sicuro? XD
Non è che poi vado fuori traccia??

PM Quote
Avatar
subazu (Normal User)
Rookie


Messaggi: 35
Iscritto: 06/08/2011

Segnala al moderatore
Postato alle 23:34
Martedì, 29/05/2012
1 Passaggio parametri
mi viene il dubbio che sia permesso solo dal c++, per ora lascia stare, mi documenterò meglio.
2 Ciclo While
Il ciclo while serve per spostare le pedine, e perciò va dentro la tua fantomatica funzione, solo che devi chiarire l'idea che hai di questa funzione....
La funzione deve muovere le pedine no? secondo te deve anche crearle? deve inizializzarle? oppure lo deve fare qualcun altro fuori dalla funzione? (come facevi tu)
Prova a pensare alla tua funzione come ad una scatola, devi buttare qualcosa in questa scatola perché faccia il suo lavoro? ha senso inizializzare valori fuori dalla funzione se questi sono inizializzati sempre allo stesso modo e sono sempre uguali?
Io per adesso sto risolvendo unicamente il problema di una giocata, poi basterà rinominare "main" in "fantomatica_funzione" e richiamarla in un altro main che riscriverai, no?
3 Show chess
La funzione va cambiata, e diventa un pelino più complicata.
Diciamo che per risolvere questo problema in generale ci sono più strade, una è quella della matrice, che occupa un botto di spazio (grandezza della scacchiera alla seconda) ed è inoltre una grande scocciatura perché hai 2 strutture dati indipendenti che hanno gli stessi dati (la matrice e le 2 strutture) e vanno fra di loro sincronizzate ad ogni modifica.
L'altra è quella più analitica e furba, perché occupa unicamente l' spazio delle pedine e per la stampa a video trova i minimi delle coordinate, per sapere quale pedina va stampata prima, si posiziona nel punto e la stampa, così per tutte.
Se fai caso la tua matrice contiene sempre un sacco di spazi "vuoti", che sono irrilevanti e 2 lettere diverse, di cui tieni traccia le coordinate.
Quindi invece di stampare l'intera matrice non ti converrebbe stampare a video solo i 2 caratteri sapendone le coordinate???
4 Rand
Esatto, questo per una questione di competenza (dico io), a me non deve interessare come fa il suo lavoro la movimento_casuale finché non devo scriverla, questo perché se un giorno decidessi che non voglio più muovere la pedina in quel modo ma con un algoritmo basato sulla genetica quantistica (non credo neanche se esista) mi basterebbe riscrivere SOLO quel metodo.
A dirla tutta sarebbe ancora più opportuno chiamarlo "movimento" ma si può anche lasciare perdere.
5 fuori traccia
Diciamo che se il tuo prof è uno sciocco pretenderà la matrice, sennò ti dirà che sei riuscito a analizzare in modo corretto il problema e a trovare una soluzione più complessa ed efficace di quanto pretendesse da voi.
La vera traccia in informatica è il problema, non i consigli di risoluzione.

Se comunque hai questo dubbio sviluppa entrambi gli algoritmi (in quello con la matrice però devi usare solo quella, senza le 2 strutture).
Io di certo non risolverei mai un problema del genere con una matrice.


PM Quote
Avatar
eclix (Normal User)
Newbie


Messaggi: 13
Iscritto: 20/05/2012

Segnala al moderatore
Postato alle 18:58
Venerdì, 08/06/2012
dopo una lunga assenza (un po' per diversi impegni, un po' perchè ho avuto problemi di connessione), mi ripresento di nuovo sbattendo nuovamente la testa su questo algoritmo che mi sta tormentando da un bel po' tempo.
Bene... della scacchiera non riesco proprio a farne a meno... XD
non riesco proprio ad immaginare l'algoritmo senza tenere in mente la scacchiera.
ho fatto di nuovo diverse modifiche ma in sostanza l'implementazione è sempre la stessa.
ti mostro la function che ho modificato e che deve essere chiamata ogni volta per eseguire il programma:
Codice sorgente - presumibilmente C/C++

  1. int cammino (char walk[][N])
  2. {
  3.     /* le pedine p1 e p2 sono variabili di tipo Pedina (struct pedina) alle quali vengono assegnate,
  4.     per ciascuna pedina, le proprie coordinate (1° campo e 2° campo) e il corrispettivo simbolo (3° campo)*/
  5.  
  6.     Pedina p1={0,0,'x'};
  7.     Pedina p2={29,29,'y'};
  8.     int cnt_passi=0; // contatore dei passi eseguiti dalle pedine inizializzato a zero
  9.     int nPed= TRUE;
  10.     initialize_chess(walk,p1,p2); //chiamata alla function che costruisce la scacchiera e inizializza le pedine
  11.     show_chess(walk); //stampa a video della scacchiera
  12.     printf("\n");
  13.     system("pause");
  14.     system("cls"); //pulisce lo schermo
  15.     srand((unsigned)time(0));
  16.  
  17.     /*il ciclo while controlla se le pedine sono situate sulla stessa casella, pertanto se il predicato del while risulta vero,
  18.     il ciclo termina, altrimenti se risulta falso procederà finquando le pedine saranno nella stessa posizione.*/
  19.  
  20.     while (! ((p1.x == p2.x) && (p1.y == p2.y))){
  21.         system("cls"); //pulitura schermo
  22.  
  23.         if(nPed){
  24.  
  25.             movimento_casuale(walk, &p1); //chiamata alla function per effettuare il cammino della pedina 1
  26.  
  27.             nPed=!nPed;
  28.         }
  29.         else{
  30.  
  31.              movimento_casuale(walk, &p2); //chiamata alla function per effettuare il cammino della pedina 2
  32.              nPed=!nPed;
  33.  
  34.         }
  35.  
  36.         show_chess(walk);
  37.  
  38.         cnt_passi++; //incremento della variabile 'passi' fintanto che non termina il ciclo while (pedine nella stessa casella)
  39.  
  40. }return cnt_passi;
  41. }



non capisco quando dici di sviluppare il codice soltanto con la matrice senza utilizzare le strutture. Le strutture di cui parli sarebbero le 2 pedine di tipo struct?

Un altro problema sorge quando devo richiamare la function per 100 volte visualizzando la lunghezza di ogni cammino effettuati.
Sarebbe brutto stare li ad attendere quando le due pedine si incontrano, quindi vorrei visualizzare semplicemente le lunghezze di ciascun cammino(100 nel mio caso).
Mi toccherà cambiare di nuovo tutto il codice?? :-o

PM Quote
Avatar
subazu (Normal User)
Rookie


Messaggi: 35
Iscritto: 06/08/2011

Segnala al moderatore
Postato alle 21:28
Venerdì, 08/06/2012
1 Matrice non matrice, il dilemma
Partendo dal presupposto che la matrice NON TI SERVE e che le strutture di cui parlo sono solo le 2 struct, ti dico che in effetti è un po macchinoso fare la Show, quindi per adesso puoi farne a meno, magari se ne hai voglia te lo posso spiegare più avanti, dopo aver consegnato il programma, magari la facciamo assieme, perché ci vuole una analisi  più complessa del problema stesso, tutto ciò che ho detto prima però è valido, anche ciò che riguarda i professori.
Togliere la matrice secondo me è un buon esercizio, molto avanzato, che ti consiglierei di provare a fare :-)

2 Matrice mia o tua?
La matrice viene inizializzata a 0 o a niente fuori dalla funzione, perché?
Ti ricordo che lo scopo è rendere indipendente la funzione, se gli passi la matrice non inizializzata o una matrice già usata succede il demonio :-)

3 Siamo un po lenti
Se non vuoi che ma funzione sia lenta diglielo, easy :-D
Codice sorgente - presumibilmente C/C++

  1. int miaFunzione(boolean devoEssereLenta)
  2. {
  3.    //operazioni molto importanti
  4.    if (devoEssereLenta)
  5.    {
  6.        //operazioni molto lente
  7.    }
  8.    //altre operazioni molto importanti
  9. }


L'esempio è ironico, ma credo sia soprattutto esaustivo.

4 Logica operativa

così dovrebbe essere:
Codice sorgente - presumibilmente Plain Text

  1. -inizializzo
  2. -finché non c'è collisione: (al primo giro non ci sarà mai collisione)
  3.    -disegno le pedine (potresti fare una show che comprende anche il "cls" e il "pause")
  4.    -muovo una pedina
  5.    -incremento le mosse
  6. -restituisco il risultato


così è:
Codice sorgente - presumibilmente Plain Text

  1. -inizializzo
  2. -disegno  (potresti fare una show che comprende anche il "cls" e il "pause" (v1 e v2))
  3. -faccio operazioni riguardanti disegno v1
  4. -finché non c'è collisione:
  5.    -faccio operazioni riguardanti disegno v2 (diverso dal v1)
  6.    -muovo una pedina
  7.    -disegno le pedine
  8.    -incremento le mosse
  9. -restituisco il risultato



Con la mia logica, per risolvere il problema della visualizzazione metterei solo un IF, nel tuo caso ne devo mettere 2, anche se è poca è da prefiggersi l'obiettivo di non spargere cose in giro e raggrupparle se possibile sempre, nel migliore dei modi, per il fantomatico principio di competenza (di mia invenzione il nome).

PM Quote
Avatar
eclix (Normal User)
Newbie


Messaggi: 13
Iscritto: 20/05/2012

Segnala al moderatore
Postato alle 16:08
Sabato, 09/06/2012
1 Matrice non matrice
mmm... nella traccia compare una array 2D. Quello che non capisco che dici tu, è che non devo proprio utilizzare l'array 2D o devo comunque utilizzarlo ma è inutile visualizzarlo??  

2 Matrice mia o tua?
beh la matrice che passo alla funzione l'ho semplicemente dichiarata nel main...
Codice sorgente - presumibilmente C/C++

  1. void main ()
  2. {
  3.     char walk[N][N];      //dichiarazione della matrice (scacchiera 30x30)
  4. ....
  5. ....
  6. }


avevo letto in qualche tuo commento precedente di pensare la mia funzione come una scatola che facesse il suo lavoro... quindi gli ho passato una matrice di dimensione 30x30 (dichiarata nel main) e poi l'ho costruita nella funzione, posizionandoci poi le due pedine. Non è corretta la mia interpretazione?

i punti 3 e 4 non li ho proprio capiti! XD
servono per visualizzare una sola volta la function?


PM Quote
Avatar
subazu (Normal User)
Rookie


Messaggi: 35
Iscritto: 06/08/2011

Segnala al moderatore
Postato alle 14:47
Domenica, 10/06/2012
1 Matrice non matrice
La matrice non è necessaria per risolvere il problema, ma per farne a meno si deve analizzare il problema in modo molto più approfondito, e ciò ti richiederebbe più tempo.
Nella consegna c'è un array 2D appunto perché evidentemente il professore ha pensato che fosse troppo difficile per voi farne a meno.
Io dico che è il caso che tu la matrice la usi, e consegni l'esercizio con la matrice, ma che sarebbe bene che tu provassi a farne a meno.
Non so se tu hai una base di strutture dati, ma con la matrice usi 2 strutture dati indipendenti che svolgono lo stesso mestiere, uno spreco inutile...

2 la matrice a mio avviso la devi dichiarare dentro la funzione e al massimo passargli un intero che rappresenti la grandezza della matrice.

Questo perché se tu dovessi ricavare dei dati per esempio per confrontare il numero di passi medi che fanno le pedine per 100 casi (fino a qui come nel tuo esercizio) ma in diverse dimensioni di scacchiere, come opereresti?

Passando diverse dimensioni di matrici (=array 2D) alla tua funzione questa funziona correttamente?
Se no allora perché gli e la passi ?

La funzione "movimento_casuale" può prendere come parametro matrici differenti e fare il suo lavoro in modo corretto?

Tieni sempre a mente che se hai la possibilità di sbagliare prima o poi sbaglierai qualcosa :-)
Quindi invece di essere così generosi da passare matrici non inizializzate e di dimensioni arbitrarie decidi di passare un intero che rappresenta il lato della scacchiera e di gestire tutto all'interno:
dichiarazione
inizializzazione
movimento

Io non vedo il codice della "movimento_casuale" e della "initialize_chess" ma da qualche parte prenderanno gli indici per muoversene fuori o per fare i cicli sulla matrice e credo che se tu gli passassi indici diversi suderebbe un disastro.

Pensa anche alla inizializzazione delle pedine... inizializzi la loro posizione con delle costanti, se cambi dimensione alla matrice le coordinate dovrebbero cambiare di conseguenza in automatico e invece...

3 Ciò che non si capisce
I due punti sono semplici, rileggili, cmq nel

P3 la soluzione è quella di passare alla funzione un booleano che determina se stampare la matrice a video ogni volta o no, e hai un esempio con dei commenti.

P4 rileggi e rifletti su cosa dovrebbe fare la funzione, c'è l'esempio a mio dire più lineare e invece dopo come hai affrontato tu il problema, in alcuni punti un pò sparso, confronta bene gli esempi e collegali al tuo codice e tutto ti sarà più chiaro.

PM Quote
Avatar
eclix (Normal User)
Newbie


Messaggi: 13
Iscritto: 20/05/2012

Segnala al moderatore
Postato alle 19:51
Lunedì, 11/06/2012
Questo è il codice della movimento_casuale:
Codice sorgente - presumibilmente C++

  1. void movimento_casuale(char walk[][30], Pedina *pawn)
  2. {
  3.     int passo;
  4.     passo=rand()%4;
  5.  
  6.     switch(passo)
  7.     {
  8.  
  9.         case SU:            if((*pawn).x==0)
  10.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[++(*pawn).x][(*pawn).y]=(*pawn).simb;}
  11.                         else
  12.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[--(*pawn).x][(*pawn).y]=(*pawn).simb;}          break;//pedina verso nord
  13.  
  14.  
  15.  
  16.                 case GIU:       if((*pawn).x==N-1)
  17.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[--(*pawn).x][(*pawn).y]=(*pawn).simb;}
  18.                                 else
  19.                                 {walk[(*pawn).x][(*pawn).y]='.'; walk[++(*pawn).x][(*pawn).y]=(*pawn).simb;}          break;//pedina verso sud
  20.  
  21.  
  22.  
  23.  
  24.                 case SINISTRA:  if((*pawn).y==0)
  25.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][++(*pawn).y]=(*pawn).simb;}
  26.                                 else
  27.                                 {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][--(*pawn).y]=(*pawn).simb;}          break;//pedina verso ovest
  28.  
  29.  
  30.  
  31.                 case DESTRA:    if((*pawn).y==N-1)
  32.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][--(*pawn).y]=(*pawn).simb;}
  33.                         else
  34.                         {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][++(*pawn).y]=(*pawn).simb;}          break;//pedina verso est
  35.         }
  36.  
  37. }



e questo invece di initialize_chess:
Codice sorgente - presumibilmente C/C++

  1. void initialize_chess(char v[][N],Pedina p1, Pedina p2)
  2. {c
  3.     int i,j;
  4.     for(i=0;i<N;i++)
  5.     for(j=0;j<N;j++)
  6.     v[i][j]='.';
  7.     v[p1.x][p1.y]=p1.simb; //postazione iniziale della pedina1
  8.     v[p2.x][p2.y]=p2.simb; //postazione iniziale della pedina2
  9. }



non mi sono state date nozioni sul tipo booleano, forse per questo non sono riuscito a capire?
o non richiede poi tutta questa scienza? :rotfl:

cmq mi manca poco per la consegna dell'esercizio... se lo lascio così dici che non va bene? non è che mi sto facendo troppi problemi? XD

Ultima modifica effettuata da eclix il 11/06/2012 alle 19:58
PM Quote
Avatar
subazu (Normal User)
Rookie


Messaggi: 35
Iscritto: 06/08/2011

Segnala al moderatore
Postato alle 15:42
Martedì, 12/06/2012
Per la questione del tempo dicevo infatti di non iniziare a sviluppare la soluzione senza tabella, anche se un professore può accettare magari per buona una cosa del genere (il mio per fortuna no) non ti sarebbe utile, il problema di per se è banale, e la soluzione può essere trovata quasi tirando un dado, il più è farlo bene ed in maniera strutturata, in modo elegante e chiaro, con logica ferrea e precisa, senza casualità ma con metodo.

Come dicevo se tu passassi ad esempio una tabella rettangolare* alla tua funzione principale (un 10x15) l'inizializzazione avverrebbe per tutte e due le dimensioni con uno dei 2 indici, invece il movimento casuale farebbe un macello perché usa una variabile N indipendente dalla tabella passata,che inoltre viene dichiarata con un valore costante (30)

*se ti stai chiedendo il perché tu debba passare una tabella rettangolare con dimensioni diverse da quelle previste dall'esercizio ti stai facendo le domande sbagliate, se puoi passare un valore questo deve essere gestito, quindi o sistemi questi casi (dato che posso passare matrici di dimensioni X per Y) oppure permetti solo le matrici di una certa grandezza.

Il booleano è un concetto che probabilmente non avete esplicitato, in pratica è una variabile che può assumere unicamente 2 valori, {1,0} cioè vero e falso.
In altri linguaggi c'è il tipo "bool" o "boolean" in C si usa semplicemente un "int" con con le costanti TRUE e FALSE (come per la variabile nPed della funzione "cammino")
Ti ricordo che in C tutti i valori > di zero valgono TRUE.

Quanto è che ti manca di preciso?

PM Quote
Pagine: [ 1 2 3 ] Precedente | Prossimo