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:
- O número de linhas e de colunas da matriz.
- Os elementos da matriz, da esquerda para a direita, de cima para baixo.
Saídas:
- 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
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:
00
0000
0050
0002
Passo 1
O que o enunciado pede e o que ele fornece:
- O enunciado pede: escrever
se a matriz for diagonal e se não for. - Entradas fornecidas:
- Um inteiro
: número de linhas e colunas da matriz (matriz ). - Em seguida, os elementos da matriz fornecidos “da esquerda para a direita, de cima para baixo” (ou seja, em ordem linha por linha).
- Um inteiro
- Saída esperada: um único número —
ou — 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
de dimensão . Denotamos o elemento da linha e coluna por . - A matriz
é diagonal se e somente se todo elemento fora da diagonal principal for zero. Ou seja, para todo par de índices com vale . - A diagonal principal é o conjunto de entradas
. Essas podem ser quaisquer números; não é exigido que sejam zero. - Logo, para testar se
é diagonal basta verificar todas as entradas com . Se alguma delas for diferente de , a matriz não é diagonal.
Passo 3
Estratégia do programa passo a passo (algoritmo que será implementado):
- Ler o inteiro
. - Ler todos os elementos da matriz, em ordem linha a linha, e montar uma lista ou uma lista de listas com dimensão
. - Percorrer todas as posições
com e . - Se
e o elemento , imprimir e encerrar (saída imediata). - Se terminar de checar todas as posições e não encontrar nenhum
com , imprimir .
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 é
no pior caso (necessário, pois há
entradas).
Passo 4
Como ler a entrada em Python (detalhes práticos e robustos):
- Entrada típica é:
- Linha 1:
- Seguem
linhas cada uma com números separados por espaços - Ou, em alguns enunciados, cada linha pode apresentar os dígitos concatenados (ex.: “0010” para quatro elementos)
- Linha 1:
- Plano de leitura robusto:
- Ler todas as linhas da entrada após o
. - Tentar primeiro separar por espaços para obter
tokens; se isso der certo, usar esses tokens convertidos em inteiros. - 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).
- Assumir que o enunciado é consistente, portanto ao final deve ser possível obter exatamente
valores. Se não for possível, a solução pode abortar com erro — mas isso não acontecerá em um problema bem formulado.
- Ler todas as linhas da entrada após o
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
linesficam 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
tokensfor menor que, faz-se um fallbackque 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
tokens para inteiros, monta matrixcomo lista de listas comnitens por linha. - Percorre todas as posições
. Se encontra algum com , define is_diagonal = Falsee interrompe as verificações — isso economiza tempo (saída imediata). - Por fim imprime
1seis_diagonalfor verdadeiro, caso contrário imprime0.
Passo 7
Complexidade, casos especiais e dicas de prova:
- Complexidade: tempo
e espaço (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:
-
: qualquer matriz é diagonal (imprimir ). - Elementos negativos ou positivos não importam — apenas checamos se são iguais a
.
-
- Dica para a prova: na mão (sem programa), basta verificar os
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):
-
- 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
.
Resposta
1