Opção para permitir que o usuário digite a mensagem codificada. O programa deverá executar o processo de decodificação e mostrar na tela a mensagem gerada. Caso a matriz decodificadora (B) ainda não tenha sido armazenada, o programa deverá imprimir uma mensagem de erro, informando ao usuário que a matriz (B) deve ser cadastrada.

Passo 1

O enunciado pede uma opção do programa que permita ao usuário digitar uma mensagem codificada e que o programa faça a decodificação mostrando a mensagem resultante na tela. Se a matriz decodificadora B ainda não tiver sido armazenada, o programa deve imprimir uma mensagem de erro informando que a matriz B deve ser cadastrada.
Informações relevantes (explicitamente dadas ou necessárias para implementar a opção):
  • Existe uma matriz decodificadora chamada B que, se cadastrada, será usada para transformar blocos da mensagem codificada em blocos da mensagem decodificada.
  • O programa deve detectar se B está cadastrada; se não estiver, exibir mensagem de erro clara: a matriz B deve ser cadastrada.
  • O usuário irá “digitar a mensagem codificada” — o enunciado não especifica o formato exato dessa mensagem (sequência de números, sequência de caracteres já mapeados, presença de separadores, uso de aritmética modular etc.). Isso é relevante porque o programa precisa interpretar corretamente a entrada.
  • É necessário que o programa verifique compatibilidade entre o tamanho dos blocos esperados por B e o tamanho da mensagem codificada (p. ex. comprimento múltiplo do tamanho do bloco) ou aplique um esquema de padding.
  • O enunciado não exige uma linguagem específica; deve-se apresentar procedimento/algoritmo (pseudocódigo) que implemente essa opção.

Passo 2

Entendimento teórico mínimo necessário (conceito-chave que o programa usa).
A ideia geral usada por esquemas de codificação por matrizes é a seguinte:
  • A mensagem original é dividida em blocos de dimensão n e cada bloco de texto é transformado em um vetor numérico \,p\in\mathbb{Z}^n, (cada componente corresponde a um caractere segundo um mapeamento acordado).
  • A codificação normalmente produz um vetor cifrado c a partir de um vetor p usando uma matriz de codificação A:
c = A\,p.
  • A decodificação usa uma matriz decodificadora B tal que, quando aplicada ao vetor cifrado, recupera o vetor original:
p = B\,c.
Isso acontece quando B é a inversa de A (no mesmo universo numérico em que A foi definida). Em notação:
B = A^{-1}\quad\text{(ou a inversa modular, se o esquema for em aritmética modular).}é
O que cada símbolo significa:
  • A: matriz de codificação (não necessariamente presente no momento do decode).
  • B: matriz de decodificação (deve estar previamente cadastrada no programa).
  • p: vetor coluna de n componentes representando um bloco de texto claro (plaintext).
  • c: vetor coluna de n componentes representando um bloco de texto codificado (ciphertext).
  • n: dimensão da matriz quadrada B (então B é n\times n e cada bloco tem n números).
  • Se o esquema usa aritmética modular (por exemplo, cifra de Hill usa módulo m=26), as operações de multiplicação e soma são feitas módulo m e B deve ser a inversa de A no anel \mathbb{Z}_m.
Resumo prático: para decodificar, o programa deve pegar a sequência codificada, agrupá-la em blocos coluna c de tamanho n e calcular p = B c (ou p \equiv B c \pmod m se for modular). Depois mapear os números do vetor p de volta para caracteres.

Passo 3

Como representar a mensagem codificada na entrada e como o programa deve interpretar — opções e recomendação.
Possíveis formatos que o usuário pode digitar:
  1. Sequência de números inteiros separados por espaço/virgula: exemplo: 23 8 4 17 0 11.
    • Interpretação direta: cada número é uma componente do vetor c. É o formato mais direto se a codificação resultou em números.
  2. String de caracteres já “codificados” (por ex., letras que correspondem a números segundo algum mapa): exemplo: X I E R A L.
    • O programa precisa aplicar o mesmo mapeamento usado na codificação (por exemplo, A\mapsto0,\;B\mapsto1,\dots ou A\mapsto1 etc.). É obrigatório que o programa saiba qual mapeamento foi usado.
  3. Sequência em base64/hex/bytes — casos mais gerais, exigem decodificação prévia para uma sequência numérica.
Recomendação para a opção do programa na prova (simplifica implementação e é robusta):
  • Exigir que o usuário digite a mensagem codificada como números inteiros separados por espaços (ou vírgulas). Isso evita ambiguidade.
  • Se quiserem aceitar letras, o programa deve pedir que o usuário informe qual mapeamento foi usado ou usar um mapeamento padrão documentado.

Passo 4

Verificações que o programa deve fazer antes de tentar decodificar (lista de checagens e por que são importantes).
  1. Verificar se a matriz B está cadastrada/armazenada:
    • Se não estiver, imprimir exatamente a mensagem de erro exigida (algo como: “Erro: matriz B não cadastrada. Cadastre a matriz B antes de decodificar.”) e abortar a operação.
  2. Verificar se B é uma matriz quadrada e obter n (número de linhas/colunas).
    • Se B não for quadrada, decodificação por blocos não faz sentido; tratar como erro.
  3. Ler a entrada da mensagem codificada e convertê-la em uma lista/array de números.
    • Se a entrada não for numérica e nem existir um mapeamento conhecido, imprimir erro de formato.
  4. Verificar se o comprimento da lista de números é múltiplo de n.
    • Se não for, aplicar padding (ex.: adicionar zeros ou um símbolo de preenchimento conhecido) ou pedir ao usuário para ajustar. Para provas, explicar e usar padding com um valor claro (por exemplo, 0 ou o código de espaço).
  5. Em caso de aritmética modular, certificar-se do valor do módulo m e que os números estão no intervalo apropriado; caso contrário, reduzir módulo m.

Passo 5

Como multiplicar a matriz B por um bloco coluna c — fórmula e explicação passo a passo para fazer à mão na prova.
Se B é n\times n e c é vetor coluna n\times1, a multiplicação p = B c dá um vetor coluna p de n componentes. Para calcular a componente i-ésima de p:
p_i = \sum_{j=1}^{n} B_{ij}\,c_j.
Explicação detalhada:
  • B_{ij} é o elemento da linha i e coluna j da matriz B.
  • c_j é o j-ésimo elemento do vetor c.
  • Multiplica-se cada elemento B_{ij} pelo correspondente c_j e soma-se todos os produtos para obter p_i.
  • Repetir para i=1,2,\dots,n.
Se as operações forem em módulo m, calcular cada produto e soma e depois reduzir módulo m:
p_i \equiv \left(\sum_{j=1}^{n} B_{ij}\,c_j\right) \pmod m.
Quando for necessário retornar caracteres, mapear cada p_i para um caractere segundo o mapeamento adotado (por ex., \,0\mapsto A,\;1\mapsto B,\dots ou outro).

Passo 6

Exemplo numérico completo (sem módulo) para fixar a técnica — mostra como computar passo a passo.
Suponha que a matriz B cadastrada seja
B=\begin{pmatrix}1 & -2\\[4pt]0 & 1\end{pmatrix},
logo n=2. Suponha que o usuário digite a mensagem codificada como números: 23 8 11 4. Interpretamos isso como dois blocos coluna c^{(1)} e c^{(2)}:
c^{(1)}=\begin{pmatrix}23\\[4pt]8\end{pmatrix},\qquad c^{(2)}=\begin{pmatrix}11\\[4pt]4\end{pmatrix}.
Decodificando bloco a bloco:
  • Para c^{(1)}:
p^{(1)}=B\,c^{(1)}= \begin{pmatrix}1 & -2\\[4pt]0 & 1\end{pmatrix} \begin{pmatrix}23\\[4pt]8\end{pmatrix} = \begin{pmatrix}1\cdot23 + (-2)\cdot8\\[4pt]0\cdot23 + 1\cdot8\end{pmatrix} = \begin{pmatrix}23 - 16\\[4pt]8\end{pmatrix} = \begin{pmatrix}7\\[4pt]8\end{pmatrix}.
  • Para c^{(2)}:
p^{(2)}=B\,c^{(2)}= \begin{pmatrix}1\cdot11 + (-2)\cdot4\\[4pt]0\cdot11 + 1\cdot4\end{pmatrix} = \begin{pmatrix}11 - 8\\[4pt]4\end{pmatrix} = \begin{pmatrix}3\\[4pt]4\end{pmatrix}.
Se o mapeamento for 0\mapsto A,\;1\mapsto B,\;\dots,\;25\mapsto Z, então:
  • p^{(1)}=(7,8) 7\mapsto H,\;8\mapsto I → “HI”.
  • p^{(2)}=(3,4) 3\mapsto D,\;4\mapsto E → “DE”.
Mensagem decodificada completa: “HIDE” (ou “HI DE” se separada por blocos). Esse exemplo mostrou passo a passo a multiplicação de linhas por colunas e o mapeamento final.]

Passo 7

Pseudocódigo robusto e didático (implementável em prova e em prática). Comentários explicativos acompanham cada etapa.
  • Entrada esperada do usuário: sequência de números inteiros separados por espaço (forma recomendada).
  • Pré-requisito: variável/estrutura B armazenada (matriz n\times n). Se não existir, imprimir erro.
Pseudocódigo:
function DecodificarMensagemEntrada():
  1. Se B não existe então
    imprimir “Erro: matriz B não cadastrada. Cadastre a matriz B antes de decodificar.”
    retornar
  2. n \leftarrow dimensão de B (número de linhas)
  3. pedir ao usuário: “Digite a mensagem codificada (números separados por espaços):”
  4. ler a string de entrada s
  5. converter s em lista de inteiros L (se falhar, imprimir “Formato inválido” e retornar)
  6. se |L| \bmod n \neq 0 então
    • perguntar se quer aplicar padding automático (ex.: adicionar zeros) ou retornar erro
    • se escolher padding então adicionar números (por ex., zeros) até |L| ser múltiplo de n
    • caso contrário retornar
  7. dividir L em blocos coluna c^{(k)} de tamanho n, para k=1,\dots,K
  8. inicializar lista vazia P para armazenar componentes decodificadas
  9. para cada bloco c^{(k)}:
    • calcular p^{(k)} = B \times c^{(k)}
      (para cada i de 1 a n: p^{(k)}_i = \sum_{j=1}^{n} B_{ij}\,c^{(k)}_j)
    • se for esquema modular com módulo m então reduzir cada p^{(k)}_i \bmod m
    • se valores de p^{(k)}_i são reais aproximados, arredondar para o inteiro mais próximo
    • anexar os componentes de p^{(k)} à lista P
  10. mapear cada número em P para caractere segundo o mapeamento acordado (ex.: 0\mapsto A, …)
  11. concatenar os caracteres resultantes numa string mensagem_decodificada
  12. imprimir “Mensagem decodificada:” seguido de mensagem_decodificada
  13. retornar mensagem_decodificada
Complexidade: para K blocos e matriz n\times n, o custo é O(K n^2) operações aritméticas (cada multiplicação de matriz por vetor leva O(n^2)).

Passo 8

Casos especiais, erros comuns e dicas para a prova (para ganhar pontos e evitar pegadinhas).
  • Se o enunciado especificou aritmética modular (por exemplo, cifra de Hill com módulo 26), o candidato deve mencionar explicitamente que a multiplicação e soma são realizadas módulo m e que B deve ser a inversa de A no módulo m. Sem isso, os resultados estarão errados.
  • Validação de dimensão é obrigatória: se a matriz B é n\times n, a entrada numérica deve ser dividida em blocos de n. Nunca tente multiplicar blocos de tamanho diferente sem redimensionar.
  • Ao lidar com números reais (se B tiver entradas não inteiras), depois da multiplicação pode ser necessário arredondar com tolerância (ex.: aceitar erro até 10^{-6} antes de arredondar).
  • Use um mapeamento documentado e consistente (por exemplo, explique no programa qual mapeamento foi usado).
  • Mensagens de erro devem ser claras e obedecer ao pedido do enunciado (no enunciado foi pedido: imprimir mensagem de erro informando que a matriz B deve ser cadastrada).
  • Para provas, é bom apresentar também um pequeno exemplo numérico (como o do Passo 6) para demonstrar que entendeu o procedimento inteiro.

Resposta

function DecodificarMensagemEntrada():
  1. if B não existe then
    imprimir “Erro: matriz B não cadastrada. Cadastre a matriz B antes de decodificar.”
    return
  2. n \leftarrow dimensão de B (número de linhas)
  3. pedir ao usuário: “Digite a mensagem codificada (números inteiros separados por espaços):”
  4. ler string s
  5. tentar converter s em lista de inteiros L
    if falha então
    imprimir “Formato inválido: entrada deve conter números inteiros separados por espaços.”
    return
  6. if |L| \bmod n \neq 0 then
    perguntar “Comprimento não múltiplo de n. Aplicar padding com zeros? (s/n)”
    if resposta = ‘s’ então
    adicionar zeros em L até |L| ser múltiplo de n
    else
    imprimir “Operação cancelada. Ajuste o tamanho da mensagem codificada.”
    return
  7. dividir L em blocos c^{(k)} de tamanho n para k=1,\dots,K
  8. inicializar lista vazia P
  9. para k = 1 to K:
    calcular vetor p^{(k)} de tamanho n por:
    para i = 1 to n:
    p^{(k)}_i \leftarrow \sum_{j=1}^{n} B_{ij}\,c^{(k)}_j
    se esquema modular com módulo m então
    para i = 1 to n: p^{(k)}_i \leftarrow p^{(k)}_i \bmod m
    senão
    para i = 1 to n: p^{(k)}_i \leftarrow arredondar( p^{(k)}_i) se necessário
    anexar componentes de p^{(k)} à lista P
  10. mapear cada número em P para caractere segundo mapeamento escolhido (ex.: 0\mapsto A,\;1\mapsto B,\dots)
  11. concatenar caracteres em mensagem_decodificada
  12. imprimir “Mensagem decodificada:” e a mensagem_decodificada
  13. return mensagem_decodificada

Exercícios relacionados