# Find the array element having equal sum of Prime Numbers on its left and right

Given an array arr[] of size N, the task is to find the index in the given array where the sum of the prime numbers present to its left is equal to the sum of the prime numbers present to its right.

Examples:

Input: arr[] = {11, 4, 7, 6, 13, 1, 5}
Output: 3
Explanation: Sum of prime numbers to left of index 3 = 11 + 7 = 18
Sum of prime numbers to right of index 3 = 13 + 5 = 18

Input: arr[] = {5, 2, 1, 7}
Output: 2
Explanation: Sum of prime numbers to left of index 2 = 5 + 2 = 7
Sum of prime numbers to right of index 2 = 7

Naive Approach: The simplest approach is to traverse the array and check for the given condition for every index in the range [0, N – 1]. If the condition is found to be true for any index, then print the value of that index.

Time Complexity: O(N2*?M), where M is the largest element in the array
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized using the Sieve of Eratosthenes and prefix sum technique to pre-store the sum of prime numbers left and right to an array element. Follow the steps below to solve the problem:

• Traverse through the array to find the maximum value present in the array.
• Use Sieve of Eratosthenes to find out the prime numbers which are less than or equal to the maximum value present in the array. Store these elements in a Map.
• Initialize an array, say first_array. Traverse the array and store the sum of all prime numbers up to ith index at first_array[i].
• Initialize an array, say second_array. Traverse the array in reverse and store the sum of all elements up to ith index at second_array[i].
• Traverse the arrays first_array and second_array and check if at any index, both their values are equal or not. If found to be true, return that index.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach#include using namespace std; // Function to find an index in the// array having sum of prime numbers// to its left and right equalint find_index(int arr[], int N){    // Stores the maximum value    // present in the array    int max_value = INT_MIN;     for (int i = 0; i < N; i++) {        max_value = max(max_value, arr[i]);    }     // Stores all positive    // elements which are <= max_value    map store;     for (int i = 1; i <= max_value; i++) {        store[i]++;    }     // If 1 is present    if (store.find(1) != store.end()) {         // Remove 1        store.erase(1);    }     // Sieve of Eratosthenes to    // store all prime numbers which    // are <= max_value in the Map    for (int i = 2; i <= sqrt(max_value); i++) {         int multiple = 2;         // Erase non-prime numbers        while ((i * multiple) <= max_value) {             if (store.find(i * multiple) != store.end()) {                store.erase(i * multiple);            }             multiple++;        }    }     // Stores the sum of    // prime numbers from left    int prime_sum_from_left = 0;     // Stores the sum of prime numbers    // to the left of each index    int first_array[N];     for (int i = 0; i < N; i++) {         // Stores the sum of prime numbers        // to the left of the current index        first_array[i] = prime_sum_from_left;         if (store.find(arr[i]) != store.end()) {             // Add current value to            // the prime sum if the            // current value is prime            prime_sum_from_left += arr[i];        }    }     // Stores the sum of    // prime numbers from right    int prime_sum_from_right = 0;     // Stores the sum of prime numbers    // to the right of each index    int second_array[N];     for (int i = N - 1; i >= 0; i--) {         // Stores the sum of prime        // numbers to the right of        // the current index        second_array[i] = prime_sum_from_right;         if (store.find(arr[i]) != store.end()) {             // Add current value to the            // prime sum if the            // current value is prime            prime_sum_from_right += arr[i];        }    }     // Traverse through the two    // arrays to find the index    for (int i = 0; i < N; i++) {         // Compare the values present        // at the current index        if (first_array[i] == second_array[i]) {             // Return the index where            // both the values are same            return i;        }    }     // No index is found.    return -1;} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 11, 4, 7, 6, 13, 1, 5 };     // Size of Array    int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    cout << find_index(arr, N);     return 0;}

## Java

 // Java program for the above approachimport java.lang.*;import java.util.*; class GFG{     // Function to find an index in the// array having sum of prime numbers// to its left and right equalstatic int find_index(int arr[], int N){         // Stores the maximum value    // present in the array    int max_value = Integer.MIN_VALUE;     for(int i = 0; i < N; i++)     {        max_value = Math.max(max_value, arr[i]);    }     // Stores all positive    // elements which are <= max_value    Map store= new HashMap<>();     for(int i = 1; i <= max_value; i++)    {        store.put(i, store.getOrDefault(i, 0) + 1);    }     // If 1 is present    if (store.containsKey(1))    {                 // Remove 1        store.remove(1);    }     // Sieve of Eratosthenes to    // store all prime numbers which    // are <= max_value in the Map    for(int i = 2; i <= Math.sqrt(max_value); i++)    {        int multiple = 2;         // Erase non-prime numbers        while ((i * multiple) <= max_value)        {            if (store.containsKey(i * multiple))            {                store.remove(i * multiple);            }            multiple++;        }    }     // Stores the sum of    // prime numbers from left    int prime_sum_from_left = 0;     // Stores the sum of prime numbers    // to the left of each index    int[] first_array = new int[N];     for(int i = 0; i < N; i++)    {                 // Stores the sum of prime numbers        // to the left of the current index        first_array[i] = prime_sum_from_left;         if (store.containsKey(arr[i]))         {             // Add current value to            // the prime sum if the            // current value is prime            prime_sum_from_left += arr[i];        }    }     // Stores the sum of    // prime numbers from right    int prime_sum_from_right = 0;     // Stores the sum of prime numbers    // to the right of each index    int[] second_array= new int[N];     for(int i = N - 1; i >= 0; i--)    {                 // Stores the sum of prime        // numbers to the right of        // the current index        second_array[i] = prime_sum_from_right;         if (store.containsKey(arr[i]))         {                         // Add current value to the            // prime sum if the            // current value is prime            prime_sum_from_right += arr[i];        }    }     // Traverse through the two    // arrays to find the index    for(int i = 0; i < N; i++)    {                 // Compare the values present        // at the current index        if (first_array[i] == second_array[i])        {                         // Return the index where            // both the values are same            return i;        }    }     // No index is found.    return -1;} // Driver codepublic static void main(String[] args){         // Given array arr[]    int arr[] = { 11, 4, 7, 6, 13, 1, 5 };         // Size of Array    int N = arr.length;         // Function Call    System.out.println(find_index(arr, N));}} // This code is contributed by offbeat

## Python3

 # Python3 program for the above approachfrom math import sqrt # Function to find an index in the# array having sum of prime numbers# to its left and right equaldef find_index(arr, N):       # Stores the maximum value    # present in the array    max_value = -10**9     for i in range(N):        max_value = max(max_value, arr[i])     # Stores all positive    # elements which are <= max_value    store = {}     for i in range(1, max_value + 1):        store[i] = store.get(i, 0) + 1     # If 1 is present    if (1 in store):         # Remove 1        del store[1]     # Sieve of Eratosthenes to    # store all prime numbers which    # are <= max_value in the Map    for i in range(2, int(sqrt(max_value)) + 1):        multiple = 2         # Erase non-prime numbers        while ((i * multiple) <= max_value):             if (i * multiple in store):                del store[i * multiple]             multiple += 1      # Stores the sum of    # prime numbers from left    prime_sum_from_left = 0     # Stores the sum of prime numbers    # to the left of each index    first_array = [0]*N     for i in range(N):               # Stores the sum of prime numbers        # to the left of the current index        first_array[i] = prime_sum_from_left        if arr[i] in store:                       # Add current value to            # the prime sum if the            # current value is prime            prime_sum_from_left += arr[i]     # Stores the sum of    # prime numbers from right    prime_sum_from_right = 0     # Stores the sum of prime numbers    # to the right of each index    second_array = [0]*N     for i in range(N - 1, -1, -1):               # Stores the sum of prime        # numbers to the right of        # the current index        second_array[i] = prime_sum_from_right         if (arr[i] in store):            # Add current value to the            # prime sum if the            # current value is prime            prime_sum_from_right += arr[i]     # Traverse through the two    # arrays to find the index    for i in range(N):               # Compare the values present        # at the current index        if (first_array[i] == second_array[i]):             # Return the index where            # both the values are same            return i     # No index is found.    return -1 # Driver Codeif __name__ == '__main__':    # Given array arr[]    arr= [11, 4, 7, 6, 13, 1, 5]     # Size of Array    N = len(arr)     # Function Call    print (find_index(arr, N))  # This code is contributed by mohit kumar 29.

## C#

 // C# program for the above approachusing System;using System.Collections.Generic; class GFG{     // Function to find an index in the// array having sum of prime numbers// to its left and right equalstatic int find_index(int[] arr, int N){         // Stores the maximum value    // present in the array    int max_value = Int32.MinValue;         for(int i = 0; i < N; i++)    {        max_value = Math.Max(max_value, arr[i]);    }     // Stores all positive    // elements which are <= max_value    Dictionary store = new Dictionary();     for(int i = 1; i <= max_value; i++)     {        if (!store.ContainsKey(i))            store[i] = 0;                     store[i]++;    }     // If 1 is present    if (store.ContainsKey(1))    {                 // Remove 1        store.Remove(1);    }     // Sieve of Eratosthenes to    // store all prime numbers which    // are <= max_value in the Map    for(int i = 2; i <= Math.Sqrt(max_value); i++)     {        int multiple = 2;         // Erase non-prime numbers        while ((i * multiple) <= max_value)         {            if (store.ContainsKey(i * multiple))             {                store.Remove(i * multiple);            }            multiple++;        }    }     // Stores the sum of    // prime numbers from left    int prime_sum_from_left = 0;     // Stores the sum of prime numbers    // to the left of each index    int[] first_array = new int[N];     for(int i = 0; i < N; i++)     {                 // Stores the sum of prime numbers        // to the left of the current index        first_array[i] = prime_sum_from_left;         if (store.ContainsKey(arr[i]))        {                         // Add current value to            // the prime sum if the            // current value is prime            prime_sum_from_left += arr[i];        }    }     // Stores the sum of    // prime numbers from right    int prime_sum_from_right = 0;     // Stores the sum of prime numbers    // to the right of each index    int[] second_array = new int[N];     for(int i = N - 1; i >= 0; i--)     {                 // Stores the sum of prime        // numbers to the right of        // the current index        second_array[i] = prime_sum_from_right;         if (store.ContainsKey(arr[i]))         {                         // Add current value to the            // prime sum if the            // current value is prime            prime_sum_from_right += arr[i];        }    }     // Traverse through the two    // arrays to find the index    for(int i = 0; i < N; i++)     {                 // Compare the values present        // at the current index        if (first_array[i] == second_array[i])         {                         // Return the index where            // both the values are same            return i;        }    }         // No index is found.    return -1;} // Driver Codepublic static void Main(){         // Given array arr[]    int[] arr = { 11, 4, 7, 6, 13, 1, 5 };     // Size of Array    int N = arr.Length;     // Function Call    Console.WriteLine(find_index(arr, N));}} // This code is contributed by ukasp

## Javascript



Output:
3

Time Complexity: O(N + max(arr[])loglog(max(arr[]))
Auxiliary Space: O(max(arr[]) + N)

Previous
Next
Share your thoughts in the comments
Similar Reads