[C] Matrice con numeri adiacenti

[trek]

ciao a tutti,
mi potreste dire per prima cosa dove posso trovare problemi sulla matrici implementati in c, e anche un libro di C con molti esercizi (magari anche guidati) facile da capire e ben strutturato?? Io ho: linguaggio C++ (dagli algoritmi alla programmazione orientata ad oggetti) della petrini ma secondo me non è ben strutturato.

e poi volevo chiedervi una cosa..
devo fare un programmino in C che risolva questo problema.

Creata una matrice 10*10 compresi tra 1 e 99 introdurre in input la posizione di una cella
e dire quanti tra i valori delle celle adiacenti sono pari e quanti dispari.
Ora ho creato la matrice ma non mi dice il numero esatto dei numeri pari e di quelli dispari. E poi non capisco perchè si ha bisogno di tre coppie cicli (VEDI UNO DUE E TRE).


Io avrei creato un programma che facesse una cosa simile :

Chiedeva la posizione del numero che volevo verificare. es

12 15 16 49 78
48 78 56 14 74
36 12 47 99 41

che posizione vuoi verificare?
colonna riga
[2] [1]

i numeri adiacenti al 56 sono:
16 49 14 99 47 12 78 15
i pari sono 3
i dispari sono 3

sapendo la posizione del numero del quale voglio sapere i numeri adiacenti es
[2][1] avrei fatto un ciclo for che controlli i tre numeri sopra, quello detro, quello sinistro e i 3 in basso. Tutto questo pero non so come farlo.. e poi vorrei anche che se inserito la posizione di un numero posizionato negli angoli dia un messaggio di errore.




[code]


#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define riga 10
#define colonna 10

int main()
{
srand(time(NULL));
int i,j,ri,co;
int mat[riga][colonna];
int massimo,minimo,totp,totd,ris;
int risp;
massimo=99;
minimo=0;
totp=0;
totd=0;

for (i=0;i<riga;i++)
{
for(j=0;j<colonna;j++)
{
mat[i][j]= (rand()%(massimo-minimo))+minimo;
}
}

for(i=0;i<riga;i++)
{
for(j=0;j<colonna;j++)
{
printf("%d \t",mat[i][j]);
}
printf("\n");
}

do
{
printf("\n**** inserire la posizione della cella ****\n");

printf("\n inserisci la riga\n");
scanf("\n%d",&ri);

printf("\n inserisci la colonna\n");
scanf("\n%d",&co);

if(ri<10 && co<10) 1 // DA QUA NON CAPISCO PIù LA LOGICA

{
for (i=ri-1;i<ri+2;i++)
{
for (j=co-1;j<co+2;j++)
{
if(!(i==ri && j==co))
{
ris=mat[i][j]%2;

if(ris==0)
{
totp=totp+1;
}
else if (ris!=0)
{
totd=totd+1;
}
}
}
}

for (i=ri;i<ri;i++) //2
{
for (j=co;j<co;j++)
{
ris=mat[i][j]%2;

if(ris==0)
{
totp=totp+1;
}
else if (ris!=0)
{
totd=totd+1;
}
}
}

for (i=ri+1;i<ri+1;i++) //3
{
for (j=co+1;j<co+1;j++)
{
ris=mat[i][j]%2;

if(ris==0)
{
totp=totp+1;
}
else if (ris!=0)
{
totd=totd+1;
}
}
}

}

printf("\nI numeri pari sono\t%d",totp);
printf("\n");

printf("\nI numeri dispari sono\t%d",totd);
printf("\n");

printf("vuoi continuare? 0=si 1=no");
scanf("%d",&risp);
}
while(risp!=1);


system("pause");
}

spero di essere stato più chiaro possibile. grazie del vostro interessamento!

[trek]

 
#include <stdio.h> 
#include <time.h> 
#include <stdlib.h>  
#define riga 10 
#define colonna 10

int main() 
{ 
    srand(time(NULL)); 
    int i,j,ri,co;
    int mat[riga][colonna]; 
    int massimo,minimo,totp,totd,ris;  
    int risp;
    massimo=99; 
    minimo=0;  
    totp=0; 
    totd=0;
     
        for (i=0;i<riga;i++) 
    { 
        for(j=0;j<colonna;j++) 
        { 
                            mat[i][j]= (rand()%(massimo-minimo))+minimo; 
        } 
    } 
    
    for(i=0;i<riga;i++) 
    { 
        for(j=0;j<colonna;j++) 
        {    
        printf("%d \t",mat[i][j]); 
    } 
    printf("\n"); 
}               

         do 
         {
         printf("\n**** inserire la posizione della cella ****\n"); 
                  
         printf("\n inserisci la riga\n"); 
         scanf("\n%d",&ri); 
                  
         printf("\n inserisci la colonna\n"); 
         scanf("\n%d",&co);
                     
             if(ri<10 && co<10)
             { 
                for (i=ri-1;i<ri+2;i++)
                {
                   for (j=co-1;j<co+2;j++)
                   {
                       if(!(i==ri && j==co))
                       {
                   ris=mat[i][j]%2;
                         
                        if(ris==0)
                        {
                         totp=totp+1;
                        }
                           else if (ris!=0)
                           {
                           totd=totd+1;          
                           }
                           }
                    }
                }   
                       
                                   for (i=ri;i<ri;i++)
                {
                   for (j=co;j<co;j++)
                   {
                   ris=mat[i][j]%2;
                         
                        if(ris==0)
                        {
                         totp=totp+1;
                        }
                           else if (ris!=0)
                           {
                           totd=totd+1;          
                           }
                    }
                } 
                
                                for (i=ri+1;i<ri+1;i++)
                {
                   for (j=co+1;j<co+1;j++)
                   {
                   ris=mat[i][j]%2;
                         
                        if(ris==0)
                        {
                         totp=totp+1;
                        }
                           else if (ris!=0)
                           {
                           totd=totd+1;          
                           }
                    }
                }
                      
                      }                
                             
                  printf("\nI numeri pari sono\t%d",totp);
                  printf("\n");
                  
                  printf("\nI numeri dispari sono\t%d",totd);
                  printf("\n"); 
                           
                  printf("vuoi continuare? 0=si 1=no"); 
                  scanf("%d",&risp);
         } 
         while(risp!=1);
                      

system("pause"); 
}

cosi capite meglio!!! scusate!

[Vincenzo1968]

Ciao trek,

nel codice seguente, la funzione "LeggiAdiacenti", accetta i seguenti parametri :
1 - Puntatore alla matrice di interi
2 - Puntatore alla struct "Adiacenti" che contiene un int che rappresenta il numero stesso e un bool che ci dice se il numero è pari o dispari
3 - Puntatore alla struct Totali che contiene i campi per il conteggio dei numeri dispari e pari
4 - Indice della riga
5 - Indice della colonna
6 - Totale delle righe
7 - totale della colonne

Se prendiamo ad esempio la matrice da te indicata:

12 15 16 49 78
48 78 56 14 74
36 12 47 99 41

chiamando la funzione così:

LeggiAdiacenti((int**)pMat, aAd, &Tot, 1, 2, 3, 5);

otteniamo il seguente risultato:


Totale numeri dispari : 4
Totale numeri pari : 4

numeri pari:
16 14 12 78

numeri dispari:
15 49 99 47



se invece chiamiamo la funzione così:

LeggiAdiacenti((int**)pMat, aAd, &Tot, 0, 0, 3, 5);

otteniamo:


Totale numeri pari : 2
Totale numeri dispari : 1

numeri pari :
78 48

numeri dispari :
15

#include <stdio.h>
#include <stdlib.h>

typedef struct tagAdiacenti
{
	int  nNum;
	bool bPari;
} Adiacenti;

typedef struct tagTotali
{
	int nTotPari;
	int nTotDispari;
	int nTotale;
} Totali;


// 12 15 16 49 78 
// 48 78 56 14 74 
// 36 12 47 99 41 


void LeggiAdiacenti(int **pMat, Adiacenti *pAdiacenti, Totali * pTot, int Riga, int Colonna, int Righe, int Colonne)
{
	div_t dt;
	
	if ( (Riga < 0) || (Riga >= Righe) )
	{
		printf("Indice riga fuori dai limiti\n");
		return;
	}

	if ( (Colonna < 0) || (Colonna >= Colonne) )
	{
		printf("Indice colonna fuori dai limiti\n");
		return;
	}

	for (int i = 0; i < 8; i++)
	{
		pAdiacenti[i].nNum = -1;
		pAdiacenti[i].bPari = false;
	}


	pTot->nTotPari = 0;
	pTot->nTotDispari = 0;
	pTot->nTotale = 0;


	if ( Riga > 0 )
	{
		if ( Colonna > 0 )
		{
			pAdiacenti[0].nNum = pMat[Riga-1][Colonna-1];
			pTot->nTotale++;
			dt = div(pAdiacenti[0].nNum, 2);
			if ( dt.rem == 0 )
			{
				pAdiacenti[0].bPari = true;
				pTot->nTotPari++;
			}
			else
			{
				pTot->nTotDispari++;
			}
		}

		pAdiacenti[1].nNum = pMat[Riga-1][Colonna];
		pTot->nTotale++;
		dt = div(pAdiacenti[1].nNum, 2);
		if ( dt.rem == 0 )
		{
			pAdiacenti[1].bPari = true;
			pTot->nTotPari++;
		}

		if ( Colonna < Colonne - 1)
		{
			pAdiacenti[2].nNum = pMat[Riga-1][Colonna+1];
			pTot->nTotale++;
			dt = div(pAdiacenti[2].nNum, 2);
			if ( dt.rem == 0 )
			{
				pAdiacenti[2].bPari = true;
				pTot->nTotPari++;
			}
			else
			{
				pTot->nTotDispari++;
			}
		}
	}

	if ( Colonna < Colonne - 1)
	{
		pAdiacenti[3].nNum = pMat[Riga][Colonna+1];
		pTot->nTotale++;
		dt = div(pAdiacenti[3].nNum, 2);
		if ( dt.rem == 0 )
		{
			pAdiacenti[3].bPari = true;
			pTot->nTotPari++;
		}
		else
		{
			pTot->nTotDispari++;
		}
	}

	if ( Riga < Righe - 1 )
	{
		if ( Colonna < Colonne - 1 )
		{
			pAdiacenti[4].nNum = pMat[Riga+1][Colonna+1];
			pTot->nTotale++;
			dt = div(pAdiacenti[4].nNum, 2);
			if ( dt.rem == 0 )
			{
				pAdiacenti[4].bPari = true;
				pTot->nTotPari++;
			}
			else
			{
				pTot->nTotDispari++;
			}
		}

		pAdiacenti[5].nNum = pMat[Riga+1][Colonna];
		pTot->nTotale++;
		dt = div(pAdiacenti[5].nNum, 2);
		if ( dt.rem == 0 )
		{
			pAdiacenti[5].bPari = true;
			pTot->nTotPari++;
		}
		else
		{
			pTot->nTotDispari++;
		}

		if ( Colonna > 0 )
		{
			pAdiacenti[6].nNum = pMat[Riga+1][Colonna-1];
			pTot->nTotale++;
			dt = div(pAdiacenti[6].nNum, 2);
			if ( dt.rem == 0 )
			{
				pAdiacenti[6].bPari = true;
				pTot->nTotPari++;
			}
			else
			{
				pTot->nTotDispari++;
			}
		}
	}

	if ( Colonna > 0 )
	{
		pAdiacenti[7].nNum = pMat[Riga][Colonna - 1];
		pTot->nTotale++;
		dt = div(pAdiacenti[7].nNum, 2);
		if ( dt.rem == 0 )
		{
			pAdiacenti[7].bPari = true;
			pTot->nTotPari++;
		}
		else
		{
			pTot->nTotDispari++;
		}
	}
}

int main(int argc, char* argv[])
{
	int nRighe = 3;
	int nColonne = 5;

	Adiacenti aAd[8];

	int **pMat;

	Totali Tot;

	// allochiamo lo spazio per le righe della matrice
	pMat = (int**)malloc(nRighe * sizeof(int*));

	//allochiamo lo spazio per le colonne della matrice
	for ( int y = 0; y < nRighe; y++ )
		pMat[y] = (int*)malloc(nColonne * sizeof(int));


	pMat[0][0] = 12;
	pMat[0][1] = 15;
	pMat[0][2] = 16;
	pMat[0][3] = 49;
	pMat[0][4] = 78;

	pMat[1][0] = 48;
	pMat[1][1] = 78;
	pMat[1][2] = 56;
	pMat[1][3] = 14;
	pMat[1][4] = 74;

	pMat[2][0] = 36;
	pMat[2][1] = 12;
	pMat[2][2] = 47;
	pMat[2][3] = 99;
	pMat[2][4] = 41;


	//LeggiAdiacenti((int**)pMat, aAd, &Tot, 1, 2, 3, 5);
	LeggiAdiacenti((int**)pMat, aAd, &Tot, 0, 0, 3, 5);


	int i;

	printf("Totale numeri pari : %d\nTotale numeri dispari : %d\n\n", Tot.nTotPari, Tot.nTotDispari);

	// stampa i numeri pari
	printf("numeri pari:\n");
	for(i = 0; i < 8; i++)
		if ( (aAd[i].nNum != -1) && (aAd[i].bPari) )
			printf("%d ", aAd[i].nNum);

	// stampa i numeri pari
	printf("\n\nnumeri dispari:\n");
	for(i = 0; i < 8; i++)
		if ( (aAd[i].nNum != -1) && (!aAd[i].bPari) )
			printf("%d ", aAd[i].nNum);


	// Deallochiamo
	for (int k = 0; k < nRighe; k++)
		free(pMat[k]);
	free(pMat);


	return 0;
}