-
.
Can someone help me to solve this exercise?
Create a new type of data which will be called MATRIX which will be a record consisting of 3 fields:
VALUES which will be an array of 1-dimensional, dynamic integers
LINES which will be a whole
COLUMNS which will be a whole
Carry out the access operations to the data type:
- Read Lines
- ReadColumns
- Read Value
- Write Lines
- Write Columns
- Write Value
Carry out the operations of addition between 2 matrices, scalar product of a matrix for an integer value
Current exercise code:
#include <stdlib.h>
typedef struct matrice_t {
int* array;
int row_count;
int column_count;
} Matrix;
void ReadLine(Matrix m, int row_index, int **out);
void ReadColumn(Matrix m, int column_index, int **out);
int ReadWrite(Matrix m, int row_index, int column_index);
void WriteLine(Matrix m, const int *row, int row_index);
void WriteColumn(Matrix m, const int *column, int column_index);
void WriteValue(Matrix m, int value, int row_index, int column_index);
void ReadLine(Matrix m, int row_index, int **out) {
if (row_index > m.row_count)
return;
*out = malloc( sizeof(int) * m.column_count);
int base_index = row_index * m.column_count;
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[i + base_index];
++i;
}
}
void ReadColumn(Matrix m, int column_index, int **out) {
if (column_index > m.column_count)
return;
*out = malloc( sizeof(int) * m.row_count);
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[column_index + (i * m.column_count)];
++i;
}
}
int ReadValue(Matrix m, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return -1;
return m.array[row_index * m.column_count + column_index];
}
void WriteLine(Matrice m, const int * row, int row_index) {
if (row_index > m.row_count + 1) {
return;
}
int i, padding;
if (row_index == m.row_count + 1) {
++m.row_count;
m.array = realloc(m.array, m.row_count * m.column_count);
}
padding = row_index * m.column_count;
i = 0;
while (i < m.column_count) {
m.array[i + padding] = row[i];
++i;
}
}
void WriteColumn(Matrix m, const int *column, int column_index) {
if (column_index > m.column_count + 1) {
return;
}
int i;
if (column_index == m.column_count + 1) {
++m.column_count;
m.array = realloc(m.array, m.row_count * m.column_count);
i = m.row_count*m.column_count-2;
int curr_row=m.row_count-1;
int quantity_shifted = 0;
while(i>column_index){
if(quantity_shifted==m.column_count-1){
--i;
quantity_shifted = 0;
++curr_row;
}
int other_pos = column_index-(m.row_count-curr_row);
m.array[i] = m.array[other_pos];
--i;
++quantity_shifted;
}
}
i = 0;
while (i < m.row_count) {
m.array[i * m.column_count + column_index] = column[i];
++i;
}
}
void WriteValue(Matrix m, int value, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return;
m.array[row_index * m.column_count + column_index] = value;
} -
.
Crie um novo tipo de dado que se chamará MATRIZ que será um registro composto por 3 campos:
VALOR, que será uma matriz de inteiros dinâmicos unidimensionais
LINHAS que serăo um todo
COLUNAS que serăo um todo
Realize as operaçőes de acesso ao tipo de dados:
- Leia linhas
- ReadColumns
- Leia valor
- Escrever linhas
- Escrever colunas
- Escrever valor
Realize as operaçőes de adiçăo entre 2 matrizes, produto escalar de uma matriz para um valor inteiro -
.
Create a new type of data which will be called MATRIX which will be a record consisting of 3 fields:
VALUES which will be an array of 1-dimensional, dynamic integers
LINES which will be a whole
COLUMNS which will be a whole
Carry out the access operations to the data type:
- Read Lines
- ReadColumns
- Read Value
- Write Lines
- Write Columns
- Write Value
Carry out the operations of addition between 2 matrices, scalar product of a matrix for an integer value -
.
#include <stdlib.h>
typedef struct matriz_t {
int* array;
int row_count;
int column_count;
} Matriz;
void LeiaLinha(Matriz m, int row_index, int **out);
void LeiaColuna(Matriz m, int column_index, int **out);
int LeiaValor(Matriz m, int row_index, int column_index);
void EscrevaRiga(Matriz m, const int *row, int row_index);
void EscrevaColuna(Matriz m, const int *column, int column_index);
void EscrevaValor(Matriz m, int value, int row_index, int column_index);
void LeiaLinha(Matriz m, int row_index, int **out) {
if (row_index > m.row_count)
return;
*out = malloc( sizeof(int) * m.column_count);
int base_index = row_index * m.column_count;
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[i + base_index];
++i;
}
}
void LeiaColuna(Matriz m, int column_index, int **out) {
if (column_index > m.column_count)
return;
*out = malloc( sizeof(int) * m.row_count);
int i = 0;
while (i < m.column_count) {
*out[i] = m.array[column_index + (i * m.column_count)];
++i;
}
}
int LeiaValor(Matriz m, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return -1;
return m.array[row_index * m.column_count + column_index];
}
void EscrevaRiga(Matriz m, const int * row, int row_index) {
if (row_index > m.row_count + 1) {
return;
}
int i, padding;
if (row_index == m.row_count + 1) {
++m.row_count;
m.array = realloc(m.array, m.row_count * m.column_count);
}
padding = row_index * m.column_count;
i = 0;
while (i < m.column_count) {
m.array[i + padding] = row[i];
++i;
}
}
void EscrevaColuna(Matriz m, const int *column, int column_index) {
if (column_index > m.column_count + 1) {
return;
}
int i;
if (column_index == m.column_count + 1) {
++m.column_count;
m.array = realloc(m.array, m.row_count * m.column_count);
i = m.row_count*m.column_count-2;
int curr_row=m.row_count-1;
int quantity_shifted = 0;
while(i>column_index){
if(quantity_shifted==m.column_count-1){
--i;
quantity_shifted = 0;
++curr_row;
}
int other_pos = column_index-(m.row_count-curr_row);
m.array[i] = m.array[other_pos];
--i;
++quantity_shifted;
}
}
i = 0;
while (i < m.row_count) {
m.array[i * m.column_count + column_index] = column[i];
++i;
}
}
void EscrevaValor(Matriz m, int value, int row_index, int column_index) {
if (row_index * m.column_count + column_index >= m.row_count * m.column_count)
return;
m.array[row_index * m.column_count + column_index] = value;
} -
.
Matrix three fields, values, rows, columns,
Matrice tre campi, valori, righe, colonne, -
.
Create a new type of data which will be called MATRIX which will be a record consisting of 3 fields:
VALUES which will be an array of 1-dimensional, dynamic integers
RIGHE which will be a whole
COLUMNS which will be a whole
Carry out the access operations to the data type:
- Read Lines
- ReadColumns
- Read Value
- Write Lines
- Write Columns
- Write Value
Carry out the operations of addition between 2 matrices, scalar product of a matrix for an integer value -
.
Buongiorno a tutti e buon anno nuovo,
ora ve lo rovino con un esercizio.
Questa e' la traccia:
Realizzare un nuovo tipo di dato che si chiamera’ MATRICE che sara’ un record costituito da 3 campi:
VALORI che sara’ un array di interi a 1 dimensione, dinamico
RIGHE che sara’ un intero
COLONNE che sara’ un intero
Realizzare le operazioni di accesso al tipo di dato:
- LeggereRighe
- LeggereColonne
- LeggereValore
- ScrivereRighe
- ScrivereColonne
- ScrivereValore
Realizzare le operazioni di somma tra 2 matrici, prodotto scalare di una matrice per un valore intero
La consegna e' fissata per martedi 11 gennaio
Buon lavoro -
.
matrice prodottotramatrici(matrice M1, matrice M2){
matrice P;//matrice risultato del prodotto tra M1 e M2
int k;//contatore righe e colonne da moltiplicare di M1 e M2
int i;//contatore righe
int j;//contatore colonne
if(leggererighe(M2)==leggerecolonne(M1)){
i=0;
while(i<leggererighe(M1)){
j=0;
while(j<leggerecolonne(M2)){
scriverevalore(P,i,j,0);
k=0;
while(k<leggerecolonne(M2)){
P=scriverevalore(P,i,j,leggerevalore(P,i,j)+leggerevalore(M1,i,k)*leggerevalore(M2,k,j));
k++;
}
j++;
}
i++;
}
}
return P;
} -
.
https://drive.google.com/file/d/1m8l5L5Jui...ew?usp=drivesdk
LeggereRighe
INPUT
Mat, matrice di interi, di dimensione nxm, n>1,m>1
OUTPUT
R, numero di righe di Mat, intero, >1
ALGORITMO
R:=campo righe di mat
LeggereColonne
INPUT
Mat, matrice di interi, di dimensione nxm, n>1,m>1
OUTPUT
C, numero di colonne di Mat, intero, >1
ALGORITMO
C:= campo colonne di Mat
ScrivereRighe
INPUT
Mat, matrice di interi, di dimensione nxm, n>1,m>1
R, numero di righe di mat, intero, >1
OUTPUT
Mat, matrice di interi con un nuovo numero di righe, di dimensione rxm, r>1,m>1
ALGORITMO
Campo righe di mat:= r
ScrivereColonne
INPUT
Mat, matrice di interi, di dimensione nxm, n>1,m>1
C, numero di colonne di mat, intero, >1
OUTPUT
Mat, matrice di interi con un nuovo numero di colonne, di dimensione nxc, n>1,c>1
ALGORITMO
Campo colonne di mat:= c
LeggereValore
INPUT
Mat, matrice di valori interi, dimensioni nxm, n>1, m>1
R, numero di riga del valore da leggere, r>0 <=n
C, numero di colonna del valore da leggere, c>0, c<=m
OUTPUT
Valore, valore di mat in posizione r e c, intero
LAVORO
I, posizione nel campo valori di mat, intero, >0, <n*m
ALGORITMO
I:=(r-1)*m+c //ma r e c sono da convertire per il linguaggio, quindi entrambe -1
//(c-1)*n+r
Valore:=elemento del campo valori di mat in posizione i
ScrivereValore
INPUT
Mat, matrice di valori interi, dimensioni nxm, n>1, m>1
R, numero di riga del valore da leggere, r>0 <=n
C, numero di colonna del valore da leggere, c>0, c<=m
V, valore da scrivere in mat in posizione r e c, intero
OUTPUT
Mat, matrice di interi con il valore in posizione r e c, modificato, dimensioni nxm, n>1, m>1
LAVORO
I, posizione nel campo valori di mat, intero, >=0, <n*m
ALGORITMO
I:=(r-1)*m+(c-1) //ma r e c sono da convertire per il linguaggio, quindi entrambe -1
//(c-1)*n+(r-1)
elemento del campo valori di mat in posizione i:=v
SommareMatrici
NPUT
M1, prima matrice da sommare, dimensioni nxm, n>1, m>1
M2, seconda matrice da sommare, dimensioni nxm, n>1, m>1
OUTPUT
R, matrice risultato della somma tra M1 e M2, dimensioni nxm, n>1, m>1
LAVORO
I, indice per scandire le righe delle matrici, intero, >1, <=n
J, indice per scandire le colonne delle matrici, intero, >1, <=m
ALGORITMO
I:=1
MENTRE (i<=LeggereRighe(M1))
J:=1
MENTRE(j<=LeggereColonne(m1))
R:=ScrivereValore(R, i, j, LeggereValore(M1,i,j)+LeggereValore(M2, i, j))
J:=j+1
FINE
I:=i+1
FINE
ProdottoScalareMatrice
NPUT
M1, matrice da moltiplicare per lo scalare, dimensioni nxm, n>1, m>1
scalare, valore da moltiplicare per M1, intero
OUTPUT
R, matrice risultato del prodotto di M1 per scalare, dimensioni nxm, n>1, m>1
LAVORO
I, indice per scandire le righe delle matrici, intero, >1, <=n
J, indice per scandire le colonne delle matrici, intero, >1, <=m
ALGORITMO
I:=1
MENTRE (i<=LeggereRighe(M1))
J:=1
MENTRE(j<=LeggereColonne(m1))
R:=ScrivereValore(R, i, j, LeggereValore(M1,i,j)*scalare)
J:=j+1
FINE
I:=i+1
FINE -
.
#include <stdio.h>
#include <stdlib.h>
#define max 30
typedef struct {
int valori[max]; //array statico a una dimensione contenente i valori della matrice scelti dall'utente
int righe; //righe della tabella, >0 e <=10
int colonne; //colonne della tabella, >0 e <=10
} matrice; //matrice che rappresenta la struttura matematica a due dimensioni contenente valori interi
//Prototipi delle funzioni per lavorare sulla tabella
matrice RiempireTabella(matrice mat);
void StampareTabella(matrice mat);
matrice RiempireTabella1(matrice mat1, matrice mat);
void StampareTabella1(matrice mat1, matrice mat);
void StampareMatrice(matrice mattrs, matrice mat);
matrice MatriceTrasposta(matrice mattrs, matrice mat);
matrice SommareMatrici(matrice mat, matrice mat1);
//Prototipi delle funzioni per accedere ai dati della tabella
int LeggereRighe(matrice mat);
int LeggereColonne(matrice mat);
int LeggereValore(matrice mat, int r, int c);
matrice ScrivereRighe(matrice mat, int righe);
matrice ScrivereColonne(matrice mat, int righe);
matrice ScrivereValore(matrice mat, int r, int c, int valore);
int main() {
matrice mat; //tabella contenente valori inseriti dall'utente con dimensioni max*max
matrice mattrs;
matrice mat1;
int r; //righe della tabella
int c; //colonne della tabella
//Do While per inserire il numero delle righe della tabella
do{
printf("Inserire il numero di righe della tabella tra 1 e %d): ", max);
scanf("%d",&r);
}while((r>max)||(r<1));
mat=ScrivereRighe(mat, r);
//Do While per inserire il numero delle colonne della tabella
do{
printf("Inserire il numero di colonne della tabella tra 1 e %d): ", max);
scanf("%d",&c);
}while((c>max)||(c<1));
mat=ScrivereColonne(mat, c);
mat=RiempireTabella(mat);
StampareTabella(mat);
mat1=RiempireTabella1(mat1, mat);
StampareTabella1(mat1, mat);
mattrs=MatriceTrasposta(mattrs, mat);
StampareMatrice(mattrs, mat);
system("pause");
return 0;
}
/*
* Funzione per inserire dei valori scelti dall'utente all'interno
* della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
matrice RiempireTabella(matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
int n; //Valore da inserire nella tabella leggendolo dalla tastiera
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("Inserire un valore in riga %d colonna %d ->: ", r+1, c+1);
scanf("%d", &n);
mat=ScrivereValore(mat, r, c, n);
c=c+1;
}
r=r+1;
}
return mat;
}
/*
* Funzione per stampare i valori all'interno della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
void StampareTabella(matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("%d ", LeggereValore(mat, r, c));
c=c+1;
}
printf("\n");
r=r+1;
}
return;
}
matrice RiempireTabella1(matrice mat1, matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
int n; //Valore da inserire nella tabella leggendolo dalla tastiera
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("Inserire un valore per calcolare il prodotto scalare della matrice");
scanf("%d", &n);
mat1=ScrivereValore(mat1, r, c, LeggereValore(mat, r, c)*n);
c=c+1;
}
r=r+1;
}
return mat1;
}
/*
* Funzione per stampare i valori all'interno della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
void StampareTabella1(matrice mat1, matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
r=0;
while(r<LeggereRighe(mat)){
c=0;
while(c<LeggereColonne(mat)){
printf("%d ", LeggereValore(mat1, r, c));
c=c+1;
}
printf("\n");
r=r+1;
}
return;
} -
.
/*
* Funzione per stampare i valori all'interno della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
void StampareTabella1(matrice mat1, matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
r=0;
while(r<LeggereRighe(mat)){
c=0;
while(c<LeggereColonne(mat)){
printf("%d ", LeggereValore(mat1, r, c));
c=c+1;
}
printf("\n");
r=r+1;
}
return;
} -
.
#include <stdio.h>
#include <stdlib.h>
#define max 30
typedef struct {
int valori[max]; //array statico a una dimensione contenente i valori della matrice scelti dall'utente
int righe; //righe della tabella, >0 e <=10
int colonne; //colonne della tabella, >0 e <=10
} matrice; //matrice che rappresenta la struttura matematica a due dimensioni contenente valori interi
//Prototipi delle funzioni per lavorare sulla tabella
matrice RiempireTabella(matrice mat);
void StampareTabella(matrice mat);
matrice RiempireTabella1(matrice mat1, matrice mat);
void StampareTabella1(matrice mat1, matrice mat);
void StampareMatrice(matrice mattrs, matrice mat);
matrice MatriceTrasposta(matrice mattrs, matrice mat);
matrice SommareMatrici(matrice mat, matrice mat1);
//Prototipi delle funzioni per accedere ai dati della tabella
int LeggereRighe(matrice mat);
int LeggereColonne(matrice mat);
int LeggereValore(matrice mat, int r, int c);
matrice ScrivereRighe(matrice mat, int righe);
matrice ScrivereColonne(matrice mat, int righe);
matrice ScrivereValore(matrice mat, int r, int c, int valore);
int main() {
matrice mat; //tabella contenente valori inseriti dall'utente con dimensioni max*max
matrice mattrs;
matrice mat1;
int r; //righe della tabella
int c; //colonne della tabella
//Do While per inserire il numero delle righe della tabella
do{
printf("Inserire il numero di righe della tabella tra 1 e %d): ", max);
scanf("%d",&r);
}while((r>max)||(r<1));
mat=ScrivereRighe(mat, r);
//Do While per inserire il numero delle colonne della tabella
do{
printf("Inserire il numero di colonne della tabella tra 1 e %d): ", max);
scanf("%d",&c);
}while((c>max)||(c<1));
mat=ScrivereColonne(mat, c);
mat=RiempireTabella(mat);
StampareTabella(mat);
mat1=RiempireTabella1(mat1, mat);
StampareTabella1(mat1, mat);
mattrs=MatriceTrasposta(mattrs, mat);
StampareMatrice(mattrs, mat);
system("pause");
return 0;
}
/*
* Funzione per inserire dei valori scelti dall'utente all'interno
* della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
matrice RiempireTabella(matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
int n; //Valore da inserire nella tabella leggendolo dalla tastiera
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("Inserire un valore in riga %d colonna %d ->: ", r+1, c+1);
scanf("%d", &n);
mat=ScrivereValore(mat, r, c, n);
c=c+1;
}
r=r+1;
}
return mat;
}
/*
* Funzione per stampare i valori all'interno della tabella nella posizione
* assegnata dai contatori c delle colonne e r delle righe
*/
void StampareTabella(matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("%d ", LeggereValore(mat, r, c));
c=c+1;
}
printf("\n");
r=r+1;
}
return;
}
matrice RiempireTabella1(matrice mat1, matrice mat){
int c; //Contatore c delle colonne della tabella
int r; //Contatore r delle righe della tabella
int n; //Valore da inserire nella tabella leggendolo dalla tastiera
r=0;
while(r<leggererighe(mat)){
c=0;
while(c<leggerecolonne(mat)){
printf("Inserire un valore per calcolare il prodotto scalare della matrice");
scanf("%d", &n);
mat1=ScrivereValore(mat1, r, c, LeggereValore(mat, r, c)*n);
c=c+1;
}
r=r+1;
}
return mat1;
}
Edited by Mind. - 22/12/2021, 15:51 -
.
#include <stdio.h>
#include <stdlib.h>
#define max 30
typedef struct {
int valori[max]; //array statico a una dimensione contenente i valori della matrice scelti dall'utente
int righe; //righe della tabella, >0 e <=10
int colonne; //colonne della tabella, >0 e <=10
} matrice; //matrice che rappresenta la struttura matematica a due dimensioni contenente valori interi
//Prototipi delle funzioni per accedere ai dati della tabella
int LeggereRighe(matrice mat);
int LeggereColonne(matrice mat);
int LeggereValore(matrice mat, int r, int c);
matrice ScrivereRighe(matrice mat, int righe);
matrice ScrivereColonne(matrice mat, int righe);
matrice ScrivereValore(matrice mat, int r, int c, int valore);
/*
* Funzione per restituire il numero di righe della tastiera
*/
int LeggereRighe(matrice mat){
int righe; //numero di righe della matrice - inter0 - >1
righe=mat.righe;
return righe;
}
/*
* Funzione per restituire il numero di colonne della tastiera
*/
int LeggereColonne(matrice mat){
int colonne;
colonne=mat.colonne;
return colonne;
}
/*
* Funzione per restituire un valore della tastiera
* in posizione r e posizione c
*/
int LeggereValore(matrice mat, int r, int c){
int valore; //valore della matrice in posizione r e c - intero
int i; //posizione nel campo valori di mat - intero - >0, <mat.righe*mat.colonne
i=r*mat.colonne+c;
valore=mat.valori[i];
return valore;
}
/*
* Funzione per modificare il numero delle righe della tabella
*/
matrice ScrivereRighe(matrice mat, int r){
mat.righe=r;
return mat;
}
/*
* Funzione per modificare il numero delle colonne della tabella
*/
matrice ScrivereColonne(matrice mat, int c){
mat.colonne=c;
return mat;
}
/*
* Funzione per scrivere un valore della tastiera
* in posizione r e posizione c
*/
matrice ScrivereValore(matrice mat, int r, int c, int valore){
int i; //posizione nel campo valori di mat - intero - >0, <mat.righe*mat.colonne
i=r*mat.colonne+c;
mat.valori[i]=valore;
return mat;
} -
.
Comunque sono un po' indeciso anch'io sulla trasposta e la moltiplicazione di due insiemi ma dovrebbe essere
Definisci il record matrice
Funzioni d'accesso
Inserisci i valori della matrice
Fai la somma di due matrici (mi sa che sta nel file? Mi ero distratto)
Fai il prodotto scalare (che ha spiegato)
Trasposta(che ancora devo capire bene)
Prodotto di due matrici(l'unica cosa che ho capito č che la matrice3(quella dei prodotti) avrŕ come righe e colonne quella piů piccola (tra m1 che ha come righe 5 e m2 che ha 4, metti 4.
Tra m1 con colonne 3 e m2 con colonne 6 metti colonne 3) -
.
www.codingcreativo.it/matrice-trasposta-in-c/
Posts written by Mind. |