Desenvolva um algoritmo em Scilab, Octave ou Python adicionar dois inteiros expressos na forma binária. As regras para adicionar números em binário são: 0+0=0 ; 0+1=1 ; 1+0=1; 1+1=1 e vai 1 . Por exemplo, 5+12 é:
& 11 & +001101 & 011100 & hline 100001 Vai 1

Passo 1

O enunciado pede para criar um algoritmo (em Scilab, Octave ou Python) que some dois números inteiros dados como strings binárias, aplicando as regras básicas de adição em base 2:
0+0=0, 0+1=1, 1+0=1 e 1+1=0 com vai-um (carry) para o bit seguinte.

Passo 2

Para somar dois binários bit a bit devemos:
. Igualar o comprimento das duas strings preenchendo à esquerda com zeros.
. Percorrer ambas da direita (LSB) para a esquerda (MSB), mantendo um carry que vale ou .
. A cada posição somamos bit\(1+\) bit\(2+\) carry. O bit resultante é esse somatório módulo , e o novo carry é o quociente inteiro da divisão por .
. Ao terminar, se ainda houver carry\(=1\), ele vira o bit mais significativo do resultado.

Passo 3

Esboço do algoritmo em Python:
. Ler duas strings binárias A e B.
. Fazer A, B \(=\) A.zfill(n), B.zfill(n) onde n \(=\) max(len(A), len(B)).
. Inicializar carry \(=0\) e resultado \(=\) [].
. Para i de n-\(1\) até \(0\):
  • soma \(=\) int(A[i]) \(+\) int(B[i]) \(+\) carry
  • resultado.append(str(soma % \(2\)))
  • carry \(=\) soma // \(2\)
    . Se carry \(==1\), fazer resultado.append('\(1\)').
    . O resultado final é ''.join(reversed(resultado)).

Passo 4

def \(soma_binaria\)(A, B):
    # \(1\)) iguala comprimentos
    n \(=\) max(len(A), len(B))
    A \(=\) A.zfill(n)
    B \(=\) B.zfill(n)
    # \(2\)) prepara variáveis
    carry \(=0\)
    resultado \(=\) []
    # \(3\)) percorre da direita para a esquerda
    for i in range(n-\(1\), -\(1\), -\(1\)):
        soma \(=\) int(A[i]) \(+\) int(B[i]) \(+\) carry
        resultado.append(str(soma % \(2\)))
        carry \(=\) soma // \(2\)
    # \(4\)) se sobrar um carry, adiciona no topo
    if carry:
        resultado.append('\(1\)')
    # \(5\)) inverte e retorna como string
    return ''.join(reversed(resultado))

# Exemplo de uso:
print(\(soma_binaria\)('\(11\)', '\(001101\)'))  # deve exibir '\(100001\)'

Resposta

def \(soma_binaria\)(A, B):
    n \(=\) max(len(A), len(B))
    A \(=\) A.zfill(n)
    B \(=\) B.zfill(n)
    carry \(=0\)
    resultado \(=\) []
    for i in range(n-\(1\), -\(1\), -\(1\)):
        soma \(=\) int(A[i]) \(+\) int(B[i]) \(+\) carry
        resultado.append(str(soma % \(2\)))
        carry \(=\) soma // \(2\)
    if carry:
        resultado.append('\(1\)')
    return ''.join(reversed(resultado))

Exercícios relacionados