Realize a operação indicada e enumere quantos módulos somadores completos ou subtratores completos, são necessários para realizar a operação. Efetue em binário as operações, usando a aritmética do complemento de 2 :
-B C_{16}+F C_{16}

Passo 1

O enunciado pede que eu calcule a operação -BC_{16} + FC_{16} em binário usando a aritmética do complemento de 2 e que eu enumere quantos módulos somadores completos ou subtratores completos são necessários para realizar a operação.
Informações dadas: BC_{16} e FC_{16} são números hexadecimais de dois dígitos (logo podemos tratá‑los como palavras de 8 bits). A operação é a soma de FC_{16} com o negativo de BC_{16}, isto é, FC_{16} + (-BC_{16}).

Passo 2

Converter os valores hexadecimais para binário (8 bits):
B = 11_{10} = 1011_2,\quad C = 12_{10} = 1100_2
Logo
BC_{16} = 1011\;1100_2.
F = 15_{10} = 1111_2,\quad C = 1100_2
Logo
FC_{16} = 1111\;1100_2.

Passo 3

Explicar como obter -BC_{16} em complemento de 2 (aula rápida):
  • Para representar o negativo de um número em complemento de 2, você inverte todos os bits (complemento de 1) e soma 1.
  • Isso cria a representação de -x tal que x + (-x) \equiv 0 (mod 2^n), onde n é o número de bits (aqui n=8).
Aplicando ao nosso BC_{16}=10111100_2:
  1. Inversão dos bits:
\widetilde{BC} = 01000011_2.
  1. Somar 1:
01000011_2 + 00000001_2 = 01000100_2.
Portanto a representação em complemento de 2 de -BC_{16} é
-BC_{16} = 01000100_2.
Observação numérica rápida: BC_{16}=188_{10}; -188 \bmod 256 = 68 e 68_{10}=01000100_2, conferindo o resultado.

Passo 4

Agora somamos FC_{16} com -BC_{16} em binário (adição em complemento de 2). Escrevendo os operandos:
FC_{16} = 11111100_2
-BC_{16} = 01000100_2
Fazendo a adição bit a bit (mostro os passos de transporte/carry para você aprender a fazer na prova):
\begin{array}{r} \phantom{+}11111100\\\\ +\,01000100\\\ \hline \end{array}
Somando do LSB para o MSB com os carries:
  • bit0: 0+0=0, carry 0
  • bit1: 0+0+0=0, carry 0
  • bit2: 1+1+0=0, carry 1
  • bit3: 1+0+1=0, carry 1
  • bit4: 1+0+1=0, carry 1
  • bit5: 1+0+1=0, carry 1
  • bit6: 1+1+1=1, carry 1
  • bit7: 1+0+1=0, carry de saída 1
O resultado de 8 bits (ignorando o carry de saída na aritmética de complemento de 2) é
01000000_2.
Verificação rápida: em hexadecimal isso é 40_{16} e em decimal é 64_{10}. Numérico: FC_{16}=252_{10}, -BC_{16}=68_{10}; 252+68=320\equiv64\pmod{256}. Em interpretação com sinal (8 bits), o resultado é +64, e não houve overflow de sinal (soma de um positivo com um negativo não gera overflow de sinal).

Passo 5

Quantos módulos somadores completos (full adders) ou subtratores completos são necessários?
Explicação didática:
  • Cada bit de um somador ripple-carry de n bits é implementado por um somador completo; logo um somador de 8 bits usa 8 somadores completos.
  • Existem duas formas práticas de implementar a operação:
    1. Fazer a negação de BC separadamente (inverter e somar 1) usando um somador de 8 bits, e depois somar o resultado a FC com outro somador de 8 bits. Isso usa 2\times 8 = 16 somadores completos no total.
    2. Implementar diretamente a subtração FC - BC usando um único somador de 8 bits que recebe FC e os bits de BC passados por XOR com um sinal de subtração (ou seja, alimentar \widetilde{BC} ao somador) e com carry‑in = 1. Assim você faz FC + (\widetilde{BC}) + 1 numa única operação de 8 bits. Nesse caso usa‑se somente 8 somadores completos (mais algumas portas XOR para inverter os bits quando necessário).
  • Se você preferir pensar em subtratores completos, um subtrator de 8 bits também pode ser construído com 8 blocos do tipo “full subtractor” equivalentes; então a operação poderia ser feita com 8 subtratores completos (um por bit) se implementar subtração direta.
Conclusão prática: o número mínimo de módulos do tipo “somador completo” necessários é \,8 (usando um único somador de 8 bits que faça a subtração via complemento de 2). Se você fizer a negação e depois a soma em duas etapas, serão \,16 somadores completos.

Resposta

\,01000000_2
\,8 somadores completos (mínimo). Pode-se usar \,16 se primeiro negar BC com um somador de 8 bits e depois somar com outro somador de 8 bits.

Exercícios relacionados