[C] matrice superiore

[s_p_81]

ho una matrice 5*5

1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

vorrei fare la somma di tutti i numeri in rosso.....con questo algoritmo riesco a fare la somma solo dell'ultima colonna.

#include <stdio.h>
#include <stdlib.h>
void main() {

int n;
int p;
int numeri_casuali;
int array1[5][5];
int somma1=0;
printf("INSERIRE I VALORI DELLA COLONNA DELLA MATRICE 5*5\n");
for(n=0;n<5;n++){
for(p=1;p<4;p++){
numeri_casuali=rand()%10;
printf("%d ",array1[n][p]);
}
scanf("%d",&array1[n][p]);
somma1=somma1+array1[n][p]; }
printf("la somma sull'ultima colonna della nostra matrice 5*5 e':%d\n",somma1 );
}

[xegallo]

inserire sempre il linguaggio

anche nel titolo

[SnakePlissken]

ho una matrice 5*5

1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

vorrei fare la somma di tutti i numeri in rosso

prova con questo codice:

#include <stdio.h>

int main()  {
    int i, j, d, somma=0, array[5][5];

    printf("\nInserisci i valori della matrice 5*5:\n");
    for(i=0; i<5; i++)  {
        for(j=0; j<5; j++)
            scanf("%d", &array[i][j]);
    }
    d=j=0;
    for (i=0; i<5; i++)  {      // gestisce le righe
        while(j<5)              // gestisce le colonne
            somma += array[i][j++];
        j=(++d);
    }
    printf("\nSomma = %d\n", somma);
    getch();
}

dovrebbe funzionare!

[SnakePlissken]

Quello che avevo scritto prima poteva essere utilizzato per qualsiasi tipo di matrice. questo qua invece solo per quello quadrate:

#include <stdio.h>

#define N 5	// dimensione del lato

int main()  {
    int i, j, somma=0, array[N][N];

    printf("\nInserisci i valori della matrice quadrata %dx%d:\n", N, N);
    for(i=0; i<5; i++)  {
	for(j=0; j<5; j++)
	    scanf("%d", &array[i][j]);
    }

    // calcola la somma
    for(j=0; j<N; j++)  {
	for(i=j; i<N; i++)
	    somma += array[i-j][i];
    }
    printf("\nSomma = %d\n", somma);
    getch();
}

forse è più criptico ma ci risparmia l'uso di una variabile... e puo a me piace complicarmi la vita col C!! :gren:

[s_p_81]

grazie funziona

se vorrei invece fare la somma della 2 riga
e dei 4 angoli
es
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

es
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

[SnakePlissken]

se vorrei invece fare la somma della 2 riga
e dei 4 angoli

innanzitutto guarda che nella protasi va il congiuntivo!!! :quote:

poi.. ma qual è il tuo problema? sono cose così facili?


(non sai proprio niente di C? )

[s_p_81]

somma += array[i-j][i];

xchè fai i-j?

Cmq il prof mi aveva dato un esercizio calcolare la matrice superiore
e poi dopo mi sn nate alcune curiosità.
come la somma dei 4 angoli della matrice,
e come si fa la somma della seconda riga

[andrea_NET-_DSL]

il primo (provali cmq :F)

/*  la somma della n* riga di una matrice quadrata n x n */
#include<stdio.h>

const int n=5;
 
int main(){

int matrix[n][n],i,j;


printf("\nInserisci gli elementi della matrice quadrata %d x %d\n ",n,n);

for(i=0;i<n;i++)
 for(j=0;j<n;j++)
  scanf("%d",&matrix[i][j]);
  
  
/* calcolo somma n* riga * /
printf("\nDi quale riga della matrice vuoi eseguire la sommatoria?\n");
scanf("%d",&i);

int somma=0;
j=0;

while (j<n){
somma += matrix[i][j];
j++;           
	   }

printf("\nSOMMA = %d",somma);
getchar();
return 0;

}

[andrea_NET-_DSL]

IL SECONDO quesito non necessiterebbe di un algortimo e vista la sua semplicità risulta un processo non molto "astratto" e "generico" ... cmq sono arrivato a questa soluzione(provalo ) :

/*  somma dei 4 angoli di una matrice quadrata n x n */
#include<stdio.h>

const int n=5;
 
int main(){

int matrix[n][n],i,j;


printf("\nInserisci gli elementi della matrice quadrata %d x %d\n ",n,n);

for(i=0;i<n;i++)
 for(j=0;j<n;j++)
  scanf("%d",&matrix[i][j]);
  
  
/* calcolo somma 4 angoli di una matrice n*n * /

int somma=0,tmp=0;

i=1; j=1;
while(tmp<2){
somma +=matrix[i][j];
j=n; tmp++;
}

i=n; j=n; tmp=0;
while(tmp<2){
somma +=matrix[i][j];
j=1; tmp++;
}

printf("\nSOMMA = %d",somma);
getchar();
return 0;

}

[SnakePlissken]

somma += array[i-j][i];

xchè fai i-j?

Sfutto una sorta di proprietà delle matrici che mi è venuta in mente osservando le coordinate degli elementi:

[0][0] [0][1] [0][2] [0][3] [0][4]
[1][0] [1][1] [1][2] [1][3] [1][4]
[2][0] [2][1] [2][2] [2][3] [2][4]
[3][0] [3][1] [3][2] [3][3] [3][4]
[4][0] [4][1] [4][2] [4][3] [4][4]

1. Guarda la diagonale principale, gli elementi sono:
[0][0] [1][1] [2][2] [3][3] [4][4]
2. di quella immediatamente sopra sono:
[0][1] [1][2] [2][3] [3][4]
3. poi:
[0][2] [1][3] [2][4]
4. poi:
[0][3] [1][4]
5. infine:
[0][4]


Ho voluto implementare questo algoritmo affinché conducesse la somma degli elementi diagonale per diagonale (e utilizzando due sole variabili).
Se osservi, la differenza tra le due coordinate [x][y] degli elementi aumenta di uno per ogni diagonale mano a mano che risaliamo a quella più in alto a destra. Va da un minimo di zero ad un massimo di N-1. Facciamo quindi un ciclo for appropriato:

    for(j=0; j<N; j++)  {
        ...
    }

Questo for quindi, che strutturiamo come ciclo maggiore, quello più esterno, regola questa differenza e di conseguenza stabilisce la diagonale sulla quale lavoriamo.

Abbiamo posto quindi che la variabile j indichi la differenza tra le due coordinate.
Fatto ciò, stabiliamo che un'altra variabile (i) debba indicare una delle due coordinate, in modo tale che da questa, tenendo conto della differenza (e quindi o sottraendo j da i oppure sommandola, a seconda che della coordinata che indichiamo con i), riusciamo a ricavarci l'altra. Io gli ho fatto indicare la y (ma anche con la x le cose cambiano di poco).

Ora dobbiamo scrivere un ciclo interno che, all'interno di una diagonale, determini quindi la colonna y sulla quale ci troviamo. Osserviamo che le coordinate delle colonne partono per la prima diagonale da zero, per la seconda da uno, per la terza da 2, ecc... La y, diagonale dopo diagonale, varia nell'intervallo che va da 0 a N-1, allo stesso modo della differenza. Possiamo quindi porla uguale a j all'inizio di ognuno di questi cicli minori. Però, nell'elaborazione di una diagonale, assume dei valori che hanno come estremità superiore sempre N-1, ma l'estremità inferiore appunto varia al variare della diagonale e quindi della differenza e quindi di j.
Scriviamo quindi il ciclo interno:

        for(i=j; i<N; i++)
            somma += array[i-j][i];

Ricapitolando, il primo ciclo stabilisce la diagonale sulla quale lavoriamo, il secondo ne stabilisce dapprima la colonna e quindi (sottraendo a questa la differenza) ne individua la riga.

Per rendertene meglio conto esegui questo ciclo:

    ...
    for(j=0; j<N; j++)  {
	for(i=j; i<N; i++)  {
	    somma += array[i-j][i];
/**/        printf("\narray[%d][%d] = %d   -   Somma = %d", i-j, i, array[i-j][i], somma);
	}
    }
    ...

Come ho già detto può sembrare un po' criptico, ma visto che me lo hai chiesto ho cercato di spiegarlo.
Se non hai capito qualcosa sono qua.




ps: scusa se mi sono spiegato un po' male ma sono le 11 si sera!!