# Find the index having sum of elements on its left equal to reverse of the sum of elements on its right

• Last Updated : 27 Jan, 2023

Given an array, arr[] size N, the task is to find the smallest index of the array such that the sum of all the array elements on the left side of the index is equal to the reverse of the digits of the sum of all the array elements on the right side of that index. If no such index is found then print -1.

Examples:

Input: arr[] = { 5, 7, 3, 6, 4, 9, 2 }
Output:
Explanation:
Sum of array elements on left side of index 2 = (5 + 7) = 12
Sum of array elements on right side of index 2 = (6 + 4 + 9 + 2) = 21
Since sum of array elements on left side of index 2 equal to the reverse of the digits of sum of elements on the right side of index 2. Therefore, the required output is 2.

Input: arr[] = { 1, 3, 6, 8, 9, 2 }
Output: -1

Naive Approach: The simplest approach to solve this problem is to traverse the array and for each index, check if the sum of elements on the left side of the index is equal to the reverse of the digits of the sum of the array elements on the right side of that index or not. If found to be true, then print that index. Otherwise, if no such index is found, print -1.

1. Iterate through the vector using a for loop with an index i from 0 to n-1.
2. Inside the for loop, call the function sum_left passing in the vector, n and the current index i, which returns
the sum of all elements in the vector before the current index.
3. Call the function sum_right passing in the vector, n, and the current index i, which returns the sum of all elements in the vector after the current index.
4. Convert the result from step 3 to a string and store in variable sum_r_str
5. Reverse the string from step 4 and store it in variable sum_r_str_reversed
6. Compare sum_l from step 2 with the result of the string from step 5, stoi(sum_r_str_reversed)
7. If the comparison is true, print i and return 0, otherwise continue with the for loop.
8. If for loop is finished, print -1 and return 0

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `int` `sum_left(vector<``int``>& arr, ``int` `n, ``int` `index)``{``    ``int` `sum = 0;``    ``for` `(``int` `i = 0; i < index; i++) {``        ``sum += arr[i];``    ``}``    ``return` `sum;``}` `int` `sum_right(vector<``int``>& arr, ``int` `n, ``int` `index)``{``    ``int` `sum = 0;``    ``for` `(``int` `i = index + 1; i < n; i++) {``        ``sum += arr[i];``    ``}``    ``return` `sum;``}` `string reverse_string(string str)``{``    ``reverse(str.begin(), str.end());``    ``return` `str;``}` `int` `main()``{``    ``vector<``int``> arr = { 5, 7, 3, 6, 4, 9, 2 };``    ``int` `n = arr.size();` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `sum_l = sum_left(arr, n, i);``        ``int` `sum_r = sum_right(arr, n, i);``        ``string sum_r_str = to_string(sum_r);``        ``string sum_r_str_reversed``            ``= reverse_string(sum_r_str);``        ``if` `(sum_l == stoi(sum_r_str_reversed)) {``            ``cout << i << endl;``            ``return` `0;``        ``}``    ``}``    ``cout << -1 << endl;``    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;``import` `java.util.Vector;` `public` `class` `Gfg {``    ``public` `static` `int` `sum_left(Vector arr, ``int` `n,``                               ``int` `index)``    ``{``        ``int` `sum = ``0``;``        ``for` `(``int` `i = ``0``; i < index; i++) {``            ``sum += arr.get(i);``        ``}``        ``return` `sum;``    ``}` `    ``public` `static` `int` `sum_right(Vector arr, ``int` `n,``                                ``int` `index)``    ``{``        ``int` `sum = ``0``;``        ``for` `(``int` `i = index + ``1``; i < n; i++) {``            ``sum += arr.get(i);``        ``}``        ``return` `sum;``    ``}` `    ``public` `static` `String reverse_string(String str)``    ``{``        ``StringBuilder sb = ``new` `StringBuilder(str);``        ``return` `sb.reverse().toString();``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``Vector arr = ``new` `Vector(``            ``Arrays.asList(``5``, ``7``, ``3``, ``6``, ``4``, ``9``, ``2``));``        ``int` `n = arr.size();` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``int` `sum_l = sum_left(arr, n, i);``            ``int` `sum_r = sum_right(arr, n, i);``            ``String sum_r_str = Integer.toString(sum_r);``            ``String sum_r_str_reversed``                ``= reverse_string(sum_r_str);``            ``if` `(sum_l``                ``== Integer.parseInt(sum_r_str_reversed)) {``                ``System.out.println(i);``                ``return``;``            ``}``        ``}``        ``System.out.println(-``1``);``    ``}``}` `// This code is contributed by divya_p123.`

## Python3

 `def` `sum_left(arr, n, index):``    ``sum` `=` `0``;``    ``for` `i ``in` `range``(``0``,index):``        ``sum` `+``=` `arr[i];``    ``return` `sum``;` `def` `sum_right( arr, n, index):``    ``sum` `=` `0``;``    ``for` `i ``in` `range``(index``+``1``,n):``        ``sum` `+``=` `arr[i];``    ` `    ``return` `sum``;` `def` `reverse_string( string):``    ``return` `string[::``-``1``]` `arr ``=` `[ ``5``, ``7``, ``3``, ``6``, ``4``, ``9``, ``2` `];``n ``=` `len``(arr);` `for` `i ``in` `range``(``0``,n):``    ``sum_l ``=` `sum_left(arr, n, i);``    ``sum_r ``=` `sum_right(arr, n, i);``    ``sum_r_str ``=` `str``(sum_r);``    ``f``=``0``;``    ``sum_r_str_reverse ``=` `reverse_string(sum_r_str);``    ``if` `(sum_l ``=``=` `int``(sum_r_str_reverse)):``        ``print``(i);``        ``f``=``1``;``        ``break``;``if``(f ``=``=` `0``):``    ``print``(``-``1``);`` ` `# This code was contributed by poojaagrawal2.`

## Javascript

 `function` `sum_left(arr, n, index) {``    ``let sum = 0;``    ``for` `(let i = 0; i < index; i++) {``        ``sum += arr[i];``    ``}``    ``return` `sum;``}` `function` `sum_right(arr, n, index) {``    ``let sum = 0;``    ``for` `(let i = index + 1; i < n; i++) {``        ``sum += arr[i];``    ``}``    ``return` `sum;``}` `function` `reverse_string(str) {``    ``return` `str.split(``''``).reverse().join(``''``);``}``let arr = [5, 7, 3, 6, 4, 9, 2];``let n = arr.length;` `for` `(let i = 0; i < n; i++) {``    ``let sum_l = sum_left(arr, n, i);``    ``let sum_r = sum_right(arr, n, i);``    ``let sum_r_str = sum_r.toString();``    ``let sum_r_str_reversed = reverse_string(sum_r_str);``    ``if` `(sum_l === parseInt(sum_r_str_reversed)) {``        ``console.log(i);``        ``return``;``    ``}``}``console.log(-1);` `// This code is contributed by agrawalpoojaa976.`

Output

`2`

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

Efficient Approach: To optimize the above approach the idea is to use prefix-sum technique. Follow the steps below to solve the problem:

• Initialize a variable, say rightSum, to store the sum of the array elements on the right side of each index.
• Initialize a variable, say leftSum, to store the sum of array elements on the left side of each index.
• Traverse the array using variable i and update the value of rightSum -= arr[i], leftSum += arr[i] and check if leftSum equal to the reverse of digits of rightSum or not. If found to be true then print i.
• Otherwise, print -1.

Below is the implementation of the above approach.

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to check if a number is equal``// to the reverse of digits of other number``bool` `checkReverse(``int` `leftSum, ``int` `rightSum)``{``    ``// Stores reverse of``    ``// digits of rightSum``    ``int` `rev = 0;` `    ``// Stores rightSum``    ``int` `temp = rightSum;` `    ``// Calculate reverse of``    ``// digits of temp``    ``while` `(temp != 0) {` `        ``// Update rev``        ``rev = (rev * 10) + (temp % 10);` `        ``// Update temp``        ``temp /= 10;``    ``}` `    ``// If reverse of digits of``    ``// rightSum equal to leftSum``    ``if` `(rev == leftSum) {``        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Function to find the index``// that satisfies the condition``int` `findIndex(``int` `arr[], ``int` `N)``{` `    ``// Stores sum of array elements``    ``// on right side of each index``    ``int` `rightSum = 0;` `    ``// Stores sum of array elements``    ``// on left side of each index``    ``int` `leftSum = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update rightSum``        ``rightSum += arr[i];``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update rightSum``        ``rightSum -= arr[i];` `        ``// If leftSum equal to``        ``// reverse of digits``        ``// of rightSum``        ``if` `(checkReverse(leftSum,``                         ``rightSum)) {``            ``return` `i;``        ``}` `        ``// Update leftSum``        ``leftSum += arr[i];``    ``}` `    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 7, 3, 6, 4, 9, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << findIndex(arr, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG {` `  ``// Function to check if a number is equal``  ``// to the reverse of digits of other number``  ``static` `boolean` `checkReverse(``int` `leftSum, ``int` `rightSum)``  ``{``    ``// Stores reverse of``    ``// digits of rightSum``    ``int` `rev = ``0``;` `    ``// Stores rightSum``    ``int` `temp = rightSum;` `    ``// Calculate reverse of``    ``// digits of temp``    ``while` `(temp != ``0``) {` `      ``// Update rev``      ``rev = (rev * ``10``) + (temp % ``10``);` `      ``// Update temp``      ``temp /= ``10``;``    ``}` `    ``// If reverse of digits of``    ``// rightSum equal to leftSum``    ``if` `(rev == leftSum) {``      ``return` `true``;``    ``}` `    ``return` `false``;``  ``}` `  ``// Function to find the index``  ``// that satisfies the condition``  ``static` `int` `findIndex(``int``[] arr, ``int` `N)``  ``{` `    ``// Stores sum of array elements``    ``// on right side of each index``    ``int` `rightSum = ``0``;` `    ``// Stores sum of array elements``    ``// on left side of each index``    ``int` `leftSum = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Update rightSum``      ``rightSum += arr[i];``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Update rightSum``      ``rightSum -= arr[i];` `      ``// If leftSum equal to``      ``// reverse of digits``      ``// of rightSum``      ``if` `(checkReverse(leftSum,``                       ``rightSum)) {``        ``return` `i;``      ``}` `      ``// Update leftSum``      ``leftSum += arr[i];``    ``}` `    ``return` `-``1``;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int``[] arr = { ``5``, ``7``, ``3``, ``6``, ``4``, ``9``, ``2` `};``    ``int` `N = arr.length;``    ``System.out.print(findIndex(arr, N));``  ``}``}` `// This code is contributed by code_hunt.`

## Python3

 `# Python3 Program to implement``# the above approach` `# Function to check if a number is equal``# to the reverse of digits of other number``def` `checkReverse(leftSum, rightSum):``    ` `    ``# Stores reverse of``    ``# digits of rightSum``    ``rev ``=` `0` `    ``# Stores rightSum``    ``temp ``=` `rightSum` `    ``# Calculate reverse of``    ``# digits of temp``    ``while` `(temp !``=` `0``):` `        ``# Update rev``        ``rev ``=` `(rev ``*` `10``) ``+` `(temp ``%` `10``)` `        ``# Update temp``        ``temp ``/``/``=` `10` `    ``# If reverse of digits of``    ``# rightSum equal to leftSum``    ``if` `(rev ``=``=` `leftSum):``        ``return` `True` `    ``return` `False` `# Function to find the index``# that satisfies the condition``def` `findIndex(arr, N):` `    ``# Stores sum of array elements``    ``# on right side of each index``    ``rightSum ``=` `0` `    ``# Stores sum of array elements``    ``# on left side of each index``    ``leftSum ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``       ` `        ``# Update rightSum``        ``rightSum ``+``=` `arr[i]` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# Update rightSum``        ``rightSum ``-``=` `arr[i]` `        ``# If leftSum equal to``        ``# reverse of digits``        ``# of rightSum``        ``if` `(checkReverse(leftSum, rightSum)):``            ``return` `i` `        ``# Update leftSum``        ``leftSum ``+``=` `arr[i]``    ``return` `-``1` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``5``, ``7``, ``3``, ``6``, ``4``, ``9``, ``2``]``    ``N ``=`  `len``(arr)``    ``print``(findIndex(arr, N))` `    ``# This code is contributed by mohit kumar 29`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG {``    ` `    ``// Function to check if a number is equal``    ``// to the reverse of digits of other number``    ``static` `bool` `checkReverse(``int` `leftSum, ``int` `rightSum)``    ``{``        ``// Stores reverse of``        ``// digits of rightSum``        ``int` `rev = 0;``     ` `        ``// Stores rightSum``        ``int` `temp = rightSum;``     ` `        ``// Calculate reverse of``        ``// digits of temp``        ``while` `(temp != 0) {``     ` `            ``// Update rev``            ``rev = (rev * 10) + (temp % 10);``     ` `            ``// Update temp``            ``temp /= 10;``        ``}``     ` `        ``// If reverse of digits of``        ``// rightSum equal to leftSum``        ``if` `(rev == leftSum) {``            ``return` `true``;``        ``}``     ` `        ``return` `false``;``    ``}``     ` `    ``// Function to find the index``    ``// that satisfies the condition``    ``static` `int` `findIndex(``int``[] arr, ``int` `N)``    ``{``     ` `        ``// Stores sum of array elements``        ``// on right side of each index``        ``int` `rightSum = 0;``     ` `        ``// Stores sum of array elements``        ``// on left side of each index``        ``int` `leftSum = 0;``     ` `        ``// Traverse the array``        ``for` `(``int` `i = 0; i < N; i++) {``     ` `            ``// Update rightSum``            ``rightSum += arr[i];``        ``}``     ` `        ``// Traverse the array``        ``for` `(``int` `i = 0; i < N; i++) {``     ` `            ``// Update rightSum``            ``rightSum -= arr[i];``     ` `            ``// If leftSum equal to``            ``// reverse of digits``            ``// of rightSum``            ``if` `(checkReverse(leftSum,``                             ``rightSum)) {``                ``return` `i;``            ``}``     ` `            ``// Update leftSum``            ``leftSum += arr[i];``        ``}``     ` `        ``return` `-1;``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] arr = { 5, 7, 3, 6, 4, 9, 2 };``    ``int` `N = arr.Length;``    ``Console.Write(findIndex(arr, N));``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output

`2`

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

My Personal Notes arrow_drop_up