# 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 ``#include ` `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)

Previous
Next