Compruebe si todos los elementos duplicados en la array son adyacentes o no

Dada una array arr[] . La tarea es verificar si los elementos duplicados en arr[] son ​​contiguos o no. 

Ejemplos

Entrada: arr[] = {1, 2, 3, 4, 5, 6}
Salida: Sí
Explicación: No hay ningún elemento duplicado en arr[], por lo que no es necesario verificar nada y la respuesta es Sí. 

Entrada: arr[] = {1, 2, 2, 4}
Salida: Sí
Explicación: 2 ocurre 2 veces y es contiguo. Por lo tanto, la respuesta es Sí. 

Entrada: arr[] = {1, 2, 3, 2, 4}
Salida: No
Explicación: Hay un espacio entre 2 y 3 está entre dos 2. Por lo tanto, la respuesta es No. 

Enfoque: este problema se puede resolver utilizando HashMaps . Siga los pasos a continuación para resolver el problema dado . 

• Usa mapas para almacenar los elementos visitados.
• Primero, marca el primer elemento en el mapa.
• Recorre la array arr[] de 1 a N-1 . donde N es el tamaño de arr[] .
• Si el elemento actual coincide con el elemento anterior, significa que hay un ciclo de repetición de un elemento, así que simplemente continúe el ciclo.
• Si el elemento actual ya está marcado en el mapa, devuelva «No» .
• Marca el elemento actual en el mapa.
• Si la función llega aquí significa que hay todos los elementos contiguos, devuelva «Sí» .

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

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

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

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

No

Complejidad temporal: O(N) 
Espacio auxiliar: O(N)