# Distinct adjacent elements in a binary array

Given a binary array arr[] of 1’s and 0’s of length N. The task is to find the number of elements which are different with respect to their neighbors.
Note:At least one of the neighbors should be distinct.

Examples:

Input : N = 4 , arr=[1, 0, 1, 1]
Output : 3
arr=1 is distinct since it’s neighbor arr=0 is different.
arr=0 is also distinct, as it has two different neighbors i.e, arr=1 & arr=1.
arr=1 has same neighbor in arr=1 but has different neighbor in arr=0. So it’s distinct.
But arr=1 is not distinct as it’s neighbor arr=1 is the same.
So total distinct elements are 1+1+1+0=3

Input : N = 2 , arr=[1, 1]
Output : 0

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• Run a loop for all the elements of list and compare every element with its previous and next neighbors. Increment count by 1 if the element is distinct.
• The first element has to be compared only with its next neighbor and similarly the last element has to be compared only with its previous element.
• The remaining elements have two neighbors . If anyone of two neighbors is different then it is considered distinct.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of ` `// the above approach ` `#include ` ` `  `using` `namespace` `std; ` ` `  `int` `distinct(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// if array has only one element, return 1 ` `    ``if` `(n == 1) ` `        ``return` `1; ` ` `  `    ``for` `( ``int` `i = 0; i < n - 1; i++) ` `    ``{ ` `  `  `        ``// For first element compare ` `        ``// with only next element ` `        ``if``(i == 0) ` `        ``{ ` `            ``if``(arr[i] != arr[i + 1]) ` `                ``count += 1; ` `        ``} ` ` `  `        ``// For remaining elements compare with ` `        ``// both prev and next elements ` `        ``else` `        ``{ ` `            ``if``(arr[i] != arr[i + 1] ||  ` `               ``arr[i] != arr[i - 1]) ` `                ``count += 1; ` `        ``} ` `    ``} ` `     `  `    ``// For last element compare ` `    ``// with only prev element ` `    ``if``(arr[n - 1] != arr[n - 2]) ` `        ``count += 1; ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {0, 0, 0, 0, 0, 1, 0}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << distinct(arr, n); ` `     `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of ` `// the above approach ` `class` `GFG  ` `{ ` `static` `int` `distinct(``int` `[]arr, ``int` `n) ` `{ ` `    ``int` `count = ``0``; ` ` `  `    ``// if array has only one element,  ` `    ``// return 1 ` `    ``if` `(n == ``1``) ` `        ``return` `1``; ` ` `  `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `    ``{ ` ` `  `        ``// For first element compare ` `        ``// with only next element ` `        ``if``(i == ``0``) ` `        ``{ ` `            ``if``(arr[i] != arr[i + ``1``]) ` `                ``count += ``1``; ` `        ``} ` ` `  `        ``// For remaining elements compare with ` `        ``// both prev and next elements ` `        ``else` `        ``{ ` `            ``if``(arr[i] != arr[i + ``1``] ||  ` `               ``arr[i] != arr[i - ``1``]) ` `                ``count += ``1``; ` `        ``} ` `    ``} ` `     `  `    ``// For last element compare ` `    ``// with only prev element ` `    ``if``(arr[n - ``1``] != arr[n - ``2``]) ` `        ``count += ``1``; ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = {``0``, ``0``, ``0``, ``0``, ``0``, ``1``, ``0``}; ` `    ``int` `n = arr.length; ` `    ``System.out.println(distinct(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of  ` `# the above approach ` `def` `distinct(arr): ` `    ``count ``=` `0` ` `  `    ``# if array has only one element, return 1 ` `    ``if` `len``(arr) ``=``=` `1``: ` `        ``return` `1` `     `  `    ``for` `i ``in` `range``(``0``, ``len``(arr) ``-` `1``): ` ` `  `        ``# For first element compare ` `        ``# with only next element ` `        ``if``(i ``=``=` `0``): ` `            ``if``(arr[i] !``=` `arr[i ``+` `1``]): ` `                ``count ``+``=` `1` ` `  `        ``# For remaining elements compare with ` `        ``# both prev and next elements ` `        ``elif``(i > ``0` `& i < ``len``(arr) ``-` `1``): ` `            ``if``(arr[i] !``=` `arr[i ``+` `1``] ``or`  `               ``arr[i] !``=` `arr[i ``-` `1``]): ` `                ``count ``+``=` `1` ` `  `    ``# For last element compare  ` `    ``# with only prev element ` `    ``if``(arr[``len``(arr) ``-` `1``] !``=` `arr[``len``(arr) ``-` `2``]): ` `        ``count ``+``=` `1` `    ``return` `count ` ` `  `# Driver code ` `arr ``=` `[``0``, ``0``, ``0``, ``0``, ``0``, ``1``, ``0``] ` ` `  `print``(distinct(arr)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# implementation of ` `// the above approach ` `using` `System; ` `     `  `class` `GFG  ` `{ ` `static` `int` `distinct(``int` `[]arr, ``int` `n) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// if array has only one element,  ` `    ``// return 1 ` `    ``if` `(n == 1) ` `        ``return` `1; ` ` `  `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `    ``{ ` ` `  `        ``// For first element compare ` `        ``// with only next element ` `        ``if``(i == 0) ` `        ``{ ` `            ``if``(arr[i] != arr[i + 1]) ` `                ``count += 1; ` `        ``} ` ` `  `        ``// For remaining elements compare with ` `        ``// both prev and next elements ` `        ``else` `        ``{ ` `            ``if``(arr[i] != arr[i + 1] ||  ` `               ``arr[i] != arr[i - 1]) ` `                ``count += 1; ` `        ``} ` `    ``} ` `     `  `    ``// For last element compare ` `    ``// with only prev element ` `    ``if``(arr[n - 1] != arr[n - 2]) ` `        ``count += 1; ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = {0, 0, 0, 0, 0, 1, 0}; ` `    ``int` `n = arr.Length; ` `    ``Console.WriteLine(distinct(arr, n)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```3
```

Time Complexity: O(N)

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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.