1. Faça uma função chamada soma, que dada dois parâmetros do tipo String, some um com o outro como se fossem inteiros. Sua solução deve somar caracter por caracter (não pode converter diretamente a string para inteiro, mas sim um caracter individual da string para um inteiro de 0 a 9 ). Para isso, deverá usar um laço de repetição para a travessia na string. Assuma que os dois parâmetros (strings) tenham comprimento equivalente. Por exemplo, a chamada soma(‘212’, ‘111’) retorna ‘323’.

Passo 1

O enunciado pede que eu implemente uma função chamada soma que recebe duas Strings e retorna outra String com a soma aritmética dos dois números representados por essas strings. Regras e informações importantes dadas pelo enunciado:
  • Os dois parâmetros são Strings que contêm apenas dígitos (0–9).
  • Assuma que as duas Strings têm o mesmo comprimento.
  • Não é permitido converter a String inteira diretamente para um inteiro; você deve converter caractere a caractere (cada caractere para um dígito de 0 a 9) e usar um laço para percorrer as strings.
  • O resultado deve ser a soma correta como se os strings fossem inteiros (ou seja, com propagação de carry quando necessário).
  • Exemplo dado: a chamada soma('212', '111') deve retornar '323'.

Passo 2

Escolha do método e ideia geral (sem resolver ainda): vou somar dígito a dígito da direita para a esquerda (como fazemos manualmente no papel) para poder tratar corretamente o carry (vai/transporta). Essa abordagem é a mais direta e eficiente aqui porque:
  • Processar da direita para a esquerda permite aplicar imediatamente o carry da posição menos significativa para as mais significativas.
  • Como as strings têm o mesmo comprimento, não preciso fazer padding.
Definições das variáveis que vou usar (explicação didática):
  • n = comprimento das strings (mesmo para as duas).
  • i = índice que percorre as posições, começando em n-1 (última posição) até 0.
  • \text{carry} = valor inteiro que guarda o transporte de uma posição para a anterior; inicialmente \text{carry}=0.
  • \text{d1} e \text{d2} = dígitos inteiros correspondentes aos caracteres atuais das duas strings (valores entre 0 e 9).
  • \text{sum} = \text{d1}+\text{d2}+\text{carry}.
  • O dígito resultante naquela posição será \text{digit} = \text{sum} \bmod 10.
  • O novo carry será \left\lfloor \dfrac{\text{sum}}{10} \right\rfloor (em linguagem de programação: sum // 10).
Explicação rápida do que significa converter caractere → dígito:
  • Cada caractere '0'..'9' pode ser transformado em seu valor numérico 0..9 usando uma função como int(char) (em Python) ou usando a diferença de códigos de caractere ord(char) - ord('0'). Ambas soluções convertem um único caractere para o dígito correspondente, conforme exigido.

Passo 3

Algoritmo passo a passo (o “como” que você aplicaria na prova):
  1. Verificar o comprimento n das strings (assumido igual, mas podemos pegar n = comprimento de qualquer uma).
  2. Inicializar \text{carry} = 0 e uma lista vazia result_digits para guardar os dígitos resultantes (vou adicionar da direita para a esquerda).
  3. Para i indo de n-1 até 0 (descendo):
    • Converter o caractere da primeira string na posição i para o inteiro \text{d1}.
    • Converter o caractere da segunda string na posição i para o inteiro \text{d2}.
    • Calcular \text{sum} = \text{d1} + \text{d2} + \text{carry}.
    • Calcular \text{digit} = \text{sum} \bmod 10 (o resto da divisão por 10) — esse é o dígito que vai na posição atual do resultado.
    • Atualizar \text{carry} = \left\lfloor \dfrac{\text{sum}}{10} \right\rfloor (0 ou 1, possivelmente maior se dígitos maiores forem permitidos, mas aqui sempre será 0 ou 1).
    • Inserir (append) a representação caractere de \text{digit} em result_digits.
  4. Depois do laço, se \text{carry} > 0, colocar o dígito(s) do carry na frente do resultado. Normalmente com dígitos 0–9 o carry será 0 ou 1, então basta prefixar '1' se \text{carry}=1.
  5. Como result_digits foi construída da direita para a esquerda, inverter a lista e juntar em uma string final com ''.join(...).
  6. Retornar essa string.
Observação didática sobre o operador módulo e divisão inteira:
  • Quando eu escrevo \text{digit} = \text{sum} \bmod 10, isso quer dizer que pego somente o resto da divisão por 10, que é justamente o dígito que fica naquela casa decimal.
  • \text{carry} = \left\lfloor \dfrac{\text{sum}}{10} \right\rfloor significa quantas dezenas sobraram para “transportar” para a casa seguinte (na prática é sum // 10).

Passo 4

Implementação em Python (código claro e direto que segue o algoritmo acima). A função chama-se soma, recebe duas strings a e b e retorna a string com o resultado:
def soma(a, b):
# Assumimos que len(a) == len(b)
n = len(a)
carry = 0
result_digits = [] # vamos guardar caracteres, do menos significativo ao mais
for i in range(n - 1, -1, -1):
    d1 = ord(a[i]) - ord('0')   # converte caractere para dígito 0..9
    d2 = ord(b[i]) - ord('0')
    s = d1 + d2 + carry
    digit = s % 10
    carry = s // 10
    result_digits.append(chr(ord('0') + digit))

if carry > 0:
    # Se ainda sobrou transporte, adiciona os dígitos do carry (normalmente 1)
    # Para generalidade (caso carry > 9), convertê-lo para string e adicionar seus caracteres
    carry_str = str(carry)
    for ch in reversed(carry_str):
        result_digits.append(ch)

# result_digits está do menos significativo para o mais; inverter e juntar
result = ''.join(reversed(result_digits))
return result

Passo 5

Exemplo passo a passo com a entrada do enunciado:
  • Entrada: a = '212', b = '111'. n=3. Inicialmente \text{carry}=0.
    • i = 2 (última posição): \text{d1}=2, \text{d2}=1, \text{sum}=3. \text{digit}=3, \text{carry}=0. result_digits = [‘3’].
    • i = 1: \text{d1}=1, \text{d2}=1, \text{sum}=2. \text{digit}=2, \text{carry}=0. result_digits = [‘3’,‘2’].
    • i = 0: \text{d1}=2, \text{d2}=1, \text{sum}=3. \text{digit}=3, \text{carry}=0. result_digits = [‘3’,‘2’,‘3’].
    • carry final = 0 → nada a adicionar.
    • Invertendo e juntando: ''.join(reversed(['3','2','3'])) = '323'.
    • Resultado: '323', que bate com o exemplo.
Exemplo com carry (para reforçar):
  • soma('9', '2') → percorre posição única: 9+2+0=11, \text{digit}=1, \text{carry}=1. result_digits=[‘1’], carry final=1 → adiciona '1' na frente → resultado '11' (correto).

Passo 6

Dicas finais para a prova (resumindo):
  • Sempre processe da direita para a esquerda quando precisar propagar carry.
  • Converta caractere para dígito com ord(char)-ord('0') (ou int(char) se permitido), nunca converta a string inteira de uma vez.
  • Use uma lista para construir dígitos do resultado e só no final junte e inverta; concatenar strings em cada iteração é mais lento e pode dar trabalho manualmente.
  • Lembre-se de tratar o carry final (pode aumentar o comprimento do resultado).

Resposta

def soma(a, b):
# Assumimos que len(a) == len(b)
n = len(a)
carry = 0
result_digits = []
for i in range(n - 1, -1, -1):
    d1 = ord(a[i]) - ord('0')
    d2 = ord(b[i]) - ord('0')
    s = d1 + d2 + carry
    digit = s % 10
    carry = s // 10
    result_digits.append(chr(ord('0') + digit))

if carry > 0:
    carry_str = str(carry)
    for ch in reversed(carry_str):
        result_digits.append(ch)

return ''.join(reversed(result_digits))

Exercícios relacionados