# Sum of integer value of input Array and reverse Array

• Last Updated : 27 Mar, 2023

Given an integer array of numbers num[], the task is to write a function to return the sum of the value of the array with its reverse value and then return the resulting array of digits.

Examples:

Input: num[] = [2, 5, 8, 2]
Output: [5, 4, 3, 4]
Explanation: Given array [2, 5, 8, 2], the numerical value is 2582 and the reverse value is 2852, so the sum is 2582 + 2852 = [5, 4, 3, 4]

Input: num[] = [2, 4, 6]
Output: [8, 8, 8]
Explanation: Given array [2, 4, 6] the numerical value is 246 and the reverse value is 642, so the sum is 246 + 642 = [8, 8, 8]

Approach: The approach for solving this problem is as follows:

• Convert the input integer array num[] into a single integer value num by concatenating all the elements of the array as strings and then converting the result into an integer.
• Reverse the input array number to get a new array reverse_number.
• Convert the reversed array reverse_number into a single integer value reverse_num using the same method as described in step 1.
• Find the sum of num and reverse_num and store it in a variable sum_num.
• Convert the value of sum_num into a list of individual digits and return it as the result.

Below is the implementation for the above approach:

## C++

 `// C++ code for the above approach:``#include ` `std::vector<``int``> sum_of_array_and_its_reverse(``const` `std::vector<``int``>& number)``{``    ``int` `num = 0, mul = 1;``    ``for` `(``int` `i = number.size() - 1; i >= 0; i--) {``        ``num += number[i] * mul;``        ``mul *= 10;``    ``}``    ``int` `rev_num = 0, mul_rev = 1;``    ``for` `(``int` `i = 0; i < number.size(); i++) {``        ``rev_num += number[i] * mul_rev;``        ``mul_rev *= 10;``    ``}``    ``int` `result = num + rev_num;``    ``std::vector<``int``> res;``    ``while` `(result > 0) {``        ``res.push_back(result % 10);``        ``result /= 10;``    ``}``    ``std::reverse(res.begin(), res.end());``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``std::vector<``int``> number1 = { 2, 5, 8, 2 };``    ``std::vector<``int``> result1 = sum_of_array_and_its_reverse(number1);``    ``for` `(``int` `i : result1) {``        ``std::cout << i << ``" "``;``    ``}``    ``std::cout << std::endl;``    ``std::vector<``int``> number2 = { 5, 5, 5 };``    ``std::vector<``int``> result2 = sum_of_array_and_its_reverse(number2);``    ``for` `(``int` `i : result2) {``        ``std::cout << i << ``" "``;``    ``}``    ``std::cout << std::endl;``    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;``import` `java.util.Collections;``import` `java.util.List;` `class` `Main {``    ``static` `List sum_of_array_and_its_reverse(List number)``    ``{``        ``int` `num = ``0``, mul = ``1``;``        ``for` `(``int` `i = number.size() - ``1``; i >= ``0``; i--) {``            ``num += number.get(i) * mul;``            ``mul *= ``10``;``        ``}``        ``int` `rev_num = ``0``, mul_rev = ``1``;``        ``for` `(``int` `i = ``0``; i < number.size(); i++) {``            ``rev_num += number.get(i) * mul_rev;``            ``mul_rev *= ``10``;``        ``}``        ``int` `result = num + rev_num;``        ``List res = ``new` `ArrayList<>();``        ``while` `(result > ``0``) {``            ``res.add(result % ``10``);``            ``result /= ``10``;``        ``}``        ``Collections.reverse(res);``        ``return` `res;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``List number1 = ``new` `ArrayList<>();``        ``number1.add(``2``);``        ``number1.add(``5``);``        ``number1.add(``8``);``        ``number1.add(``2``);``        ``List result1 = sum_of_array_and_its_reverse(number1);``        ``System.out.println(result1);``        ``List number2 = ``new` `ArrayList<>();``        ``number2.add(``2``);``        ``number2.add(``4``);``        ``number2.add(``6``);``        ``List result2 = sum_of_array_and_its_reverse(number2);``        ``System.out.println(result2);``    ``}``}`

## Python3

 `def` `sum_of_array_and_its_reverse(number):``    ``num ``=` `int``("".join(``str``(x) ``for` `x ``in` `number))``    ``rev_num ``=` `int``("".join(``str``(x) ``for` `x ``in` `reversed``(number)))``    ``result ``=` `num ``+` `rev_num``    ``return` `[``int``(x) ``for` `x ``in` `str``(result)]` `print``(sum_of_array_and_its_reverse([``2``, ``5``, ``8``, ``2``])) ``# Output: [5, 4, 3, 4]``print``(sum_of_array_and_its_reverse([``2``, ``4``, ``6``])) ``# Output: [8, 8, 8]`

## Javascript

 `function` `sum_of_array_and_its_reverse(number) {``    ``let num = 0, mul = 1;``    ``for` `(let i = number.length - 1; i >= 0; i--) {``        ``num += number[i] * mul;``        ``mul *= 10;``    ``}``    ``let rev_num = 0, mul_rev = 1;``    ``for` `(let i = 0; i < number.length; i++) {``        ``rev_num += number[i] * mul_rev;``        ``mul_rev *= 10;``    ``}``    ``let result = num + rev_num;``    ``let res = [];``    ``while` `(result > 0) {``        ``res.push(result % 10);``        ``result = Math.floor(result / 10);``    ``}``    ``res.reverse();``    ``return` `res;``}` `let number1 = [2, 5, 8, 2];``let result1 = sum_of_array_and_its_reverse(number1);``console.log(result1);``let number2 = [2, 4, 6];``let result2 = sum_of_array_and_its_reverse(number2);``console.log(result2);`

## C#

 `using` `System;``using` `System.Linq;` `namespace` `SumOfArrayWithReverse {``class` `Program {``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] number = ``new` `int``[] { 9, 9, 9 };``        ``int``[] result = SumArrayWithReverse(number);``        ``Console.WriteLine(``"Result: "` `+ ``string``.Join(``", "``, result));` `        ``int``[] number2 = ``new` `int``[] { 5, 5, 5 };``        ``int``[] result2 = SumArrayWithReverse(number2);``        ``Console.WriteLine(``"\nResult: "` `+ ``string``.Join(``", "``, result2));``    ``}` `    ``static` `int``[] SumArrayWithReverse(``int``[] number)``    ``{``        ``int``[] reverseNumber = number.Reverse().ToArray();``        ``int``[] result = ``new` `int``[number.Length];``        ``int` `carry = 0;` `        ``for` `(``int` `i = 0; i < number.Length; i++) {``            ``int` `sum = number[i] + reverseNumber[i] + carry;``            ``result[i] = sum % 10;``            ``carry = sum / 10;``        ``}` `        ``if` `(carry > 0) {``            ``Array.Resize(``ref` `result, result.Length + 1);``            ``result[result.Length - 1] = carry;``        ``}` `        ``return` `result.Reverse().ToArray();``    ``}``}``}`

Output

```5 4 3 4
1 1 1 0 ```

Time complexity: O(n) where n is the length of the input array

This is because the code iterates through the input array twice, once to compute the original number and once to compute the reversed number. The size of the result vector is also proportional to the size of the input array, so iterating through the result vector has a time complexity of O(n) as well. Therefore, the overall time complexity of the function is O(n), which is linear with respect to the size of the input.
Auxiliary Space: O(n) where n is the size of the input vector.

This is because the code creates a new vector to store the digits of the result, which can also be of size n in the worst case.

## Method: Numerical reverse-and-add approach

The numerical reverse-and-add approach involves the following steps:

1. Convert the array to a numerical value: Iterate through the array and multiply each digit by its corresponding place value to obtain the numerical value of the array.
2. Reverse the array: Reverse the array to obtain the reversed array.
3. Convert the reversed array to a numerical value: Iterate through the reversed array and multiply each digit by its corresponding place value to obtain the numerical value of the reversed array.
4. Add the two numerical values: Add the numerical values obtained in steps 1 and 3 to obtain the sum.
5. Convert the sum to an array of digits: Repeatedly divide the sum by 10 and take the remainder to obtain each digit. Add each digit to the resulting array until the sum becomes 0. Reverse the resulting array to obtain the final array of digits.

This approach can be used to efficiently compute the sum of the value of an array with its reverse value.

## Python3

 `def` `reverse_sum(num):``    ``# Convert the array to a numerical value``    ``n ``=` `len``(num)``    ``num_value ``=` `0``    ``for` `i ``in` `range``(n):``        ``num_value ``+``=` `num[i] ``*` `10``*``*``(n``-``i``-``1``)` `    ``# Reverse the array and obtain the numerical value of the reversed array``    ``reverse_num ``=` `num[::``-``1``]``    ``reverse_value ``=` `0``    ``for` `i ``in` `range``(n):``        ``reverse_value ``+``=` `reverse_num[i] ``*` `10``*``*``(n``-``i``-``1``)` `    ``# Add the two numerical values``    ``sum_value ``=` `num_value ``+` `reverse_value` `    ``# Convert the sum to an array of digits``    ``result ``=` `[]``    ``while` `sum_value > ``0``:``        ``result.append(sum_value ``%` `10``)``        ``sum_value ``/``/``=` `10` `    ``return` `result[::``-``1``]` `print``(reverse_sum([``2``, ``5``, ``8``, ``2``]))``# Output: [5, 4, 3, 4]` `print``(reverse_sum([``2``, ``4``, ``6``]))``# Output: [8, 8, 8]`

## C++

 `#include ``#include ``#include ` `using` `namespace` `std;` `vector<``int``> reverse_sum(vector<``int``> num) {``    ``// Convert the vector to a numerical value``    ``int` `n = num.size();``    ``int` `num_value = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``num_value += num[i] * ``pow``(10, n-i-1);``    ``}` `    ``// Reverse the vector and obtain the numerical value of the reversed vector``    ``vector<``int``> reverse_num(num.rbegin(), num.rend());``    ``int` `reverse_value = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``reverse_value += reverse_num[i] * ``pow``(10, n-i-1);``    ``}` `    ``// Add the two numerical values``    ``int` `sum_value = num_value + reverse_value;` `    ``// Convert the sum to a vector of digits``    ``vector<``int``> result;``    ``while` `(sum_value > 0) {``        ``result.insert(result.begin(), sum_value % 10);``        ``sum_value /= 10;``    ``}` `    ``return` `result;``}` `int` `main() {``    ``vector<``int``> num1 = {2, 5, 8, 2};``    ``vector<``int``> num2 = {2, 4, 6};` `    ``vector<``int``> result1 = reverse_sum(num1);``    ``vector<``int``> result2 = reverse_sum(num2);` `    ``// Print the results``    ``for` `(``int` `i = 0; i < result1.size(); i++) {``        ``cout << result1[i]<<``" "``;``    ``}``    ``cout << endl;` `    ``for` `(``int` `i = 0; i < result2.size(); i++) {``        ``cout << result2[i]<<``" "``;``    ``}``    ``cout << endl;` `    ``return` `0;``}`

Output

```[5, 4, 3, 4]
[8, 8, 8]
```

The time complexity of this approach is O(n), where n is the length of the input array.
The space complexity is also O(n), as we need to store the reversed array and the resulting array of digits.

My Personal Notes arrow_drop_up