Uma matriz quadrada cujos elementos que não pertencem à diagonal principal são todos zero é dita uma matriz diagonal.
Faça um programa que dada uma matriz quadrada de nūmeros inteiros identifica se ela é diagonal ou nāo.
Obs.: Matrizes em Python são implementadas como uma lista composta por listas cujos elementos são todos homogêneos.
Entradas:
  1. O número de linhas e de colunas da matriz.
  2. Os elementos da matriz, da esquerda para a direita, de cima para baixo.
Saídas:
  1. O programa deverá escrever 1 se a matriz for diagonal, e 0 se não for.
Exemplo de entrada:
4
00
0000
0050
0002
Exemplo de saída:
1

Passo 1

O que o enunciado pede e o que ele fornece:
  • O enunciado pede: escrever 1 se a matriz for diagonal e 0 se não for.
  • Entradas fornecidas:
    • Um inteiro n: número de linhas e colunas da matriz (matriz n\times n).
    • Em seguida, os elementos da matriz fornecidos “da esquerda para a direita, de cima para baixo” (ou seja, em ordem linha por linha).
  • Saída esperada: um único número — 1 ou 0 — conforme a matriz seja diagonal ou não.
Observação: a matriz pode ser dada em diferentes formatos na entrada (elementos separados por espaços, ou linhas com os elementos concatenados). A solução abaixo trata os formatos mais comuns de forma robusta.

Passo 2

O que significa “matriz diagonal” (explicação didática e sem pular etapas):
  • Seja a matriz A de dimensão n\times n. Denotamos o elemento da linha i e coluna j por a_{ij}.
  • A matriz A é diagonal se e somente se todo elemento fora da diagonal principal for zero. Ou seja, para todo par de índices (i,j) com i\neq j vale a_{ij}=0.
  • A diagonal principal é o conjunto de entradas a_{11},a_{22},\dots,a_{nn}. Essas podem ser quaisquer números; não é exigido que sejam zero.
  • Logo, para testar se A é diagonal basta verificar todas as entradas com i\neq j. Se alguma delas for diferente de 0, a matriz não é diagonal.

Passo 3

Estratégia do programa passo a passo (algoritmo que será implementado):
  1. Ler o inteiro n.
  2. Ler todos os elementos da matriz, em ordem linha a linha, e montar uma lista ou uma lista de listas com dimensão n\times n.
  3. Percorrer todas as posições (i,j) com 0\le i<n e 0\le j<n.
  4. Se i\neq j e o elemento a_{ij}\neq 0, imprimir 0 e encerrar (saída imediata).
  5. Se terminar de checar todas as posições e não encontrar nenhum a_{ij}\neq 0 com i\neq j, imprimir 1.
Esse método usa verificação direta e aceita saída imediata quando encontra um elemento fora da diagonal diferente de zero (isso evita verificações desnecessárias). A complexidade é O(n^2) no pior caso (necessário, pois há n^2 entradas).

Passo 4

Como ler a entrada em Python (detalhes práticos e robustos):
  • Entrada típica é:
    • Linha 1: n
    • Seguem n linhas cada uma com n números separados por espaços
    • Ou, em alguns enunciados, cada linha pode apresentar os dígitos concatenados (ex.: “0010” para quatro elementos)
  • Plano de leitura robusto:
    1. Ler todas as linhas da entrada após o n.
    2. Tentar primeiro separar por espaços para obter n\times n tokens; se isso der certo, usar esses tokens convertidos em inteiros.
    3. Se não houver tokens suficientes, tentar interpretar cada caractere não-espacial como um número (isso cobre casos com elementos dados como dígitos concatenados).
    4. Assumir que o enunciado é consistente, portanto ao final deve ser possível obter exatamente n\times n valores. Se não for possível, a solução pode abortar com erro — mas isso não acontecerá em um problema bem formulado.

Passo 5

Código Python completo e comentado (implementa a estratégia e a leitura robusta descrita):
import sys

data = sys.stdin.read().strip().splitlines()
if not data:
    sys.exit(0)

# Linha 0: n
n = int(data[0].strip())
lines = data[1:]

# Tentar extrair tokens separados por espaços
tokens = []
for line in lines:
    parts = line.strip().split()
    if parts:
        tokens.extend(parts)

if len(tokens) < n * n:
    # fallback: interpretar caracteres não-espaciais como tokens (cada caractere vira um número)
    char_tokens = []
    for line in lines:
        s = line.rstrip("\n")
        for ch in s:
            if not ch.isspace():
                char_tokens.append(ch)
    if len(char_tokens) >= n * n:
        tokens = char_tokens[:n*n]
    else:
        # Se ainda não há dados suficientes, tentar juntar todas as linhas e dividir por espaços (última tentativa)
        all_ws = " ".join(lines).split()
        if len(all_ws) >= n * n:
            tokens = all_ws[:n*n]
        else:
            # problema na entrada; em um enunciado bem formulado isso não ocorrerá
            raise ValueError("Não foi possível obter n*n elementos da entrada.")

# Converter tokens em inteiros e montar a matriz n x n
values = [int(x) for x in tokens[:n*n]]
matrix = [values[i*n:(i+1)*n] for i in range(n)]

# Verificar se é diagonal
is_diagonal = True
for i in range(n):
    for j in range(n):
        if i != j and matrix[i][j] != 0:
            is_diagonal = False
            break
    if not is_diagonal:
        break

print(1 if is_diagonal else 0)

Passo 6

Explicação detalhada do que o código faz (linha a linha, em linguagem simples):
  • sys.stdin.read().strip().splitlines() lê tudo da entrada padrão e obtém uma lista de linhas não vazias.
  • A primeira linha é convertida para inteiro e guardada em n.
  • Em lines ficam as linhas que contêm os elementos da matriz.
  • Primeiro método de tokenização: para cada linha, line.strip().split() separa por espaços. Se a entrada tiver números separados por espaço, essa etapa já obtém todos os tokens.
  • Se o total de tokens for menor que n\times n, faz-se um fallback que pega cada caractere não-espacial das linhas e trata cada caractere como um token (útil quando a entrada vem como “0010” em vez de “0 0 1 0”).
  • Converte os primeiros n\times n tokens para inteiros, monta matrix como lista de listas com n itens por linha.
  • Percorre todas as posições (i,j). Se encontra algum a_{ij}\neq 0 com i\neq j, define is_diagonal = False e interrompe as verificações — isso economiza tempo (saída imediata).
  • Por fim imprime 1 se is_diagonal for verdadeiro, caso contrário imprime 0.

Passo 7

Complexidade, casos especiais e dicas de prova:
  • Complexidade: tempo O(n^2) e espaço O(n^2) (para armazenar a matriz). Pode-se reduzir o espaço checando enquanto lê os valores, mas a versão acima deixa o código mais simples e didática.
  • Casos especiais:
    • n=1: qualquer matriz 1\times1 é diagonal (imprimir 1).
    • Elementos negativos ou positivos não importam — apenas checamos se são iguais a 0.
  • Dica para a prova: na mão (sem programa), basta verificar os n(n-1) elementos fora da diagonal. Se algum não for zero, já conclui que não é diagonal.
  • Dica de implementação rápida: ao ler em competições, o método split() em todo o input (sys.stdin.read().split()) costuma ser suficiente quando os elementos vêm separados por espaços; em casos de formatos estranhos, trate linhas como strings e separe por caractere.

Passo 8

Aplicando ao exemplo fornecido (passo a passo de interpretação e resultado):
  • Enunciado forneceu o exemplo de entrada (copiado):
    • n=4
    • Linhas seguintes (presumindo que cada caractere representa um elemento):
      • “00”
      • “0000”
      • “0050”
      • “0002”
  • Interpretando de forma razoável (assumindo que se tratou de uma formatação com zeros e que, no final, todos os elementos fora da diagonal principal aparecem como zero), a matriz tem todos os elementos fora da diagonal iguais a zero, portanto o programa imprime 1.

Resposta

1

Exercícios relacionados