A tabela abaixo demonstra como os números em decimal são representados em diferentes tipos de códigos, BCD8421, Excesso 3, BCD7421, BCD5211, BCD2421, Johnson, 2 entre 5 e Gray.
Decimal BCD8421 Excesso3 BCD7421 BCD5211 BCD2421 Johnson 2 entre 5 Gray
0 0000 0011 0000 0000 0000 00000 00011 0000
1 0001 0100 0001 0001 0001 00001 00101 0001
2 0010 0101 0010 0011 0010 00011 00110 0011
3 0011 0110 0011 0101 0011 00111 01001 0010
4 0100 0111 0100 0111 0100 01111 01010 0110
5 0101 1000 0101 1000 1011 11111 01100 0111
6 0110 1001 0110 1001 1100 11110 10001 0101
7 0111 1010 1000 1011 1101 11100 10010 0100
8 1000 1011 1001 1101 1110 11000 10100 1100
9 1001 1100 1010 1111 1111 10000 11000 1101
10 1111
11 1110
12 1010
13 1011
14 1001
15 1000
Para a tabela acima implemente um sistema onde o usuário possa realizar a conversão entre os códigos a depender do que foi selecionado na entrada.

Passo 1

O problema pede que a gente monte um sistema que converta valores entre diferentes codificações para dígitos decimais (0–9) — as codificações são BCD8421, Excesso 3, BCD7421, BCD5211, BCD2421, Johnson, 2 entre 5 e Gray (esta última até 15). A ideia é usar um dicionário para cada código, permitindo decodificar um valor de entrada para decimal e recodificar para o código de saída escolhido.

Passo 2

Vamos definir um dicionário Python para cada código, mapeando inteiros (0–9 ou 0–15 no caso de Gray) para strings de bits. Depois criamos inversos desses dicionários para decodificar uma string de bits de volta ao seu valor decimal.

Passo 3

Implementamos uma função convert(src, dst, value) que:
  1. Se src não for 'Decimal', usa o dicionário inverso para obter o número decimal correspondente a value.
  2. Se src for 'Decimal', converte value diretamente para inteiro.
  3. Verifica se o decimal está dentro do alcance suportado por dst.
  4. Retorna a string de bits correspondente em dst.

Passo 4

Fazemos uma interação simples no console:
  1. Perguntamos ao usuário o código de origem (src).
  2. Perguntamos o código de destino (dst).
  3. Perguntamos o valor a converter (value).
  4. Chamamos convert(src, dst, value) e mostramos o resultado.

Resposta

# dicionários de codificação
codes = {
    'Decimal': {i: str(i) for i in range(10)},
    'BCD8421': {
        0: '0000', 1: '0001', 2: '0010', 3: '0011',
        4: '0100', 5: '0101', 6: '0110', 7: '0111',
        8: '1000', 9: '1001'
    },
    'Excesso3': {
        0: '0011', 1: '0100', 2: '0101', 3: '0110',
        4: '0111', 5: '1000', 6: '1001', 7: '1010',
        8: '1011', 9: '1100'
    },
    'BCD7421': {
        0: '0000', 1: '0001', 2: '0010', 3: '0011',
        4: '0100', 5: '0101', 6: '0110', 7: '1000',
        8: '1001', 9: '1010'
    },
    'BCD5211': {
        0: '0000', 1: '0001', 2: '0011', 3: '0101',
        4: '0111', 5: '1000', 6: '1001', 7: '1011',
        8: '1101', 9: '1111'
    },
    'BCD2421': {
        0: '0000', 1: '0001', 2: '0010', 3: '0011',
        4: '0100', 5: '1011', 6: '1100', 7: '1101',
        8: '1110', 9: '1111'
    },
    'Johnson': {
        0: '00000', 1: '00001', 2: '00011', 3: '00111',
        4: '01111', 5: '11111', 6: '11110', 7: '11100',
        8: '11000', 9: '10000'
    },
    '2entre5': {
        0: '00011', 1: '00101', 2: '00110', 3: '01001',
        4: '01010', 5: '01100', 6: '10001', 7: '10010',
        8: '10100', 9: '11000'
    },
    'Gray': {
        0: '0000', 1: '0001', 2: '0011', 3: '0010',
        4: '0110', 5: '0111', 6: '0101', 7: '0100',
        8: '1100', 9: '1101', 10: '1111', 11: '1110',
        12: '1010', 13: '1011', 14: '1001', 15: '1000'
    }
}

# dicionários inversos para decodificar
inverse = {}
for code_name, mapping in codes.items():
    inverse[code_name] = {bits: dec for dec, bits in mapping.items()}

def convert(src, dst, value):
    # decodifica para inteiro
    if src == 'Decimal':
        dec = int(value)
    else:
        if value not in inverse[src]:
            raise ValueError(f"Valor '{value}' não é válido em {src}")
        dec = inverse[src][value]
    # verifica alcance
    if dec not in codes[dst]:
        raise ValueError(
            f"Decimal {dec} não suportado por {dst} (faixa: {min(codes[dst])}{max(codes[dst])})"
        )
    # codifica no destino
    return codes[dst][dec]

if __name__ == '__main__':
    print("Códigos disponíveis:", ', '.join(codes.keys()))
    src = input("Código de origem: ").strip()
    dst = input("Código de destino: ").strip()
    value = input("Valor a converter: ").strip()
    try:
        result = convert(src, dst, value)
        print(f"Resultado em {dst}: {result}")
    except Exception as e:
        print("Erro:", e)

Exercícios relacionados