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[0]=1 is distinct since it’s neighbor arr[1]=0 is different.

arr[1]=0 is also distinct, as it has two different neighbors i.e, arr[2]=1 & arr[0]=1.

arr[2]=1 has same neighbor in arr[3]=1 but has different neighbor in arr[1]=0. So it’s distinct.

But arr[3]=1 is not distinct as it’s neighbor arr[2]=1 is the same.

So total distinct elements are 1+1+1+0=3

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

Output :0

**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 <bits/stdc++.h> ` ` ` `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[0]); ` ` ` `cout << distinct(arr, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**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.

## Recommended Posts:

- Distinct adjacent elements in an array
- Minimize the cost to make all the adjacent elements distinct in an Array
- Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
- Sort elements of an array in increasing order of absolute difference of adjacent elements
- Count of array elements which is smaller than both its adjacent elements
- Length of array pair formed where one contains all distinct elements and other all same elements
- Split an array containing N elements into K sets of distinct elements
- Kth array element after M replacements of array elements by XOR of adjacent pairs
- Minimize array length by repeatedly replacing pairs of unequal adjacent array elements by their sum
- Form an array of distinct elements with each element as sum of an element from each array
- Count distinct elements after adding each element of First Array with Second Array
- Count all distinct pairs of repeating elements from the array for every array element
- Check if all the elements can be made of same parity by inverting adjacent elements
- Minimum elements to be removed such that sum of adjacent elements is always odd
- Minimum elements to be removed such that sum of adjacent elements is always even
- Minimum adjacent swaps required to Sort Binary array
- Remove all 1s from the adjacent left of 0s in a Binary Array
- Sum of distinct elements when elements are in range 1 to n
- Maximum distinct elements after removing k elements
- Search an element in an array where difference between adjacent elements is 1

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.