a) Escreva a função decodifica para exibir na tela a decodificação de mensagens. As mensagens foram codificadas utilizando símbolos especiais no lugar das vogais. Para decodificar a mensagem deve ser utilizado o seguinte dicionário dVogal: dVogal = {’@’:‘A’,’&’:‘E’,’%’:‘I’,’*’:‘O’,’$’:‘U’} A função decodifica:
  • recebe uma string com a mensagem codificada em maiúsculas e o dicionário dVogal
  • retorna uma string com a mensagem decodificada.
EXEMPLOS:
A mensagem codificada ‘BN&C@’ retorna ‘BONECA’
A mensagem codificada 'Q$@ND
@ CH$V@ P@SS*$’ retorna ‘QUANDO A CHUVA PASSOU’
3.b) Teste a função decodifica para as mensagens abaixo (msg1 e msg2) exibindo as respostas retornadas.
msg1: ‘Q$@ND* @ CH$V@ P@SS*$’
msg2: ‘$R BR@NC* $R N&GR*’
Obs: dicionários devem ser manipulados como dicionários. Não é para transformar em outra estrutura (como lista) e usar a outra estrutura.

Passo 1

O que o enunciado pede e o que já temos (informação extraída do enunciado):
  • Pede-se implementar uma função chamada decodifica.
  • A função:
    • recebe uma string com a mensagem codificada em maiúsculas;
    • recebe um dicionário chamado dVogal que mapeia símbolos especiais para vogais;
    • devolve (retorna) uma string com a mensagem decodificada.
  • O dicionário dado é:
    • dVogal = {'@':'A', '&':'E', '%':'I', '*':'O', '$':'U'}
  • Exemplos informados no enunciado (para conferir depois):
    • A mensagem codificada 'B*N\&C@' (interpretação: B*N&C@) deve retornar 'BONECA'.
    • A mensagem codificada 'Q\$@ND* @ CH\$V@ P@SS*\$' (interpretação: Q\(@ND* @ CH\)V@ P@SS*$) deve retornar 'QUANDO A CHUVA PASSOU'.
  • Pedido extra (3.b): testar a função para duas mensagens e exibir as respostas retornadas:
    • msg1 = 'Q\(@ND* @ CH\)V@ P@SS*$'
    • msg2 = '*\(R* BR@NC* *\)R* N&GR*'
  • Observação importante dada: os dicionários devem ser usados como dicionários (não transformar o dicionário em outra estrutura para fazer a tradução).

Passo 2

Escolha do método (algoritmo) — explicando devagar e por que é uma boa opção:
  • Vamos percorrer (iterar) a string caractere por caractere. Para cada caractere:
    • se o caractere for uma chave presente em dVogal, substituímos pelo valor dVogal[caractere] (a vogal correspondente);
    • caso contrário, mantemos o caractere igual (ex.: consoantes, espaços, pontuação).
  • Por que usar dicionário diretamente:
    • Dicionário em Python permite consulta rápida por chave: dVogal[ch] ou, melhor, dVogal.get(ch, ch) para obter o mapeamento ou, se não existir, retornar o próprio caractere.
    • Isso respeita a exigência de manipular dicionários como dicionários (não transformar dVogal numa lista para buscar).
  • Complexidade e comportamento:
    • Percorrer a string tem custo linear no tamanho da mensagem (cada caractere é processado uma vez).
    • Mantém maiúsculas e espaços tal como estão.
    • Esta abordagem funciona sem usar funções “mágicas” (como tabelas de tradução) e é simples de raciocinar numa prova.
  • Exemplo rápido de ideia (sem código ainda): ao ver '\(' consulto dVogal['\)'] e obtenho 'U'; ao ver 'B' consulto dVogal.get('B', 'B') que não existe, então recebo 'B'.

Passo 3

Implementação passo a passo em Python — explicando cada linha como se estivéssemos escrevendo na prova:
  • Definição da função e parâmetros:
    • def decodifica(mensagem, dVogal):
      • mensagem é a string codificada (ex.: 'Q$@ND* ...').
      • dVogal é o dicionário que mapeia símbolos para vogais.
  • Criação de uma lista para ir acumulando os caracteres decodificados (usar lista é eficiente para concatenar depois com ''.join(...)):
    • resultado = []
      • Explicação: strings são imutáveis em Python; concatenar repetidamente em um laço é custoso. Montar uma lista de caracteres e depois juntar é a prática recomendada.
  • Percorrer cada caractere da mensagem:
    • for ch in mensagem:
      • ch é uma variável que toma cada caractere da string, um por vez, da esquerda para a direita.
  • Para cada caractere, obter a tradução no dicionário ou manter o caractere original:
    • dec = dVogal.get(ch, ch)
      • dVogal.get(ch, ch) significa: se ch for chave em dVogal, retorna dVogal[ch]; caso contrário, retorna ch (o segundo argumento é o valor padrão).
      • Isso garante que consoantes, espaços e símbolos não mapeados fiquem iguais.
  • Guardar o caractere decodificado na lista:
    • resultado.append(dec)
  • No final, juntar a lista de caracteres em uma string:
    • return ''.join(resultado)
      • ''.join(resultado) pega todos os elementos da lista resultado e concatena numa única string.
  • Código completo (resumido em uma “receita” que pode ser copiada na prova):
    • def decodifica(mensagem, dVogal):
    • resultado = []
    • for ch in mensagem:
    • dec = dVogal.get(ch, ch)
    • resultado.append(dec)
    • return ''.join(resultado)

Passo 4

Observações finais sobre a implementação e variações possíveis (dicas para a prova):
  • A função usa o dicionário diretamente para consulta; isso cumpre a restrição do enunciado.
  • Não altera o dicionário nem o transforma em outra estrutura para fazer a conversão.
  • Alternativa (mais “pythonica”): em vez de criar lista e fazer join, poderia construir uma compreensão de lista: ''.join(dVogal.get(ch, ch) for ch in mensagem). Mas na prova, a versão passo a passo é mais clara para justificar.
  • Tratamento de casos não previstos:
    • Se a mensagem contiver letras minúsculas e quiser decodificar também, deve-se normalizar com mensagem.upper() antes (aqui enunciado já diz que vem em maiúsculas).
    • Se quiser preservar acentos ou outros símbolos, o dicionário pode ser expandido.

Passo 5

Testes solicitados (como executar os testes; os resultados finais estão na seção de resposta):
  • Definir o dicionário conforme pedido:
    • dVogal = {'@':'A', '&':'E', '%':'I', '*':'O', '$':'U'}
  • Definir as mensagens de teste (retirando as barras de escape que aparecem em texto):
    • msg1 = 'Q\(@ND* @ CH\)V@ P@SS*$'
    • msg2 = '*\(R* BR@NC* *\)R* N&GR*'
  • Chamar a função com cada mensagem:
    • res1 = decodifica(msg1, dVogal)
    • res2 = decodifica(msg2, dVogal)
  • Para exibir na tela (em um programa Python), usar:
    • print(res1)
    • print(res2)
  • Observação amigável: você pode copiar exatamente a função do Passo 3 e as linhas de teste acima no interpretador Python ou num arquivo .py e rodar para ver os resultados.

Resposta

QUANDO A CHUVA PASSOU
OURO BRANCO OURO NEGRO

Exercícios relacionados