C/C++ - Cammino casuale di una pedina su scacchiera

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?

credo di aver capito cosa vuoi dire:

dovrei passare alla funzione "cammino" semplicemente la dimensione della matrice (ad esempio dichiaro un "int n=30" nel main e poi lo passo alla funzione).
di conseguenza avrei nella mia function "cammino" la dichiarazione della matrice nel modo seguente:

char walk[n][n];

il problema è che il mio prof. ha sempre detto che, in allocazione statica, nella dichiarazione di una matrice il size delle righe e il size colonne deve necessariamente definito attraverso un numero e non una variabile, ad esempio:

Char matrice[30][30] (o come nel mio caso char matrice[N][N] - con #define N 30 -)

e non

char matrice[n][n] (dove n è una variabile int inizializzata a 30).


in effetti dichiariando la matrice all'interno della funzione "cammino" potrei passargli un qualsiasi size alla matrice che preferisco in modo da poter gestire più matrici di diverso size, ma non vorrei che il prof. si incacchiasse su questo. XD

Cmq...l'ulteriore cosa che volevo "aggiustare" era tipo di far visualizzare una sola volta su schermo l'esecuzione del programma ed ad una esecuzione successiva di mostrare per intero le diverse lunghezze di tutti i cammini effettuati (100).

Considerando pero che 100 chiamate sarebbero un tantino troppe, non è che poi diventa un po' un casino mostrare una sfilza di numeri tutti in un botto solo?
In realtà non so nemmeno se è possibile questa mia idea visto che le due pedine devono necessariamente incontrarsi e quindi avrebbero bisogno del loro tempo per farlo...

Mi mancano circa 2 settimane alla consegna dell'esercizio ma c'è da considerare che ho anche la relazione da fare sul progetto.

Se devi dichiarare la matrice con una costante allora dichiara la matrice dentro la funzione con la costante N e festa finita!!! Senza passaggio di parametri ulteriori....

Per quanto riguarda il fatto di visualizzare o no, basta che tu passi alla funzione un parametro int per cui sai che se è 0 non stampa a video niente (basta un if dentro alla funzione) e se invece è uno stampa a video la posizione delle pedine.

ahahahah... le tarantelle!! XD

cmq ho fatto come mi dicevi tu...
ora non so se ho sbagliato io qualcosa o deve andare così inevitabilmente.
in pratica per come ho impostato il codice, la matrice non viene più visualizzata, ovvero visualizzo soltanto le coordinate [x,y] delle pedine (mi riferisco alle chiamate alla function successive alla prima).

il mio discorso era diverso ( o forse nn sono stato io in grado di implementarlo):

volevo far in modo che, una volta eseguita la prima operazione, nell'operazione successiva mi sarebbero comparsi all'istante tutti i cammini delle pedine effettuati (tutte e 100 le lunghezze insieme) e non le coordinate delle pedine per ciascuna chiamata alla function. è impossibile vero?
devo cmq attendere che il predicato del while sia falso (che corrisponde alla collisione delle pedine), che sostanzialmente, nel mio caso, non è una cosa rapida.
è giusta la mia osservazione?

Sinceramente non ho capito nulla, io credevo che tu volessi far si che la funzione possa stampare a video il percorso oppure no.
Questo significa che nel primo caso la funzione non deve stampare la matrice e poi non deve fare la pausa, e questo è possibile.

Precisa meglio di quale iterazione parli
la prima è quella che muove le pedine (ed è quella in cui stampavi la matrice) che è un while
la seconda è un for che gira per un numero N = al numero di esperimenti

Cmq nulla è impossibile in informatica :-)

per farti capire quello che ho combinato ti riposto il codice, sperando di aver inteso quello che mi hai detto tu:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define TRUE 1
#define FALSE 0
#define N 30
#define SU 0
#define GIU 1
#define DESTRA 2
#define SINISTRA 3

struct pedina {
    int x;
    int y;
    char simb;
    } ;

typedef struct pedina Pedina;


void initialize_chess(char [][N],Pedina,Pedina);
void show_chess(char v[][N]);
void movimento_casuale(char [][N],Pedina*);
int cammino(char [][N],int);

void main ()

{

    char walk[N][N]; 
    int n=30; 
    int i, conta_passi;
    for(i=0;i<100;i++)
    {
        conta_passi=cammino(walk,i);
        printf("\n\tCammino terminato!\n\n\tNumero di passi eseguiti: %d\n\n\tChiamate restanti: %d", conta_passi, 99-i);
        printf("\n");
        system("PAUSE");
        system("CLS"); //pulitura schermo
    }


}

int cammino (char walk [][N], int i)
{
    

    //char walk[n][n];
    Pedina p1={0,0,'x'};
    Pedina p2={29,29,'y'};

    int cnt_passi=0; 
    int nPed= TRUE;


    initialize_chess(walk,p1,p2); 
     if(i==0)
    {show_chess(walk); //stampa a video della scacchiera
    printf("\ncoordinate di x: [%d, %d]\n", p1.x,p1.y);
    printf("\ncoordinate di y: [%d, %d]\n", p2.x,p2.y);
    printf("\n");
    system("pause");
    system("cls"); //pulisce lo schermo
    }srand((unsigned)time(0));

    

    while (! ((p1.x == p2.x) && (p1.y == p2.y))){
        system("cls"); //pulitura schermo

        if(nPed){

            movimento_casuale(walk, &p1); 

            nPed=!nPed;
        }
        else{

             movimento_casuale(walk, &p2); 
             nPed=!nPed;

        }

       if(i==0) show_chess(walk);
       else printf("- CAMMINO CASUALE DI UNA PEDINA -\n");
        printf("\ncoordinate di x: [%d, %d]\n", p1.x,p1.y);
        printf("\ncoordinate di y: [%d, %d]\n", p2.x,p2.y);
        //system("PAUSE");

        cnt_passi++; //incremento della variabile 'passi' fintanto che non termina il ciclo while (pedine nella stessa casella)

}return cnt_passi;
}



void movimento_casuale(char walk[][N], Pedina *pawn)
{
    int passo;
    passo=rand()%4;

    
    switch(passo)
    {
        


        case SU:	    if((*pawn).x==0)
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[++(*pawn).x][(*pawn).y]=(*pawn).simb;}
                        else
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[--(*pawn).x][(*pawn).y]=(*pawn).simb;}          break;//pedina verso nord

        


		case GIU:       if((*pawn).x==N-1)
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[--(*pawn).x][(*pawn).y]=(*pawn).simb;}
		                else
		                {walk[(*pawn).x][(*pawn).y]='.'; walk[++(*pawn).x][(*pawn).y]=(*pawn).simb;}          break;//pedina verso sud

        
		case SINISTRA:  if((*pawn).y==0)
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][++(*pawn).y]=(*pawn).simb;}
		                else
		                {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][--(*pawn).y]=(*pawn).simb;}          break;//pedina verso ovest

		
		case DESTRA:	if((*pawn).y==N-1)
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][--(*pawn).y]=(*pawn).simb;}
                        else
                        {walk[(*pawn).x][(*pawn).y]='.'; walk[(*pawn).x][++(*pawn).y]=(*pawn).simb;}          break;//pedina verso est
	}

}



void initialize_chess(char v[][N],Pedina p1, Pedina p2)
{
    int i,j;
    for(i=0;i<N;i++)
    for(j=0;j<N;j++)
    v[i][j]='.';
    v[p1.x][p1.y]=p1.simb; //postazione iniziale della pedina1
    v[p2.x][p2.y]=p2.simb; //postazione iniziale della pedina2
}


void show_chess(char v[][N])
{
    printf("\t- CAMMINO CASUALE DI UNA PEDINA -\n"); //Intestazione del programma
    printf("\n\t");
    int i,j;
    for(i=0;i<N;i++)
    {for(j=0;j<N;j++)
            printf("%c",v[i][j]);
            printf("\n\t");
            }

}

come si può vedere, appena viene eseguito il programma, compare la bellissima matrice con tanto di pedine sopra che si divertono ad andare di qua e di la...
successivamente, ovvero dopo essere terminato il primo cammino, la matrice non c'è più, ma compaiono solo le coordinate di entrambe le pedine che cambiano fino a che non avranno i valori uguali...

secondo te, alla seconda visualizzazione, posso far comparire i risultati di tutti e 100 i cammini (le 100 iterazioni del for) all'istante? senza visualizzare per forza i cammini uno per uno?
è una cosa che si può fare?