# Multiply Large Numbers represented as Strings

Given two numbers as strings. The numbers may be very large (may not fit in long long int), the task is to find sum of these two numbers.

Examples:

```Input : num1 = 4154
num2 = 51454
Output : 213779916

Input :  num1 = 654154154151454545415415454
num2 = 63516561563156316545145146514654
Output : 41549622603955309777243716069997997007620439937711509062916
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The idea is based on school mathematics.

We start from last digit of second number multiply it with first number. Then we multiply second digit of second number with first number, and so on. We add all these multiplications. While adding, we put i-th multiplication shifted.

The approach used in below solution is to keep only one array for result. We traverse all digits first and second numbers in a loop and add the result at appropriate position.

```// C++ program to multiply two numbers represented
// as strings.
#include<bits/stdc++.h>
using namespace std;

// Multiplies str1 and str2, and prints result.
string multiply(string num1, string num2)
{
int n1 = num1.size();
int n2 = num2.size();
if (n1 == 0 || n2 == 0)
return "0";

// will keep the result number in vector
// in reverse order
vector<int> result(n1 + n2, 0);

// Below two indexes are used to find positions
// in result.
int i_n1 = 0;
int i_n2 = 0;

// Go from right to left in num1
for (int i=n1-1; i>=0; i--)
{
int carry = 0;
int n1 = num1[i] - '0';

// To shift position to left after every
// multiplication of a digit in num2
i_n2 = 0;

// Go from right to left in num2
for (int j=n2-1; j>=0; j--)
{
// Take current digit of second number
int n2 = num2[j] - '0';

// Multiply with current digit of first number
// and add result to previously stored result
// at current position.
int sum = n1*n2 + result[i_n1 + i_n2] + carry;

// Carry for next iteration
carry = sum/10;

// Store result
result[i_n1 + i_n2] = sum % 10;

i_n2++;
}

// store carry in next cell
if (carry > 0)
result[i_n1 + i_n2] += carry;

// To shift position to left after every
// multiplication of a digit in num1.
i_n1++;
}

// ignore '0's from the right
int i = result.size() - 1;
while (i>=0 && result[i] == 0)
i--;

// If all were '0's - means either both or
// one of num1 or num2 were '0'
if (i == -1)
return "0";

// generate the result string
string s = "";
while (i >= 0)
s += std::to_string(result[i--]);

return s;
}

// Driver code
int main()
{
string str1 = "1235421415454545454545454544";
string str2 = "1714546546546545454544548544544545";
cout << multiply(str1, str2);
return 0;
}
```

Output:

```2118187521397235888154583183918321221520083884298838480662480
```

The above code is adapted from the code provided by Gaurav here.

Time Complexity : O(m*n), where m and n are length of two number that need to be multiplied.

Related Article :
Karatsuba algorithm for fast multiplication

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
4.4 Average Difficulty : 4.4/5.0
Based on 24 vote(s)