Multiply Large Numbers using Grid Method

Given two large numbers A and B, the task is to find the product of these two numbers using Grid Method.
Examples:

Input: A = 23, B = 15 
Output: 345
Input: A = 321, B = 69 
Output: 22149 

Approach:

• Create 2D Array of N Rows and M columns where N is number of digit in first number and M is number of digit in second number. 
  

• Multiply each element of row with each element of column 
  

• Total Number of Diagonal = Row + Columns – 1 
  = 2 + 2 -1 
  = 3
  

• Create 1D Array which contains the addition of elements in each diagonal 
  d3 = 2 
  d2 = 13 
  d1 = 15
  Diagonal sum[] = {2, 13, 15} 
  output = “” 
  total = 0 
  i = DiagonalSum.length – 1
  

• Repeat in reverse order of insertion except for first element in Diagonal Sum[] Array 
  total = total + DiagonalSum[i]. If total contain more than single digit then total = all digit from total except unit place digit. output = unit_place_digit + output else total = 0
  

• total = total + DiagonalSum[0] 
  output = total + output
  

Below is the implementation of the above approach:

C++

#include <iostream>
#include <string>

class GFG {
public:
    // Function to return the multiplication of a and b
    static std::string multiply(std::string a, std::string b) {
        bool flag1 = false;
        bool flag2 = false;
        a = trim(a);
        b = trim(b);

        // To check whether numbers are
        // negative or positive
        if (a[0] == '-') {
            a = a.substr(1);
            flag1 = true;
        }
        if (b[0] == '-') {
            b = b.substr(1);
            flag2 = true;
        }

        // To store the result of multiplication
        std::string out1 = "";

        // To create matrix(Grid) of row * column
        int row = a.length();
        int column = b.length();
        int** c = new int*[row];
        for (int i = 0; i < row; ++i) {
            c[i] = new int[column];
            for (int j = 0; j < column; ++j) {
                int n1 = a[i] - '0';
                int n2 = b[j] - '0';
                c[i][j] = n1 * n2;
            }
        }

        // To create 1D array of (row+column-1) size
        // which is equal to the total number
        // of diagonals in the matrix
        int* sum = new int[row + column - 1];
        int m = 0;

        // To add elements of each diagonal
        for (int i = 0; i < row; ++i) {
            int k = i;
            int add = 0;

            for (int j = 0; j < column && k >= 0; ++j, --k) {
                add = add + c[k][j];
            }
            sum[m] = add;
            ++m;
        }
        for (int k = 1; k < column; ++k) {
            int i = row - 1;
            int j = k;
            int add = 0;
            while (j < column && i >= 0) {
                add = add + c[i][j];
                ++j;
                --i;
            }
            sum[m] = add;
            ++m;
        }

        // To check both numbers are not
        // single-digit numbers
        if (m != 1) {
            std::string temp = std::to_string(sum[m - 1]);
            int t = 0;

            // Repeat elements in the "sum" array
            // in reverse order
            for (int n = m - 1; n >= 1; --n) {
                // Add element with the result "t"
                t = t + sum[n];

                // Convert the integer element into a string
                // which is the sum of all elements
                // of a particular diagonal
                temp = std::to_string(t);
                if (temp.length() > 1) {
                    // If the number contains more than a
                    // single digit, then copy all the digits
                    // into "temp" as a string except for the
                    // unit place digit
                    std::string str = temp.substr(0, temp.length() - 1);
                    t = std::stoi(str);
                } else {
                    t = 0;
                }

                // Concatenate the unit place digit at the
                // beginning of the string "out1"
                out1 = temp[temp.length() - 1] + out1;
            }

            // Add the first element with the result "t"
            t = t + sum[0];
            temp = std::to_string(t);
            out1 = temp + out1;
        } else {
            out1 = out1 + std::to_string(sum[0]);
        }

        // To remove zeros from the beginning
        // of the multiplication result
        for (int i = 0; i < out1.length() - 1; ++i) {
            if (out1[i] == '0') {
                out1.erase(i, 1);
                --i;
            } else {
                break;
            }
        }

        // Check if the result of the multiplication
        // operation is zero
        if (out1 != "0") {
            // If one of the two numbers is negative, then
            // assign the minus sign to the result of
            // the multiplication operation
            if (flag1 && !flag2) {
                out1 = "-" + out1;
            } else if (flag2 && !flag1) {
                out1 = "-" + out1;
            }
        }
        return out1;
    }

    // Driver code
    static void main(std::string str1, std::string str2) {
        std::cout << multiply(str1, str2) << std::endl;
    }

private:
    // Trim leading and trailing whitespace from a string
    static std::string trim(const std::string& str) {
        size_t start = str.find_first_not_of(" \t\n\r\f\v");
        size_t end = str.find_last_not_of(" \t\n\r\f\v");
        return (start != std::string::npos && end != std::string::npos) ?
          str.substr(start, end - start + 1) : "";
    }
};

int main() {
    GFG::main("123456789", "987654321");
    GFG::main("1235421415454545454545454544", "1714546546546545454544548544544545");

    return 0;
}

Java

// Java program to multiply Large
// numbers using the grid method

class GFG {

    // Function to return the multiplication of a and b
    public static String multiply(String a, String b)
    {
        boolean flag1 = false;
        boolean flag2 = false;
        a = a.trim();
        b = b.trim();

        // To check whether numbers are
        // negative or positive
        if (a.charAt(0) == '-') {
            a = a.replace("-", "");
            flag1 = true;
        }
        if (b.charAt(0) == '-') {
            b = b.replace("-", "");
            flag2 = true;
        }

        // To store the result of
        // multiplication
        String out = "";

        // To create matrix(Grid) of row * column
        int row = a.length();
        int column = b.length();
        int[][] c = new int[row][column];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                int n1
                    = Character
                          .getNumericValue(
                              a.charAt(i));
                int n2
                    = Character
                          .getNumericValue(
                              b.charAt(j));
                c[i][j] = n1 * n2;
            }
        }

        // To create 1D array of (row+column-1) size
        // which is equal to total number
        // of diagonal in matrix
        int[] sum = new int[row + column - 1];
        int m = 0;

        // To add elements of each diagonals
        for (int i = 0; i < row; i++) {
            int k = i;
            int add = 0;

            for (int j = 0; j < column && k >= 0; j++, k--) {
                add = add + c[k][j];
            }
            sum[m] = add;
            m = m + 1;
        }
        for (int k = 1; k < column; k++) {
            int i = row - 1;
            int j = k;
            int add = 0;
            while (j < column && i >= 0) {
                add = add + c[i][j];
                j = j + 1;
                i = i - 1;
            }
            sum[m] = add;
            m = m + 1;
        }

        // To check both numbers are not
        // single digit number
        if (sum.length != 1) {

            String temp
                = Integer
                      .toString(
                          sum[sum.length - 1]);
            int t = 0;

            // Repeat element in "sum" Array
            // in reverse order
            for (int n = sum.length - 1; n >= 1; n--) {

                // Add element with result "t"
                t = t + sum[n];

                // Convert integer element into String
                // which is sum of all elements
                // of particular diagonal
                temp = Integer.toString(t);
                if (temp.length() > 1) {

                    // If the number contains more than a single-digit
                    // then copy all the digit into "temp"
                    // as String except for the unit place digit
                    String str = temp.substring(0, temp.length() - 1);
                    t = Integer.parseInt(str);
                }
                else {
                    t = 0;
                }

                // Concat unit place digit at the
                // beginning of String "out"
                out = temp.charAt(temp.length() - 1) + out;
            }

            // Add first element with result "t"
            t = t + sum[0];
            temp = Integer.toString(t);
            out = temp + out;
        }
        else {
            out = out + sum[0];
        }

        StringBuffer s = new StringBuffer(out);

        // To remove Zero's from the beginning
        // of the multiplication result
        for (int i = 0; i < s.length() - 1; i++) {
            if (s.charAt(i) == '0') {
                s.deleteCharAt(i);
                i = i - 1;
            }
            else {
                break;
            }
        }
        out = s.toString();

        // Check if the result of multiplication
        // operation is zero
        if (!out.equals("0")) {

            // If one of two numbers is negative then
            // assign minus sign to the result of
            // multiplication operation
            if (flag1 == true && flag2 == false) {
                out = "-" + out;
            }
            else if (flag2 == true && flag1 == false) {
                out = "-" + out;
            }
        }
        return out;
    }

    // Driver code
    public static void main(String args[])
    {
        String str1 = "123456789";
        String str2 = "987654321";
        System.out.println(multiply(str1, str2));

        str1 = "1235421415454545454545454544";
        str2 = "1714546546546545454544548544544545";
        System.out.println(multiply(str1, str2));
    }
}

Python3

# Python3 program to multiply Large
# numbers using the grid method

# Function to return the multiplication of a and b
def multiply(a, b):

    flag1 = False;
    flag2 = False;
    a = a.strip()
    b = b.strip()

    # To check whether numbers are
    # negative or positive
    if (a[0] == '-') :
        a = a.replace("-", "");
        flag1 = True;

    if (b[0] == '-'):
        b = b.replace("-", "");
        flag2 = True;

    # To store the result of
    # multiplication
    out1 = "";

    # To create matrix(Grid) of row * column
    row = len(a);
    column = len(b);
    c =[ [0 for _ in range(column)] for __ in range(row)]
    for i in range(row):
        for j in range(column):
            n1 = int(a[i]);
            n2 = int(b[j]);
            c[i][j] = n1 * n2;

    # To create 1D array of (row+column-1) size
    # which is equal to total number
    # of diagonal in matrix
    sum1 = [0 for _ in range(row + column - 1)];
    m = 0;

    # To add elements of each diagonals
    for i in range(row):
        k = i;
        add = 0;

        j = 0
        while j < column and k >= 0:
            add = add + c[k][j];
            j += 1
            k -= 1

        sum1[m] = add;
        m = m + 1;

    for k in range(1, column):
        i = row - 1;
        j = k;
        add = 0;
        while (j < column and i >= 0):
            add = add + c[i][j];
            j = j + 1;
            i = i - 1;

        sum1[m] = add;
        m = m + 1;

    # To check both numbers are not
    # single digit number
    if (len(sum1) != 1) :

        temp  = str(sum1[len(sum1) - 1]);
        t = 0;

        # Repeat element in "sum1" Array
        # in reverse order
        for n in range(len(sum1) - 1, 0, -1):

            # Add element with result "t"
            t = t + sum1[n];

            # Convert integer element into string
            # which is sum1 of all elements
            # of particular diagonal
            temp = str(t);
            if (len(temp) > 1) :

                # If the number contains more than a
                # single-digit then copy all the digit
                # into "temp" as except for the
                # unit place digit
                str1 = temp[0 : len(temp) - 1]
                t = int(str1);

            else :
                t = 0;

            # Concat unit place digit at the
            # beginning of "out1"
            out1 = temp[len(temp) - 1] + out1;

        # Add first element with result "t"
        t = t + sum1[0];
        temp = str(t);
        out1 = temp + out1;

    else :
        out1 = out1 + sum1[0];


    s = out1

    # To remove Zero's from the beginning
    # of the multiplication result
    for i in range(len(s) - 1):
        if (s[i] == '0') :
            s = s[:i] + s[i + 1:]
            i = i - 1;

        else :
            break;


    out1 = s

    # Check if the result of multiplication
    # operation is zero
    if (out1 != "0"):

        # If one of two numbers is negative then
        # assign minus sign to the result of
        # multiplication operation
        if (flag1 == True and flag2 == False) :
            out1 = "-" + out1;

        elif (flag2 == True and flag1 == False) :
            out1 = "-" + out1;


    return out1;

# Driver code
str1 = "123456789";
str2 = "987654321";
print(multiply(str1, str2));

str1 = "1235421415454545454545454544";
str2 = "1714546546546545454544548544544545";
print(multiply(str1, str2));

# This code is contributed by phasing17

C#

// C# program to multiply Large
// numbers using the grid method
using System;
using System.Text;
using System.Collections.Generic;

class GFG {

    // Function to return the multiplication of a and b
    public static string multiply(string a, string b)
    {
        bool flag1 = false;
        bool flag2 = false;
        a = a.Trim();
        b = b.Trim();

        // To check whether numbers are
        // negative or positive
        if (a[0] == '-') {
            a = a.Replace("-", "");
            flag1 = true;
        }
        if (b[0] == '-') {
            b = b.Replace("-", "");
            flag2 = true;
        }

        // To store the result of
        // multiplication
        string out1 = "";

        // To create matrix(Grid) of row * column
        int row = a.Length;
        int column = b.Length;
        int[, ] c = new int[row, column];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                int n1 = a[i] - '0';
                int n2 = b[j] - '0';
                c[i, j] = n1 * n2;
            }
        }

        // To create 1D array of (row+column-1) size
        // which is equal to total number
        // of diagonal in matrix
        int[] sum = new int[row + column - 1];
        int m = 0;

        // To add elements of each diagonals
        for (int i = 0; i < row; i++) {
            int k = i;
            int add = 0;

            for (int j = 0; j < column && k >= 0;
                 j++, k--) {
                add = add + c[k, j];
            }
            sum[m] = add;
            m = m + 1;
        }
        for (int k = 1; k < column; k++) {
            int i = row - 1;
            int j = k;
            int add = 0;
            while (j < column && i >= 0) {
                add = add + c[i, j];
                j = j + 1;
                i = i - 1;
            }
            sum[m] = add;
            m = m + 1;
        }

        // To check both numbers are not
        // single digit number
        if (sum.Length != 1) {

            string temp
                = Convert.ToString(sum[sum.Length - 1]);
            int t = 0;

            // Repeat element in "sum" Array
            // in reverse order
            for (int n = sum.Length - 1; n >= 1; n--) {

                // Add element with result "t"
                t = t + sum[n];

                // Convert integer element into string
                // which is sum of all elements
                // of particular diagonal
                temp = Convert.ToString(t);
                if (temp.Length > 1) {

                    // If the number contains more than a
                    // single-digit then copy all the digit
                    // into "temp" as string except for the
                    // unit place digit
                    string str = temp.Substring(
                        0, temp.Length - 1);
                    t = Convert.ToInt32(str);
                }
                else {
                    t = 0;
                }

                // Concat unit place digit at the
                // beginning of string "out1"
                out1 = temp[temp.Length - 1] + out1;
            }

            // Add first element with result "t"
            t = t + sum[0];
            temp = Convert.ToString(t);
            out1 = temp + out1;
        }
        else {
            out1 = out1 + sum[0];
        }

        StringBuilder s = new StringBuilder(out1);

        // To remove Zero's from the beginning
        // of the multiplication result
        for (int i = 0; i < s.Length - 1; i++) {
            if (s[i] == '0') {
                s.Remove(i, 1);
                i = i - 1;
            }
            else {
                break;
            }
        }
        out1 = s.ToString();

        // Check if the result of multiplication
        // operation is zero
        if (!out1.Equals("0")) {

            // If one of two numbers is negative then
            // assign minus sign to the result of
            // multiplication operation
            if (flag1 == true && flag2 == false) {
                out1 = "-" + out1;
            }
            else if (flag2 == true && flag1 == false) {
                out1 = "-" + out1;
            }
        }
        return out1;
    }

    // Driver code
    public static void Main(string[] args)
    {
        string str1 = "123456789";
        string str2 = "987654321";
        Console.WriteLine(multiply(str1, str2));

        str1 = "1235421415454545454545454544";
        str2 = "1714546546546545454544548544544545";
        Console.WriteLine(multiply(str1, str2));
    }
}

// This code is contributed by phasing17

Javascript

// Function to return the multiplication of a and b
function multiply(a, b) {
    let flag1 = false;
    let flag2 = false;
    a = a.trim();
    b = b.trim();

    // To check whether numbers are negative or positive
    if (a[0] === '-') {
        a = a.replace("-", "");
        flag1 = true;
    }

    if (b[0] === '-') {
        b = b.replace("-", "");
        flag2 = true;
    }

    // To store the result of multiplication
    let out1 = "";

    // To create matrix(Grid) of row * column
    const row = a.length;
    const column = b.length;
    const c = new Array(row).fill(null).map(() => new Array(column).fill(0));

    for (let i = 0; i < row; i++) {
        for (let j = 0; j < column; j++) {
            const n1 = parseInt(a[i]);
            const n2 = parseInt(b[j]);
            c[i][j] = n1 * n2;
        }
    }

    // To create 1D array of (row+column-1) size
    // which is equal to total number of diagonals in the matrix
    const sum1 = new Array(row + column - 1).fill(0);
    let m = 0;

    // To add elements of each diagonal
    for (let i = 0; i < row; i++) {
        let k = i;
        let add = 0;
        let j = 0;
        while (j < column && k >= 0) {
            add = add + c[k][j];
            j++;
            k--;
        }
        sum1[m] = add;
        m++;
    }

    for (let k = 1; k < column; k++) {
        let i = row - 1;
        let j = k;
        let add = 0;
        while (j < column && i >= 0) {
            add = add + c[i][j];
            j++;
            i--;
        }
        sum1[m] = add;
        m++;
    }

    // To check both numbers are not single-digit numbers
    if (sum1.length !== 1) {
        let temp = sum1[sum1.length - 1].toString();
        let t = 0;

        // Repeat element in "sum1" Array in reverse order
        for (let n = sum1.length - 1; n > 0; n--) {
            t = t + sum1[n];
            temp = t.toString();
            if (temp.length > 1) {
                const str1 = temp.substring(0, temp.length - 1);
                t = parseInt(str1);
            } else {
                t = 0;
            }
            out1 = temp[temp.length - 1] + out1;
        }

        t = t + sum1[0];
        temp = t.toString();
        out1 = temp + out1;
    } else {
        out1 = out1 + sum1[0];
    }

    let s = out1;

    // To remove zeros from the beginning of the multiplication result
    for (let i = 0; i < s.length - 1; i++) {
        if (s[i] === '0') {
            s = s.slice(0, i) + s.slice(i + 1);
            i--;
        } else {
            break;
        }
    }

    out1 = s;

    // Check if the result of the multiplication operation is zero
    if (out1 !== "0") {
        if (flag1 === true && flag2 === false) {
            out1 = "-" + out1;
        } else if (flag2 === true && flag1 === false) {
            out1 = "-" + out1;
        }
    }

    return out1;
}

// Driver code
const str1 = "123456789";
const str2 = "987654321";
console.log(multiply(str1, str2));

const str3 = "1235421415454545454545454544";
const str4 = "1714546546546545454544548544544545";
console.log(multiply(str3, str4));

Output

121932631112635269
2118187521397235888154583183918321221520083884298838480662480

Time Complexity: O(row * column)

Auxiliary Space: O(row * column)