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:
  1. Soma total de todos os elementos da matriz — denoto por S_{total}.
  2. Soma de cada linha — i.e., para cada linha i calcular S_{linha}[i].
  3. Soma de cada coluna — i.e., para cada coluna j calcular S_{coluna}[j].
  4. Soma da diagonal principal — denoto por S_{diag\_principal} (elementos com i=j).
  5. Soma da diagonal secundária — denoto por S_{diag\_sec} (elementos com i+j=4, pois o índice vai de 0 a 4).
  6. Soma dos elementos acima da diagonal principal (acima, estritamente, onde i<j) — denoto por S_{acima}.
  7. 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:
  1. Declarar int M[5][5]; e as variáveis de soma descritas no passo anterior; inicializá-las com zero.
  2. 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.
  3. Após a leitura e acumulação, imprimir a matriz M linha por linha com printf("%4d", M[i][j]); para ficar alinhada.
  4. 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>

int main(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");
                return 1;
            }
            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);

    return 0;
}

Exercícios relacionados