Open In App

# Sum of two large numbers

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  : str1 = "3333311111111111",
str2 =   "44422222221111"
Output : 3377733333332222

Input  : str1 = "7777555511111111",
str2 =    "3332222221111"
Output : 7780887733332222```
Recommended Practice

### Approach 1: Using BigInteger class

The simplest approach is use BigInteger class. BigInteger provides analogues to all of Java’s primitive integer operators, and all relevant methods from java.lang.Math. In this approach we will create 2 objects of BigInteger and pass string in it then add simply add those objects using add() method.

## Java

 `import` `java.util.*;``import` `java.math.*;``public` `class` `GFG{`` ` `     ``public` `static` `void` `main(String []args){``        ``String str=``"7777555511111111"``;``        ``String str1=``"3332222221111"``;``         ` `        ``BigInteger a=``new` `BigInteger(str); ``// creating obj of biginteger and pass str in it``        ``BigInteger b=``new` `BigInteger(str1); ``// creating obj of biginteger and pass str1 in it``        ` `        ``System.out.println(a.add(b)); ``//add``         ` `     ``}``}`

## Python3

 `# Define the input strings``str` `=` `"7777555511111111"``str1 ``=` `"3332222221111"`` ` `# Create int objects with arbitrary precision``a ``=` `int``(``str``)``b ``=` `int``(str1)`` ` `# Add the int objects``result ``=` `a ``+` `b`` ` `# Print the result``print``(result)`

## Javascript

 `// Define the input strings``let str = ``"7777555511111111"``;``let str1 = ``"3332222221111"``;`` ` `// Create BigInt objects with arbitrary precision``let a = BigInt(str);``let b = BigInt(str1);`` ` `// Add the BigInt objects``let result = a + b;`` ` `// Print the result``console.log(result.toString());`

## C++

 `#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include ``#include `` ` `using` `namespace` `std;`` ` `// Define a struct to represent BigInteger``struct` `BigInteger {``    ``string str;`` ` `    ``// Constructor to initialize``    ``// BigInteger with a string``    ``BigInteger(string s) { str = s; }`` ` `    ``// Overload + operator to add``    ``// two BigInteger objects``    ``BigInteger operator+(``const` `BigInteger& b)``    ``{``        ``string a = str;``        ``string c = b.str;``        ``int` `alen = a.length(), clen = c.length();``        ``int` `n = max(alen, clen);``        ``if` `(alen > clen)``            ``c.insert(0, alen - clen, ``'0'``);``        ``else` `if` `(alen < clen)``            ``a.insert(0, clen - alen, ``'0'``);``        ``string res(n + 1, ``'0'``);``        ``int` `carry = 0;``        ``for` `(``int` `i = n - 1; i >= 0; i--) {``            ``int` `digit = (a[i] - ``'0'``) + (c[i] - ``'0'``) + carry;``            ``carry = digit / 10;``            ``res[i + 1] = digit % 10 + ``'0'``;``        ``}``        ``if` `(carry == 1) {``            ``res[0] = ``'1'``;``            ``return` `BigInteger(res);``        ``}``        ``else` `{``            ``return` `BigInteger(res.substr(1));``        ``}``    ``}`` ` `    ``// Overload << operator to output``    ``// BigInteger object``    ``friend` `ostream& operator<<(ostream& out,``                               ``const` `BigInteger& b)``    ``{``        ``out << b.str;``        ``return` `out;``    ``}``};`` ` `// Driver Code``int` `main()``{``    ``string str = ``"7777555511111111"``;``    ``string str1 = ``"3332222221111"``;`` ` `    ``// Create BigInteger objects``    ``// and add them``    ``BigInteger a(str);``    ``BigInteger b(str1);``    ``BigInteger sum = a + b;`` ` `    ``// Output the result``    ``cout << sum << endl;``    ``return` `0;``}`

## C#

 `// C# code addition `` ` `using` `System;``using` `System.Collections.Generic;`` ` `// Implementing biginteger class. ``public` `class` `BigInteger {``    ``private` `List<``int``> digits;``     ` `    ``// Constructor ``    ``public` `BigInteger(``string` `value) {``        ``digits = ``new` `List<``int``>();``         ` `        ``for` `(``int` `i = value.Length - 1; i >= 0; i--) {``            ``digits.Add(``int``.Parse(value[i].ToString()));``        ``}``    ``}``     ` `    ``// Add function  in BigInteger. ``    ``public` `static` `BigInteger Add(BigInteger a, BigInteger b) {``        ``List<``int``> sum = ``new` `List<``int``>();``        ``int` `carry = 0;``        ``int` `i = 0;``         ` `        ``while` `(i < a.digits.Count || i < b.digits.Count) {``            ``int` `x = i < a.digits.Count ? a.digits[i] : 0;``            ``int` `y = i < b.digits.Count ? b.digits[i] : 0;``            ``int` `s = x + y + carry;``             ` `            ``sum.Add(s % 10);``            ``carry = s / 10;``            ``i++;``        ``}``         ` `        ``if` `(carry > 0) {``            ``sum.Add(carry);``        ``}``         ` `        ``BigInteger result = ``new` `BigInteger(``""``);``         ` `        ``for` `(``int` `j = sum.Count - 1; j >= 0; j--) {``            ``result.digits.Add(sum[j]);``        ``}``         ` `        ``return` `result;``    ``}``     ` `    ``// An override function to convert them to string. ``    ``public` `override` `string` `ToString() {``        ``string` `result = ``""``;``         ` `        ``foreach` `(``int` `digit ``in` `digits) {``            ``result += digit.ToString();``        ``}``         ` `        ``return` `result;``    ``}``}`` ` `public` `class` `GFG {``    ``public` `static` `void` `Main() {``        ``string` `str = ``"7777555511111111"``;``        ``string` `str1 = ``"3332222221111"``;``         ` `        ``BigInteger a = ``new` `BigInteger(str);``// convert the string to a BigInteger``        ``BigInteger b = ``new` `BigInteger(str1);``// convert the string to a BigInteger``        ` `        ``Console.WriteLine(BigInteger.Add(a, b)); ``// add the two BigIntegers and print the result``    ``}``}`` ` `// The code is  contributed by Nidhi goel. `

Output

`7780887733332222`

Time Complexity: O(1)
Auxiliary Space: O(1)

### Approach 2: Iterative approach

The idea is based on school mathematics. We traverse both strings from end, one by one add digits and keep track of carry. To simplify the process, we do following:
1) Reverse both strings.
2) Keep adding digits one by one from 0’th index (in reversed strings) to end of smaller string, append the sum % 10 to end of result and keep track of carry as sum/10.
3) Finally reverse the result.

## C++

 `// C++ program to find sum of two large numbers.``#include``using` `namespace` `std;`` ` `// Function for finding sum of larger numbers``string findSum(string str1, string str2)``{``    ``// Before proceeding further, make sure length``    ``// of str2 is larger.``    ``if` `(str1.length() > str2.length())``        ``swap(str1, str2);`` ` `    ``// Take an empty string for storing result``    ``string str = ``""``;`` ` `    ``// Calculate length of both string``    ``int` `n1 = str1.length(), n2 = str2.length();`` ` `    ``// Reverse both of strings``    ``reverse(str1.begin(), str1.end());``    ``reverse(str2.begin(), str2.end());`` ` `    ``int` `carry = 0;``    ``for` `(``int` `i=0; i

## Java

 `// Java program to find sum of two large numbers. ``import` `java.util.*;``class` `GFG``{``// Function for finding sum of larger numbers ``static` `String findSum(String str1, String str2) ``{ ``    ``// Before proceeding further, make sure length ``    ``// of str2 is larger. ``    ``if` `(str1.length() > str2.length()){ ``        ``String t = str1;``        ``str1 = str2;``        ``str2 = t;``    ``}`` ` `    ``// Take an empty String for storing result ``    ``String str = ``""``; `` ` `    ``// Calculate length of both String ``    ``int` `n1 = str1.length(), n2 = str2.length(); `` ` `    ``// Reverse both of Strings``    ``str1=``new` `StringBuilder(str1).reverse().toString();``    ``str2=``new` `StringBuilder(str2).reverse().toString();`` ` `    ``int` `carry = ``0``; ``    ``for` `(``int` `i = ``0``; i < n1; i++) ``    ``{ ``        ``// Do school mathematics, compute sum of ``        ``// current digits and carry ``        ``int` `sum = ((``int``)(str1.charAt(i) - ``'0'``) + ``                    ``(``int``)(str2.charAt(i) - ``'0'``) + carry); ``        ``str += (``char``)(sum % ``10` `+ ``'0'``); `` ` `        ``// Calculate carry for next step ``        ``carry = sum / ``10``; ``    ``} `` ` `    ``// Add remaining digits of larger number ``    ``for` `(``int` `i = n1; i < n2; i++) ``    ``{ ``        ``int` `sum = ((``int``)(str2.charAt(i) - ``'0'``) + carry); ``        ``str += (``char``)(sum % ``10` `+ ``'0'``); ``        ``carry = sum / ``10``; ``    ``} `` ` `    ``// Add remaining carry ``    ``if` `(carry > ``0``) ``        ``str += (``char``)(carry + ``'0'``); `` ` `    ``// reverse resultant String``    ``str = ``new` `StringBuilder(str).reverse().toString();`` ` `    ``return` `str; ``} `` ` `// Driver code ``public` `static` `void` `main(String[] args) ``{ ``    ``String str1 = ``"12"``; ``    ``String str2 = ``"198111"``; ``    ``System.out.println(findSum(str1, str2)); ``} ``}``// This code is contributed by mits`

## Python3

 `# Python3 program to find sum of ``# two large numbers. `` ` `# Function for finding sum of ``# larger numbers ``def` `findSum(str1, str2): ``     ` `    ``# Before proceeding further, ``    ``# make sure length of str2 is larger. ``    ``if` `(``len``(str1) > ``len``(str2)):``        ``t ``=` `str1;``        ``str1 ``=` `str2;``        ``str2 ``=` `t;`` ` `    ``# Take an empty string for ``    ``# storing result ``    ``str` `=` `""; `` ` `    ``# Calculate length of both string ``    ``n1 ``=` `len``(str1);``    ``n2 ``=` `len``(str2); `` ` `    ``# Reverse both of strings ``    ``str1 ``=` `str1[::``-``1``]; ``    ``str2 ``=` `str2[::``-``1``]; `` ` `    ``carry ``=` `0``; ``    ``for` `i ``in` `range``(n1): ``         ` `        ``# Do school mathematics, compute ``        ``# sum of current digits and carry ``        ``sum` `=` `((``ord``(str1[i]) ``-` `48``) ``+` `              ``((``ord``(str2[i]) ``-` `48``) ``+` `carry)); ``        ``str` `+``=` `chr``(``sum` `%` `10` `+` `48``); `` ` `        ``# Calculate carry for next step ``        ``carry ``=` `int``(``sum` `/` `10``); `` ` `    ``# Add remaining digits of larger number ``    ``for` `i ``in` `range``(n1, n2): ``        ``sum` `=` `((``ord``(str2[i]) ``-` `48``) ``+` `carry); ``        ``str` `+``=` `chr``(``sum` `%` `10` `+` `48``); ``        ``carry ``=` `(``int``)(``sum` `/` `10``); `` ` `    ``# Add remaining carry ``    ``if` `(carry): ``        ``str` `+``=` `chr``(carry ``+` `48``); `` ` `    ``# reverse resultant string ``    ``str` `=` `str``[::``-``1``]; `` ` `    ``return` `str``; `` ` `# Driver code ``str1 ``=` `"12"``; ``str2 ``=` `"198111"``; ``print``(findSum(str1, str2)); `` ` `# This code is contributed by mits`

## C#

 `// C# program to find sum of two large numbers. ``using` `System;``class` `GFG``{``// Function for finding sum of larger numbers ``static` `string` `findSum(``string` `str1, ``string` `str2) ``{ ``    ``// Before proceeding further, make sure length ``    ``// of str2 is larger. ``    ``if` `(str1.Length > str2.Length){ ``        ``string` `t = str1;``        ``str1 = str2;``        ``str2 = t;``    ``}`` ` `    ``// Take an empty string for storing result ``    ``string` `str = ``""``; `` ` `    ``// Calculate length of both string ``    ``int` `n1 = str1.Length, n2 = str2.Length; `` ` `    ``// Reverse both of strings``    ``char``[] ch = str1.ToCharArray();``    ``Array.Reverse( ch );``    ``str1 = ``new` `string``( ch );``    ``char``[] ch1 = str2.ToCharArray();``    ``Array.Reverse( ch1 );``    ``str2 = ``new` `string``( ch1 );`` ` `    ``int` `carry = 0; ``    ``for` `(``int` `i = 0; i < n1; i++) ``    ``{ ``        ``// Do school mathematics, compute sum of ``        ``// current digits and carry ``        ``int` `sum = ((``int``)(str1[i] - ``'0'``) + ``                ``(``int``)(str2[i] - ``'0'``) + carry); ``        ``str += (``char``)(sum % 10 + ``'0'``); `` ` `        ``// Calculate carry for next step ``        ``carry = sum/10; ``    ``} `` ` `    ``// Add remaining digits of larger number ``    ``for` `(``int` `i = n1; i < n2; i++) ``    ``{ ``        ``int` `sum = ((``int``)(str2[i] - ``'0'``) + carry); ``        ``str += (``char``)(sum % 10 + ``'0'``); ``        ``carry = sum/10; ``    ``} `` ` `    ``// Add remaining carry ``    ``if` `(carry > 0) ``        ``str += (``char``)(carry + ``'0'``); `` ` `    ``// reverse resultant string``    ``char``[] ch2 = str.ToCharArray();``    ``Array.Reverse( ch2 );``    ``str = ``new` `string``( ch2 );`` ` `    ``return` `str; ``} `` ` `// Driver code ``static` `void` `Main() ``{ ``    ``string` `str1 = ``"12"``; ``    ``string` `str2 = ``"198111"``; ``    ``Console.WriteLine(findSum(str1, str2)); ``} ``}`` ` `// This code is contributed by mits`

## PHP

 ` ``strlen``(``\$str2``)) {``        ``\$t``=``\$str1``;``        ``\$str1``=``\$str2``;``        ``\$str2``=``\$t``;``    ``}`` ` `    ``// Take an empty string for storing result ``    ``\$str` `= ``""``; `` ` `    ``// Calculate length of both string ``    ``\$n1` `= ``strlen``(``\$str1``);``    ``\$n2` `= ``strlen``(``\$str2``); `` ` `    ``// Reverse both of strings ``    ``\$str1` `= ``strrev``(``\$str1``); ``    ``\$str2` `= ``strrev``(``\$str2``); `` ` `    ``\$carry` `= 0; ``    ``for` `(``\$i``=0; ``\$i``<``\$n1``; ``\$i``++) ``    ``{ ``        ``// Do school mathematics, compute sum of ``        ``// current digits and carry ``        ``\$sum` `= ((ord(``\$str1``[``\$i``])-48)+((ord(``\$str2``[``\$i``])-48)+``\$carry``)); ``        ``\$str``.=``chr``(``\$sum``%10 + 48); `` ` `        ``// Calculate carry for next step ``        ``\$carry` `= (int)(``\$sum``/10); ``    ``} `` ` `    ``// Add remaining digits of larger number ``    ``for` `(``\$i``=``\$n1``; ``\$i``<``\$n2``; ``\$i``++) ``    ``{ ``        ``\$sum` `= ((ord(``\$str2``[``\$i``])-48)+``\$carry``); ``        ``\$str``.=``chr``(``\$sum``%10 + 48); ``        ``\$carry` `= (int)(``\$sum``/10); ``    ``} `` ` `    ``// Add remaining carry ``    ``if` `(``\$carry``) ``        ``\$str``.=``chr``(``\$carry``+48); `` ` `    ``// reverse resultant string ``    ``\$str``=``strrev``(``\$str``); `` ` `    ``return` `\$str``; ``} `` ` `// Driver code ``  ` `    ``\$str1` `= ``"12"``; ``    ``\$str2` `= ``"198111"``; ``    ``echo` `findSum(``\$str1``, ``\$str2``); `` ` `// This code is contributed by mits``?>`

## Javascript

 ``

Output:

`198123`

Time Complexity: O(n1+n2) where n1 and n2 are lengths of two input strings representing numbers.

Auxiliary Space: O(max(n1, n2))

### Approach 3 : Optimization

We can avoid the first two string reverse operations by traversing them from the end. Below is the optimized solution.

## C++

 `// C++ program to find sum of two large numbers.``#include``using` `namespace` `std;`` ` `// Function for finding sum of larger numbers``string findSum(string str1, string str2)``{``    ``// Before proceeding further, make sure length``    ``// of str2 is larger.``    ``if` `(str1.length() > str2.length())``        ``swap(str1, str2);`` ` `    ``// Take an empty string for storing result``    ``string str = ``""``;`` ` `    ``// Calculate length of both string``    ``int` `n1 = str1.length(), n2 = str2.length();``    ``int` `diff = n2 - n1;`` ` `    ``// Initially take carry zero``    ``int` `carry = 0;`` ` `    ``// Traverse from end of both strings``    ``for` `(``int` `i=n1-1; i>=0; i--)``    ``{``        ``// Do school mathematics, compute sum of``        ``// current digits and carry``        ``int` `sum = ((str1[i]-``'0'``) +``                   ``(str2[i+diff]-``'0'``) +``                   ``carry);``        ``str.push_back(sum%10 + ``'0'``);``        ``carry = sum/10;``    ``}`` ` `    ``// Add remaining digits of str2[]``    ``for` `(``int` `i=n2-n1-1; i>=0; i--)``    ``{``        ``int` `sum = ((str2[i]-``'0'``)+carry);``        ``str.push_back(sum%10 + ``'0'``);``        ``carry = sum/10;``    ``}`` ` `    ``// Add remaining carry``    ``if` `(carry)``        ``str.push_back(carry+``'0'``);`` ` `    ``// reverse resultant string``    ``reverse(str.begin(), str.end());`` ` `    ``return` `str;``}`` ` `// Driver code``int` `main()``{``    ``string str1 = ``"12"``;``    ``string str2 = ``"198111"``;``    ``cout << findSum(str1, str2);``    ``return` `0;``}`

## Java

 `// Java program to find sum of two large numbers. ``import` `java.util.*;`` ` `class` `GFG{``     ` ` ``// Function for finding sum of larger numbers ``static` `String findSum(String str1, String str2) ``{ ``    ``// Before proceeding further, make sure length ``    ``// of str2 is larger. ``    ``if` `(str1.length() > str2.length()){``        ``String t = str1;``        ``str1 = str2;``        ``str2 = t;``    ``}`` ` `    ``// Take an empty String for storing result ``    ``String str = ``""``; `` ` `    ``// Calculate length of both String ``    ``int` `n1 = str1.length(), n2 = str2.length(); ``    ``int` `diff = n2 - n1; `` ` `    ``// Initially take carry zero ``    ``int` `carry = ``0``; `` ` `    ``// Traverse from end of both Strings ``    ``for` `(``int` `i = n1 - ``1``; i>=``0``; i--) ``    ``{ ``        ``// Do school mathematics, compute sum of ``        ``// current digits and carry ``        ``int` `sum = ((``int``)(str1.charAt(i)-``'0'``) + ``            ``(``int``)(str2.charAt(i+diff)-``'0'``) + carry); ``        ``str += (``char``)(sum % ``10` `+ ``'0'``); ``        ``carry = sum / ``10``; ``    ``} `` ` `    ``// Add remaining digits of str2[] ``    ``for` `(``int` `i = n2 - n1 - ``1``; i >= ``0``; i--) ``    ``{ ``        ``int` `sum = ((``int``)(str2.charAt(i) - ``'0'``) + carry); ``        ``str += (``char``)(sum % ``10` `+ ``'0'``); ``        ``carry = sum / ``10``; ``    ``} `` ` `    ``// Add remaining carry ``    ``if` `(carry > ``0``) ``        ``str += (``char``)(carry + ``'0'``); `` ` `    ``// reverse resultant String``    ``return` `new` `StringBuilder(str).reverse().toString();``} `` ` `// Driver code ``public` `static` `void` `main(String[] args) ``{ ``    ``String str1 = ``"12"``; ``    ``String str2 = ``"198111"``; ``    ``System.out.println(findSum(str1, str2)); ``} ``}`` ` `// This code is contributed by mits`

## Python3

 `# python 3 program to find sum of two large numbers.``  ` `# Function for finding sum of larger numbers``def` `findSum(str1, str2):`` ` `    ``# Before proceeding further, make sure length``    ``# of str2 is larger.``    ``if` `len``(str1)> ``len``(str2):``        ``temp ``=` `str1``        ``str1 ``=` `str2``        ``str2 ``=` `temp``  ` `    ``# Take an empty string for storing result``    ``str3 ``=` `""``  ` `    ``# Calculate length of both string``    ``n1 ``=` `len``(str1)``    ``n2 ``=` `len``(str2)``    ``diff ``=` `n2 ``-` `n1``  ` `    ``# Initially take carry zero``    ``carry ``=` `0``  ` `    ``# Traverse from end of both strings``    ``for` `i ``in` `range``(n1``-``1``,``-``1``,``-``1``):``     ` `        ``# Do school mathematics, compute sum of``        ``# current digits and carry``       ` `        ``sum` `=` `((``ord``(str1[i])``-``ord``(``'0'``)) ``+``                   ``int``((``ord``(str2[i``+``diff])``-``ord``(``'0'``))) ``+` `carry)``      ` `        ``str3 ``=` `str3``+``str``(``sum``%``10` `)``         ` `        ` `        ``carry ``=` `sum``/``/``10``  ` `    ``# Add remaining digits of str2[]``    ``for` `i ``in` `range``(n2``-``n1``-``1``,``-``1``,``-``1``):``     ` `        ``sum` `=` `((``ord``(str2[i])``-``ord``(``'0'``))``+``carry)``        ``str3 ``=` `str3``+``str``(``sum``%``10` `)``        ``carry ``=` `sum``/``/``10``  ` `    ``# Add remaining carry``    ``if` `(carry):``        ``str3``+``str``(carry``+``'0'``)``  ` `    ``# reverse resultant string``    ``str3 ``=` `str3[::``-``1``]``  ` `    ``return` `str3``  ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``str1 ``=` `"12"``    ``str2 ``=` `"198111"``    ``print``(findSum(str1, str2))`` ` `# This code is contributed by ChitraNayal`

## C#

 `// C# program to find sum of two large numbers. ``using` `System; `` ` `class` `GFG{``     ` `// Function for finding sum of larger numbers ``static` `string` `findSum(``string` `str1, ``string` `str2) ``{ ``    ``// Before proceeding further, make sure length ``    ``// of str2 is larger. ``    ``if` `(str1.Length > str2.Length)``    ``{``        ``string` `t = str1;``        ``str1 = str2;``        ``str2 = t;``    ``}`` ` `    ``// Take an empty string for storing result ``    ``string` `str = ``""``; `` ` `    ``// Calculate length of both string ``    ``int` `n1 = str1.Length, n2 = str2.Length; ``    ``int` `diff = n2 - n1; `` ` `    ``// Initially take carry zero ``    ``int` `carry = 0; `` ` `    ``// Traverse from end of both strings ``    ``for` `(``int` `i = n1 - 1; i >= 0; i--) ``    ``{ ``        ``// Do school mathematics, compute sum of ``        ``// current digits and carry ``        ``int` `sum = ((``int``)(str1[i] - ``'0'``) + ``                ``(``int``)(str2[i + diff]-``'0'``) + carry); ``        ``str += (``char``)(sum % 10 + ``'0'``); ``        ``carry = sum / 10; ``    ``} `` ` `    ``// Add remaining digits of str2[] ``    ``for` `(``int` `i = n2 - n1 - 1; i >= 0; i--) ``    ``{ ``        ``int` `sum = ((``int``)(str2[i] - ``'0'``) + carry); ``        ``str += (``char``)(sum % 10 + ``'0'``); ``        ``carry = sum / 10; ``    ``} `` ` `    ``// Add remaining carry ``    ``if` `(carry > 0) ``        ``str += (``char``)(carry + ``'0'``); `` ` `    ``// reverse resultant string``    ``char``[] ch2 = str.ToCharArray();``    ``Array.Reverse(ch2);``    ``return` `new` `string``(ch2);``} `` ` `// Driver code ``static` `void` `Main() ``{ ``    ``string` `str1 = ``"12"``; ``    ``string` `str2 = ``"198111"``; ``    ``Console.WriteLine(findSum(str1, str2)); ``} ``}`` ` `// This code is contributed by mits`

## PHP

 ` ``strlen``(``\$str2``))``    ``{ ``        ``\$temp` `= ``\$str1``; ``        ``\$str1` `= ``\$str2``; ``        ``\$str2` `= ``\$temp``;``    ``}`` ` `    ``// Take an empty string for storing result ``    ``\$str3` `= ``""``; `` ` `    ``// Calculate length of both string ``    ``\$n1` `= ``strlen``(``\$str1``); ``    ``\$n2` `= ``strlen``(``\$str2``); ``    ``\$diff` `= ``\$n2` `- ``\$n1``; `` ` `    ``// Initially take carry zero ``    ``\$carry` `= 0;`` ` `    ``// Traverse from end of both strings ``    ``for` `(``\$i` `= ``\$n1` `- 1; ``\$i` `>= 0; ``\$i``--) ``    ``{``        ``// Do school mathematics, compute sum  ``        ``// of current digits and carry ``        ``\$sum` `= ((ord(``\$str1``[``\$i``]) - ord(``'0'``)) + ``               ``((ord(``\$str2``[``\$i` `+ ``\$diff``]) - ``                 ``ord(``'0'``))) + ``\$carry``); ``     ` `        ``\$str3` `.= ``chr``(``\$sum` `% 10 + ord(``'0'``)); ``         ` `         ` `        ``\$carry` `= (int)(``\$sum` `/ 10);``    ``}`` ` `    ``// Add remaining digits of str2[]``    ``for` `(``\$i` `= ``\$n2` `- ``\$n1` `- 1; ``\$i` `>= 0; ``\$i``--) ``    ``{``        ``\$sum` `= ((ord(``\$str2``[``\$i``]) - ord(``'0'``)) + ``\$carry``); ``        ``\$str3` `.= ``chr``(``\$sum` `% 10 + ord(``'0'``)); ``        ``\$carry` `= (int)(``\$sum` `/ 10);``    ``}`` ` `    ``// Add remaining carry ``    ``if` `(``\$carry``) ``        ``\$str3` `.= ``chr``(``\$carry` `+ ord(``'0'``)); `` ` `    ``// reverse resultant string ``    ``return` `strrev``(``\$str3``); ``}`` ` `// Driver code ``\$str1` `= ``"12"``;``\$str2` `= ``"198111"``;``print``(findSum(``\$str1``, ``\$str2``)); `` ` `// This code is contributed by mits ``?>`

## Javascript

 ``

Output:

`198123`

Time Complexity: O(max(n1, n2)) where n1 and n2 are lengths of two input strings representing numbers.

Auxiliary Space: O(max(n1, n2))

This article is contributed by DANISH_RAZA. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.