Skip to content
Related Articles

Related Articles

Count of distinct pair sum between two 1 to N value Arrays
  • Last Updated : 24 Mar, 2021
GeeksforGeeks - Summer Carnival Banner

Given a positive integer N such that there exists two arrays a[] and b[] each containing values {1, 2, 3, .., N}, the task is to find the count of all pairs (a[i], b[j]) such that a[i] + b[j] is unique among all the pairs i.e. if two pairs have equal sum then only one will be counted in the result.
Examples: 
 

Input: N = 2 
Output:
Explanation: 
a[] = {1, 2}, b[] = {1, 2} 
The three possible pairs are (a[0], b[0]), (a[1], b[0]) and (a[1], b[1]). 
Pair 1: 1 + 1 = 2 
Pair 2: 2 + 1 = 3 
Pair 3: 2 + 2 = 4
Input: N = 3 
Output:
a[] = {1, 2, 3}, b[] = {1, 2, 3} 
The possible pairs with distinct sum are: 
Pair 1: 1 + 1 = 2 
Pair 2: 2 + 1 = 3 
Pair 3: 2 + 2 = 4 
Pair 4: 3 + 2 = 5 
Pair 5: 3 + 3 = 6 
 

Naive approach: 
To solve the problem mentioned above, the naive approach is to to use to a Set to store distinct sums of {1, 2, 3, .. N} and {1, 2, 3, .. N} by using two loops.
Below is the implementation of above approach: 
 

C++




// C++ implementation to count
// of distinct pair sum between
// two Array with values 1 to N
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the distinct sums
int findDistinctSums(int n)
{
    // Set to store distinct sums
    set<int> s;
 
    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
 
            // Inserting every sum
            s.insert(i + j);
        }
    }
 
    // returning distinct sums
    return s.size();
}
 
// Driver code
int main()
{
 
    int N = 3;
 
    cout << findDistinctSums(N);
 
    return 0;
}

Java




// Java implementation to count
// of distinct pair sum between
// two Array with values 1 to N
import java.util.*;
 
class GFG{
 
// Function to find the distinct sums
static int findDistinctSums(int n)
{
     
    // Set to store distinct sums
    HashSet<Integer> s = new HashSet<>();
 
    for(int i = 1; i <= n; i++)
    {
        for(int j = i; j <= n; j++)
        {
             
            // Inserting every sum
            s.add(i + j);
        }
    }
     
    // Returning distinct sums
    return s.size();
}
 
// Driver code
public static void main(String[] args)
{
    int N = 3;
 
    System.out.print(findDistinctSums(N));
}
}
 
// This code is contributed by gauravrajput1

Python3




# Python3 implementation to count
# of distinct pair sum between
# two Array with values 1 to N
 
# Function to find the distinct sums
def findDistinctSums(n):
 
    # Set to store distinct sums
    s = set()
 
    for i in range(1, n + 1):
        for j in range(i, n + 1):
 
            # Inserting every sum
            s.add(i + j)
         
    # Returning distinct sums
    return len(s)
 
# Driver code
N = 3
print(findDistinctSums(N))
     
# This code is contributed by divyamohan123

C#




// C# implementation to count
// of distinct pair sum between
// two Array with values 1 to N
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the distinct sums
static int findDistinctSums(int n)
{
     
    // Set to store distinct sums
    HashSet<int> s = new HashSet<int>();
 
    for(int i = 1; i <= n; i++)
    {
        for(int j = i; j <= n; j++)
        {
             
            // Inserting every sum
            s.Add(i + j);
        }
    }
     
    // Returning distinct sums
    return s.Count;
}
 
// Driver code
public static void Main(String[] args)
{
    int N = 3;
 
    Console.Write(findDistinctSums(N));
}
}
 
// This code is contributed by gauravrajput1
Output: 
5

 

Efficient approach: To optimize the above method: 
 



  1. Observe that the series formed for the count of distinct sums in {1, 2, 3, .., N} and {1, 2, 3, .., N} is given as 1, 3, 5, 7, … 
     
  2. Therefore Nth term of the above series = 2 * N – 1
  3. Hence the count of distinct pair sum can be calculated as 2 * N – 1

Below is the implementation of above approach:
 

C++




// C++ implementation to find count
// of distinct pair sum between
// two 1 to N value Arrays
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the distinct sums
int findDistinctSums(int N)
{
    return (2 * N - 1);
}
 
// Driver code
int main()
{
 
    int N = 3;
 
    cout << findDistinctSums(N);
 
    return 0;
}

Java




// Java implementation to find count
// of distinct pair sum between
// two 1 to N value Arrays
import java.util.*;
class GFG{
 
// Function to find the distinct sums
static int findDistinctSums(int N)
{
    return (2 * N - 1);
}
 
// Driver code
public static void main(String[] args)
{
    int N = 3;
 
    System.out.print(findDistinctSums(N));
}
}
 
// This code is contributed by shivanisinghss2110

Python3




# Python3 implementation to find count
# of distinct pair sum between
# two 1 to N value Arrays
 
# Function to find the distinct sums
def findDistinctSums(N):
 
    return (2 * N - 1)
 
# Driver code
N = 3
print(findDistinctSums(N))
 
# This code is contributed by divyamohan123

C#




// C# implementation to find count
// of distinct pair sum between
// two 1 to N value Arrays
using System;
class GFG{
 
// Function to find the distinct sums
static int findDistinctSums(int N)
{
    return (2 * N - 1);
}
 
// Driver code
public static void Main()
{
    int N = 3;
 
    Console.Write(findDistinctSums(N));
}
}
 
// This code is contributed by Code_Mech

Javascript




<script>
 
    // Javascript implementation to find count
    // of distinct pair sum between
    // two 1 to N value Arrays
     
    // Function to find the distinct sums
    function findDistinctSums(N)
    {
        return (2 * N - 1);
    }
     
    let N = 3;
  
    document.write(findDistinctSums(N));
 
</script>
Output: 
5

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :