 GeeksforGeeks App
Open App Browser
Continue

# Number of pairs of Array where the max and min of pair is same as their indices

Given an array A[] of N  integers, the task is to calculate the total number of pairs of indices (i, j) satisfying the following conditions –

• 1 ≤ i < j ≤ N
• minimum(A[i], A[j]) = i
• maximum(A[i], A[j]) = j

Note: 1-based indexing is considered.

Examples:

Input: N = 4, A[] = {1, 3, 2, 4}
Output: 2
Explanation: First pair of indices is (1, 4),
As minimum(A, A) = minimum(1, 4) = 1 and
maximum(A, A) = maximum(1, 4) = 4.
Similarly, second pair is (3, 2).

Input: N = 10, A[] = {5, 8, 2, 2, 1, 6, 7, 2, 9, 10}
Output: 8

Approach: The problem can be solved based on the following idea:

The conditions given in the problem would be satisfied, if one of these two conditions holds :

• 1st Type: A[i] = i and A[j] = j
• 2nd Type: A[i] = j and A[j] = i

Say there are K such indices where A[i] = i. So, number of pairs satisfying the first condition is K * (K – 1) / 2.
The number of pairs satisfying the second condition can be simply counted by traversing through the array.
i.e., checking if A[i] ≠ i and A[A[i]] = i.

Follow the steps mentioned below to implement the idea:

• Traverse through the array and find the position where the value and the position are same (say K).
• Find the pairs of the first type mentioned above using the provided formula.
• Now traverse again using and find the second type of pair following the mentioned method.

Below is the implementation of this approach:

## C++

```// C++ code for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to count Number of pairs in
// array satisfying the given conditions
int countPairs(int N, int A[])
{
// Variable to store the number of indices such
// that their value is equal to their position
int count = 0;

// Variable to store the total number of pairs
// following the given condition

for (int i = 0; i < N; i++) {
if (A[i] == (i + 1)) {
count++;
}
}

// Pairs following the first condition
answer += count * (count - 1) / 2;

// Calculating number of pairs following
// the second condition
for (int i = 0; i < N; i++) {
if (A[i] > (i + 1) && A[A[i] - 1] == (i + 1)) {
}
}

}

// Driver Code
int main()
{
int N = 4;
int A[] = { 1, 3, 2, 4 };

// Function call
return 0;
}```

## Java

```/*package whatever //do not write package name here */
import java.io.*;

class GFG {

// Function to count Number of pairs in
// array satisfying the given conditions
static int countPairs(int N, int A[])
{

// Variable to store the number of indices such
// that their value is equal to their position
int count = 0;

// Variable to store the total number of pairs
// following the given condition

for (int i = 0; i < N; i++) {
if (A[i] == (i + 1)) {
count++;
}
}

// Pairs following the first condition
answer += count * (count - 1) / 2;

// Calculating number of pairs following
// the second condition
for (int i = 0; i < N; i++) {
if (A[i] > (i + 1) && A[A[i] - 1] == (i + 1)) {
}
}

}

public static void main (String[] args)
{

int N = 4;
int A[] = { 1, 3, 2, 4 };

// Function call
}
}

// This code is contributed by aadityapburujwale```

## Python3

``` # Python3 code for the above approach

# Function to count Number of pairs
# in array satisfying the given conditions
def countpairs(n,a)->int:

# Variable to store the number of indices
# such that their value is equal to their position
count = 0

# Variable to store the total number
# of pairs following the given condition

for i in range(0,n):
if(a[i] == i+1):
count += 1

# Pairs following the first condition

# Calculating number of pairs following the second condition
for i in range(0,n):
if(a[i] > (i+1) and a[a[i]-1] == (i+1)):

# Driver Code
if __name__ == '__main__':
n = 4
a = [1,3,2,4]

# Function call
ans = countpairs(n,a)
print(ans)

# This code is contributed by ajaymakvana.```

## C#

```// C# program for above approach
using System;
class GFG
{

// Function to count Number of pairs in
// array satisfying the given conditions
static int countPairs(int N, int[] A)
{

// Variable to store the number of indices such
// that their value is equal to their position
int count = 0;

// Variable to store the total number of pairs
// following the given condition

for (int i = 0; i < N; i++) {
if (A[i] == (i + 1)) {
count++;
}
}

// Pairs following the first condition
answer += count * (count - 1) / 2;

// Calculating number of pairs following
// the second condition
for (int i = 0; i < N; i++) {
if (A[i] > (i + 1) && A[A[i] - 1] == (i + 1)) {
}
}

}

// Driver Code
public static void Main()
{
int N = 4;
int[] A = { 1, 3, 2, 4 };

// Function call
}
}

// This code is contributed by code_hunt.```

## Javascript

```<script>
// Javascript  code for the above approach

// Function to count Number of pairs in
// array satisfying the given conditions
function countPairs( N,A)
{
// Variable to store the number of indices such
// that their value is equal to their position
let count = 0;

// Variable to store the total number of pairs
// following the given condition

for (let i = 0; i < N; i++) {
if (A[i] == (i + 1)) {
count++;
}
}

// Pairs following the first condition
answer += count * (count - 1) / 2;

// Calculating number of pairs following
// the second condition
for ( let i = 0; i < N; i++) {
if (A[i] > (i + 1) && A[A[i] - 1] == (i + 1)) {
}
}

}

// Driver Code

let N = 4;
let A = [ 1, 3, 2, 4 ];

// Function call
`2`