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 that 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 the 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

Javascript

<script>

// JavaScript implementation of
// the above approach

function distinct(arr, n)
{
    let count = 0;

    // if array has only one element, return 1
    if (n == 1)
        return 1;

    for ( let 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
    let arr = [0, 0, 0, 0, 0, 1, 0];
    let n = arr.length;
    document.write(distinct(arr, n));

</script>

Output

3

Time Complexity: O(N)
Auxiliary Space: O(1)