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++ - Progetto pedine in C
Forum - C/C++ - Progetto pedine in C

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


Messaggi: 12
Iscritto: 18/02/2016

Segnala al moderatore
Postato alle 17:51
Giovedì, 18/02/2016
Salve, avrei bisogno di un piccolo aiuto riguardo la realizzazione di un progetto in C. La traccia è la seguente:
"Si vuole sviluppare un algoritmo del cammino casuale di una pedina. Un cammino si svolge su una scacchiera in cui ogni casella rappresenta una possibile posizione del cammino della pedina. Stando in una casella, una pedina può muoversi solo nella casella a destra, nella casella a sinistra, nella casella sopra o nella casella sotto. La scelta di una tra queste quattro caselle deve essere fatta a caso (generando per esempio un numero intero in {0,1,2,3}).
Ogni movimento da una casella all’altra è detto passo del cammino. L’algoritmo usa un array 2D nxn, con n=30, per simulare la scacchiera. Ci sono due pedine sulla scacchiera, e all’inizio una si trova nella casella in alto a sinistra e l’altra nella casella in basso a destra. A ogni movimento di una pedina, segue il movimento dell’altra pedina. Fare attenzione al movimento di una pedina quando si trova sul bordo della scacchiera. L’algoritmo procede finché accade che le due pedine tentano di muoversi sulla stessa casella della scacchiera; in tal caso l’algoritmo termina (cammino terminato), restituendo il numero di passi effettuati. Organizzare l’algoritmo come una function che restituisce il numero di passi (lunghezza) del cammino. Scrivere un main che per 100 volte chiama la function e visualizza la lunghezza di ogni cammino effettuati."

Ho già scritto tutto il codice, ma questo non funziona, nel senso che il compilatore non mi da errori e il codice viene anche eseguito, ma viene immediatamente terminato senza dare nessun risultato. Qui il codice:
Codice sorgente - presumibilmente C++
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. typedef char pedina;
  5.  
  6. void passo_casuale(char [][30],pedina,pedina,int,int,int,int);
  7. int cammino(char [][30]);
  8.  
  9. int main()
  10. {
  11. int i,cammino_totale=0;
  12. char scacchiera[30][30]=
  13.       {{'_',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  14.        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  15.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  16.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  17.        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  18.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  19.        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  20.        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  21.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  22.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  23.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  24.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  25.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  26.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  27.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  28.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  29.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  30.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  31.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  32.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  33.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  34.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  35.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  36.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  37.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  38.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  39.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  40.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  41.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  42.            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-'}};
  43. for (i=0;i<10;i++)
  44. {
  45.         cammino_totale=cammino(scacchiera);
  46.         printf("Cammino terminato\nNumero di passi eseguiti: %d\nEsecuzioni rimanenti: %d\n",cammino_totale,9-i);
  47. }
  48. }
  49.  
  50.  
  51. int cammino(char scacchiera[][30])
  52. {
  53. pedina p1;
  54. pedina p2;
  55. int cammino_totale=0;
  56. int x1=0,y1=0,x2=29,y2=29;
  57. p1=scacchiera[x1][y1];
  58. p2=scacchiera[x2][y2];
  59. srand(time(NULL));
  60. while (x1!=x2 && y1!=y2)
  61. {
  62.         passo_casuale(scacchiera[30][30],p1,p2,x1,y1,x2,y2);
  63.         cammino_totale++;
  64. }
  65. return cammino_totale;
  66. }
  67.  
  68. void passo_casuale(char scacchiera[][30],pedina p1, pedina p2,int x1,int y1,int x2,int y2)
  69. {
  70. int pass1,pass2;
  71. p1=scacchiera[x1][y1];
  72. p2=scacchiera[x2][y2];
  73. pass1=rand()%4;
  74. pass2=rand()%4;
  75. if (pass1==0)
  76. {
  77.         if (y1==29)
  78.         {
  79.                 y1=0;
  80.                 p1=scacchiera[x1][y1];
  81.         }
  82.         else
  83.         {
  84.         y1++;
  85.         p1=scacchiera[x1][y1];
  86.         }
  87. }
  88. if (pass1==1)
  89. {
  90.         if (y1==0)
  91.         {
  92.                 y1=29;
  93.                 p1=scacchiera[x1][y1];
  94.         }
  95.         else
  96.         {
  97.         y1--;
  98.         p1=scacchiera[x1][y1];
  99.         }
  100. }
  101. if (pass1==2)
  102. {
  103.         if (x1==29)
  104.         {
  105.                 x1=0;
  106.                 p1=scacchiera[x1][y1];
  107.         }
  108.         else
  109.         {
  110.         x1++;
  111.         p1=scacchiera[x1][y1];
  112.         }
  113. }
  114. if (pass1==3)
  115. {
  116.         if (x1==0)
  117.         {
  118.                 x1=29;
  119.                 p1=scacchiera[x1][y1];
  120.         }
  121.         else
  122.         {
  123.         x1--;
  124.         p1=scacchiera[x1][y1];
  125.         }
  126. }
  127. if (pass2==0)
  128. {
  129.         if (y2==29)
  130.         {
  131.                 y2=0;
  132.                 p2=scacchiera[x2][y2];
  133.         }
  134.         else
  135.         {
  136.         y2++;
  137.         p2=scacchiera[x2][y2];
  138.         }
  139. }
  140. if (pass2==1)
  141. {
  142.         if (y2==0)
  143.         {
  144.                 y2=29;
  145.                 p2=scacchiera[x2][y2];
  146.         }
  147.         else
  148.         {
  149.         y2--;
  150.         p2=scacchiera[x2][y2];
  151.         }
  152. }
  153. if (pass2==2)
  154. {
  155.         if
  156.         (x2==29)
  157.         {
  158.                 x2=0;
  159.                 p2=scacchiera[x2][y2];
  160.         }
  161.         else
  162.         {
  163.         x2++;
  164.         p2=scacchiera[x2][y2];
  165.         }
  166. }
  167. if (pass2==3)
  168. {
  169.         if (x2==0)
  170.         {
  171.                 x2=29;
  172.                 p2=scacchiera[x2][y2];
  173.         }
  174.         else
  175.         {
  176.         x2--;
  177.         p2=scacchiera[x2][y2];
  178.         }
  179. }
  180. }


So che è un po' "rudimentale", ma la mia intenzione era di scrivere prima qualcosa che effettivamente funzionasse e poi ottimizzare. Qualcuno mi saprebbe dire qual è l'errore che impedisce l'esecuzione corretta? Sono giorni che cerco di capire ma non ci arrivo, ho solo il sospetto che l'errore sia nella function passo_casuale(), ma effettivamente non l'ho trovato. Grazie in anticipo per l'aiuto!

PM Quote
Avatar
Template (Member)
Pro


Messaggi: 177
Iscritto: 09/12/2015

Segnala al moderatore
Postato alle 19:47
Giovedì, 18/02/2016
la funzione passo_casuale, in sostanza, cosa dovrebbe fare? Qual è l'idea che sottende la sua implementazione?

Chiedo perchè credo anch'io che il problema stia lì, ma per identificarlo con più facilità vorrei capire cosa la funzione dovrebbe fare.

PM Quote
Avatar
luibo (Normal User)
Newbie


Messaggi: 12
Iscritto: 18/02/2016

Segnala al moderatore
Postato alle 20:38
Giovedì, 18/02/2016
in pratica determina in quale direzione si muovono la pedina p1 e la pedina p2, dovrebbe restituire un numero tra 0 e 3 dove 0=passo in basso, 1=passo in alto, 2=passo a destra e 3=passo a sinistra, e dovrebbe fermarsi fin quando le due pedine non vogliono muoversi sulla stessa casella (quindi fin quando x1=x2 e y1=y2, dato che ho impostato e inizializzato queste posizioni come coordinate). La funzione deve prevedere anche il caso in cui la pedina si trovi al bordo della scacchiera, ad esempio se si trova sul bordo destro e il passo casuale è a destra, la pedina deve ritrovarsi dall'altro lato della scacchiera

Ultima modifica effettuata da luibo il 18/02/2016 alle 20:39
PM Quote
Avatar
Template (Member)
Pro


Messaggi: 177
Iscritto: 09/12/2015

Segnala al moderatore
Postato alle 23:14
Giovedì, 18/02/2016
Ok... posso dirti subito che ci sono alcuni problemi:

RIGA 62: nel while, tu hai posto una condizione che non si verificherà mai, perchè passando le coordinate by value alla funzione passo_casuale in effetti il loro valore non cambierà mai: dovresti passarle by reference.
Questo, tra parentesi, è il motivo per cui il tuo programma rimane "bloccato": perchè, di fatto, gli hai inserito un ciclo infinito.

RIGHE DA 80 IN POI: tutte le volte che scrivi l'assegnamento

Codice sorgente - presumibilmente Plain Text
  1. p1=scacchiera[x1][y1];



O analogo con p2, di fatto compi un passo inutile, perchè ti limiti a spostare il "puntatore alla posizione" della pedina, senza che effettivamente essa (che immagino sia rappresentata dal trattino o dall'underscore) si sposti: dovresti anche aggiornare le caselle della tua matrice in modo che il simbolo della pedina si sposti dove opportuno ;)


FUNZIONE MAIN: dovresti resettare la matrice ed i "puntatori" prima di ogni esecuzione della funzione dei cammini.

Questo è ciò che ho notato appena ri-letto il tuo codice... forse ci sono altri problemi (non credo, ma non si sa mai), ma al momento sono troppo stanco per leggere il codice con più attenzione... se domani, dopo aver risolto i problemi che ti ho segnalato ancora il programma non funzionerà, sarò ben felice di aiutarti al massimo delle mie possibilità... per il momento, ti prego di scusarmi, di più non posso fare :d

Ultima modifica effettuata da Template il 18/02/2016 alle 23:32
PM Quote
Avatar
luibo (Normal User)
Newbie


Messaggi: 12
Iscritto: 18/02/2016

Segnala al moderatore
Postato alle 0:31
Venerdì, 19/02/2016
Innanzitutto ti ringrazio per la gentilezza e la disponibilità!
Allora, ho cambiato la funzione attuando il passaggio dei parametri per indirizzo, non è comunque bastato a far funzionare l'algoritmo; riflettendo sul tuo suggerimento credo che effettivamente il problema sia proprio il mancato "aggiornamento" della matrice con le nuove posizioni delle pedine, ma come posso implementare al meglio questa cosa? Avevo pensato magari di fare una nuova function che aggiorna di continuo la scacchiera, da richiamare all'inizio del ciclo for che si trova nel main, ma in realtà non sono tanto sicuro.. fatto sta che non mi vengono in mente molte altre soluzioni

PM Quote
Avatar
luibo (Normal User)
Newbie


Messaggi: 12
Iscritto: 18/02/2016

Segnala al moderatore
Postato alle 1:36
Venerdì, 19/02/2016
Nel frattempo qualche modifica l'ho apportata (perdonami se ci sono errori banali, è pur sempre l'1:30 di notte..), ora il codice si presenta così:
Codice sorgente - presumibilmente C++
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. typedef char pedina;
  6.  
  7. void passo_casuale(char [][30],pedina*,pedina*,int*,int*,int*,int*);
  8. int cammino(char [][30],pedina*,pedina*);
  9.  
  10. int main()
  11. {
  12. char scacchiera[30][30]=
  13.                       {{'_',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  14.                        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  15.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  16.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  17.                        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  18.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  19.                        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  20.                        {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  21.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  22.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  23.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  24.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  25.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  26.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  27.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  28.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  29.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  30.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  31.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  32.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  33.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  34.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  35.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  36.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  37.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  38.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  39.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  40.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  41.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  42.                            {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-'}};
  43. int i,x1,y1,x2,y2,cammino_totale=0;
  44. pedina p1,p2;
  45. for (i=0;i<10;i++)
  46. {
  47.         p1=scacchiera[x1][y1];
  48.         p2=scacchiera[x2][y2];
  49.         cammino_totale=cammino(scacchiera,&p1,&p2);
  50.         printf("Cammino terminato\nNumero di passi eseguiti: %d\nEsecuzioni rimanenti: %d\n",cammino_totale,9-i);
  51. }
  52. }
  53.  
  54.  
  55. int cammino(char scacchiera[][30],pedina *p1,pedina *p2)
  56. {
  57. int cammino_totale=0;
  58. int x1=0,y1=0,x2=29,y2=29;
  59. srand(time(NULL));
  60. while (x1!=x2 && y1!=y2)
  61. {
  62.         passo_casuale(scacchiera,&p1,&p2,&x1,&y1,&x2,&y2);
  63.         cammino_totale++;
  64. }
  65. return cammino_totale;
  66. }
  67.  
  68. void passo_casuale(char scacchiera[][30],pedina *p1, pedina *p2,int *x1,int *y1,int *x2,int *y2)
  69. {
  70. int pass1,pass2;
  71. pass1=rand()%4;
  72. pass2=rand()%4;
  73. if (pass1==0)
  74. {
  75.         if (*y1==29)
  76.         {
  77.                 *y1=0;
  78.                 *p1=scacchiera[*x1][*y1];
  79.         }
  80.         else
  81.         {
  82.         y1++;
  83.         *p1=scacchiera[*x1][*y1];
  84.         }
  85. }
  86. if (pass1==1)
  87. {
  88.         if (*y1==0)
  89.         {
  90.                 *y1=29;
  91.                 *p1=scacchiera[*x1][*y1];
  92.         }
  93.         else
  94.         {
  95.         y1--;
  96.         *p1=scacchiera[*x1][*y1];
  97.         }
  98. }
  99. if (pass1==2)
  100. {
  101.         if (*x1==29)
  102.         {
  103.                 *x1=0;
  104.                 *p1=scacchiera[*x1][*y1];
  105.         }
  106.         else
  107.         {
  108.         x1++;
  109.         *p1=scacchiera[*x1][*y1];
  110.         }
  111. }
  112. if (pass1==3)
  113. {
  114.         if (*x1==0)
  115.         {
  116.                 *x1=29;
  117.                 *p1=scacchiera[*x1][*y1];
  118.         }
  119.         else
  120.         {
  121.         x1--;
  122.         *p1=scacchiera[*x1][*y1];
  123.         }
  124. }
  125. if (pass2==0)
  126. {
  127.         if (*y2==29)
  128.         {
  129.                 *y2=0;
  130.                 *p2=scacchiera[*x2][*y2];
  131.         }
  132.         else
  133.         {
  134.         y2++;
  135.         *p2=scacchiera[*x2][*y2];
  136.         }
  137. }
  138. if (pass2==1)
  139. {
  140.         if (*y2==0)
  141.         {
  142.                 *y2=29;
  143.                 *p2=scacchiera[*x2][*y2];
  144.         }
  145.         else
  146.         {
  147.         y2--;
  148.         *p2=scacchiera[*x2][*y2];
  149.         }
  150. }
  151. if (pass2==2)
  152. {
  153.         if
  154.         (*x2==29)
  155.         {
  156.                 *x2=0;
  157.                 *p2=scacchiera[*x2][*y2];
  158.         }
  159.         else
  160.         {
  161.         x2++;
  162.         *p2=scacchiera[*x2][*y2];
  163.         }
  164. }
  165. if (pass2==3)
  166. {
  167.         if (*x2==0)
  168.         {
  169.                 *x2=29;
  170.                 *p2=scacchiera[*x2][*y2];
  171.         }
  172.         else
  173.         {
  174.         x2--;
  175.         *p2=scacchiera[*x2][*y2];
  176.         }
  177. }
  178. }


Ora finalmente l'algoritmo si esegue, ma non funziona bene. Come numero di passi delle pedine eseguiti prima che esse cerchino di andare sulla stessa casella riporta sempre 1,2 o al massimo 3 (il che capirai che è un po' improbabile), e il numero di passi totali è uguale per ogni esecuzione (mi spiego meglio: il main richiama la function per 10 volte e, quando eseguo l'algoritmo, mi restituisce che per tutte le 10 esecuzioni della function cammino() i passi totali sono stati 1 -o 2 o 3, a volte cambia-). L'unica cosa che mi viene in mente per questo problema è un errore nell'implementazione delle rand()%4, ma non riesco a capire come risolvere..

PM Quote
Avatar
Template (Member)
Pro


Messaggi: 177
Iscritto: 09/12/2015

Segnala al moderatore
Postato alle 9:15
Venerdì, 19/02/2016
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ì:

Codice sorgente - presumibilmente Plain Text
  1. 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ì:

Codice sorgente - presumibilmente Plain Text
  1. pass1 = (rand() + *x1) % 4;
  2.         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 ;)

Ultima modifica effettuata da Template il 19/02/2016 alle 9:16
PM Quote
Avatar
torn24 (Normal User)
Pro


Messaggi: 156
Iscritto: 04/01/2008

Segnala al moderatore
Postato alle 9:39
Venerdì, 19/02/2016
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 ??

PM Quote
Avatar
luibo (Normal User)
Newbie


Messaggi: 12
Iscritto: 18/02/2016

Segnala al moderatore
Postato alle 12:28
Venerdì, 19/02/2016
Testo quotato
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
Codice sorgente - presumibilmente C/C++
  1. if (*y1==29)
  2.         {
  3.                 *y1=0;
  4.                 *p1=scacchiera[*x1][*y1];
  5.         }

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)

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