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

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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


Output:

3

Time Complexity: O(N)



My Personal Notes arrow_drop_up

Graduate in Computer Science and Engineering Skills and Research interests include Progressive Enhancement in Web Development, Network & Information Security, and Blockchain

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.