Adição de Inteiros Grandes

Introdução

Neste projeto, você aprenderá como implementar uma função que pode somar dois inteiros grandes representados como strings. Este é um problema comum encontrado em cenários do mundo real, onde o tipo de dado numérico embutido do JavaScript tem limitações na representação e execução de operações aritméticas em números extremamente grandes.

Tarefas

Neste projeto, você aprenderá a:

• Configurar o ambiente do projeto e criar os arquivos necessários.
• Implementar a lógica para somar dois números grandes representados como strings.
• Testar a função addBigNum com os exemplos fornecidos.
• Explorar maneiras de otimizar a solução (opcional).

Conquistas

Neste projeto, você aprenderá:

• Como trabalhar com números grandes em JavaScript, representando-os como strings.
• Técnicas para lidar com casos extremos (edge cases) e garantir a correção da operação de adição.
• Estratégias para otimizar o desempenho da função addBigNum.
• Melhores práticas para escrever código legível e de fácil manutenção.

Configurar o ambiente do projeto

Nesta etapa, você configurará o ambiente do projeto e criará os arquivos necessários para o projeto "Adição de Inteiros Grandes".

1. Abra seu editor de código preferido e navegue até o diretório /home/labex/project.

2. Crie um novo arquivo chamado addBigNum.js no diretório /home/labex/project.

3. No arquivo addBigNum.js, adicione o seguinte código como ponto de partida:

/*
  Soma dois números grandes representados como strings e retorna a soma como uma string.

  Parâmetros:
  - num1: Uma string representando o primeiro número grande.
  - num2: Uma string representando o segundo número grande.

  Retorna:
  - Uma string representando a soma dos dois números de entrada.
*/

function addBigNum(num1, num2) {
  // Sua implementação vai aqui
}

module.exports = addBigNum;

Este código define a função addBigNum e a exporta, conforme exigido pelas instruções do projeto.

Implementar a lógica de adição

Nesta etapa, você implementará a lógica para somar dois números grandes representados como strings.

1. Na função addBigNum, comece convertendo as strings de entrada num1 e num2 em arrays de dígitos.

const digits1 = num1.split("").map(Number); // Converte a string num1 em um array de dígitos
const digits2 = num2.split("").map(Number); // Converte a string num2 em um array de dígitos

2. Certifique-se de que os arrays digits1 e digits2 tenham o mesmo comprimento, adicionando zeros à esquerda, se necessário.

while (digits1.length < digits2.length) {
  digits1.unshift(0);
}
while (digits2.length < digits1.length) {
  digits2.unshift(0);
}

3. Inicialize um array result para armazenar os dígitos da soma final e uma variável carry para controlar o valor de transporte (carry value) durante a adição.

const result = [];
let carry = 0; // Valor de transporte para adição

4. Itere pelos dígitos da direita para a esquerda, realizando a adição e atualizando o valor de carry.

for (let i = digits1.length - 1; i >= 0; i--) {
  const sum = digits1[i] + digits2[i] + carry;
  const digit = sum % 10; // Valor do dígito atual
  carry = Math.floor(sum / 10); // Calcula o transporte
  result.unshift(digit); // Adiciona o dígito atual ao início do array result
}

5. Se houver um valor de transporte restante, adicione-o ao início do array result.

if (carry > 0) {
  result.unshift(carry);
}

6. Converta o array result em uma string e retorne-a como a soma final.

const sumStr = result.join(""); // Converte o array result em uma string
return sumStr;

Testar a função addBigNum

Nesta etapa, você testará a função addBigNum com os exemplos fornecidos.

1. No seu editor de código, adicione o seguinte código ao final do arquivo addBigNum.js:

// Testar a função addBigNum
console.log(addBigNum("0", "0")); // Output: 0
console.log(addBigNum("99", "1")); // Output: 100
console.log(addBigNum("11", "123")); // Output: 134
console.log(addBigNum("9007199254740992", "1")); // Output: 9007199254740993

2. Salve o arquivo addBigNum.js e execute o script no seu terminal:

node /home/labex/project/addBigNum.js

A saída (output) deve corresponder aos resultados esperados nas instruções do projeto.

Refinar e otimizar a solução (opcional)

Nesta etapa opcional, você pode explorar maneiras de otimizar ainda mais a função addBigNum. Algumas melhorias potenciais incluem:

• Lidar com números negativos ou zero como entrada.
• Melhorar o desempenho para números extremamente grandes.
• Adicionar tratamento de erros para entrada inválida.
• Melhorar a legibilidade e a capacidade de manutenção do código.

Sinta-se à vontade para experimentar o código e fazer as alterações necessárias para aprimorar a solução geral.

Parabéns! Você concluiu o projeto "Adição de Inteiros Grandes". Se tiver alguma dúvida ou precisar de mais assistência, não hesite em perguntar.

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.