#include<stdio.h> int positiviIntorno (int r, int c, int m[r][c],int i,int j) { int…
- User
#include<stdio.h>
int positiviIntorno (int r, int c, int m[r][c],int i,int j) {
int numeroCelleJpos=0;
for(int h=i-1;h<=i+1;h++) { for(int k=j-1;k<=j+1;k++) { if((h>=0 && h<r) && (k>=0 && k<c) && (h!=i || k!=j) && m[h][k]>0) { numeroCelleJpos++; } } }
return numeroCelleJpos;
}
int main() {
int rig,col; int i,j;
printf("inserisci le dimensioni della matrice: \n"); scanf("%d%d",&rig,&col);
int mat[rig][col];
printf("inserisci gli elementi della matrice:\n");
for(int i=0;i<rig;i++) { for(int j=0;j<col;j++) { printf("inserisci l' elemento di posizione [%d][%d]: \n",i,j); scanf("%d",&mat[i][j]); } }
printf("inserisci i due indici (di riga e colonna)\n"); scanf("%d%d",&i,&j);
printf("la matrice inserita e' \n:");
for(int i=0;i<rig;i++) { for(int j=0;j<col;j++) { printf("%d ",mat[i][j]);
} printf("\n");}
int num=positiviIntorno(rig,col,mat,i,j); printf("il numero di elementi positivi adiacenti a %d, %d e' %d ",i,j,num);
} perche questo quando lo compilo ci mette tanto tempo #include <stdio.h>
int positiviIntorno(int r, int c, int m[r][c], int i, int j) { int numeroCelleJpos = 0;
// Scorrere le celle intorno alla posizione (i, j) for (int h = i - 1; h <= i + 1; h++) { for (int k = j - 1; k <= j + 1; k++) { if ((h >= 0 && h < r) && (k >= 0 && k < c) && (h != i || k != j) && m[h][k] > 0) { numeroCelleJpos++; // Conta solo i valori positivi } } } return numeroCelleJpos;}
int main() { int rig, col, i, j;
// Input delle dimensioni della matrice printf("Inserisci le dimensioni della matrice (righe e colonne): \n"); scanf("%d%d", &rig, &col); int mat[rig][col]; // Input degli elementi della matrice printf("Inserisci gli elementi della matrice:\n"); for (int i = 0; i < rig; i++) { for (int j = 0; j < col; j++) { printf("Inserisci l'elemento di posizione [%d][%d]: \n", i, j); scanf("%d", &mat[i][j]); } } // Mostra la matrice inserita printf("La matrice inserita è:\n"); for (int i = 0; i < rig; i++) { for (int j = 0; j < col; j++) { printf("%d ", mat[i][j]); } printf("\n"); } // Input degli indici di riga e colonna per controllare gli adiacenti printf("Inserisci i due indici (di riga e colonna):\n"); scanf("%d%d", &i, &j); // Verifica se gli indici sono validi if (i < 0 || i >= rig || j < 0 || j >= col) { printf("Errore: Indici fuori dal range della matrice!\n"); return 1; } // Calcolo degli elementi positivi adiacenti int num = positiviIntorno(rig, col, mat, i, j); printf("Il numero di elementi positivi adiacenti a [%d, %d] è: %d\n", i, j, num); return 0;} e questo pocshissimo?
- Assistant
Il problema che stai riscontrando potrebbe dipendere da diversi fattori legati al modo in cui il codice utilizza le matrici a lunghezza variabile (Variable Length Arrays, VLA) e da come il compilatore gestisce tali strutture. Di seguito ti fornisco una panoramica delle potenziali cause e alcune soluzioni per risolvere il problema.
1. Uso delle Matrici a Lunghezza Variabile (VLA)
Nel tuo codice, stai utilizzando matrici a lunghezza variabile, definite come
int mat[rig][col];. Anche se i VLA sono supportati da C99 e versioni successive dello standard C, non tutti i compilatori li gestiscono in modo efficiente, specialmente se le dimensioni sono molto grandi. Questo potrebbe causare un tempo di compilazione elevato o altri problemi.Soluzione: Considera l'uso di allocazione dinamica della memoria tramite
mallocinvece delle VLA. Questo approccio è più flessibile e generalmente più supportato dai compilatori.Ecco come puoi riscrivere il tuo programma utilizzando l'allocazione dinamica:
#include <stdio.h> #include <stdlib.h> // Funzione per contare i numeri positivi intorno a (i, j) int positiviIntorno(int r, int c, int **m, int i, int j) { int numeroCelleJpos = 0; for (int h = i - 1; h <= i + 1; h++) { for (int k = j - 1; k <= j + 1; k++) { if ((h >= 0 && h < r) && (k >= 0 && k < c) && !(h == i && k == j) && m[h][k] > 0) { numeroCelleJpos++; } } } return numeroCelleJpos; } int main() { int rig, col, i, j; // Input delle dimensioni della matrice printf("Inserisci le dimensioni della matrice (righe e colonne): \n"); if (scanf("%d%d", &rig, &col) != 2 || rig <= 0 || col <= 0) { printf("Errore nell'inserimento delle dimensioni.\n"); return 1; } // Allocazione dinamica della matrice int **mat = malloc(rig * sizeof(int *)); if (mat == NULL) { printf("Errore di allocazione della memoria.\n"); return 1; } for (int x = 0; x < rig; x++) { mat[x] = malloc(col * sizeof(int)); if (mat[x] == NULL) { printf("Errore di allocazione della memoria.\n"); // Libera la memoria già allocata prima di uscire for (int y = 0; y < x; y++) { free(mat[y]); } free(mat); return 1; } } // Input degli elementi della matrice printf("Inserisci gli elementi della matrice:\n"); for (int x = 0; x < rig; x++) { for (int y = 0; y < col; y++) { printf("Inserisci l'elemento di posizione [%d][%d]: ", x, y); if (scanf("%d", &mat[x][y]) != 1) { printf("Errore nell'inserimento degli elementi.\n"); // Libera tutta la memoria allocata prima di uscire for (int z = 0; z < rig; z++) { free(mat[z]); } free(mat); return 1; } } } // Stampa della matrice printf("La matrice inserita è:\n"); for (int x = 0; x < rig; x++) { for (int y = 0; y < col; y++) { printf("%d ", mat[x][y]); } printf("\n"); } // Input degli indici di riga e colonna printf("Inserisci i due indici (di riga e colonna):\n"); if (scanf("%d%d", &i, &j) != 2) { printf("Errore nell'inserimento degli indici.\n"); // Libera tutta la memoria allocata prima di uscire for (int z = 0; z < rig; z++) { free(mat[z]); } free(mat); return 1; } // Verifica degli indici if (i < 0 || i >= rig || j < 0 || j >= col) { printf("Errore: Indici fuori dal range della matrice!\n"); } else { // Calcolo degli elementi positivi adiacenti int num = positiviIntorno(rig, col, mat, i, j); printf("Il numero di elementi positivi adiacenti a [%d, %d] è: %d\n", i, j, num); } // Deallocazione della memoria for (int x = 0; x < rig; x++) { free(mat[x]); } free(mat); return 0; }2. Shadowing delle Variabili
iejNel tuo primo codice, dichiari le variabili
iejall'inizio dimain, ma poi le riassegni all'interno dei ciclifor. Questo shadowing non causa problemi di compilazione, ma può rendere il codice meno leggibile e potenzialmente introdurre errori logici.Soluzione: Utilizza nomi di variabili differenti all'interno dei cicli o evita di dichiararle all'inizio di
mainse non necessario. Nell'esempio sopra, ho usato variabili comexeyper evitare confusione.3. Verifica degli Input
Assicurati sempre di verificare gli input dell'utente per evitare situazioni in cui il programma si comporta in modo imprevedibile, inclusi valori fuori dal range o input non validi.
4. Ottimizzazione del Codice
Il secondo frammento di codice che hai fornito include una verifica degli indici prima di chiamare la funzione
positiviIntorno. Questo è una buona pratica e può prevenire comportamenti indesiderati, ma non dovrebbe influenzare significativamente il tempo di compilazione. Assicurati sempre di includere queste verifiche per migliorare la robustezza del tuo programma.5. Configurazione del Compilatore
Se continui a riscontrare tempi di compilazione elevati, potrebbe essere utile:
- Aggiornare il compilatore all'ultima versione disponibile.
- Controllare le impostazioni del compilatore per ottimizzazioni non necessarie che potrebbero rallentare la compilazione (ad esempio, evitare flag come
-O3se non necessari). - Compilare il codice in modo semplice per diagnosticare se il problema persiste. Ad esempio:
gcc -std=c99 -o programma programma.c
Conclusione
Entrambi i frammenti di codice che hai fornito sono simili e dovrebbero compilare rapidamente su compilatori moderni. Tuttavia, l'uso delle matrici a lunghezza variabile può introdurre complessità extra. Utilizzare l'allocazione dinamica della memoria può rendere il tuo programma più robusto e compatibile. Inoltre, assicurati di seguire buone pratiche di programmazione, come la verifica degli input e la gestione corretta delle risorse.
Se dopo aver implementato queste modifiche il problema persiste, ti consiglio di fornire ulteriori dettagli sul compilatore utilizzato, i flag di compilazione e qualsiasi messaggio di errore o comportamento specifico che osservi.
Buona programmazione!
Nota: Ricorda sempre di liberare la memoria allocata dinamicamente per evitare memory leaks e altri problemi di gestione della memoria.
Buona fortuna!