Related Articles

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

• Last Updated : 22 Apr, 2021

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

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);``    ``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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up