aiuto programma c++!

[dev85]

Salve a tutti, innanzitutto mi presento, mi chiamo Davide e sono un programmatore alle prime armi..mi ritrovo alle prese con un programma che qui di seguito espongo:

Scrivere un programma in linguaggio C che dopo aver acquisito da tastiera una matrice A di interi verifichi, per ogni elemento a[i][j], se è un divisore della somma s degli elementi ad esso adiacenti e, in caso affermativo, sostituisca a[i][j] con s/a[i][j]. La scansione della matrice deve quindi continuare nell'ordine stabilito e ripartire dall'inizio finchè nessun elemento verifichi la condizione sopra detta o comunque dopo un fissato numero massimo di iterazioni. Si visualizzi, ad ogni sostituzione, la matrice come risulta prima e dopo la sostituzione stessa.

Sono riuscito ad elaborare il seguente codice:

#include <stdio.h>
# define nmax 10
# define mmax 10
void visualizza(int[][mmax],int,int);
void carica(int[][mmax],int *,int *);
void calcola_somma(int[][mmax],int,int,int [][mmax]);
int calcola_somma_up(int v[][mmax],int,int,int,int);
int calcola_somma_down(int v[][mmax],int,int,int,int);
int calcola_somma_left(int v[][mmax],int,int,int,int);
int calcola_somma_right(int v[][mmax],int,int,int,int);
void confronto(int[][mmax],int[][mmax],int,int);
int main(){
int v[nmax][mmax];
int n,m,s,p[nmax][mmax];
carica(v,&n,&m);
visualizza(v,n,m);
calcola_somma(v,n,m,p);
confronto(v,p,n,m);
getchar();
getchar();
}
void carica(int v[][mmax],int *n,int *m){ //caricamento matrice
int i,j;
do{
printf("\ninserisci numero righe: ");
scanf("%d",n);
}while(*n<=0 || *n>nmax);
do{
printf("\ninserisci numero colonne: ");
scanf("%d",m);
}while(*m<=0 || *m>mmax);
for(i=0;i<*n;i++)
for(j=0;j<*m;j++){
printf("\ninserisci matrice[%d][%d]: ",i,j);
scanf("%d",&v[i][j]);}
}
void visualizza(int v[][mmax],int n,int m){ //visualizzazione matrice
int i,j;
printf("\n\n");
for(i=0;i<n;i++){
printf("\n");
for(j=0;j<m;j++)
printf("%4d",v[i][j]);
}
}
void confronto(int v[][mmax], int p[][mmax],int n,int m){
int i,j,k=0;
for(i=0;i<n;i++){
for(j=0;j<m;j++)
if(p[i][j]%v[i][j]==0){
k++;
printf("\n\nmatrice prima della %d^ sostituzione:",k);
visualizza(v,n,m); //matrice prima della sostituzione
printf("\n\n");
v[i][j]=p[i][j]/v[i][j];
printf("matrice dopo la %d^ sostituzione:",k);
visualizza(v,n,m);}} //matrice dopo la sostituzione
confronto(v,p,n,m); //fa ripartire la scansione (e provoca l'errore)
}
int calcola_somma_up(int v[][mmax],int n,int m,int i,int j){ //se i=0
int s;
if(j=0)
s=s+v[i][j+1]+v[i+1][j+1]+v[i+1][j];
if(j=m-1)
s=s+v[i+1][j]+v[i+1][j-1]+v[i][j-1];
if(0<j<m-1)
s=s+v[i][j-1]+v[i+1][j-1]+v[i+1][j]+v[i+1][j+1]+v[i][j+1];
return s;
}
int calcola_somma_down(int v[][mmax],int n,int m,int i,int j){ //se i=n
int s;
if(j=0)
s=s+v[i-1][j]+v[i-1][j+1]+v[i][j+1];
if(j=m-1)
s=s+v[i-1][j]+v[i-1][j-1]+v[i][j-1];
if(0<j<m-1)
s=s+v[i][j+1]+v[i-1][j+1]+v[i-1][j]+v[i-1][j-1]+v[i][j-1];
return s;
}
int calcola_somma_left(int v[][mmax],int n,int m,int i,int j){ //se j=0
int s;
if(i=0)
s=s+v[i][j+1]+v[i+1][j+1]+v[i+1][j];
if(i=n-1)
s=s+v[i-1][j]+v[i-1][j+1]+v[i][j+1];
if(0<i<n-1)
s=s+v[i-1][j]+v[i-1][j+1]+v[i][j+1]+v[i+1][j+1]+v[i+1][j];
return s;
}
int calcola_somma_right(int v[][mmax],int n,int m,int i,int j){ //se j=m
int s;
if(i=0)
s=s+v[i+1][j]+v[i+1][j-1]+v[i][j-1];
if(i=n-1)
s=s+v[i-1][j]+v[i-1][j-1]+v[i][j-1];
if(0<i<n-1)
s=s+v[i-1][j]+v[i-1][j-1]+v[i][j-1]+v[i+1][j-1]+v[i+1][j];
return s;
}
void calcola_somma(int v[][mmax],int n,int m,int p[][mmax]){
int i,j,s;
for(i=0;i<n;i++){
for(j=0;j<m;j++)
s=0;
{if(i=0)
s=calcola_somma_up(v,n,m,i,j);
if(i=n-1)
s=calcola_somma_down(v,n,m,i,j);
if(j=0)
s=calcola_somma_left(v,n,m,i,j);
if(j=m-1)
s=calcola_somma_right(v,n,m,i,j);
else s=s+v[i][j+1]+v[i+1][j+1]+v[i+1][j]+v[i+1][j-1]+v[i][j-1]+v[i-1][j-1]+v[ i-1][j]+v[i-1][j+1];}
p[i][j]=s;}
}


Però quando lo mando in esecuzione non da i risultati giusti, da dei numeri enormi..se non chiedo troppo potrei sapere perchè?
Inoltre non capisco perchè (durante l'esecuzione)quando arriva il momento in cui dovrebbe essere richiamata ricorsivamente la funzione "confronto" appare l'errore di windows..(io uso Dev C++)

Ringrazio anticipatamente chiunque voglia darmi una mano e faccio i miei complimenti per il forum!

[andbin]

Salve a tutti, innanzitutto mi presento, mi chiamo Davide e sono un programmatore alle prime armi..mi ritrovo alle prese con un programma che qui di seguito espongo:

Scrivere un programma in linguaggio C che dopo aver acquisito da tastiera una matrice A di interi verifichi, per ogni elemento a[i][j], se è un divisore della somma s degli elementi ad esso adiacenti e, in caso affermativo, sostituisca a[i][j] con s/a[i][j]. La scansione della matrice deve quindi continuare nell'ordine stabilito e ripartire dall'inizio finchè nessun elemento verifichi la condizione sopra detta o comunque dopo un fissato numero massimo di iterazioni. Si visualizzi, ad ogni sostituzione, la matrice come risulta prima e dopo la sostituzione stessa.

Sono riuscito ad elaborare il seguente codice:
[...]

Però quando lo mando in esecuzione non da i risultati giusti, da dei numeri enormi..se non chiedo troppo potrei sapere perchè?
Inoltre non capisco perchè (durante l'esecuzione)quando arriva il momento in cui dovrebbe essere richiamata ricorsivamente la funzione "confronto" appare l'errore di windows..(io uso Dev C++)

Ringrazio anticipatamente chiunque voglia darmi una mano e faccio i miei complimenti per il forum!Ciao, innanzitutto è bene precisare alcune cose: il tuo programma non è in effetti un programma C++ ma solo "C". Quando posti del codice nel forum, dovresti metterlo all'interno del tag CODE e, cosa molto importante, indentarlo in modo corretto e adeguato per essere più leggibile.

Fatte queste premesse, veniamo al sorgente in questione. Al momento gli ho solo dato una occhiata veloce (non l'ho ancora provato praticamente) ma posso già dirti una cosa. La funzione confronto() è una funzione ricorsiva, perché dal suo interno richiama se stessa.
Il problema è che la ricorsione avviene sempre, cioè non hai gestito alcun test per fare in modo che la ricorsione, in base a qualche condizione, termini ad un certo punto.
Questo vuol dire che quando entri per la prima volta dentro la funzione, non ci uscirai mai più!!! La funzione continuerà all'infinito a richiamare se stessa e questo, prima o poi, dipende dal sistema, causerà uno stack overflow con conseguente crash del programma.

Verifica prima di tutto questa cosa.

[dev85]

Ti ringrazio per la precisa e tempestiva spiegazione!!

Vedrò di impostare una condizione che faccia terminare la ricorsione..

Scusa ma sono nuovo e ancora non conosco bene le regole del forum..

Grazie ancora, più tardi farò sapere come va..

Ciao!!

[dev85]

sono riuscito a risolvere il problema..adesso il programma funziona come voglio io..
però non sono riuscito a trovare una condizione che faccia terminare la ricorsione della funzione confronto..

mi puoi aiutare?

grazie ancora a tutti

[andbin]

sono riuscito a risolvere il problema..adesso il programma funziona come voglio io..
però non sono riuscito a trovare una condizione che faccia terminare la ricorsione della funzione confronto..

mi puoi aiutare?Sì, certamente. Rileggi bene innanzitutto il testo della specifica: ... "e ripartire dall'inizio finchè nessun elemento verifichi la condizione sopra detta" ... ;)

Questo vuol dire che se nel doppio ciclo for annidato non entri almeno 1 volta nel blocco if (quindi quella condizione non si verifica), allora non devi richiamare ricorsivamente la funzione. È facile da fare: usi una variabile che fa da "flag", la metti inizialmente a 0; se entri nel blocco if, la metti a 1. Alla fine, solo se il flag è a 1 devi richiamare la funzione. Il risultato è che se nessun elemento verifica la condizione ... la ricorsione termina.

Comunque, per essere pignoli (e io lo sono ;) ), il problema si può risolvere anche senza l'utilizzo della ricorsione! Nel testo della specifica in effetti non c'è scritto espressamente di usare la ricorsione. :p Quindi non so se ti è stato chiesto di usare la ricorsione o hai voluto utilizzarla tu di proposito.

In genere, se non c'è una necessità specifica, sarebbe meglio non usare la ricorsione, almeno secondo la mia opinione.

[andbin]

È facile da fare: usi una variabile che fa da "flag"Non ci ho pensato subito. :doh: Il flag ce l'hai già in effetti: è la variabile k. Se k è zero, vuol dire che la condizione non si è verificata, quindi niente ricorsione da fare. ;)

[dev85]

ecco qua:


#include <stdio.h>
# define nmax 10
# define mmax 10
void visualizza(int[][mmax],int,int);
void carica(int[][mmax],int *,int *);
void calcola_somma(int[][mmax],int,int,int [][mmax]);
void confronto(int[][mmax],int[][mmax],int,int);
int main(){
int v[nmax][mmax],n,m,s,p[nmax][mmax];
printf("\nPROGRAMMA SOMMA ADIACENZE MATRICE A");
printf("\n___________________________________\n\n\n");
carica(v,&n,&m);
printf("\n\n\nLA MATRICE A INSERITA RISULTA:");
visualizza(v,n,m);
calcola_somma(v,n,m,p);
confronto(v,p,n,m);
getchar();
getchar();
}
void carica(int v[][mmax],int *n,int *m){ //caricamento matrice
int i,j;
do{
printf("\nInserisci il numero delle righe: ");
scanf("%d",n);
}while(*n<=0 || *n>nmax);
do{
printf("\nInserisci il numero delle colonne: ");
scanf("%d",m);
}while(*m<=0 || *m>mmax);
printf("\n\nINSERIMENTO ELEMENTI DI A:\n\n");
for(i=0;i<*n;i++)
for(j=0;j<*m;j++){
printf("\nInserisci elemento[%d][%d]: ",i,j);
scanf("%d",&v[i][j]);}
}
void visualizza(int v[][mmax],int n,int m){ //visualizzazione matrice
int i,j;
printf("\n\n");
for(i=0;i<n;i++){
printf("\n");
for(j=0;j<m;j++)
printf("%4d",v[i][j]);
}
}
void confronto(int v[][mmax], int p[][mmax],int n,int m){
int i,j,k=0; //confronta le due matrici
for(i=0;i<n;i++){ //e sostituisce dove necessario
for(j=0;j<m;j++)
if((p[i][j])%(v[i][j])==0){
k++;
printf("\n\n\nMatrice A prima della %d^ sostituzione:",k);
visualizza(v,n,m); //matrice prima della sostituzione
printf("\n\n");
v[i][j]=(p[i][j])/(v[i][j]);
printf("\nMatrice A dopo la %d^ sostituzione:",k);
visualizza(v,n,m);}} //matrice dopo la sostituzione
(***)
}
void calcola_somma(int v[][mmax],int n,int m,int p[][mmax]){
int i,j,s; //calcola le somme delle adiacenze
for(i=0;i<n;i++){ //e le memorizza nella matrice p
for(j=0;j<m;j++){
if(i==0 && j==0){ //primo elemento prima riga
s=v[i+1][j+1]+v[i][j+1]+v[i+1][j];
p[i][j]=s;}
else
if(i==0 && j==m-1){ //ultimo elemento prima riga
s=v[i][j-1]+v[i+1][j-1]+v[i+1][j];
p[i][j]=s;}
else
if(i==n-1 && j==0){ //primo elemento ultima riga
s=v[i-1][j]+v[i-1][j+1]+v[i][j+1];
p[i][j]=s;}
else
if(i==n-1 && j==m-1){ //ultimo elemento ultima riga
s=v[i-1][j-1]+v[i][j-1]+v[i-1][j];
p[i][j]=s;}
else
if(j==0 && 0<i<n-1){ //elementi centrali prima colonna
s=v[i-1][j]+v[i-1][j+1]+v[i][j+1]+v[i+1][j+1]+v[i+1][j];
p[i][j]=s;}
else
if(j==m-1 && 0<i<n-1){ //elementi centrali ultima colonna
s=v[i-1][j]+v[i-1][j-1]+v[i][j-1]+v[i+1][j-1]+v[i+1][j];
p[i][j]=s;}
else
if(i==0 && 0<j<m-1){ //elementi centrali prima riga
s=v[i][j-1]+v[i+1][j-1]+v[i+1][j]+v[i+1][j+1]+v[i][j+1];
p[i][j]=s;}
else
if(i==n-1 && 0<j<m-1){ //elementi centrali ultima riga
s=v[i][j+1]+v[i-1][j+1]+v[i-1][j]+v[i-1][j-1]+v[i][j-1];
p[i][j]=s;}
else //generico elemento interno (non sul bordo)
{s=v[i][j+1]+v[i+1][j+1]+v[i+1][j]+v[i+1][j-1]+v[i][j-1]+v[i-1][j-1]+v[i-1][j]+v[i-1][j+1];
p[i][j]=s;}}}
}



il programma ora funziona, ma la scansione della matrice viene effettuata una sola volta e non "finchè nessun elemento verifichi la condizione.."
ho provato ad aggiungere

while(k)
confronto(v,p,n,m);

in questo punto (***),ma la ricorsione continua all'infinito.. :muro: :mc:

:help:

[andbin]

ho provato ad aggiungere

while(k)
confronto(v,p,n,m);

in questo punto (***),ma la ricorsione continua all'infinito.. :muro: :mc:No ... come ho già detto, si può fare con e senza ricorsione:

Con ricorsione:
void confronto(int v[][mmax], int p[][mmax],int n,int m) {
int i,j,k=0;

for(i=0;i<n;i++) {
for(j=0;j<m;j++) {
if((p[i][j])%(v[i][j])==0) {
k++;
printf("\n\n\nMatrice A prima della %d^ sostituzione:",k);
visualizza(v,n,m); //matrice prima della sostituzione
printf("\n\n");
v[i][j]=(p[i][j])/(v[i][j]);
printf("\nMatrice A dopo la %d^ sostituzione:",k);
visualizza(v,n,m); //matrice dopo la sostituzione
}
}
}

if (k > 0)
confronto(v,p,n,m);
}

Senza ricorsione:
void confronto(int v[][mmax], int p[][mmax],int n,int m) {
int i,j,k;

do {
k = 0;

for(i=0;i<n;i++) {
for(j=0;j<m;j++) {
if((p[i][j])%(v[i][j])==0) {
k++;
printf("\n\n\nMatrice A prima della %d^ sostituzione:",k);
visualizza(v,n,m); //matrice prima della sostituzione
printf("\n\n");
v[i][j]=(p[i][j])/(v[i][j]);
printf("\nMatrice A dopo la %d^ sostituzione:",k);
visualizza(v,n,m); //matrice dopo la sostituzione
}
}
}
} while (k > 0);
}
E sai già quale è la mia preferita. ;)

[dev85]

Li ho provati entrambi, ma sia nel primo che nel secondo modo esegue all'infinito..
non capisco come mai..
a questo punto non so più che fare..
finirò per lasciarlo com'era prima, cioè fargli eseguire la scansione una sola volta..
:muro: :cry:
ciao e grazie!!!

[andbin]

Li ho provati entrambi, ma sia nel primo che nel secondo modo esegue all'infinito..
non capisco come mai..
a questo punto non so più che fare..Alt!!! ;) Allora bisogna esaminare bene la condizione di test e il calcolo nel blocco if.
Premetto che non mi sono "addentrato" più di tanto nella problematica, a livello matematico, dell'esercizio!

Prendiamo il test:
if((p[i][j])%(v[i][j])==0)tra l'altro puoi togliere le parentesi e farlo diventare:
if(p[i][j]%v[i][j]==0)
perché è la stessa cosa.

In pratica si verifica se p[i][j] è divisibile per v[i][j] (perché il modulo dà un resto di 0). Ammettiamo, come esempio, che inizialmente ci siano i seguenti valori:
p[i][j] = 10 e v[i][j] = 2
p[i][j]=10 % v[i][j]=2 // == 0, entra nel if
v[i][j]=10 / 2 // 5nella successiva elaborazionep[i][j]=10 % v[i][j]=5 // == 0, entra nel if
v[i][j]=10 / 5 // 2nella successiva elaborazione ... si ripete all'infinito. Dipende dai valori!!!

A questo punto, se il calcolo è giusto (cioè è proprio da fare così) è necessario fare qualcos'altro. Ad esempio impostare un limite massimo al numero di elaborazioni. Cioè fare in modo (sia nel caso di ricorsione o meno) che il doppio for venga eseguito al massimo N volte).

Spero di essermi spiegato in modo chiaro. L'entrata nel blocco del if dipende dai valori ma per il tipo di calcolo nel blocco del if, a seconda dei valori si può avere una situazione di ripetizione continua.

bello ... ma che razza di esercizio è?? ;) :D

[andbin]

Non vorrei dire una castroneria (in matematica non sono un guru ;) ) ma se:

A % B == 0
allora è anche sempre vero:
A % (A/B) == 0

Quindi se non si pongono dei limiti sul numero di elaborazioni, basta che la condizione si verifichi almeno 1 volta su una certa cella i,j affinché l'elaborazione si ripeta all'infinito.

Bastonatemi pure se non è giusto. :p

[dev85]

era proprio quello il fatto che faceva ripetere all'infinito..
il testo l'ha scritto un prof di ingegneria.. :tapiro:
adesso l'ho fatto così e funziona!


void confronto(int m1[][mmax], int m2[][mmax],int n,int m,int t){
int i,j,k=0; //confronta le due matrici
t++; //fa terminare la ricorsione
for(i=0;i<n;i++){ //e sostituisce dove necessario
for(j=0;j<m;j++){
if((m2[i][j])%(m1[i][j])==0){
k++;
printf("\n\n\nMatrice A prima della %d^ sostituzione:",k);
visualizza(m1,n,m); //matrice prima della sostituzione
printf("\n\n");
m1[i][j]=(m2[i][j])/(m1[i][j]);
printf("\nMatrice A dopo la %d^ sostituzione:",k);
visualizza(m1,n,m); //matrice dopo la sostituzione
}
}
}
if(k>0 ^ t==3) //3 numero massimo di iterazioni
confronto(m1,m2,n,m,t);
}


con t inizializzato a zero fuori dalla funzione ;)

ti ringrazio per la disponibilità e l'aiuto che mi hai dato,
sei un genio..
ciao alla prossima!!!!
:gluglu: :ops: :ubriachi: :winner: :sborone: :huh:

[andbin]

if(k>0 ^ t==3) //3 numero massimo di iterazioni
Occhio che ^ è l'operatore del "bitwise exclusive OR", non è un operatore logico.
Io personalmente l'avrei scritto:
if (k > 0 && t <= 3)
È anche più semplice da leggere. ;)


ti ringrazio per la disponibilità e l'aiuto che mi hai dato,
sei un genio.. :O