[C] Somma per righe numeri matrice

[AB03]

Ciao a tutti,
il mio problema e' il seguente:

Ho una matrice esempio questa:

1 2 3 4 5
7 8 1 2 6
2 2 0 7 3

e devo fare la somma dei valori delle righe da salvare in un vettore, esempio:

15 <-- somma valori prima riga
24 <-- somma valori seconda riga
14 <-- somma valori terza riga


Io ho provato cosi ma non funziona (vedi codice seguente):

for (j=0; j<3; j++) {
	for (l=0; l<3; l++) {
		for (c=0; c<5; c++) {

			vet[i]+=matr[l][c];
		}
	}
}

[oregon]

Perche' 3 cicli?

La variabile i dove e' dichiarata e come e' gestita?

Il vettore vet[i] dove e' azzerato?

[AB03]

scusa ho scritto un po' in fretta,

in realta' e' vet[j], ed e' dichiarsto fuori come int vet[3]

[oregon]

Non hai risposto nè alla prima domanda nè all'ultima ...

Fai con calma ma posta il codice completo e corretto ... altrimenti le risposte non hanno senso ...

[furiaceka]

Mi sono permesso di provare a fornirti una risposta:

#include <stdio.h>

#define MAXM 20
#define MAXN 20

main()
{
       int i,j,r,c;
       int a[MAXM][MAXN];
       int vett[MAXM]={0};

   printf("inserisci il numero di righe : ");
   scanf("%d",&r);
   
   printf("\ninserisci il numero di colonne : ");
   scanf("%d",&c);


   for (i=0; i<r; i++){
      for (j=0; j<c; j++){
         printf("a[%d][%d] = ",i+1,j+1);
         scanf("%d",&a[i][j]);
   
      }
   }

for(i=0;i<r;i++)
   for (j=0; j<c; j++)
   vett[i]+=a[i][j];

for(i=0;i<r;i++)
printf("\nSomma %d-esima riga = %d\n",i+1,vett[i]);


getch();
}

Il programma richiede il numero di righe e colonne di cui è formata la matrice, poi fa inserire i valori e infine calcola la somma per righe.

Come vedi sono sufficienti due cicli for.

[AB03]

Ciao, io ho prato cosi ma non va mi stampa tutti zeri, pero la matrice di partenza me la crea

Vedi codice:

Mi sapete dire inoltre se ho usato correttamente la thread?

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <time.h>
#include <string.h>
#include <sys/stat.h>
#include <pthread.h>

#define N 12800
#define L 128
#define C 100

FILE *fp;

int matr[L][C];

void rewind(FILE *fp);

void *init_matr () {

	int j, c;

	for (c=0; c<C; c++) {
		fscanf(fp, "%d", &matr[L][c]);
		//printf(" %d", matr[L][c]);
	}

	int vett[L];

   	for (c=0; c<L; c++)
   		vett[L]+=matr[L][c];

	for(c=0;c<L;c++)
		printf("%d\n", vett[c]);

}

int main (int argc, char **argv) {

	pthread_t threads[L];
	int rc;

	int i, l;
	char nome_file[81];

	printf("Nome file su cui scrivere i 12800 numeri random: ");
	scanf("%s", &nome_file);

	fp = fopen(nome_file,"w+");

	srand (time(0));

	for (i=0; i<=N; i++) {
		if (i==12800) {
			fprintf(fp, "%d", rand() % 100);
		}
		else {
			fprintf(fp,"%d\n",rand() % 100);
		}
	}
	rewind(fp);

	//int matr[L][100];

	for (l=0; l<L; l++) {
		//for (c=0; c<100; c++) {

			rc = pthread_create(&threads[l], NULL, init_matr, (void *)l);
		//}
	}

	pthread_exit(NULL);
	fclose (fp);

}

[oregon]

Ma ... a che ti serve il nuovo thread?

Non mi pare che per fare una somma ci voglia un nuovo thread ...

[AB03]

Devo fare un programma per l'uni. Se tu non sei il mio prof ti metto l'indirizzo internet dove puoi trovare il testo

[AB03]

Ecco il testo

Scrivere un programma C che sfrutti le thread POSIX (Pthread) per effettuare in parallelo la somma
 di 12.800 numeri interi casuali. Tali numeri devono essere memorizzati, uno per riga, in un file
 passato al programma tramite linea di comando.
 Il main deve creare una prima thread di inizializzazione il cui obiettivo consiste nel copiare i numeri
 dal file all’interno di 128 array (100 numeri per ogni array), e nell’inizializzare a 0 una variabile
 counter.
 Il main, attesa la terminazione della thread di inizializzazione, deve creare 128 ulteriori thread T[i],
 con 0<= i <128, una per ogni array, il cui obbiettivo consiste innanzitutto nel calcolare la somma
 S[i] dei 100 interi memorizzati nel corrispondente array A[i]. Pertanto, dopo la fase di
 inizializzazione il programma deve procedere come segue:
     1. Ciascuna thread T[i] con 0<= i <128 calcola la somma S[i] degli elementi contenuti
         nell’array A[i].
     2. Ciascuna thread T[i] con 0<= i <64, rimane attiva e aggiunge a S[i] la somma
         S[i+64] eseguita dalla thread T[i+64]. Ad esempio, la thread T[0] somma a S[0] il
         valore S[64] calcolato dalla thread T[64], la thread T[1] somma a S[1] il valore
         S[65] calcolato dalla thread T[65], etc.
     3. Ciascuna thread T[i] con 64<= i <128, termina la propria esecuzione.
     4. I passi 2 e 3 devono esser ripetuti considerando questa volta le 64 thread rimaste attive.
         Pertanto, ciascuna thread T[i] con 0<= i <32, rimane attiva e aggiunge a S[i] la somma
         S[i+32] eseguita dalla thread T[i+32] mentre le thread T[i] con 32<= i <64,
         terminano la propria esecuzione.
     5. Il passo 4 va ripetuto ricorsivamente, fino a quando rimane una sola thread (la numero 0), che
         di conseguenza conterrà la somma totale dei 12.800 numeri iniziali.
 Durante i passi 2-5, ciascuna thread deve incrementare di una unità la variabile condivisa counter
 ogni volta che viene effettuata una somma. La variabile deve essere modificata dalle thread in modo
 mutuamente esclusivo.
Il main attesa la terminazione di tutte le thread dovrà stampare la somma dei 128.000 numeri e il
valore della variabile counter.

[AB03]

Non c'è più nessuno che mi sa dare una mano !?