Escreva um programa em C que leia os dados de uma matriz M(5,5) e calcule as somas:
f) Escreva estas somas e a matriz
Passo 1
O enunciado pede que a gente escreva um programa em C que leia os dados de uma matriz M(5,5) e calcule “as somas” e depois escreva (imprima) essas somas e a própria matriz. As informações relevantes que o enunciado dá são:
A matriz tem dimensão 5\times5 (ou seja, 5 linhas e 5 colunas).
Devemos ler os dados (os 25 elementos) da matriz.
Devemos calcular somas (o enunciado pede “estas somas” — vou considerar as somas mais comuns e úteis para este tipo de exercício, listadas no próximo passo).
Devemos escrever (imprimir) a matriz e as somas calculadas.
Passo 2
Como o enunciado não especificou exatamente quais somas, vou escolher um conjunto padrão e didático de somas que normalmente aparecem nesse tipo de exercício. Essas são fáceis de implementar e úteis para a prova:
Soma total de todos os elementos da matriz — denoto por S_{total}.
Soma de cada linha — i.e., para cada linha i calcular S_{linha}[i].
Soma de cada coluna — i.e., para cada coluna j calcular S_{coluna}[j].
Soma da diagonal principal — denoto por S_{diag\_principal} (elementos com i=j).
Soma da diagonal secundária — denoto por S_{diag\_sec} (elementos com i+j=4, pois o índice vai de 0 a 4).
Soma dos elementos acima da diagonal principal (acima, estritamente, onde i<j) — denoto por S_{acima}.
Soma dos elementos abaixo da diagonal principal (estritamente, onde i>j) — denoto por S_{abaixo}.
Escolhi essas porque são básicas (o professor costuma cobrar), mostram manipulação de índices e agregações por linha/coluna, e podem ser calculadas em uma única passagem pela matriz — isso facilita na prova.
Passo 3
Agora vou explicar a estrutura de dados e as variáveis em C que usamos:
A matriz será armazenada em um array bidimensional: int M[5][5];. Aqui M[i][j] representa o elemento da linha i e coluna j.
Índices: em C as linhas e colunas vão de 0 até 4. Então usamos dois laços aninhados for (i = 0; i < 5; i++) e for (j = 0; j < 5; j++).
Para acumular somas:
int S_total = 0; guarda S_{total}.
int S_linha[5] = {0}; guarda S_{linha}[i] para cada i.
int S_coluna[5] = {0}; guarda S_{coluna}[j] para cada j.
int S_diag_principal = 0; guarda S_{diag\_principal}.
int S_diag_sec = 0; guarda S_{diag\_sec}.
int S_acima = 0; guarda S_{acima}.
int S_abaixo = 0; guarda S_{abaixo}.
Leitura: usamos scanf("%d", &M[i][j]); para ler cada elemento como inteiro. Se quiser usar float ou double, o raciocínio é o mesmo; aqui escolhi int por simplicidade.
Impressão: usamos printf para imprimir a matriz e os resultados formatados.
Observação de estilo: podemos calcular todas essas somas em uma única passagem enquanto lemos os elementos — isso economiza tempo, código e é ideal para prova.
Passo 4
Vou descrever o algoritmo passo a passo, mastigado, para implementar no programa:
Declarar int M[5][5]; e as variáveis de soma descritas no passo anterior; inicializá-las com zero.
Fazer dois loops aninhados para percorrer índices i e j:
Ler M[i][j] com scanf.
Atualizar S_total somando M[i][j].
Atualizar S_linha[i] adicionando M[i][j].
Atualizar S_coluna[j] adicionando M[i][j].
Se i==j então adicionar M[i][j] a S_diag_principal.
Se i+j==4 então adicionar M[i][j] a S_diag_sec. (Aqui usei 4 porque os índices variam de 0 a 4, portanto a condição da diagonal secundária numa matriz 5\times5 é i+j=4.)
Se i<j então adicionar M[i][j] a S_acima.
Se i>j então adicionar M[i][j] a S_abaixo.
Após a leitura e acumulação, imprimir a matriz M linha por linha com printf("%4d", M[i][j]); para ficar alinhada.
Imprimir cada soma com explicação: S_total, S_linha[i] para cada linha i, S_coluna[j] para cada coluna j, S_diag_principal, S_diag_sec, S_acima, S_abaixo.
Exemplo simples (apenas para entender): se a matriz fosse 2\times2
\begin{pmatrix}1 & 2\\\\ 3 & 4\end{pmatrix}
a soma total seria 1+2+3+4=10. A soma da primeira linha seria 1+2=3, da segunda 3+4=7. A diagonal principal seria 1+4=5, a secundária 2+3=5. Acima da diagonal principal só tem 2 e abaixo só tem 3.
Passo 5
Algumas dicas práticas e detalhes que normalmente caem na prova:
Lembre-se que os índices em C começam em 0. Portanto, para uma matriz 5\times5 as linhas/colunas vão de 0 a 4.
Para evitar muitos loops separados, faça todos os cálculos na leitura — isso economiza tempo na prova.
Use for aninhado e inicialize claramente os acumuladores a zero.
Para imprimir a matriz com boa formatação, dentro do loop das linhas faça outro loop das colunas e ao final de cada linha imprima \n.
Se a prova exige entrada formatada, esteja atento ao que o avaliador espera (por exemplo, números separados por espaço ou por linhas). O código abaixo lê números sequencialmente, independente de quebra de linha — isso é flexível.
Passo 6
Segue o código em C completo, comentado e pronto para compilar com gcc ou outro compilador. Ele lê 25 inteiros (linha a linha ou separados por espaços), calcula as somas listadas e imprime a matriz e todas as somas pedidas.
Resposta
#include<stdio.h>intmain(void) {
int M[5][5];
int S_total = 0;
int S_linha[5] = {0};
int S_coluna[5] = {0};
int S_diag_principal = 0;
int S_diag_sec = 0;
int S_acima = 0;
int S_abaixo = 0;
int i, j;
printf("Digite os 25 elementos da matriz 5x5 (linha por linha):\n");
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (scanf("%d", &M[i][j]) != 1) {
printf("Erro na leitura. Certifique-se de digitar inteiros.\n");
return1;
}
S_total += M[i][j];
S_linha[i] += M[i][j];
S_coluna[j] += M[i][j];
if (i == j) {
S_diag_principal += M[i][j];
}
if (i + j == 4) {
S_diag_sec += M[i][j];
}
if (i < j) {
S_acima += M[i][j];
}
if (i > j) {
S_abaixo += M[i][j];
}
}
}
printf("\nMatriz 5x5:\n");
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
printf("%6d", M[i][j]);
}
printf("\n");
}
printf("\nSomas calculadas:\n");
printf("Soma total (S_total): %d\n", S_total);
printf("\nSoma por linha:\n");
for (i = 0; i < 5; i++) {
printf("Linha %d: %d\n", i, S_linha[i]);
}
printf("\nSoma por coluna:\n");
for (j = 0; j < 5; j++) {
printf("Coluna %d: %d\n", j, S_coluna[j]);
}
printf("\nSoma da diagonal principal (i == j): %d\n", S_diag_principal);
printf("Soma da diagonal secundaria (i + j == 4): %d\n", S_diag_sec);
printf("Soma dos elementos acima da diagonal principal (i < j): %d\n", S_acima);
printf("Soma dos elementos abaixo da diagonal principal (i > j): %d\n", S_abaixo);
return0;
}