Objetivo: validação booleana com curto-circuito manual.
Descrição: leia uma matriz \mathrm{N} \times \mathrm{N}(\mathrm{N}=5). Verifique se é identidade (1 na principal, 0 fora). Imprima “IDENTIDADE” ou “NAO”.
Critérios:
for duplo; usar if ( \mathrm{i}==\mathrm{j} ) e if ( \mathrm{i}!=\mathrm{j} ).
Permitir sair mais cedo marcando um flag (ex.: ehldentidade =0 ).
Extensão: contar quantas posições violam a regra.
Passo 1
O que o enunciado pede:
Ler uma matriz quadrada de tamanho N\times N com N=5.
Verificar se a matriz é a matriz identidade (ou seja, 1 na diagonal principal e 0 em todas as demais posições).
Imprimir a string “IDENTIDADE” se for identidade, ou “NAO” caso contrário.
Critério de implementação: usar um for duplo; usar os testes \text{if }(i==j) e \text{if }(i!=j); permitir sair cedo marcando um flag (por exemplo, ehIdentidade=0).
Extensão: contar quantas posições violam a regra (quantos elementos estão errados).
Informações fornecidas:
N=5.
A matriz (vou chamar de A) será lida do input; cada entrada é um número (assumimos valores inteiros 0 ou 1, mas o método funciona mesmo que apareça outro número).
Não foi fornecida uma matriz específica, então a tarefa é explicar o algoritmo e como implementá-lo, incluindo a variante que conta violações.
Passo 2
Definição precisa do que é uma matriz identidade:
Uma matriz A\) de ordem \(N\) é a identidade se, para todo par de índices \(i,j\) com \(0\le i,j\le N-1\),
\[A_{ij} = \begin{cases} 1, & \text{se } i=j,\\[4pt] 0, & \text{se } i\neq j. \end{cases}
Em palavras: todos os elementos na diagonal principal (posições onde i=j\]) devem ser \(1; todos os elementos fora da diagonal (onde i\neq j) devem ser 0.
Por que usar um flag (curto-circuito manual)?
Se encontramos uma posição que viola a regra, já sabemos que a matriz não é identidade. Não é necessário continuar verificando todas as posições (economia de trabalho). Colocamos ehIdentidade=0 e paramos os loops cedo — isso é o “curto-circuito manual”.
Porém, se a extensão pede contar todas as violações, não podemos parar no primeiro erro. Então há duas variantes: a) versão com saída precoce (mais eficiente), b) versão que conta todas as violações (variante para a extensão).]
Passo 3
Estratégia detalhada (passo a passo lógico):
Inicializar ehIdentidade = 1 (supondo inicialmente que é identidade) e cont = 0 (contador de violações).
Fazer dois loops aninhados: para i de 0 até N-1; dentro dele, para j de 0 até N-1.
Em cada par (i,j):
Se i==j: testar se A[i][j]==1. Se não for, incrementar cont e fazer ehIdentidade=0. Na versão com saída precoce, sair dos loops imediatamente.
Se i!=j: testar se A[i][j]==0. Se não for, incrementar cont e fazer ehIdentidade=0. Na versão com saída precoce, sair dos loops imediatamente.
Depois dos loops (ou logo após o curto-circuito), imprimir “IDENTIDADE” se ehIdentidade==1, caso contrário imprimir “NAO”.
Se estiver implementando a extensão, imprimir também o número de violações (valor de cont).
Passo 4
Pseudocódigo C-like (versão com saída precoce — atende os critérios):
\begin{aligned} &\text{/* suposição: leitura da matriz em A[5][5] já foi feita */}\\\ &N \leftarrow 5\\\ &ehIdentidade \leftarrow 1\\\ &cont \leftarrow 0\\\ &\text{for }( \,i=0\,; \; i < N \,; \; i++\, )\{\\\ &\quad\text{for }( \,j=0\,; \; j < N \,; \; j++\, )\{\\\ &\quad\quad\text{if }( \,i==j\, )\{\\\ &\quad\quad\quad\text{if }( \,A[i][j] != 1\, )\{ \; cont = cont + 1; \; ehIdentidade = 0; \; \text{break;} \; \}\\\ &\quad\quad\}\text{ else if }( \,i!=j\, )\{\\\ &\quad\quad\quad\text{if }( \,A[i][j] != 0\, )\{ \; cont = cont + 1; \; ehIdentidade = 0; \; \text{break;} \; \}\\\ &\quad\quad\}\\\ &\quad\}\\\ &\quad\text{if }( \,ehIdentidade==0\, ) \text{ break;} \quad\text{/* sai do loop de i */}\\\ &\}\\\ &\text{if }( \,ehIdentidade==1\, )\; \text{print }"IDENTIDADE" \;\text{else}\; \text{print }"NAO"\\\ &\text{(opcional: print } cont \text{ para ver quantas violações foram encontradas até o ponto em que parou)} \end{aligned}
Observações sobre o pseudocódigo:
Usei explicitamente os testes \text{if }(i==j) e \text{if }(i!=j) como exigido.
Quando detecto uma violação eu faço cont = cont + 1 e ehIdentidade=0, e uso um \text{break} para sair do loop interno. Após o loop interno verifico ehIdentidade para quebrar o loop externo também — assim ocorre o curto-circuito manual.
Passo 5
Variante para a extensão (contar todas as violações — não sair cedo):
Basta remover os \text{break} e permitir que os dois loops percorram todas as N^2 posições. Mantemos ehIdentidade=0 sempre que encontrarmos uma violação, e mantemos acumulando cont.
Pseudocódigo:
Observações: B[1][1]=0 deveria ser 1 (violação 1). Também B[2][3]=1 deveria ser 0 (violação 2).
Versão com saída precoce: o algoritmo encontra a primeira violação (por exemplo em (1,1)), faz cont=1, ehIdentidade=0 e pára; imprime “NAO” e cont=1 (mas parou cedo).
Versão que conta todas: percorre toda a matriz, encontra ambas violações; no fim ehIdentidade=0 e cont=2. Imprime “NAO” e imprime cont=2.]
Passo 7
Complexidade e recomendações práticas
Versão com curto-circuito: pior caso percorre N^2 elementos; melhor caso, se houver uma violação logo no início, para muito cedo. Complexidade no pior caso O(N^2).
Versão que conta tudo: sempre testa todas as N^2 posições — complexidade O(N^2).
Para N=5 o custo é trivial, então prefira a versão que conta todas as violações se você precisa do número exato; se apenas precisa saber se é identidade, a versão com curto-circuito é ligeiramente mais eficiente.
Atenção à leitura da matriz: ao ler valores, trate possíveis espaços/newlines e valide que leu inteiros.
Resposta
Se ehIdentidade==1 imprimir:
IDENTIDADE
Caso contrário imprimir:
NAO
Número de posições que violam a regra: cont