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++ - random walk [C]
Forum - C/C++ - random walk [C]

Avatar
belledetta (Normal User)
Rookie


Messaggi: 25
Iscritto: 07/09/2010

Segnala al moderatore
Postato alle 17:29
Mercoledì, 18/05/2011
sto creando un programma in cui c'è una matrice 10x10 e partendo dalla posizione 0,0 genero una passeggiata casuale che si arresta in 2 casi: ho effettuato 26 passi oppure sono in un vicolo cieco.

ho provato a implementare il codice ma siccome ho studiato solo ieri i puntatori credo di aver fatto un gran macello più che altro perchè non passere le matrici per riferimento, in questo esercizio c'è la funzione mossa che dovrebbe cambiare lo stato della matrice, della posiz corrente e del passo ma non va. (in particolare la swich è tutta sbagliata credo)
potete dare uno sguardo?
Codice sorgente - presumibilmente C++
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <stdbool.h>
  5.  
  6. #define N 10
  7.  
  8.  
  9. //funzione che stampa la matrice quadrata
  10. void stampa (int matrix[N][N], int N)
  11. {
  12.         for(int i = 0; i < N; i++) {
  13.                 for(int j = 0; j < N; j++)
  14.                         printf("%d ", matrix[i][j]);
  15.                 printf("\n");
  16.                 }
  17.         printf("\n");
  18.         return void;
  19. }
  20.  
  21. //procedura che controlla se e quante caselle adiacenti alla posizione attuale sono disponibili
  22. bool avanzamento(unsigned int walk[N][N], unsigned int coordinata[2], bool *mosse_disponibili )
  23. {
  24.         if ( coordinata[0]+1 < N )   //se la riga sotto è contenuta nel bordo
  25.                 if ( walk[coordinata[0]+1][coordinata[1]] == 0 )   //se la cella sotto è libera
  26.                         mosse_disponibili[1] = true;
  27.        
  28.         if ( coordinata[0] -1 > 0 )     //se la riga sopra è contenuta nel bordo
  29.                 if (walk[coordinata[0]-1][coordinata[1]] == 0 ) // se la cella sopra è libera
  30.                         mosse_disponibili[0] = true;
  31.                        
  32.         if ( coordinata[1]+1 <N )       //se la colonna a destra è nel bordo
  33.                 if( walk[coordinata[0]][coordinata[1]+1] == 0 ) //se la cella a destra è libera
  34.                         mosse_disponibili[2] = true;
  35.        
  36.         if ( coordinata [1]-1 > 0)      // la colonna a sinistra è nel bordo
  37.                 if (walk[coordinata[0]][coordinata[1]-1] == 0)  //se la cella è libera
  38.                         mosse_disponibili[3] = true;
  39.        
  40.         int i=0;
  41.         for (; mosse_disponibili[i]==false && mosse_disponibili[i]<4; i++)
  42.        
  43.         if(mosse_disponibili[i]== true) return true;
  44.         else return false;
  45. }
  46.  
  47. //procedura che fa spostare la pedina di una posizione
  48. void mossa (unsigned int **p , unsigned int *coordinata, bool* mosse_disponibili, unsigned int *passo)
  49. {      
  50.         /*conto le mosse disponibili*/
  51.         int count=0;    //conta le mosse possibili     
  52.         for(int i=1; i<4; i++)  
  53.                 if ( mosse_disponibili[i] == true) count++;
  54.        
  55.         int sposta = rand()%count;              //estrae una mossa tra quelle disponibili
  56.        
  57.         //capisco quale mossa devo fare
  58.        
  59.         int j=-1;       //variabile per capire la mossa, inizializ a -1 perchè le mosse vanno da 0 a 3
  60.         for(int i=0; i < count + 1 ; i++)
  61.                 if ( mosse_disponibili[i] == true ) j++;                //la mossa sarà mosse_disponibili[j]
  62.        
  63.         //fai il passo
  64.         switch (j)
  65.         {
  66.                 case 0: { coordinata[0]-=1;                     //cambio coordinata nella riga superiore
  67.                                  ++(*passo);                            //incremento il passo effettuato
  68.                                  p[coordinata[0]][coordinata[ 1]]= passo;       //walk[pos1][pos2] segna il nuovo passo
  69.                                  p = &p[coordinata[0]][coordinata[1]];                                   // sposta il puntatore nella nuova posizione della matrice??????
  70.                                  break;
  71.                                 }                      
  72.                 case 1: { coordinata[0]+=1;                             //coordinata su riga inferiore
  73.                                 ++(*passo);
  74.                                 p[coordinata[0]][coordinata[ 1]]= passo;        //walk[pos1][pos2] segna il nuovo passo
  75.                                  p = &p[coordinata[0]][coordinata[1]];                                  // sposta il puntatore nella nuova posizione della matrice??????
  76.                                 break;
  77.                                 }
  78.                 case 2: { coordinata[1]+=1;                             //posizione su riga destra
  79.                                 ++(*passo);
  80.                                 p[coordinata[0]][coordinata[ 1]]= passo;        //walk[pos1][pos2] segna il nuovo passo
  81.                                  p = &p[coordinata[0]][coordinata[1]];                                  // sposta il puntatore nella nuova posizione della matrice??????
  82.                                 break;
  83.                                 }
  84.  
  85.                 case 3: { coordinata[1]-=1;                             //posizione su riga sinistra
  86.                                 ++(*passo);
  87.                                 p[coordinata[0]][coordinata[ 1]]= passo;        //walk[pos1][pos2] segna il nuovo passo
  88.                                  p = &p[coordinata[0]][coordinata[1]];                                  // sposta il puntatore nella nuova posizione della matrice??????
  89.                                 break;
  90.                                 }                                              
  91.         }
  92.         return ;
  93.        
  94.         }
  95.        
  96.  
  97. int main()
  98. {
  99.         unsigned int walk[N][N]={0};                                    //matrice cammino
  100.        
  101.         unsigned int coordinata[2]={0};                                 //coordinate posizione pedina
  102.         unsigned int passo = 0;                                                 //passo corrente
  103.         bool mosse_disponibili[4]={false};                              //mosse che si possono fare dalla posizione corrente 0=su 1=giù 2=dx 3=sx
  104.         unsigned int *p;        //punt a elemento matrice
  105.        
  106.        
  107.         p = &walk[0][0];                                                                //puntatore al primo elemento della matrice
  108.        
  109.         walk[coordinata[1]][coordinata[2]]= ++passo;            //parto dalla cella [0][0] con il primo passo
  110.        
  111.         for (passo = 1; passo <= 26; passo++){
  112.                 mosse_disponibili[4] = {false};
  113.                 if ( avanzamento( walk[N][N], coordinata[2]; mosse_disponibili ) )      //la f cambia lo stato di mosse disponibili rispetto alla posizione
  114.                         {
  115.                         mossa ( p, coordinata, mosse_disponibili, &passo);                      //la f cambia lo stato della matrice, delle coordinate della pedina, dei passi effettuati
  116.                         stampa(walk[N][N], N);
  117.                         }
  118.                 else { printf("\nnon sono più possibili nuove mosse\n"); break; }
  119.  
  120.         }
  121.        
  122.         stampa(walk[N][N], N);
  123.        
  124.        
  125.         return 0;
  126. }


PM
Avatar
Peppe91 (Member)
Rookie


Messaggi: 41
Iscritto: 09/04/2011

Up
0
Down
V
Segnala al moderatore
Postato alle 13:36
Giovedì, 19/05/2011
Quando chiami la funzione di stampa non devi assolutamente chiamarla così. Devi chiamarla nel modo seguente:

stampa(matrice);    /*N puoi anche non metterlo perchè è una macro, puoi usarlo dovunque senza passarlo*/

Piccolo suggerimento: quando passi una matrice ad una funzione, devi specificare obbligatoriamente, soltanto il numero di colonne. Il numero di righe puoi anche evitare di passarlo. Il numero di colonne è obbligatorio affinchè il programma possa generare la mappa di memorizzazione corretta.

ok grazie mille.. posso farti una domanda? c'è la funzione mossa che deve cambiare lo stato della matrice , le coordinate della pedina e il passo....come si fa a passare a una funzione una matrice che deve essere modificata? - belledetta - 19/05/11 19:33
PM