GeeksforGeeks App
Open App
Browser
Continue

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

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.`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `public` `class` `GFG {``    ``static` `int` `SumLeft(List<``int``> arr, ``int` `n, ``int` `index)``    ``{``        ``int` `sum = 0;``        ``for` `(``int` `i = 0; i < index; i++) {``            ``sum += arr[i];``        ``}``        ``return` `sum;``    ``}` `    ``static` `int` `SumRight(List<``int``> arr, ``int` `n, ``int` `index)``    ``{``        ``int` `sum = 0;``        ``for` `(``int` `i = index + 1; i < n; i++) {``            ``sum += arr[i];``        ``}``        ``return` `sum;``    ``}` `    ``static` `string` `ReverseString(``string` `str)``    ``{``        ``char``[] charArray = str.ToCharArray();``        ``Array.Reverse(charArray);``        ``return` `new` `string``(charArray);``    ``}` `    ``static` `public` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> arr``            ``= ``new` `List<``int``>{ 5, 7, 3, 6, 4, 9, 2 };``        ``int` `n = arr.Count();` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``int` `sumLeft = SumLeft(arr, n, i);``            ``int` `sumRight = SumRight(arr, n, i);``            ``string` `sumRightStr = sumRight.ToString();``            ``string` `sumRightStrReversed``                ``= ReverseString(sumRightStr);``            ``if` `(sumLeft == ``int``.Parse(sumRightStrReversed)) {``                ``Console.WriteLine(i);``                ``return``;``            ``}``        ``}``        ``Console.WriteLine(-1);``    ``}``}` `// This code is contributed by Prasad Kandekar(prasad264)`

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

Approach 3: Binary Search :

Here’s the approach using binary search:

• Initialize two vectors sum_left and sum_right to store the prefix sums of the array from the left and right respectively.
• Traverse the array from left to right and calculate the prefix sums of the array from the left and store them in the vector sum_left.
• Traverse the array from right to left and calculate the prefix sums of the array from the right and store them in the vector sum_right.
• Initialize a variable n to be the size of the array.
• For each index i in the array, do the following:
• a. If the sum_left[i] equals the reversed string of sum_right[n-i-1], return i.
• If no such index is found, return -1.
Here’s the code:

## Python3

 `def` `reverse_integer(n):``    ``return` `int``(``str``(n)[::``-``1``])` `def` `check_index(arr, index):``    ``left_sum ``=` `sum``(arr[:index])``    ``right_sum ``=` `sum``(arr[index``+``1``:])``    ``if` `left_sum ``=``=` `reverse_integer(right_sum):``        ``return` `True``    ``return` `False` `def` `find_index(arr):``    ``total_sum ``=` `sum``(arr)``    ``left_sum ``=` `0``    ``for` `i ``in` `range``(``len``(arr)):``        ``right_sum ``=` `total_sum ``-` `left_sum ``-` `arr[i]``        ``if` `left_sum ``=``=` `reverse_integer(right_sum):``            ``return` `i``        ``left_sum ``+``=` `arr[i]``    ``return` `-``1` `arr ``=` `[``5``, ``7``, ``3``, ``6``, ``4``, ``9``, ``2``]``index ``=` `find_index(arr)``print``(index)`

## Javascript

 `function` `reverseInteger(n) {``  ``return` `parseInt(n.toString().split(``''``).reverse().join(``''``));``}` `function` `checkIndex(arr, index) {``  ``const leftSum = arr.slice(0, index).reduce((acc, val) => acc + val, 0);``  ``const rightSum = arr.slice(index + 1).reduce((acc, val) => acc + val, 0);``  ``if` `(leftSum === reverseInteger(rightSum)) {``    ``return` `true``;``  ``}``  ``return` `false``;``}` `function` `findIndex(arr) {``  ``const totalSum = arr.reduce((acc, val) => acc + val, 0);``  ``let leftSum = 0;``  ``for` `(let i = 0; i < arr.length; i++) {``    ``const rightSum = totalSum - leftSum - arr[i];``    ``if` `(leftSum === reverseInteger(rightSum)) {``      ``return` `i;``    ``}``    ``leftSum += arr[i];``  ``}``  ``return` `-1;``}` `const arr = [5, 7, 3, 6, 4, 9, 2];``const index = findIndex(arr);``console.log(index);`

Output

`2`

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

My Personal Notes arrow_drop_up