 Open in App
Not now

# Count of distinct pair sum between two 1 to N value Arrays

• Last Updated : 20 Apr, 2021

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, b), (a, b) and (a, b).
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 ``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 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`

## Javascript

 ``

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 ``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

 ``

Output:

`5`

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

My Personal Notes arrow_drop_up