Skip to content
Related Articles

Related Articles

Count pairs (i, j) from an array such that |arr[i]| and |arr[j]| both lies between |arr[i] – arr[j]| and |arr[i] + arr[j]|
  • Last Updated : 31 Mar, 2021

Given an array arr[] of size N, the task is to count the number of pairs (arr[i], arr[j]) such that |arr[i]| and |arr[j]| lies between |arr[i] – arr[j]| and |arr[i] + arr[j]|.

Examples:

Input: arr[] = {1, 3, 5, 7} 
Output: 2 
Explanation: 
Pair (arr[1], arr[2]) (= (3, 5)) lies between |3 – 5| (= 2) and |3 + 5| (= 8).
Pair (arr[2], arr[3]) (= (5, 7)) lies between |5 – 7| (= 2) and |5 + 7| (= 12).    

Input: arr[] = {-4, 1, 9, 7, -1, 2, 8} 
Output: 9

 

Approach: The given problem can be solved by analyzing the following cases:

  • If X is positive and Y is positive:
    • |X – Y| remains |X – Y|.
    • |X + Y| remains |X + Y|.
  • If X is negative and Y is positive:
    • |X – Y| becomes |-(X + Y)|, i.e. |X + Y|.
    • |X + Y| becomes |-(X – Y)|, i.e. |X – Y|.
  • If X is positive and Y is negative:
    • |X – Y| becomes |X + Y|.
    • |X + Y| becomes |X – Y|.
  • If X is negative and Y is negative:
    • |X – Y| remains |X – Y|.
    • |X + Y| remains |X + Y|.

It is clear from the above cases, that |X – Y| and |X + Y| are at most swapping values, which does not change the solution.
Therefore, if a pair is valid for (X, Y), then it will also be valid for any of the above cases like (-X, Y). Therefore, the task reduces to just take absolute values of X and Y while finding the solution, i.e. to find (X, Y), where |X – Y| ≤ X, Y ≤ X + Y. 

Follow the steps below to solve the problem:



  • Take absolute values of all elements present in the array arr[].
  • Sort the array arr[].
  • Initialize a variable, say left, as 0. 
  • Initialize a variable, say ans, to store the count of valid pairs.
  • Traverse the array arr[] using a variable, say right, and perform the following steps:
    • Increment left until 2 *arr[left] is less than arr[right].
    • Add the value (i – left) to ans to include the number of valid pairs.
  • After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find pairs (i, j) such that
// |arr[i]| and |arr[j]| lies in between
// |arr[i] - arr[j]| and |arr[i] + arr[j]|
void findPairs(int arr[], int N)
{
    // Calculate absolute value
    // of all array elements
    for (int i = 0; i < N; i++)
        arr[i] = abs(arr[i]);
 
    // Sort the array
    sort(arr, arr + N);
 
    int left = 0;
 
    // Stores the count of pairs
    int ans = 0;
 
    // Traverse the array
    for (int right = 0; right < N; right++) {
 
        while (2 * arr[left] < arr[right])
 
            // Increment left
            left++;
 
        // Add to the current
        // count of pairs
        ans += (right - left);
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 3, 5, 7 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    findPairs(arr, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.Arrays;
 
class GFG{
 
// Function to find pairs (i, j) such that
// |arr[i]| and |arr[j]| lies in between
// |arr[i] - arr[j]| and |arr[i] + arr[j]|
static void findPairs(int arr[], int N)
{
     
    // Calculate absolute value
    // of all array elements
    for(int i = 0; i < N; i++)
        arr[i] = Math.abs(arr[i]);
 
    // Sort the array
    Arrays.sort(arr);
 
    int left = 0;
 
    // Stores the count of pairs
    int ans = 0;
 
    // Traverse the array
    for(int right = 0; right < N; right++)
    {
        while (2 * arr[left] < arr[right])
 
            // Increment left
            left++;
 
        // Add to the current
        // count of pairs
        ans += (right - left);
    }
 
    // Print the answer
    System.out.print(ans);
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 3, 5, 7 };
    int N = arr.length;
 
    findPairs(arr, N);
}
}
 
// This code is contributed by AnkThon
Python3



# Python3 program for the above approach
 
# Function to find pairs (i, j) such that
# |arr[i]| and |arr[j]| lies in between
# |arr[i] - arr[j]| and |arr[i] + arr[j]|
def findPairs(arr,  N):
 
    # Calculate absolute value
    # of all array elements
    for i in range(N):
        arr[i] = abs(arr[i])
 
    # Sort the array
    arr.sort()
    left = 0
 
    # Stores the count of pairs
    ans = 0
 
    # Traverse the array
    for right in range(N):
        while (2 * arr[left] < arr[right]):
 
            # Increment left
            left += 1
 
        # Add to the current
        # count of pairs
        ans += (right - left)
 
    # Print the answer
    print(ans)
 
# Driver Code
if __name__ == "__main__":
    arr = [1, 3, 5, 7]
    N = len(arr)
 
    findPairs(arr, N)
 
    # This code is contributed by ukasp.
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function to find pairs (i, j) such that
// |arr[i]| and |arr[j]| lies in between
// |arr[i] - arr[j]| and |arr[i] + arr[j]|
static void findPairs(int []arr, int N)
{
     
    // Calculate absolute value
    // of all array elements
    for(int i = 0; i < N; i++)
        arr[i] = Math.Abs(arr[i]);
 
    // Sort the array
    Array.Sort(arr);
 
    int left = 0;
 
    // Stores the count of pairs
    int ans = 0;
 
    // Traverse the array
    for(int right = 0; right < N; right++)
    {
        while (2 * arr[left] < arr[right])
 
            // Increment left
            left++;
 
        // Add to the current
        // count of pairs
        ans += (right - left);
    }
 
    // Print the answer
    Console.Write(ans);
}
 
// Driver Code
public static void Main(string[] args)
{
    int []arr = { 1, 3, 5, 7 };
    int N = arr.Length;
 
    findPairs(arr, N);
}
}
 
// This code is contributed by AnkThon
Javascript



<script>
// JavaScript program for the above approach
 
// Function to find pairs (i, j) such that
// |arr[i]| and |arr[j]| lies in between
// |arr[i] - arr[j]| and |arr[i] + arr[j]|
function findPairs(arr, N)
{
 
    // Calculate absolute value
    // of all array elements
    for (let i = 0; i < N; i++)
        arr[i] = Math.abs(arr[i]);
 
    // Sort the array
    arr.sort((a, b) => a - b);
 
    let left = 0;
 
    // Stores the count of pairs
    let ans = 0;
 
    // Traverse the array
    for (let right = 0; right < N; right++) {
 
        while (2 * arr[left] < arr[right])
 
            // Increment left
            left++;
 
        // Add to the current
        // count of pairs
        ans += (right - left);
    }
 
    // Print the answer
    document.write(ans);
}
 
// Driver Code
 
    let arr = [ 1, 3, 5, 7 ];
    let N = arr.length;
 
    findPairs(arr, N);
 
 
// This code is contributed by Manoj.
</script>
Output: 
2
 
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
 
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
My Personal Notes
arrow_drop_up
Previous
Calculate cost of visiting all array elements in increasing order
Next

Generate longest possible array with product K such that each array element is divisible by its previous adjacent element
Recommended Articles
Page :
Choose points from two ranges such that no point lies in both the ranges
04, Feb 19
Count pairs in an array such that both elements has equal set bits
16, Nov 18
Count pairs (i,j) such that (i+j) is divisible by A and B both
28, Oct 18
Maximum time such that absolute difference between hour and minute lies in given range
08, Jul 20
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 20
Split array into maximum subarrays such that every distinct element lies in a single subarray
27, Sep 20
Find two distinct numbers such that their LCM lies in given range
15, Aug 20
Rearrange two given arrays such that sum of same indexed elements lies within given range
03, Nov 20
Count pairs with Bitwise XOR greater than both the elements of the pair
06, Nov 20
Count points from an array that lies inside a semi-circle
08, Feb 21
Count of pairs {X, Y} from an array such that sum of count of set bits in X ⊕ Y and twice the count of set bits in X & Y is M
12, Mar 21
Numbers in range [L, R] such that the count of their divisors is both even and prime
29, Oct 18
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Probability that the sum of all numbers obtained on throwing a dice N times lies between two given integers
13, Jan 21
Count the number of intervals in which a given value lies
03, Dec 18
Count of integral coordinates that lies inside a Square
06, May 20
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Remove minimum number of elements such that no common element exist in both array
23, Sep 17
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Remove elements from the array whose frequency lies in the range [l, r]
11, Nov 18
Count the pairs in an array such that the difference between them and their indices is equal
09, Oct 19
Count subarrays which contains both the maximum and minimum array element
10, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pkjrockzz
@pkjrockzz
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox