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.
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 |
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:- Se
src
não for'Decimal'
, usa o dicionário inverso para obter o número decimal correspondente avalue
. - Se
src
for'Decimal'
, convertevalue
diretamente para inteiro. - Verifica se o decimal está dentro do alcance suportado por
dst
. - Retorna a string de bits correspondente em
dst
.
Passo 4
Fazemos uma interação simples no console:
- Perguntamos ao usuário o código de origem (
src
). - Perguntamos o código de destino (
dst
). - Perguntamos o valor a converter (
value
). - 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)