# 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[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 [tabbyending]

**Output:**

3

**Time Complexity:** O(N)

## Recommended Posts:

- Distinct adjacent elements in an array
- Maximum set bit sum in array without considering adjacent elements
- Maximum sum in circular array such that no two elements are adjacent
- Search an element in an array where difference between adjacent elements is 1
- Minimum adjacent swaps required to Sort Binary array
- Check if all array elements are distinct
- Count distinct elements in an array
- Minimum absolute difference of adjacent elements in a circular array
- Find sum of non-repeating (distinct) elements in an array
- Product of non-repeating (distinct) elements in an Array
- Print All Distinct Elements of a given integer array
- Print sorted distinct elements of array
- Third largest element in an array of distinct elements
- Minimum operations required to modify the array such that parity of adjacent elements is different
- Find minimum changes required in an array for it to contain k distinct elements

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.