PDA

Visualizza la versione completa : [C] Difficoltà nel creare un algoritmo per...


ZioDema2
25-12-2008, 16:36
Ciao a tutti, ho un problema con l'ennesimo esercizio universitario.
Il testo dell'esercizio è il seguente:
__________________________________________________ __________________________

Sia data una matrice quadrata di numeri interi positivi di dimensione pari a N(con N < 16).

Scrivere un programma C che:
1. Legga da tastiera la dimensione N della matrice;
2. Legga da tastiera gli NxN valori della matrice controllando che siano tutti numeri positivi;
3. Per ogni riga della matrice ne calcoli la somma degli elementi;
4. Raggruppi le righe la cui somma degli elementi è uguale producendo per ogni gruppo il seguente output:

Somma <valore della somma>: Stampa delle righe la cui somma degli elementi vale <valore della somma>

N.B. Ogni riga deve essere stampata racchiusa tra parentesi tonde e con gli elementi separati da uno spa-zio. Le varie righe devono essere separate da una virgola

Esempio:

Sia data la matrice

0 2 3 1
0 6 0 0
1 2 2 4
1 1 1 3

(N=4)
Il programma deve produrre il seguente output:

Somma 6: (0 2 3 1), (0 6 0 0), (1 1 1 3)
Somma 9: (1 2 2 4)

__________________________________________________ _________________________

La mia difficoltà, sta nel non capire come uscirne dal punto 4, ho provato diversi algoritmi e ognuno di essi ha grossi problemi, voi come suggerite?
Intanto posto il testo fatto fino al punto 3 (il punto 4 è stato fatto però senza controllo di somma uguale)



#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

int main()
{
int N,i,j=0;
int temp=0;
int condizione=0;

//Inserimento in N della grandezza matrice quadrata
do
{
printf("Inserisci la dimensione della matrice quadrata ");
scanf("%d",&N);
if(N<16)
condizione=0;
else
{
condizione=1;
printf("Errore N, deve essere minore di 16 ");
}
}while(condizione==1);

//Creazione matrice quadrata, azzeramento condizione, creazione vettore somme righe
int matrice[N][N];
condizione=0;
int vet[N];

for(i=0;i<N;i++)
vet[i]=0;

//Input matrice con controllo sui numeri positivi
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
do
{
printf("[%d][%d]",i+1,j+1);
scanf("%d",&matrice[i][j]);
if(matrice[i][j]<0)
{
printf("Errore, i valori negativi non sono ammessi ");
condizione=0;
}
else
condizione=1;
}while(condizione==0);
}
printf("\n");
}

//Somma delle righe della matrice
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
temp=temp+matrice[i][j];
vet[i]=temp;
}
temp=0;
}

//Stampa somme
for(i=0;i<N;i++)
printf("La somma della %d riga e' %d \n",i+1,vet[i]);

//Stampa raggruppata di righe di matrice
for(i=0;i<N;i++)
{
printf("Somma %d ( ",vet[i]);
for(j=0;j<N;j++)
{
printf("%d ",matrice[i][j]);
}
printf(")");

printf("\n");
}


system("pause");
}



Grazie a tutti coloro che mi aiuteranno,
auguroni!!

:)

MrX87
25-12-2008, 18:56
ciao, ho visto un pò il tuo codice, e mi sono accorto di qualche errore devo dire, non so ma forse non hai ancora sentito parlare di allocazione dinamica della memoria!
perchè non è molto lecito fare questo:


//Creazione matrice quadrata, azzeramento condizione, creazione vettore somme righe
int matrice[N][N];
condizione=0;
int vet[N];

ma è molto più lecito dichiarare:


int *vet, **matrice;

e allocare con la malloc entrambi i puntatori:


//CREAZIONE MATRICE DINAMICA E VETTORE DINAMICO
vet = (int*)malloc(N*sizeof(int));
if ( vet == NULL ) {
printf ("Errore di allocazione\n");
exit(1);
}
matrice = (int**)malloc(N*sizeof(int*));
if ( matrice == NULL ) {
printf ("Errore di allocazione\n");
exit(1);
}
for ( i=0; i<N; i++ ) {
matrice[i] = (int*)malloc(N*sizeof(int));
if ( matrice[i] == NULL ) {
printf ("Errore allocazione\n");
exit(1);
}
}
per il resto ho provato a fare una soluzione del problema 4, vedi un pò se funziona perchè io ho fatto una prova sola... ti posto comunque tutto il codice qua sotto:


#include <stdio.h>
#include <stdlib.h>

void stampaRiga ( int* rig, int dim );

int main()
{
int N,i,j=0;
int temp=0;
int condizione=0;
int *vet, **matrice;

//Inserimento in N della grandezza matrice quadrata
do
{
printf("Inserisci la dimensione della matrice quadrata ");
scanf("%d",&N);
if(N<16)
condizione=0;
else
{
condizione=1;
printf("Errore N, deve essere minore di 16 ");
}
}while(condizione==1);

condizione=0;

//CREAZIONE MATRICE DINAMICA E VETTORE DINAMICO
vet = (int*)malloc(N*sizeof(int));
if ( vet == NULL ) {
printf ("Errore di allocazione\n");
exit(1);
}
matrice = (int**)malloc(N*sizeof(int*));
if ( matrice == NULL ) {
printf ("Errore di allocazione\n");
exit(1);
}
for ( i=0; i<N; i++ ) {
matrice[i] = (int*)malloc(N*sizeof(int));
if ( matrice[i] == NULL ) {
printf ("Errore allocazione\n");
exit(1);
}
}



for(i=0;i<N;i++)
vet[i]=0;

//Input matrice con controllo sui numeri positivi
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
do
{
printf("[%d][%d]",i+1,j+1);
scanf("%d",&matrice[i][j]);
if(matrice[i][j]<0)
{
printf("Errore, i valori negativi non sono ammessi ");
condizione=0;
}
else
condizione=1;
}while(condizione==0);
}
printf("\n");
}

//Somma delle righe della matrice
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
temp=temp+matrice[i][j];
}
vet[i]=temp;
temp=0;
}

//Stampa somme
for(i=0;i<N;i++)
printf("La somma della %d riga e' %d \n",i+1,vet[i]);

//Stampa raggruppata di righe di matrice
for(i=0;i<N;i++) {
if ( vet[i] >= 0 ) {
printf("Somma %d:",vet[i]);
stampaRiga ( matrice[i], N );
for(j=0;j<N;j++) {
if ( vet[j] == vet[i] && i != j ) {
stampaRiga ( matrice[i], N );
vet[j]=-1;
}
}
vet[i]=-1;
printf("\n");
}
}
system("pause");
}

void stampaRiga ( int* rig, int dim )
{
int i;
printf (" ( ");
for ( i=0; i<dim; i++ )
printf("%d ",rig[i]);
printf (" )");
return;
}

ZioDema2
26-12-2008, 11:01
Mmm proverò questa tua soluzione e magari vedrò di informarmi un pochettino di questa "allocazione temporanea della memoria" visto che all'uni ancora questo argomento non e stato trattato.
Ti ringrazio tanto del tempo dedicato. :D

sotoli
26-12-2008, 16:00
Ciao....visto che non hai ancora affrontato l'allocazione dinamica della memoria, prova a dare un'occhiata a questa:


#include <stdio.h>
#include <stdlib.h>

#define N 16

int main()
{
int n, i, j, k;
int matrix[N-1][N] = {0};
do
{
printf("Dimensione della matrice: ");
scanf(" %d",&n);
}
while(n <= 0 || n >= N);
printf("Inserimento valori della matrice\n");
for(i=0; i<N; i++)
{
if(i < n)
{
printf("\nRiga %d:\n",i+1);
for(j=0; j<n; j++)
{
printf("Valore %d: ",j+1);
scanf(" %d",&matrix[i][j]);
if(matrix[i][j] < 0)
{
printf("Valore errato!\n");
j--;
}
else
matrix[i][n] += matrix[i][j];
}
}
}
printf("\nCalcolo delle somme.\n");
for(i=0; i<n; i++)
{
if(matrix[i][n] >= 0)
{
printf("Somma %d: (", matrix[i][n]);
for(j=0; j<n; j++)
printf("%d%s", matrix[i][j], ((j == n-1) ? ")" : " "));
for(j=i+1; j<n; j++)
{
if(matrix[i][n] == matrix[j][n])
{
printf(", (");
for(k=0; k<n; k++)
printf("%d%s", matrix[j][k], ((k == n-1) ? ")" : " "));
matrix[j][n] = -1;
}
}
printf("\n");
}
}
return 0;
}


L'ho provata solo con i valori dell'esempio nel testo dell'esercizio, quindi magari fai qualche prova con altri valori o con dimensione diversa da quella dell'esempio.
Fammi sapere se può andare.

Loading