Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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)
 

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 :
Count of Pairs in given Array having both even or both odd or sum as K
11, Jan 22
Choose points from two ranges such that no point lies in both the ranges
04, Feb 19
Reduce Binary Array by replacing both 0s or both 1s pair with 0 and 10 or 01 pair with 1
14, Dec 21
Count pairs in an array such that both elements has equal set bits
16, Nov 18
Count pairs from a given array whose product lies in a given range
12, Jul 21
Count pairs from a given array whose sum lies from a given range
09, Jul 21
Count pairs (i,j) such that (i+j) is divisible by A and B both
28, Oct 18
Minimize operations to make both arrays equal by decrementing a value from either or both
16, Nov 21
Maximum time such that absolute difference between hour and minute lies in given range
08, Jul 20
Split array into maximum subarrays such that every distinct element lies in a single subarray
27, Sep 20
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 20
Count pairs with Bitwise XOR greater than both the elements of the pair
06, Nov 20
Rearrange two given arrays such that sum of same indexed elements lies within given range
03, Nov 20
Maximum cost of a value over the range [1, N] such that values lies in at most K given ranges
08, Oct 21
Find two distinct numbers such that their LCM lies in given range
15, Aug 20
Count points from an array that lies inside a semi-circle
08, Feb 21
Numbers in range [L, R] such that the count of their divisors is both even and prime
29, Oct 18
Maximize sum of K pairs made up of elements that are equidistant from both ends of the array
18, Jun 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
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Largest value of K such that both K and -K exist in Array in given index range [L, R]
23, Nov 21
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
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
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

Start Your Coding Journey Now!