# Print all repeating adjacent pairs in sorted order from an array

Given an array arr[] consisting of N integers, the task is to print all adjacent integer pairs from the array which appears more than once in the given array. If the array contains more than one such pair, print all pairs in sorted order.

Examples:

Input: arr[] = {1, 2, 5, 1, 2}
Output:
1 2
Explanation:
1 2 is the only repeating integer pair in the array.

Input: arr[] = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2}
Output:
1 2
2 3
3 4
4 1
Explanation:
Since the array has more than one repeating pair, all the pairs are printed in the sorted order.

Approach: The simplest approach is to traverse the array and store every adjacent pair in a Map. Print all such pairs having frequency greater than 1. Follow the steps below to solve the problem:

1. Create a Map M to store all adjacent pairs in an array.
2. Traverse the given array and store every adjacent pair in the Map M.
3. After the above step, traverse the map, and if the frequency of any pair is at least one, then insert it into a vector V.
4. Sort the vector v in ascending order and print all the pairs stored in it.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``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, ``int``> m;` `    ``// Stores the resultant pairs``    ``vector > 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

 `// 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 m=``new` `HashMap<>();` `    ``// Stores the resultant pairs``    ``ArrayList 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 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

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

## C#

 `// C# code of above approach``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `pair``{``  ``public` `int` `first, second;` `  ``public` `pair(``int` `f, ``int` `s)``  ``{``    ``this``.first = f;``    ``this``.second = s;``  ``}` `  ``public` `override` `bool` `Equals(Object obj)``  ``{``    ``// if both the object references are  ``    ``// referring to the same object. ``    ``if` `(``this` `== obj)``      ``return` `true``;` `    ``if` `(obj == ``null` `|| obj.GetType() != ``this``.GetType())``      ``return` `false``;` `    ``// type casting of the argument.  ``    ``pair p = (pair)obj;` `    ``return` `(p.first == ``this``.first && p.second == ``this``.second);``  ``}` `  ``public` `override` `int` `GetHashCode()``  ``{``    ``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``    ``Dictionary m = ``new` `Dictionary();``    ``// Stores the resultant pairs``    ``List v = ``new` `List();` `    ``// Stores the count of all``    ``// adjacent pairs``    ``for` `(``int` `i = 0; i < N - 1; i++)``    ``{``      ``pair p = ``new` `pair(arr[i], arr[i + 1]);``      ``if` `(!m.ContainsKey(p))``      ``{``        ``m[p] = 0;``      ``}``      ``// Increment the count of pair``      ``m[p]++;``    ``}` `    ``// Store pairs that appears more``    ``// than once``    ``foreach` `(KeyValuePair k ``in` `m)``    ``{``      ``// If frequency is at least ``      ``if` `(k.Value > 1)``      ``{``        ``// Insert pair into vector``        ``v.Add(k.Key);``      ``}``    ``}` `    ``// Sort the vector``    ``v.Sort((a, b) => a.first - b.first);` `    ``// print the pair``    ``foreach` `(pair k ``in` `v)``    ``{``      ``// print pair``      ``Console.WriteLine(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 Aditya Sharma`

## Javascript

 `// Function to print adjacent pairs``// in sorted order``function` `repeated_pairs(arr, N) {``    ` `    ``// Store the frequency of all``    ``// the adjacent pairs``    ``const m = {};` `    ``// Stores the resultant pairs``    ``const v = [];` `    ``// Stores the count of all``    ``// adjacent pairs``    ``for` `(let i = 0; i < N - 1; i++) {``        ``const p = [arr[i], arr[i + 1]];` `        ``// Increment the count of pair``        ``m[p] = (m[p] || 0) + 1;``    ``}` `    ``// Store pairs that appears more``    ``// than once``    ``for` `(let i ``in` `m) {``        ` `        ``// If frequency is at least 1``        ``if` `(m[i] > 1) {``            ``const p = i.split(``','``);``            ` `            ``// Insert pair into vector``            ``v.push([parseInt(p[0]), parseInt(p[1])]);``        ``}``    ``}` `    ``// Sort the vector``    ``v.sort();` `    ``// Print the pairs``    ``for` `(let i = 0; i < v.length; i++) {``        ``const p = v[i];` `        ``// Print the pair``        ``console.log(p[0], p[1]);``    ``}``}` `// Driver Code``const arr = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2];``const N = arr.length;` `// Function call``repeated_pairs(arr, N);`  `// This code is contributed by Aditya Sharma`

Output:
```1 2
2 3
3 4
4 1```

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

Previous
Next
Share your thoughts in the comments
Similar Reads