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

## 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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**