Skip to content
Related Articles

Related Articles

Check if all duplicate elements in the Array are adjacent or not

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 09 Feb, 2022

Given an array arr[]. The task is to check whether duplicate elements in arr[] are contiguous or not. 

Examples

Input: arr[] = {1, 2, 3, 4, 5, 6}
Output: Yes
Explanation: There is no duplicate element in arr[] so there is no need to check anything and answer is Yes. 

Input: arr[] = {1, 2, 2, 4}
Output: Yes
Explanation: 2 is occurring 2 times and it is contiguous. Hence, answer is Yes. 

Input: arr[] = {1, 2, 3, 2, 4}
Output: No
Explanation: There is a gap between 2’s and 3 is between two 2’s. Therefore, the answer is No. 

 

Approach: This problem can be solved by using HashMaps. Follow the steps below to solve the given problem

  • Use maps to store the visited elements.
  • First, mark the first element on the map.
  • Traverse the array arr[] from 1 to N-1. where N is the size of arr[].
  • If the current element matches the previous element means there is a cycle of one element repeating so simply continue the loop.
  • If the current element is already marked in the map return “No”.
  • Mark the current element in the map.
  • If the function reaches here means there are all contiguous elements so return “Yes”.

Below is the implementation of the above approach. 

C++14




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check whether duplicate
// elements in array arr[] are contiguous or not
string checkContiguous(int* arr, int& n)
{
    int i;
 
    // Map to keep track of elements
    unordered_map<int, bool> visited;
 
    visited.clear();
    visited.insert({ arr[0], 1 });
 
    for (i = 1; i < n; i++) {
        if (arr[i] == arr[i - 1])
            continue;
        else if (visited[arr[i]])
            return "No";
        visited[arr[i]] = 1;
    }
 
    return "Yes";
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 4, 5, 5, 3, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << checkContiguous(arr, N);
 
    return 0;
}

Java




// Java code for the above approach
import java.io.*;
 
class GFG {
 
  // Function to check whether duplicate
  // elements in array arr[] are contiguous or not
  static String checkContiguous(int[] arr, int n)
  {
    int i;
 
    // Map to keep track of elements
    int[] visited = new int[n];
 
    for (i = 1; i < n; i++) {
      if (arr[i] == arr[i - 1])
        continue;
      else if (visited[arr[i]] == 0)
        return "No";
      visited[arr[i]] = 1;
    }
 
    return "Yes";
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    int arr[] = { 2, 4, 5, 5, 3, 5 };
    int N = arr.length;
 
    // Function Call
    System.out.println(checkContiguous(arr, N));
  }
}
 
// This code is contributed by Potta Lokesh

Python3




# Python program for the above approach
 
# Function to check whether duplicate
# elements in array arr[] are contiguous or not
def checkContiguous  (arr, n):
    i = None
 
    # Map to keep track of elements
    visited = [0] * n;
 
 
    for i in range(1, n):
        if (arr[i] == arr[i - 1]):
            continue;
        elif (visited[arr[i]] == 0):
            return "No";
        visited[arr[i]] = 1;
     
 
    return "Yes";
 
 
# Driver Code
 
arr = [2, 4, 5, 5, 3, 5];
N = len(arr)
 
# Function Call
print(checkContiguous(arr, N));
 
# This code is contributed by Saurabh Jaiswal

C#




// C# code for the above approach
using System;
class GFG {
 
  // Function to check whether duplicate
  // elements in array arr[] are contiguous or not
  static String checkContiguous(int[] arr, int n)
  {
    int i;
 
    // Map to keep track of elements
    int[] visited = new int[n];
 
    for (i = 1; i < n; i++) {
      if (arr[i] == arr[i - 1])
        continue;
      else if (visited[arr[i]] == 0)
        return "No";
      visited[arr[i]] = 1;
    }
 
    return "Yes";
  }
 
  // Driver Code
  public static void Main()
  {
 
    int[] arr = { 2, 4, 5, 5, 3, 5 };
    int N = arr.Length;
 
    // Function Call
    Console.WriteLine(checkContiguous(arr, N));
  }
}
 
// This code is contributed by ukasp.

Javascript




<script>
    // JavaScript program for the above approach
 
    // Function to check whether duplicate
    // elements in array arr[] are contiguous or not
    const checkContiguous = (arr, n) => {
        let i;
 
        // Map to keep track of elements
        let visited = {};
 
        visited[arr[0]] = 1;
 
        for (i = 1; i < n; i++) {
            if (arr[i] == arr[i - 1])
                continue;
            else if (visited[arr[i]])
                return "No";
            visited[arr[i]] = 1;
        }
 
        return "Yes";
    }
 
    // Driver Code
 
    let arr = [2, 4, 5, 5, 3, 5];
    let N = arr.length;
 
    // Function Call
    document.write(checkContiguous(arr, N));
 
// This code is contributed by rakeshsahni
 
</script>

Output

No

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!