# Count pairs of indices having equal prefix and suffix sums

• Last Updated : 11 Jun, 2021

Given an array arr[] of length N, the task is to find the count of pairs of indices (i, j) (0-based indexing) such that prefix sum of the subarray {arr[0], … arr[i]} is equal to the suffix sum of the subarray {arr[N – 1], …, arr[j]} ( 0 â‰¤ i, j < N).

Examples:

Input: arr[] = {1, 2, 1, 1}
Output: 3
Explanation:
The 3 possible pairs of indices are as follows:

1. Pair {0, 3}: Prefix Sum of subarray {arr[0]} = 1. Suffix Sum of subarray {arr[3]} = 1.
2. Pair {2, 1}: Prefix Sum of subarray {arr[0], .. arr[2]} = 4. Suffix Sum of subarray {arr[3], …, arr[1]} = 4.
3. Pair {3, 0}: Prefix Sum of subarray {arr[0], .. arr[3]} = 5. Suffix Sum of subarray {arr[3], …, arr[0]} = 5.

Input: arr[] = {1, 0, -1}
Output: 1

Approach: The idea is to use Hashing to solve this problem. Follow the steps below to solve the problem:

1. Traverse the array arr[] and calculate prefix sum for all array indices and store their frequencies in a HashMap.
2. Traverse the array in reverse and keep calculating suffix sum up to every array index.
3. For every suffix sum obtained, check if it is present in the Map or not. If found to be true, increase count by 1.
4. Print the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the count of``// index pairs having equal``// prefix and suffix sums``void` `countPairs(``int``* arr, ``int` `n)``{``    ``// Maps indices with prefix sums``    ``unordered_map<``int``, ``int``> mp1;``    ``int` `sum = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Update prefix sum``        ``sum += arr[i];` `        ``// Update frequency in Map``        ``mp1[sum] += 1;``    ``}` `    ``sum = 0;``    ``int` `ans = 0;` `    ``// Traverse the array in reverse``    ``for` `(``int` `i = n - 1; i >= 0; i--) {` `        ``// Update suffix sum``        ``sum += arr[i];` `        ``// Check if any prefix sum of``        ``// equal value exists or not``        ``if` `(mp1.find(sum) != mp1.end()) {``            ``ans += mp1[sum];``        ``}``    ``}` `    ``// Print the obtained count``    ``cout << ans;``}` `// Driver code``int` `main()``{` `    ``// Given array``    ``int` `arr[] = { 1, 2, 1, 1 };` `    ``// Given size``    ``int` `n = ``sizeof``(arr)``            ``/ ``sizeof``(arr[0]);` `    ``// Function Call``    ``countPairs(arr, n);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `  ``// Function to find the count of``  ``// index pairs having equal``  ``// prefix and suffix sums``  ``static` `void` `countPairs(``int` `[]arr, ``int` `n)``  ``{` `    ``// Maps indices with prefix sums``    ``HashMap mp1 = ``new` `HashMap();``    ``int` `sum = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `      ``// Update prefix sum``      ``sum += arr[i];` `      ``// Update frequency in Map``      ``if``(mp1.containsKey(sum)){``        ``mp1.put(sum, mp1.get(sum)+``1``);``      ``}``      ``else``{``        ``mp1.put(sum, ``1``);``      ``}``    ``}` `    ``sum = ``0``;``    ``int` `ans = ``0``;` `    ``// Traverse the array in reverse``    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)``    ``{` `      ``// Update suffix sum``      ``sum += arr[i];` `      ``// Check if any prefix sum of``      ``// equal value exists or not``      ``if` `(mp1.containsKey(sum))``      ``{``        ``ans += mp1.get(sum);``      ``}``    ``}` `    ``// Print the obtained count``    ``System.out.print(ans);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Given array``    ``int` `arr[] = { ``1``, ``2``, ``1``, ``1` `};` `    ``// Given size``    ``int` `n = arr.length;` `    ``// Function Call``    ``countPairs(arr, n);``  ``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Function to find the count of``# index pairs having equal``# prefix and suffix sums``def` `countPairs(arr, n):``    ` `    ``# Maps indices with prefix sums``    ``mp1 ``=` `{}``    ``sum` `=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ` `        ``# Update prefix sum``        ``sum` `+``=` `arr[i]` `        ``# Update frequency in Map``        ``mp1[``sum``] ``=` `mp1.get(``sum``, ``0``) ``+` `1` `    ``sum` `=` `0``    ``ans ``=` `0` `    ``# Traverse the array in reverse``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):` `        ``# Update suffix sum``        ``sum` `+``=` `arr[i]` `        ``# Check if any prefix sum of``        ``# equal value exists or not``        ``if` `(``sum` `in` `mp1):``            ``ans ``+``=` `mp1[``sum``]` `    ``# Print the obtained count``    ``print` `(ans)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given array``    ``arr ``=` `[ ``1``, ``2``, ``1``, ``1` `]` `    ``# Given size``    ``n ``=` `len``(arr)` `    ``# Function Call``    ``countPairs(arr, n)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# code for above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `  ``// Function to find the count of``  ``// index pairs having equal``  ``// prefix and suffix sums``  ``static` `void` `countPairs(``int``[] arr, ``int` `n)``  ``{` `    ``// Maps indices with prefix sums``    ``Dictionary<``int``, ``int``> mp1 = ``new` `Dictionary<``int``, ``int``>();``    ``int` `sum = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `      ``// Update prefix sum``      ``sum += arr[i];` `      ``// Update frequency in Map``      ``if``(mp1.ContainsKey(sum))``      ``{``        ``mp1.Add(sum, mp1[sum] + 1);``      ``}``      ``else``{``        ``mp1.Add(sum, 1);``      ``}``    ``}` `    ``sum = 0;``    ``int` `ans = 0;` `    ``// Traverse the array in reverse``    ``for` `(``int` `i = n - 1; i >= 0; i--)``    ``{` `      ``// Update suffix sum``      ``sum += arr[i];` `      ``// Check if any prefix sum of``      ``// equal value exists or not``      ``if` `(mp1.ContainsKey(sum))``      ``{``        ``ans += mp1[sum];``      ``}``    ``}` `    ``// Print the obtained count``    ``Console.Write(ans);``  ``}` `  ``// Driver code``  ``static` `public` `void` `Main ()``  ``{` `    ``// Given array``    ``int``[] arr = { 1, 2, 1, 1 };` `    ``// Given size``    ``int` `n = arr.Length;` `    ``// Function Call``    ``countPairs(arr, n);``  ``}``}` `// This code is contributed by offbeat`

## Javascript

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up