Elementos adyacentes distintos en una array binaria

Dada una array binaria arr[] de 1 y 0 de longitud N . La tarea es encontrar el número de elementos que son diferentes con respecto a sus vecinos. 
Nota: Al menos uno de los vecinos debe ser distinto.
Ejemplos:
 

Entrada: N = 4, arr=[1, 0, 1, 1] 
Salida: 3 
arr[0]=1 es distinto ya que su vecino arr[1]=0 es diferente. 
arr[1]=0 también es distinto, ya que tiene dos vecinos diferentes, es decir, arr[2]=1 y arr[0]=1. 
arr[2]=1 tiene el mismo vecino en arr[3]=1 pero tiene un vecino diferente en arr[1]=0. Entonces es distinto. 
Pero arr[3]=1 no es distinto ya que su vecino arr[2]=1 es el mismo. 
Entonces, los elementos distintos totales son 1+1+1+0=3
Entrada: N = 2, arr=[1, 1] 
Salida: 0
 

Acercarse: 
 

• Ejecute un bucle para todos los elementos de la lista y compare cada elemento con sus vecinos anterior y siguiente. Incremente el conteo en 1 si el elemento es distinto.
• El primer elemento debe compararse solo con su siguiente vecino y, de manera similar, el último elemento debe compararse solo con su elemento anterior.
• Los elementos restantes tienen dos vecinos. Si cualquiera de dos vecinos es diferente, se considera distinto.

A continuación se muestra la implementación del enfoque anterior: 
 

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

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

3

Complejidad de tiempo: O(N)