Implemente uma funçīo em Julia que receba um número inteiro e retorne uma string com sua representaçio em complemento de dois usando 8 bits. Por exemplo, se a entrada for -5 , a funçāo deve retornar (11111011) . A funçiōo Julia já dispōe de funçōes para fazer essa conversio, mas tente implementar a lógica de conversio manualmente usando operaçōes aritméticas.

Passo 1

O que o problema pede e quais são as informações importantes:
  • O objetivo é implementar uma função em Julia que receba um número inteiro e retorne uma string com a sua representação em complemento de dois usando exatamente 8 bits.
  • A string de saída deve ter o formato com parênteses, por exemplo: “(11111011)” para a entrada -5.
  • Não usar funções prontas de conversão (como bitstring, bytes, etc.). Usar operações aritméticas/manuais para construir os bits.
  • Deve-se decidir o comportamento para números fora do intervalo representável em 8 bits (isto é, fora de [-128,127]). Neste exercício vou usar a regra natural do complemento de dois para 8 bits: reduzir o inteiro modulo 2^8 (ou seja, trabalhar com o representante em [0,255]). Assim qualquer inteiro mapeia para um padrão de 8 bits (comportamento de overflow modular).

Passo 2

Conceito essencial (a “aula rápida” de complemento de dois):
  • Em complemento de dois com 8 bits, existem 2^8 = 256 padrões de bits, que representam os inteiros de -128 até 127 se interpretados como números com sinal.
  • A transformação matemática simples: dado um inteiro n, o seu representante não-negativo em 8 bits é
v \equiv n \pmod{2^8},
ou, mais operacionalmente, se n<0 então v = n + 2^8 (ou então adicionar 2^8 repetidamente até ficar em [0,255]). Para n\ge0 pode-se reduzir por subtrações de 2^8 até ficar em [0,255].
  • Exemplo numérico: para n=-5, temos v = -5 + 256 = 251. O número 251 em binário com 8 bits é 11111011. Esse é exatamente o complemento de dois de -5 em 8 bits.

Passo 3

Como construir os bits manualmente (algoritmo passo a passo):
  • Primeiro, obter o inteiro v no intervalo [0,255] equivalente a n (redução modular).
  • Depois, extrair os 8 bits do menos significativo ao mais significativo usando divisão inteira e resto por 2:
    • Para cada posição de bit (de 8 a 1):
      • calcular b = v \bmod 2 que dá o bit menos significativo atual (0 ou 1);
      • armazenar b naquela posição (na prática colocamos este bit à direita ou usamos um array e preenchemos de trás para frente);
      • atualizar v = \lfloor v/2\rfloor (divisão inteira).
  • Ao final obtemos 8 bits; juntar como string e colocar parênteses ao redor.

Passo 4

Detalhando as operações que usaremos em Julia (sem usar conversão pronta):
  • Para reduzir para [0,255] sem usar uma função pronta como bitstring, podemos:
    • usar um laço while: enquanto v<0 faça v += 256; enquanto v \ge 256 faça v -= 256.
    • isso usa apenas soma e subtração repetidas — é bem explícito e funciona para qualquer inteiro.
  • Para extrair bits, usamos:
    • o operador de resto % para obter v \bmod 2 (em Julia, v % 2);
    • div(v,2) (divisão inteira) para atualizar v.
  • Para montar a string, preenchemos um array de 8 caracteres e depois unimos em uma String; finalmente concatenamos os parênteses.

Passo 5

Exemplo numérico passo a passo para n=-5:
  • Redução para [0,255]: v = -5 + 256 = 251.
  • Extração dos bits:
    • 251 \bmod 2 = 1 → bit menos significativo = 1; v \leftarrow \lfloor 251/2\rfloor = 125.
    • 125 \bmod 2 = 1 → próximo bit = 1; v \leftarrow 62.
    • 62 \bmod 2 = 0 → próximo bit = 0; v \leftarrow 31.
    • 31 \bmod 2 = 1 → próximo bit = 1; v \leftarrow 15.
    • 15 \bmod 2 = 1 → próximo bit = 1; v \leftarrow 7.
    • 7 \bmod 2 = 1 → próximo bit = 1; v \leftarrow 3.
    • 3 \bmod 2 = 1 → próximo bit = 1; v \leftarrow 1.
    • 1 \bmod 2 = 1 → bit mais significativo = 1; v \leftarrow 0.
  • Lendo do bit mais significativo ao menos significativo obtemos 11111011.
  • Colocando parênteses: “(11111011)”. É exatamente o exemplo pedido.

Passo 6

Observações práticas e dicas para a prova:
  • Se a prova exigir que a função valide o intervalo e dê erro fora de [-128,127], basta trocar a redução modular por um teste e lançar erro. Aqui adotamos redução modular porque isso corresponde ao comportamento natural do complemento de dois com overflow.
  • A técnica de extrair bits por resto e divisão é a mais clássica e funciona sem bibliotecas.
  • Em teste rápido: para n=5 o algoritmo devolve “(00000101)”; para n=128 devolve “(10000000)” (que, interpretado como complemento de dois, é -128).

Passo 7

v = n
while v < 0
v += 256
end
while v >= 256
v -= 256
end

Passo 8

bits = Vector{Char}(undef, 8)
for i in 8👎1
b = v % 2
bits[i] = (b == 1) ? ‘1’ : ‘0’
v = div(v, 2)
end

Passo 9

return “(” * String(bits) * “)”
end

Resposta

function twos_complement8(n::Integer)::String

Exercícios relacionados