Count number of pairs with positive sum in an array
Last Updated :
30 Nov, 2023
Given an array arr[] of N integers, the task is to count the number of pairs with positive sum.
Examples:
Input: arr[] = {-7, -1, 3, 2}
Output: 3
Explanation: The pairs with positive sum are: {-1, 3}, {-1, 2}, {3, 2}.
Input: arr[] = {-4, -2, 5}
Output: 2
Explanation: The pairs with positive sum are: {-4, 5}, {-2, 5}.
Naive Approach: A naive approach is to traverse each element and check if there is another number in the array arr[] which can be added to it to give the positive-sum or not.
Below is the implementation of the above approach:
C++
// Naive approach to count pairs
// with positive sum.
#include <bits/stdc++.h>
using namespace std;
// Returns number of pairs in
// arr[0..n-1] with positive sum
int CountPairs(int arr[], int n)
{
// Initialize result
int count = 0;
// Consider all possible pairs
// and check their sums
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
// If arr[i] & arr[j]
// form valid pair
if (arr[i] + arr[j] > 0)
count += 1;
}
}
return count;
}
// Driver's Code
int main()
{
int arr[] = { -7, -1, 3, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
// Function call to find the
// count of pairs
cout << CountPairs(arr, n);
return 0;
}
// Java implementation of the above approach
class GFG {
// Naive approach to count pairs
// with positive sum.
// Returns number of pairs in
// arr[0..n-1] with positive sum
static int CountPairs(int arr[], int n)
{
// Initialize result
int count = 0;
// Consider all possible pairs
// and check their sums
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
// If arr[i] & arr[j]
// form valid pair
if (arr[i] + arr[j] > 0)
count += 1;
}
}
return count;
}
// Driver's Code
public static void main(String[] args)
{
int[] arr = { -7, -1, 3, 2 };
int n = arr.length;
// Function call to find the
// count of pairs
System.out.println(CountPairs(arr, n));
}
}
// This code is contributed by Yash_R
# Naive approach to count pairs
# with positive sum.
# Returns number of pairs in
# arr[0..n-1] with positive sum
def CountPairs(arr, n):
# Initialize result
count = 0
# Consider all possible pairs
# and check their sums
for i in range(n):
for j in range(i + 1, n):
# If arr[i] & arr[j]
# form valid pair
if (arr[i] + arr[j] > 0):
count += 1
return count
# Driver's Code
if __name__ == "__main__":
arr = [-7, -1, 3, 2]
n = len(arr)
# Function call to find the
# count of pairs
print(CountPairs(arr, n))
# This code is contributed by Yash_R
// C# implementation of the above approach
using System;
class GFG {
// Naive approach to count pairs with positive sum.
// Returns the number of pairs in arr[0..n-1] with a
// positive sum
static int CountPairs(int[] arr, int n)
{
// Initialize result
int count = 0;
// Consider all possible pairs and check their sums
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
// If arr[i] and arr[j] form a valid pair
if (arr[i] + arr[j] > 0) {
count += 1;
}
}
}
return count;
}
// Driver's Code
public static void Main(string[] args)
{
int[] arr = { -7, -1, 3, 2 };
int n = arr.Length;
// Function call to find the count of pairs
Console.WriteLine(CountPairs(arr, n));
}
}
function CountPairs(arr, n) {
// Initialize the result
let count = 0;
// Consider all possible pairs and check their sums
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
// If arr[i] and arr[j] form a valid pair
if (arr[i] + arr[j] > 0) {
count++;
}
}
}
return count;
}
// Driver's Code
const arr = [-7, -1, 3, 2];
const n = arr.length;
// Function call to find the count of pairs
console.log(CountPairs(arr, n));
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: The idea is to use the Two Pointers Technique
Step-by-step approach:
- Sort the given array arr[] in increasing order.
- Take two pointers. one representing the first element and second representing the last element of the sorted array.
- If the sum of elements at these pointers is greater than 0, then the difference between the pointers will give the count of pairs with positive-sum for the element at second pointers. Decrease the second pointer by 1.
- Else increase the first pointers by 1.
- Repeat the above steps untill both pointers converge towards each other.
Below is the implementation of the above approach:
C++
// C++ program to count the
// pairs with positive sum
#include <bits/stdc++.h>
using namespace std;
// Returns number of pairs
// in arr[0..n-1] with
// positive sum
int CountPairs(int arr[], int n)
{
// Sort the array in
// increasing order
sort(arr, arr + n);
// Intialise result
int count = 0;
// Intialise first and
// second pointer
int l = 0, r = n - 1;
// Till the pointers
// doesn't converge
// traverse array to
// count the pairs
while (l < r) {
// If sum of arr[i] &&
// arr[j] > 0, then the
// count of pairs with
// positive sum is the
// difference between
// the two pointers
if (arr[l] + arr[r] > 0) {
// Increase the count
count += (r - l);
r--;
}
else {
l++;
}
}
return count;
}
// Driver's Code
int main()
{
int arr[] = { -7, -1, 3, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
// Function call to count
// the pairs with positive
// sum
cout << CountPairs(arr, n);
return 0;
}
import java.util.Arrays;
public class Main {
// Returns the number of pairs in arr[0..n-1] with a positive sum
static int countPairs(int arr[], int n) {
// Sort the array in increasing order
Arrays.sort(arr);
// Initialize result
int count = 0;
// Initialize first and second pointers
int l = 0, r = n - 1;
// Traverse the array to count the pairs until the pointers converge
while (l < r) {
// If the sum of arr[i] and arr[j] > 0, then the count of pairs with positive sum
// is the difference between the two pointers
if (arr[l] + arr[r] > 0) {
// Increase the count
count += (r - l);
r--;
} else {
l++;
}
}
return count;
}
// Driver's Code
public static void main(String[] args) {
int arr[] = { -7, -1, 3, 2 };
int n = arr.length;
// Function call to count the pairs with positive sum
System.out.println(countPairs(arr, n));
}
}
# Python3 program to count the
# pairs with positive sum
# Returns number of pairs
# in arr[0..n-1] with
# positive sum
def CountPairs(arr, n):
# Sort the array in
# increasing order
arr.sort()
# Intialise result
count = 0
# Intialise first and
# second pointer
l = 0
r = n - 1
# Till the pointers
# doesn't converge
# traverse array to
# count the pairs
while (l < r):
# If sum of arr[i] &&
# arr[j] > 0, then the
# count of pairs with
# positive sum is the
# difference between
# the two pointers
if (arr[l] + arr[r] > 0):
# Increase the count
count += (r - l)
r -= 1
else:
l += 1
return count
# Driver's Code
if __name__ == "__main__":
arr = [-7, -1, 3, 2]
n = len(arr)
# Function call to count
# the pairs with positive
# sum
print(CountPairs(arr, n))
# This code is contributed by Yash_R
using System;
class GFG {
public static int countPairs(int[] arr)
{
// Sort the array in increasing order
Array.Sort(arr);
// Initialize the result
int count = 0;
// Initialize the left and right pointers
int l = 0;
int r = arr.Length - 1;
// Traverse the array to count the pairs
while (l < r) {
// If the sum of arr[i] and arr[j] > 0,
// then the count of pairs with a positive sum
// is the difference between the two pointers
if (arr[l] + arr[r] > 0) {
count += r - l;
r--;
}
else {
l++;
}
}
return count;
}
public static void Main(string[] args)
{
// Example usage:
int[] arr = new int[] { -7, -1, 3, 2 };
int result = countPairs(arr);
Console.WriteLine(result);
}
}
function countPairs(arr) {
// Sort the array in increasing order
arr.sort((a, b) => a - b);
// Initialize the result
let count = 0;
// Initialize the left and right pointers
let l = 0;
let r = arr.length - 1;
// Traverse the array to count the pairs
while (l < r) {
// If the sum of arr[i] and arr[j] > 0,
// then the count of pairs with a positive sum
// is the difference between the two pointers
if (arr[l] + arr[r] > 0) {
count += r - l;
r--;
} else {
l++;
}
}
return count;
}
// Example usage:
const arr = [-7, -1, 3, 2];
const result = countPairs(arr);
console.log(result);
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Similar Reads
Number of pairs whose sum is a power of 2 Given an array arr[] of positive integers, the task is to count the maximum possible number of pairs (arr[i], arr[j]) such that arr[i] + arr[j] is a power of 2. Note: One element can be used at most once to form a pair. Examples: Input: arr[] = {3, 11, 14, 5, 13} Output: 2 All valid pairs are (13,
9 min read
C++ Program to Count pairs with given sum Given an array of integers, and a number 'sum', find the number of pairs of integers in the array whose sum is equal to 'sum'. Examples: Input : arr[] = {1, 5, 7, -1}, sum = 6 Output : 2 Pairs with sum 6 are (1, 5) and (7, -1) Input : arr[] = {1, 5, 7, -1, 5}, sum = 6 Output : 3 Pairs with sum 6 are
4 min read
Count pairs from a given array whose sum lies from a given range Given an array arr[] consisting of N integers and two integers L and R, the task is to count the number of pairs whose sum lies in the range [L, R]. Examples: Input: arr[] = {5, 1, 2}, L = 4, R = 7Output: 2Explanation:The pairs satisfying the necessary conditions are as follows: (5, 1): Sum = 5 + 1
13 min read
Count of elements which cannot form any pair whose sum is power of 2 Given an array arr[] of length N, the task is to print the number of array elements that cannot form a pair with any other array element whose sum is a power of two.Examples: Input: arr[] = {6, 2, 11} Output: 1 Explanation: Since 6 and 2 can form a pair with sum 8 (= 23). So only 11 has to be remove
8 min read
Count ways to place '+' and '-' in front of array elements to obtain sum K Given an array A[] consisting of N non-negative integers, and an integer K, the task is to find the number of ways '+' and '-' operators can be placed in front of elements of the array A[] such that the sum of the array becomes K. Examples: Input: A[] = {1, 1, 2, 3}, N = 4, K = 1Output: 3Explanation
10 min read