JavaScript Program to Divide Large Number Represented as String

In this article, we will explore dividing large numbers represented as strings in JavaScript. Dividing a large number represented as a string in JavaScript is a common computational task that involves dividing a numerical line by another numerical value.

Approach 1: Brute Force

We will use basic maths, as the dividend and result can be huge we store them in string. We first take digits which are divisible by a number. After this take each digit and store the result in a string.

• This JavaScript program simulates long division to calculate the quotient of two numbers, dividend, and divisor, without using the division operator.
• It iteratively processes each digit in the dividend, determining the quotient digit for each step and updating the remainder.
• The result is stored as a string and returned, making it a versatile solution for division operations, especially when precise division is required or when dealing with large numbers.
• This approach effectively emulates manual long division, enabling the computation of the quotient without using the division operator and is particularly useful when dealing with large numbers or precision-sensitive calculations.

Syntax:

function divide(dividend, divisor) {
    // Implementation
    return result;
}

Example: Below is the implementation of the program.

Javascript

function divide(dividend, divisor) {

    // Initialize an empty
    // string to store the result
    if (divisor === 0) {
        throw new Error(
            "Division by zero is not allowed."
        );
    }
    let quotient = "";

    // Initialize variables for
    // index and temporary storage
    let currentIndex = 0;
    let currentDividendPart =
        dividend[currentIndex] - "0";

    /* Find the first part of the dividend that is
       greater than or equal to the divisor */
    while (currentDividendPart < divisor) {
        currentDividendPart =
            currentDividendPart * 10 +
            dividend[currentIndex + 1].
                charCodeAt(0) - "0".charCodeAt(0);
        currentIndex += 1;
    }
    currentIndex += 1;

    // Perform long division
    while (dividend.length > currentIndex) {

        // Store the result of
        // the division in the quotient
        quotient += String.fromCharCode(
            Math.floor(currentDividendPart / divisor)
            + "0".charCodeAt(0)
        );

        // Calculate the next remainder
        // and digit of the dividend
        currentDividendPart =
            (currentDividendPart % divisor) * 10 +
            dividend[currentIndex].charCodeAt(0) -
            "0".charCodeAt(0);
        currentIndex += 1;
    }
    quotient += String.fromCharCode(
        Math.floor(currentDividendPart / divisor)
        + "0".charCodeAt(0)
    );

    // If the result is empty, return "0"
    if (quotient.length === 0) {
        return "0";
    }

    // Otherwise, return the result as a string
    return quotient;
}

// Driver Code
let dividend = "1322145464651";
let divisor = 125;
console.log(divide(dividend, divisor));

Output

10577163717

Appraoch 2: Using BigInt() in JavaScript

• Convert the input strings num1 and num2 to BigInt.
• Check for division by zero (if bigint2 is zero), and throw an error if necessary.
• Perform the division using the / operator between bigint1 and bigint2, and store the result.
• Return the result of the division as a string.

Syntax:

const bigint1 = BigInt(num1);
const bigint2 = BigInt(num2);

Example: Below is the implementation of the above approach.

Javascript

function divideLargeNumbers(num1, num2) {

    // Convert the input strings to BigInt
    const bigint1 = BigInt(num1);
    const bigint2 = BigInt(num2);

    // Check if num2 is zero (division by zero)
    if (bigint2 === 0) {
        throw new Error("Division by zero is not allowed.");
    }

    // Perform the division
    const result = bigint1 / bigint2;

    // Convert the result back to a string
    return result.toString();
}

// Example usage:
const num1 = "1322145464651";
const num2 = "125";
const result = divideLargeNumbers(num1, num2);
console.log(result);

Output

10577163717

Approach 3: Using parseInt and toString:

• Parse the input strings num1 and num2 to regular numbers using parseInt().
• Check for division by zero by verifying if number2 is equal to zero, and throw an error if it is.
• Perform the division using the / operator between number1 and number2, and store the result.
• Convert the result to a string, split it at the decimal point, and keep only the integer part for the final result. Return this integer part as a string.

Syntax:

const number1 = parseInt(num1, 10);
const number2 = parseInt(num2, 10);

Example: Below is the implementation of the above approach.

Javascript

function divideLargeNumbers(num1, num2) {

    // Parse the input strings to numbers
    const number1 = parseInt(num1, 10);
    const number2 = parseInt(num2, 10);

    // Check if num2 is zero (division by zero)
    if (number2 === 0) {
        throw new Error("Division by zero is not allowed.");
    }

    // Perform the division
    const result = number1 / number2;

    // Convert the result back to a string
    return result.toString().split('.')[0];
}

// Example usage:
const num1 = "1322145464651";
const num2 = "125";
const result = divideLargeNumbers(num1, num2);
console.log(result);

Output

10577163717