Elabore uma estrutura composta por três matrizes quadradas de dimensões iguais a 4 e dois vetores de tamanho igual a 16. No programa principal, faça a leitura de uma matriz 4x4 e armazene-a na primeira matriz da estrutura. A seguir, desenvolva funções realizar as seguintes tarefas:
a. armazenar na segunda matriz da estrutura, a transposta da matriz lida;
b. armazenar na terceira matriz da estrutura, a matriz lida multiplicada pelo seu elemento de maior valor;
c. armazenar no primeiro vetor da estrutura, de forma sequencial (linha por linha), a matriz lida;
d. armazenar no segundo vetor da estrutura, o resultado do produto da matriz lida por sua transposta.

Passo 1

A ideia é criar uma estrutura em C que contenha três matrizes 4\times4 e dois vetores de tamanho 16. No main vamos ler uma matriz 4\times4 e armazená-la na primeira matriz da estrutura. Depois teremos quatro funções auxiliares:
  1. gerar a transposta da matriz lida e guardar na segunda matriz,
  2. encontrar o maior elemento da matriz lida, multiplicar toda a matriz por esse valor e guardar na terceira matriz,
  3. “linearizar” a matriz (armazenar linha por linha) num vetor de 16 elementos,
  4. calcular o produto da matriz lida pela sua transposta e armazenar o resultado (também 4\times4) linearizado no segundo vetor.

Passo 2

Definimos a estrutura com três matrizes e dois vetores:
typedef struct {
 int m1[4][4];
 int m2[4][4];
 int m3[4][4];
 int v1[16];
 int v2[16];
} TStruct;

Passo 3

Função que computa a transposta de uma matriz 4\times4:
void transpose(int src[4][4], int dest[4][4]) {
 for (int i \(=0\); i < 4; i\(++\)) {
 for (int j \(=0\); j < 4; j\(++\)) {
 dest[j][i] = src[i][j];
 }
 }
}

Passo 4

Função que encontra o maior elemento de src, multiplica toda a matriz por esse valor e guarda em dest:
void \(scale_by_max\)(int src[4][4], int dest[4][4]) {
 int max = src[0][0];
 for (int i \(=0\); i < 4; i\(++\))
 for (int j \(=0\); j < 4; j\(++\))
 if (src[i][j] > max)
 max = src[i][j];
 for (int i \(=0\); i < 4; i\(++\))
 for (int j \(=0\); j < 4; j\(++\))
 dest[i][j] = src[i][j] * max;
}

Passo 5

Função que armazena a matriz linha por linha num vetor de 16 posições:
void linearize(int src[4][4], int dest[16]) {
 int k \(=0\);
 for (int i \(=0\); i < 4; i\(++\)) {
 for (int j \(=0\); j < 4; j\(++\)) {
 dest[k\(++\)] = src[i][j];
 }
 }
}

Passo 6

Função que multiplica a matriz pela sua transposta e, em seguida, lineariza o resultado num vetor:
void \(prod_mat_transpose\)(int src[4][4], int dest[16]) {
 int temp[4][4];
 // primeiro computa src * \(src^T\)
 for (int i \(=0\); i < 4; i\(++\)) {
 for (int j \(=0\); j < 4; j\(++\)) {
 int soma \(=0\);
 for (int k \(=0\); k < 4; k\(++\)) {
 soma \(+=\) src[i][k] * src[j][k]; // uso da transposta
 }
 temp[i][j] = soma;
 }
 }
 // agora lineariza em dest
 int idx \(=0\);
 for (int i \(=0\); i < 4; i\(++\))
 for (int j \(=0\); j < 4; j\(++\))
 dest[idx\(++\)] = temp[i][j];
}

Passo 7

Programa principal: leitura da matriz, chamadas às funções e armazenamento na estrutura.
#include <stdio.h>

int main() {
 TStruct s;

 // leitura da primeira matriz
 printf("Digite os 16 elementos da matriz 4x4 (linha a linha):
");
 for (int i \(=0\); i < 4; i\(++\)) {
 for (int j \(=0\); j < 4; j\(++\)) {
 scanf("%d", &s.m1[i][j]);
 }
 }

 // (a) transposta em m2
 transpose(s.m1, s.m2);

 // (b) matriz lida escalonada pelo maior elemento em m3
 \(scale_by_max\)(s.m1, s.m3);

 // \text{(c)} matriz lida linearizada em v1
 linearize(s.m1, s.v1);

 // (d) produto da matriz pela sua transposta linearizado em v2
 \(prod_mat_transpose\)(s.m1, s.v2);

 // opcional: você pode imprimir para conferir
 return 0;
}

Resposta

O código acima implementa exatamente os requisitos:
(a) transposta em m2,
(b) matriz escalonada em m3,
(c) vetor linha-por-linha em v1,
(d) produto pela transposta em v2.

Exercícios relacionados