# Absolute distinct count in a sorted array

Given a sorted array of integers, return the number of distinct absolute values among the elements of the array. The input can contain duplicates values.
Examples:

```Input: [-3, -2, 0, 3, 4, 5]
Output: 5
There are 5 distinct absolute values
among the elements of this array, i.e.
0, 2, 3, 4 and 5)

Input:  [-1, -1, -1, -1, 0, 1, 1, 1, 1]
Output: 2

Input:  [-1, -1, -1, -1, 0]
Output: 2

Input:  [0, 0, 0]
Output: 1
```

The solution should do only one scan of the input array and should not use any extra space. i.e. expected time complexity is O(n) and auxiliary space is O(1).

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

One simple solution is to use set. For each element of the input array, we insert its absolute value in the set. As set doesn’t support duplicate elements, the element’s absolute value will be inserted only once. Therefore, the required count is size of the set.

Below is the implementation of the idea.

## C++

 `// C++ program to find absolute distinct ` `// count of an array in O(n) time. ` `#include ` `using` `namespace` `std; ` ` `  `// The function returns number of ` `// distinct absolute values among ` `// the elements of the array ` `int` `distinctCount(``int` `arr[], ``int` `n) ` `{ ` `    ``unordered_set<``int``> s; ` ` `  `    ``// Note that set keeps only one ` `    ``// copy even if we try to insert ` `    ``// multiple values ` `    ``for` `(``int` `i = 0 ; i < n; i++) ` `        ``s.insert(``abs``(arr[i])); ` ` `  `    ``return` `s.size(); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {-2, -1, 0, 1, 1}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` ` `  `    ``cout << ``"Count of absolute distinct values : "` `         ``<< distinctCount(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// java code to find absolute distinct ` `// count of an array in O(n) time. ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `    ``// The function returns number of ` `    ``// distinct absolute values among ` `    ``// the elements of the array ` `    ``static` `int` `distinctCount(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``Set s = ``new` `HashSet (); ` ` `  `        ``// Note that set keeps only one ` `        ``// copy even if we try to insert ` `        ``// multiple values ` `        ``for` `(``int` `i = ``0` `; i < n; i++) ` `        ``s.add(Math.abs(arr[i])); ` `         `  `        ``return` `s.size(); ` `         `  `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = {-``2``, -``1``, ``0``, ``1``, ``1``}; ` `        ``int` `n = arr.length; ` ` `  `        ``System.out.println(``"Count of absolute distinct values : "` `                           ``+ distinctCount(arr, n)); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by prerna saini `

## Python3

 `# Python3 code to find absolute distinct ` `# count of an array in O(n) time. ` ` `  `# This function returns number of ` `# distinct absolute values among ` `# the elements of the array ` `def` `distinctCount(arr, n): ` `    ``s ``=` `set``() ` `     `  `    ``# set keeps all unique elements ` `    ``for` `i ``in` `range``(n): ` `        ``s.add(``abs``(arr[i])) ` `    ``return` `len``(s) ` ` `  `# Driver Code ` `arr ``=` `[``-``2``, ``-``1``, ``0``, ``1``, ``1``] ` `n ``=` `len``(arr) ` `print``(``"Count of absolute distinct values:"``, ` `                     ``distinctCount(arr, n)) ` ` `  `# This code is contributed ` `# by Adarsh_Verma  `

## C#

 `     `  `// C# code to find absolute distinct ` `// count of an array in O(n) time. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `    ``// The function returns number of ` `    ``// distinct absolute values among ` `    ``// the elements of the array ` `    ``static` `int` `distinctCount(``int` `[]arr, ``int` `n) ` `    ``{ ` `        ``HashSet<``int``> s = ``new` `HashSet<``int``>(); ` ` `  `        ``// Note that set keeps only one ` `        ``// copy even if we try to insert ` `        ``// multiple values ` `        ``for` `(``int` `i = 0 ; i < n; i++) ` `        ``s.Add(Math.Abs(arr[i])); ` `         `  `        ``return` `s.Count; ` `         `  `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = {-2, -1, 0, 1, 1}; ` `        ``int` `n = arr.Length; ` ` `  `        ``Console.Write(``"Count of absolute distinct values : "` `                        ``+ distinctCount(arr, n)); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output :

`Count of absolute distinct values : 3`

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

The above implementation takes O(n) extra space, how to do in O(1) extra space?

The idea is to take advantage of the fact that the array is already Sorted. We initialize the count of distinct elements to number of elements in the array. We start with two index variables from two corners of the array and check for pair in the input array with sum as 0. If pair with 0 sum is found or duplicates are encountered, we decrement the count of distinct elements.Finally we return the updated count.

Below is the implementation of above approach.

## C++

 `// C++ program to find absolute distinct ` `// count of an array using O(1) space. ` `#include ` `using` `namespace` `std; ` ` `  `// The function returns return number ` `// of distinct absolute values ` `// among the elements of the array ` `int` `distinctCount(``int` `arr[], ``int` `n) ` `{ ` `    ``// initialize count as number of elements ` `    ``int` `count = n; ` `    ``int` `i = 0, j = n - 1, sum = 0; ` ` `  `    ``while` `(i < j) ` `    ``{ ` `        ``// Remove duplicate elements from the ` `        ``// left of the current window (i, j) ` `        ``// and also decrease the count ` `        ``while` `(i != j && arr[i] == arr[i + 1]) ` `            ``count--, i++; ` ` `  `        ``// Remove duplicate elements from the ` `        ``// right of the current window (i, j) ` `        ``// and also decrease the count ` `        ``while` `(i != j && arr[j] == arr[j - 1]) ` `            ``count--, j--; ` ` `  `        ``// break if only one element is left ` `        ``if` `(i == j) ` `            ``break``; ` ` `  `        ``// Now look for the zero sum pair ` `        ``// in current window (i, j) ` `        ``sum = arr[i] + arr[j]; ` ` `  `        ``if` `(sum == 0) ` `        ``{ ` `            ``// decrease the count if (positive, ` `            ``// negative) pair is encountered ` `            ``count--; ` `            ``i++, j--; ` `        ``} ` `        ``else` `if``(sum < 0) ` `            ``i++; ` `        ``else` `            ``j--; ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {-2, -1, 0, 1, 1}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` ` `  `    ``cout << ``"Count of absolute distinct values : "` `         ``<< distinctCount(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find absolute distinct  ` `// count of an array using O(1) space.  ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `     `  `// The function returns return number  ` `// of distinct absolute values  ` `// among the elements of the array  ` `static` `int` `distinctCount(``int` `arr[], ``int` `n)  ` `{  ` `    ``// initialize count as number of elements  ` `    ``int` `count = n;  ` `    ``int` `i = ``0``, j = n - ``1``, sum = ``0``;  ` ` `  `    ``while` `(i < j)  ` `    ``{  ` `        ``// Remove duplicate elements from the  ` `        ``// left of the current window (i, j)  ` `        ``// and also decrease the count  ` `        ``while` `(i != j && arr[i] == arr[i + ``1``])  ` `        ``{ ` `            ``count--; ` `            ``i++;  ` `        ``} ` `        ``// Remove duplicate elements from the  ` `        ``// right of the current window (i, j)  ` `        ``// and also decrease the count  ` `        ``while` `(i != j && arr[j] == arr[j - ``1``])  ` `        ``{ ` `            ``count--; ` `            ``j--;  ` `        ``} ` `        ``// break if only one element is left  ` `        ``if` `(i == j)  ` `            ``break``;  ` ` `  `        ``// Now look for the zero sum pair  ` `        ``// in current window (i, j)  ` `        ``sum = arr[i] + arr[j];  ` ` `  `        ``if` `(sum == ``0``)  ` `        ``{  ` `            ``// decrease the count if (positive,  ` `            ``// negative) pair is encountered  ` `            ``count--;  ` `            ``i++; ` `            ``j--;  ` `        ``}  ` `        ``else` `if``(sum < ``0``)  ` `            ``i++;  ` `        ``else` `            ``j--;  ` `    ``}  ` ` `  `    ``return` `count;  ` `}  ` ` `  `// Driver code  ` `     `  `    ``public` `static` `void` `main (String[] args) { ` `     `  `    ``int` `arr[] = {-``2``, -``1``, ``0``, ``1``, ``1``};  ` `    ``int` `n = arr.length;  ` ` `  `    ``System.out.println (``"Count of absolute distinct values : "``+ ` `             ``distinctCount(arr, n)); ` `         `  `         `  `    ``} ` `} `

## Python3

 `# Python3 program to find absolute distinct ` `# count of an array using O(1) space. ` ` `  `# The function returns return number ` `# of distinct absolute values ` `# among the elements of the array ` `def` `distinctCount(arr, n): ` ` `  `    ``# initialize count as number of elements ` `    ``count ``=` `n; ` `    ``i ``=` `0``; j ``=` `n ``-` `1``; ``sum` `=` `0``; ` ` `  `    ``while` `(i < j): ` `         `  `        ``# Remove duplicate elements from the ` `        ``# left of the current window (i, j) ` `        ``# and also decrease the count ` `        ``while` `(i !``=` `j ``and` `arr[i] ``=``=` `arr[i ``+` `1``]): ` `            ``count ``=` `count ``-` `1``;  ` `            ``i ``=` `i ``+` `1``; ` ` `  `        ``# Remove duplicate elements from the ` `        ``# right of the current window (i, j) ` `        ``# and also decrease the count ` `        ``while` `(i !``=` `j ``and` `arr[j] ``=``=` `arr[j ``-` `1``]): ` `            ``count ``=` `count ``-` `1``; ` `            ``j ``=` `j ``-` `1``; ` ` `  `        ``# break if only one element is left ` `        ``if` `(i ``=``=` `j): ` `            ``break``; ` ` `  `        ``# Now look for the zero sum pair ` `        ``# in current window (i, j) ` `        ``sum` `=` `arr[i] ``+` `arr[j]; ` ` `  `        ``if` `(``sum` `=``=` `0``): ` `         `  `            ``# decrease the count if (positive, ` `            ``# negative) pair is encountered ` `            ``count ``=` `count ``-` `1``; ` `            ``i ``=` `i ``+` `1``; ` `            ``j ``=` `j ``-` `1``; ` `             `  `        ``elif``(``sum` `< ``0``): ` `            ``i ``=` `i ``+` `1``; ` `        ``else``: ` `            ``j ``=` `j ``-` `1``; ` `     `  `    ``return` `count; ` ` `  ` `  `# Driver code ` `arr ``=` `[``-``2``, ``-``1``, ``0``, ``1``, ``1``]; ` `n ``=` `len``(arr); ` ` `  `print``(``"Count of absolute distinct values : "``,  ` `                      ``distinctCount(arr, n)); ` ` `  `# This code is contributed ` `# by Akanksha Rai `

## C#

 `//C# program to find absolute distinct  ` `// count of an array using O(1) space.  ` `using` `System; ` ` `  `class` `GFG { ` `     `  `     `  `// The function returns return number  ` `// of distinct absolute values  ` `// among the elements of the array  ` `static` `int` `distinctCount(``int` `[]arr, ``int` `n)  ` `{  ` `    ``// initialize count as number of elements  ` `    ``int` `count = n;  ` `    ``int` `i = 0, j = n - 1, sum = 0;  ` ` `  `    ``while` `(i < j)  ` `    ``{  ` `        ``// Remove duplicate elements from the  ` `        ``// left of the current window (i, j)  ` `        ``// and also decrease the count  ` `        ``while` `(i != j && arr[i] == arr[i + 1])  ` `        ``{ ` `            ``count--; ` `            ``i++;  ` `        ``} ` `        ``// Remove duplicate elements from the  ` `        ``// right of the current window (i, j)  ` `        ``// and also decrease the count  ` `        ``while` `(i != j && arr[j] == arr[j - 1])  ` `        ``{ ` `            ``count--; ` `            ``j--;  ` `        ``} ` `        ``// break if only one element is left  ` `        ``if` `(i == j)  ` `            ``break``;  ` ` `  `        ``// Now look for the zero sum pair  ` `        ``// in current window (i, j)  ` `        ``sum = arr[i] + arr[j];  ` ` `  `        ``if` `(sum == 0)  ` `        ``{  ` `            ``// decrease the count if (positive,  ` `            ``// negative) pair is encountered  ` `            ``count--;  ` `            ``i++; ` `            ``j--;  ` `        ``}  ` `        ``else` `if``(sum < 0)  ` `            ``i++;  ` `        ``else` `            ``j--;  ` `    ``}  ` ` `  `    ``return` `count;  ` `}  ` ` `  `// Driver code  ` `     `  `    ``public` `static` `void` `Main () { ` `     `  `    ``int` `[]arr = {-2, -1, 0, 1, 1};  ` `    ``int` `n = arr.Length;  ` ` `  `    ``Console.WriteLine(``"Count of absolute distinct values : "``+ ` `            ``distinctCount(arr, n)); ` `         `  `    ``// This code is contributed by inder_verma     ` `    ``} ` `} `

## PHP

 ` `

Output :

`Count of absolute distinct values : 3`

Time Complexity: O(n)
Auxiliary Space: 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

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.