Imprima todos los pares adyacentes repetidos en orden ordenado desde una array

Dada una array arr[] que consta de N enteros, la tarea es imprimir todos los pares de enteros adyacentes de la array que aparece más de una vez en la array dada. Si la array contiene más de uno de estos pares, imprima todos los pares en orden.

Ejemplos:

Entrada: arr[] = {1, 2, 5, 1, 2}
Salida:
1 2
Explicación:
1 2 es el único par de enteros repetidos en la array.

Entrada: arr[] = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2}
Salida:
1 2
2 3
3 4
4 1
Explicación:
Dado que la array tiene más de un par repetido, todos los pares se imprimen en el orden ordenado.

Enfoque: el enfoque más simple es atravesar la array y almacenar cada par adyacente en un Map . Imprima todos esos pares que tengan una frecuencia mayor que 1 . Siga los pasos a continuación para resolver el problema:

1. Cree un Mapa M para almacenar todos los pares adyacentes en una array.
2. Recorra la array dada y almacene cada par adyacente en el Mapa M .
3. Después del paso anterior, recorra el mapa y, si la frecuencia de cualquier par es al menos uno, insértelo en un vector V.
4. Ordene el vector v en orden ascendente e imprima todos los pares almacenados en él.

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 print adjacent pairs
// in sorted order
void repeated_pairs(int arr[], int N)
{
    // Store the frequency of all
    // the adjacent pairs
    map<pair<int, int>, int> m;
 
    // Stores the resultant pairs
    vector<pair<int, int> > v;
    int i, j;
 
    // Stores the count of all
    // adjacent pairs
    for (i = 0; i < N - 1; i++) {
 
        pair<int, int> p
            = { arr[i], arr[i + 1] };
 
        // Increment the count of pair
        m[p]++;
    }
 
    // Store pairs that appears more
    // than once
    for (auto i = m.begin();
         i != m.end(); i++) {
 
        // If frequency is at least 1
        if (i->second > 1) {
            pair<int, int> p = i->first;
 
            // Insert pair into vector
            v.push_back(p);
        }
    }
 
    // Sort the vector
    sort(v.begin(), v.end());
 
    // Print the pairs
    for (i = 0; i < v.size(); i++) {
 
        pair<int, int> p = v[i];
 
        // Print the pair
        cout << p.first << " "
             << p.second << endl;
    }
}
 
// Driver Code
int main()
{
    // Given arr[]
    int arr[] = { 1, 2, 3, 4, 1,
                  2, 3, 4, 1, 2 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    repeated_pairs(arr, N);
 
    return 0;
}

// Java code of above approach
import java.util.*;
import java.lang.*;
 
class pair
{
  int first, second;   
  pair(int f, int s)
  {
    this.first = f;
    this.second = s;
  }
 
  @Override
  public boolean equals(Object obj)
  {
 
    // if both the object references are 
    // referring to the same object.
    if(this == obj)
      return true;
 
    if(obj == null || obj.getClass() != this.getClass())
      return false;
 
    // type casting of the argument. 
    pair p = (pair) obj;
 
    return (p.first == this.first  && p.second == this.second);
  }
  @Override
  public int hashCode()
  {
    return this.first + this.second/2;
  }
}
class GFG {
 
  // Function to print adjacent pairs
  // in sorted order
  static void repeated_pairs(int arr[], int N)
  {
 
    // Store the frequency of all
    // the adjacent pairs
    Map<pair, Integer> m=new HashMap<>();
 
    // Stores the resultant pairs
    ArrayList<pair> v = new ArrayList<>();
    int i, j;
 
    // Stores the count of all
    // adjacent pairs
    for (i = 0; i < N - 1; i++)
    {
 
      pair p = new pair(arr[i], arr[i + 1]);
 
      // Increment the count of pair
      m.put(p,m.getOrDefault(p, 0) + 1);
 
    }
 
    // Store pairs that appears more
    // than once
    for (Map.Entry<pair,Integer> k: m.entrySet())
    {
 
      // If frequency is at least
      if (k.getValue() > 1)
      {
 
        // Insert pair into vector
        v.add(k.getKey());
      }
    }
 
    // Sort the vector
    Collections.sort(v, (a, b)->a.first-b.first);
 
    // Print the pairs
    for (pair k:v)
    {
 
      // Print the pair
      System.out.println(k.first + " " + k.second);
    }
  }  
 
  // Driver code
  public static void main(String[] args)
  {
 
    // Given arr[]
    int arr[] = { 1, 2, 3, 4, 1,
                 2, 3, 4, 1, 2 };
 
    int N = arr.length;
 
    // Function call
    repeated_pairs(arr, N);
  }
}
 
// This code is contributed by offbeat

# Python3 program for the above approach
 
# Function to print adjacent pairs
# in sorted order
def repeated_pairs(arr, N):
     
    # Store the frequency of all
    # the adjacent pairs
    m = {}
 
    # Stores the resultant pairs
    v = []
 
    # Stores the count of all
    # adjacent pairs
    for i in range(N - 1):
        p = (arr[i], arr[i + 1])
 
        # Increment the count of pair
        m[p] = m.get(p, 0) + 1
 
    # Store pairs that appears more
    # than once
    for i in m:
         
        # If frequency is at least 1
        if (m[i] > 1):
            p = i
             
            # Insert pair into vector
            v.append(p)
 
    # Sort the vector
    v = sorted(v)
 
    # Print the pairs
    for i in range(len(v)):
        p = v[i]
 
        # Print the pair
        print(p[0], p[1])
 
# Driver Code
if __name__ == '__main__':
     
    # Given arr[]
    arr = [ 1, 2, 3, 4, 1,
            2, 3, 4, 1, 2 ]
 
    N = len(arr)
 
    # Function call
    repeated_pairs(arr, N)
 
# This code is contributed by mohit kumar 29

1 2
2 3
3 4
4 1

Complejidad de tiempo: O(N*log N)
Espacio auxiliar: O(N)