- 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):
-
= comprimento das strings (mesmo para as duas). -
= índice que percorre as posições, começando em (última posição) até . -
= valor inteiro que guarda o transporte de uma posição para a anterior; inicialmente . -
e = dígitos inteiros correspondentes aos caracteres atuais das duas strings (valores entre e ). -
= . - O dígito resultante naquela posição será
. - O novo carry será
(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éricousando uma função como int(char)(em Python) ou usando a diferença de códigos de caractereord(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):
- Verificar o comprimento
das strings (assumido igual, mas podemos pegar comprimento de qualquer uma). - Inicializar
e uma lista vazia result_digitspara guardar os dígitos resultantes (vou adicionar da direita para a esquerda). - Para
indo de até (descendo): - Converter o caractere da primeira string na posição
para o inteiro . - Converter o caractere da segunda string na posição
para o inteiro . - Calcular
. - Calcular
(o resto da divisão por 10) — esse é o dígito que vai na posição atual do resultado. - Atualizar
(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
em result_digits.
- Converter o caractere da primeira string na posição
- Depois do laço, se
, 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. - Como
result_digitsfoi construída da direita para a esquerda, inverter a lista e juntar em uma string final com''.join(...). - Retornar essa string.
Observação didática sobre o operador módulo e divisão inteira:
- Quando eu escrevo
, isso quer dizer que pego somente o resto da divisão por , que é justamente o dígito que fica naquela casa decimal. -
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
# 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:
'212','111'.. Inicialmente . - i = 2 (última posição):
, , . , . result_digits = [‘3’]. - i = 1:
, , . , . result_digits = [‘3’,‘2’]. - i = 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.
- i = 2 (última posição):
Exemplo com carry (para reforçar):
soma('9', '2')→ percorre posição única:, , . 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')(ouint(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 = []
# 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))