Questão 4

Construa um programa em LINGUAGEM C que crie uma matriz identidade com o tamanho informado pelo usuário N e armazene os seus respectivos valores. Em seguida mostre na tela a matriz identidade.
Dica 1: Matriz identidade é uma matriz quadrada onde os termos da diagonal principal são 1 e os demais termos são 0 .
Dica 2: Use o teste condicional “if” para verificar se a posição da linha é igual da coluna para armazenar o 1, caso contrário “else” armazene 0 na posição.

Passo 1

O enunciado pede claramente o seguinte:
  • O usuário informa um número inteiro N (tamanho).
  • Deve-se construir uma matriz identidade de tamanho N\times N e armazenar seus valores.
  • Em seguida, mostrar na tela a matriz identidade.
    Informações dadas/úteis:
  • Matriz identidade: elementos da diagonal principal são 1 e todos os outros elementos são 0.
  • Sugestão do enunciado: usar um teste condicional que verifica se a posição da linha é igual à coluna (se sim, armazenar 1; senão, armazenar 0).

Passo 2

Escolha do método e ideia geral (algoritmo):
  • Vamos usar uma matriz armazenada em memória dinâmica para aceitar qualquer N informado em tempo de execução. A implementação usará um bloco contíguo de memória com tamanho N\times N e indexação por fórmula.
  • Usaremos dois laços aninhados para percorrer linhas i e colunas j, com i variando de 0 até N-1 e j variando de 0 até N-1.
  • Para cada posição (i,j) aplicamos o teste condicional: se i==j então armazenamos 1, caso contrário armazenamos 0.
  • A razão de usar alocação contígua (uma única chamada a malloc) é simplicidade e eficiência de memória; a posição (i,j) ficará em índice linear i\times N + j.

Passo 3

Conceitos de C que vamos usar (explicação didática, calma e sem pânico):
  • Entrada do usuário: usamos scanf para ler um inteiro N. Conferir o retorno de scanf garante que a entrada é válida.
  • Teste de validade: verificar se N>0. Se não, avisar e encerrar.
  • Alocação dinâmica: malloc retorna um ponteiro para um bloco de memória. Aqui vamos pedir N * N * sizeof(int) bytes. Sempre checar se malloc retornou NULL (falha de alocação).
  • Indexação em bloco contíguo: se mat é int *, então o elemento da linha i e coluna j é mat[i * N + j]. Atenção: em C os índices começam em 0, então usamos i\in\{0,\dots,N-1\}.
  • Laços for: percorrem índices i e j.
  • Condicional if (i == j): quando verdade guardamos 1, senão 0.
  • Impressão: printf para mostrar a matriz; imprimiremos cada linha numa linha do terminal, separando colunas por espaço para ficar legível.
  • Liberação de memória: usar free ao final para evitar vazamento.

Passo 4

Construção passo a passo do código (comentado linha a linha na lógica):
  1. Inclusões necessárias:
    • #include <stdio.h> para printf/scanf.
    • #include <stdlib.h> para malloc, free e perror.
  2. Ler N:
    • Perguntar ao usuário e usar scanf("%d", &N).
    • Verificar se scanf devolveu 1 (leitura bem-sucedida).
    • Verificar se N>0; se não, imprimir mensagem de erro e sair com código de erro.
  3. Alocar memória:
    • Fazer int *mat = malloc((size_t)N * N * sizeof(int));
    • Verificar mat != NULL. Se NULL, usar perror e terminar.
  4. Preencher a matriz:
    • Dois for: for (int i = 0; i < N; ++i) e dentro for (int j = 0; j < N; ++j).
    • linha de armazenamento: mat[i * N + j] = (i == j) ? 1 : 0;
      • Aqui uso o operador ternário para ficar compacto; pode-se usar if/else como sugerido.
  5. Imprimir a matriz:
    • Novos laços aninhados; para cada elemento imprimir com printf("%d", mat[i*N + j]); e imprimir espaço entre colunas, \n ao final de cada linha.
  6. Liberar memória com free(mat); e terminar return 0;.

Passo 5

Observações importantes para a prova e variantes simples que podem aparecer:
  • O enunciado sugeriu usar if; se preferir, substitua a expressão ternária por:
    if (i == j) {
        mat[i*N + j] = 1;
    } else {
        mat[i*N + j] = 0;
    }
    
  • Atenção ao índice começar em 0. Muitos iniciantes esquecem e fazem for (i=1;i<=N;i++) sem ajustar indexação.
  • Se o professor permitir, outra forma mais simples (mas menos flexível) é declarar int mat[100][100]; e usar N até 100; isso evita malloc mas limita o tamanho. Em prova, adapte conforme instrução.
  • Sempre checar erros de entrada e de malloc para programas robustos.

Passo 6

Exemplo de execução no shell (para testar mentalmente):
  • Suponha que o usuário digite N=4.
  • O programa imprimirá:
    (linha 1) 1 0 0 0
    (linha 2) 0 1 0 0
    (linha 3) 0 0 1 0
    (linha 4) 0 0 0 1
    Isto é exatamente a matriz identidade 4\times 4.

Passo 7

Compilar e rodar (dicas práticas):
  • Compile com gcc -std=c99 -Wall -Wextra programa.c -o programa (opcional -std=c11).
  • Execute com ./programa e informe N quando solicitado.
  • Se usar Windows com MinGW, o comando gcc é o mesmo; execute programa.exe.

Passo 8

Encerramento motivacional e resumo rápido:
  • A ideia central para a prova é esta: percorrer todas as posições (i,j), testar se i==j e escrever 1 ou 0. Isso é repetição + condicional + armazenamento em array.
  • Respira fundo — uma vez que você entenda o mecanismo i*N + j e que índices começam em 0, a resolução fica bem direta. Vai dar certo!

Resposta

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int N;
    printf("Informe o tamanho N da matriz identidade: ");
    if (scanf("%d", &N) != 1) {
        fprintf(stderr, "Entrada inválida.\n");
        return 1;
    }

    if (N <= 0) {
        fprintf(stderr, "N deve ser um inteiro positivo.\n");
        return 1;
    }

    int *mat = malloc((size_t)N * N * sizeof(int));
    if (mat == NULL) {
        perror("Erro ao alocar memória");
        return 1;
    }

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (i == j) {
                mat[i * N + j] = 1;
            } else {
                mat[i * N + j] = 0;
            }
        }
    }

    printf("Matriz identidade %d x %d:\n", N, N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            printf("%d", mat[i * N + j]);
            if (j < N - 1) printf(" ");
        }
        printf("\n");
    }

    free(mat);
    return 0;
}

Exercícios relacionados