Adding Large Integers

Introduction

In this project, you will learn how to implement a function that can add two large integers represented as strings. This is a common problem encountered in real-world scenarios, where the built-in JavaScript number data type has limitations in representing and performing arithmetic operations on extremely large numbers.

Tasks

In this project, you will learn to:

• Set up the project environment and create the necessary files.
• Implement the logic to add two large numbers represented as strings.
• Test the addBigNum function with provided examples.
• Explore ways to optimize the solution (optional).

Achievements

In this project, you will learn:

• How to work with large numbers in JavaScript by representing them as strings.
• Techniques for handling edge cases and ensuring the correctness of the addition operation.
• Strategies for optimizing the performance of the addBigNum function.
• Best practices for writing maintainable and readable code.

Set up the project environment

In this step, you will set up the project environment and create the necessary files for the "Adding Large Integers" project.

1. Open your preferred code editor and navigate to the /home/labex/project directory.

2. Create a new file named addBigNum.js in the /home/labex/project directory.

3. In the addBigNum.js file, add the following code as a starting point:

/*
  Adds two large numbers represented as strings and returns the sum as a string.

  Parameters:
  - num1: A string representing the first large number.
  - num2: A string representing the second large number.

  Returns:
  - A string representing the sum of the two input numbers.
*/

function addBigNum(num1, num2) {
  // Your implementation goes here
}

module.exports = addBigNum;

This code defines the addBigNum function and exports it, as required by the project instructions.

Implement the addition logic

In this step, you will implement the logic to add two large numbers represented as strings.

1. In the addBigNum function, start by converting the input strings num1 and num2 into arrays of digits.

const digits1 = num1.split("").map(Number); // Convert num1 string to an array of digits
const digits2 = num2.split("").map(Number); // Convert num2 string to an array of digits

2. Ensure that the arrays digits1 and digits2 have the same length by adding leading zeros if necessary.

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

3. Initialize a result array to store the digits of the final sum, and a carry variable to keep track of the carry value during the addition.

const result = [];
let carry = 0; // Carry value for addition

4. Iterate through the digits from right to left, performing the addition and updating the carry value.

for (let i = digits1.length - 1; i >= 0; i--) {
  const sum = digits1[i] + digits2[i] + carry;
  const digit = sum % 10; // Current digit value
  carry = Math.floor(sum / 10); // Calculate carry
  result.unshift(digit); // Add current digit to the beginning of the result array
}

5. If there is a remaining carry value, add it to the beginning of the result array.

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

6. Convert the result array to a string and return it as the final sum.

const sumStr = result.join(""); // Convert the result array to a string
return sumStr;

Test the addBigNum function

In this step, you will test the addBigNum function with the provided examples.

1. In your code editor, add the following code at the end of the addBigNum.js file:

// Test the addBigNum function
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. Save the addBigNum.js file and run the script in your terminal:

node /home/labex/project/addBigNum.js

The output should match the expected results in the project instructions.

Refine and optimize the solution (optional)

In this optional step, you can explore ways to optimize the addBigNum function further. Some potential improvements include:

• Handling negative numbers or zero as input.
• Improving the performance for extremely large numbers.
• Adding error handling for invalid input.
• Enhancing the code readability and maintainability.

Feel free to experiment with the code and make any necessary changes to improve the overall solution.

Congratulations! You have completed the "Adding Large Integers" project. If you have any questions or need further assistance, please don't hesitate to ask.

Summary

Congratulations! You have completed this project. You can practice more labs in LabEx to improve your skills.