JavaScript Program to Divide Large Number Represented as String

Last Updated : 10 Jul, 2024

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.

Table of Content

Approach 1: Brute Force
Appraoch 2: Using BigInt() in JavaScript
Approach 3: Using parseInt and toString:

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

JavaScript Program to Check Whether a Number is Harshad Number

anjugaeu01

Improve

Article Tags :

JavaScript Program to Divide Large Number Represented as String

Approach 1: Brute Force

Appraoch 2: Using BigInt() in JavaScript

Syntax:

Approach 3: Using parseInt and toString:

Similar Reads

Thank You!

What kind of Experience do you want to share?