Utilizando um array bidimensional, desenvolva um programa na linguagem C que:
(a) leia do usuário uma matriz quadrada de ordem quatro;
(b) indique ao usuário se a matriz é diagonal;
(c) indique ao usuário se a matriz é simétrica.

Passo 1

O enunciado pede três coisas claras:
  • Leia do usuário uma matriz quadrada de ordem 4 (ou seja, uma matriz 4\times4).
  • Informe ao usuário se a matriz é diagonal.
  • Informe ao usuário se a matriz é simétrica.
Informações relevantes fornecidas pelo enunciado:
  • A matriz tem ordem 4, logo tem 4 linhas e 4 colunas.
  • A entrada vem do usuário (devemos ler os 16 elementos).
  • Devemos testar e imprimir dois resultados distintos: “é diagonal / não é diagonal” e “é simétrica / não é simétrica”.

Passo 2

O que significa “matriz diagonal”? Vou explicar devagarinho e com carinho:
  • Seja a matriz A=(a_{ij}), onde i é o índice da linha e j o índice da coluna.
  • Definição: A é diagonal se todos os elementos fora da diagonal principal forem zero. Em linguagem matemática:
\text{A é diagonal} \iff a_{ij}=0\quad\text{para todo }i\neq j.é
Ou seja, só os elementos com i=j (a diagonal principal) podem ser diferentes de zero.
Exemplo simples: a matriz
\begin{pmatrix} 3 & 0 & 0 & 0\\\\ 0 & -1 & 0 & 0\\\\ 0 & 0 & 7 & 0\\\\ 0 & 0 & 0 & 0 \end{pmatrix}
é diagonal.

Passo 3

O que significa “matriz simétrica”? Também explico passo a passo:
  • Para a mesma matriz A=(a_{ij}), dizemos que A é simétrica se ela for igual à sua transposta. Em termos de elementos:
\text{A é simétrica} \iff a_{ij} = a_{ji}\quad\text{para todo }i,j.éé
Na prática, basta verificar as posições acima da diagonal e compará-las com as posições correspondentes abaixo da diagonal. Exemplo:
\begin{pmatrix} 1 & 2 & 5 & 0\\\\ 2 & 3 & -1 & 4\\\\ 5 & -1 & 0 & 7\\\\ 0 & 4 & 7 & 2 \end{pmatrix}
é simétrica porque, por exemplo, o elemento na posição (1,2) é igual ao da posição (2,1), o de (1,3) igual ao de (3,1), etc.

Passo 4

Ideia do algoritmo para checar “diagonal”:
  • Percorremos todos os elementos a_{ij} da matriz.
  • Sempre que encontrarmos um elemento com i\neq j que não seja zero, já podemos concluir que a matriz não é diagonal.
  • Se percorrermos todos os elementos e nenhum elemento fora da diagonal for diferente de zero, então a matriz é diagonal.
    Em pseudo-passo:
  • isDiagonal = true
  • Para cada i de 1 a 4:
    • Para cada j de 1 a 4:
      • Se i\neq j e a_{ij}\neq 0 então isDiagonal = false
Observação prática: em C os índices vão de 0 a 3, então no código usaremos i=0..3 e j=0..3.

Passo 5

Ideia do algoritmo para checar “simetria”:
  • Não precisamos comparar todas as 16 posições com todas — isso seria redundante.
  • Basta comparar os elementos acima da diagonal com os correspondentes abaixo da diagonal. Ou seja, só testar pares (i,j) com j>i e verificar se a_{ij} == a_{ji}.
  • Se encontrarmos alguma diferença, a matriz não é simétrica; se todas as comparações forem iguais, a matriz é simétrica.
    Em pseudo-passo:
  • isSymmetric = true
  • Para cada i de 0 a 3:
    • Para cada j de i+1 a 3:
      • Se a_{ij} \neq a_{ji} então isSymmetric = false
Essa estratégia economiza comparações e é fácil de implementar.

Passo 6

Detalhes de implementação em C (coisas práticas que você precisa saber para implementar na prova):
  • Use um array bidimensional: int mat[4][4];
  • Leitura: dois laços for aninhados que fazem scanf("%d", &mat[i][j]);. Vou assumir inteiros, mas poderia ser double se for pedido.
  • Inicialize duas variáveis booleanas (em C puro sem <stdbool.h> podemos usar int isDiagonal = 1; int isSymmetric = 1;).
  • Faça primeiro a leitura dos 16 números, depois verifique as propriedades com laços.
  • Imprima mensagens claras para o usuário, por exemplo: “A matriz é diagonal.” ou “A matriz não é diagonal.” e similar para simetria.
  • Lembre-se: em C, 0 significa falso e qualquer valor não-zero é verdadeiro; aqui usaremos 1 para verdadeiro e 0 para falso.

Passo 7

Escrevendo o programa passo a passo (explicando cada parte do código):
  • #include <stdio.h>: traz printf e scanf.
  • int main() com retorno 0 no final.
  • Declaração: int mat[4][4]; int i, j; int isDiagonal = 1; int isSymmetric = 1;
  • Leitura dos elementos: dois laços for (i = 0; i < 4; i++) e dentro for (j = 0; j < 4; j++) e scanf("%d", &mat[i][j]);.
  • Verificação de diagonal: percorrer todos os i,j e, quando i != j e mat[i][j] != 0, atribuir isDiagonal = 0.
  • Verificação de simetria: percorrer só com j = i+1 e comparar mat[i][j] com mat[j][i], se diferente então isSymmetric = 0.
  • Impressão do resultado usando printf.

Passo 8

Um pequeno exemplo mental para você ganhar confiança:
  • Suponha que o usuário digite a matriz
\begin{pmatrix} 2 & 0 & 0 & 0\\\\ 0 & 5 & 0 & 0\\\\ 0 & 0 & -1 & 0\\\\ 0 & 0 & 0 & 9 \end{pmatrix}
Então o programa vai detectar que todos os a_{ij} com i\neq j são zero, logo isDiagonal fica 1. Também a matriz é simétrica (toda matriz diagonal é simétrica), então isSymmetric fica 1. O programa imprimirá que a matriz é diagonal e é simétrica — perfeito!

Resposta

#include <stdio.h>

int main() {
    int mat[4][4];
    int i, j;
    int isDiagonal = 1;  /* 1 = verdadeiro, 0 = falso */
    int isSymmetric = 1; /* 1 = verdadeiro, 0 = falso */

    printf("Digite os 16 elementos da matriz 4x4 (linha por linha):\n");
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            if (scanf("%d", &mat[i][j]) != 1) {
                printf("Entrada inválida.\n");
                return 1;
            }
        }
    }

    /* Verifica se é diagonal: todos os elementos fora da diagonal principal devem ser zero */
    for (i = 0; i < 4 && isDiagonal; i++) {
        for (j = 0; j < 4; j++) {
            if (i != j && mat[i][j] != 0) {
                isDiagonal = 0;
                break;
            }
        }
    }

    /* Verifica se é simétrica: mat[i][j] == mat[j][i] para todo i,j (só checamos j>i) */
    for (i = 0; i < 4 && isSymmetric; i++) {
        for (j = i + 1; j < 4; j++) {
            if (mat[i][j] != mat[j][i]) {
                isSymmetric = 0;
                break;
            }
        }
    }

    if (isDiagonal)
        printf("A matriz é diagonal.\n");
    else
        printf("A matriz não é diagonal.\n");

    if (isSymmetric)
        printf("A matriz é simétrica.\n");
    else
        printf("A matriz não é simétrica.\n");

    return 0;
}

Exercícios relacionados