Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

#include<stdio.h> int positiviIntorno (int r, int c, int m[r][c],int i,int j) { int…

  1. 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?

  2. 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 malloc invece 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 i e j

    Nel tuo primo codice, dichiari le variabili i e j all'inizio di main, ma poi le riassegni all'interno dei cicli for. 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 main se non necessario. Nell'esempio sopra, ho usato variabili come x e y per 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 -O3 se 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!