Data Modelling & AI Data Structure & Algorithm

Print all repeating adjacent pairs in sorted order from an array

23 June 2025

2

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:

Create a Map M to store all adjacent pairs in an array.
Traverse the given array and store every adjacent pair in the Map M.
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.
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 <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

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

# 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<pair, int> m = new Dictionary<pair, int>();
    // Stores the resultant pairs
    List<pair> v = new List<pair>();
 
    // 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<pair, int> 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:

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

1 COMMENT

igratkazinovostok.website/ 20 February 2026 At 6:24 pm

… [Trackback]

[…] Read More Information here on that Topic: geeksforgeeks.org/print-all-repeating-adjacent-pairs-in-sorted-order-from-an-array/ […]

Log in to leave a comment

Print all repeating adjacent pairs in sorted order from an array

C++

Java

Python3

C#

Javascript

Adding Persistent Memory to Claude Code with the Lightweight memsearch Plugin

GLM-5 vs. MiniMax M2.5 vs. Gemini 3 Deep Think: Which Model Fits Your AI Agent Stack?

We Extracted OpenClaw’s Memory System and Open-Sourced It (memsearch)

1 COMMENT

LEAVE A REPLY Cancel reply

Most Popular

Spotify just launched Reserved, and it’s a direct shot at ticket scalpers

The iPhone is holding Android back. [Video.]

Android 17’s Wi-Fi connectivity bug appears to hit Google apps the hardest

Android 17 is fixing battery drain, camera crashes, and display glitches you’ve probably hit

EDITOR PICKS

Spotify just launched Reserved, and it’s a direct shot at ticket scalpers

The iPhone is holding Android back. [Video.]

Android 17’s Wi-Fi connectivity bug appears to hit Google apps the hardest

POPULAR POSTS

Spotify just launched Reserved, and it’s a direct shot at ticket scalpers

The iPhone is holding Android back. [Video.]

Android 17’s Wi-Fi connectivity bug appears to hit Google apps the hardest

POPULAR CATEGORY

ABOUT US

FOLLOW US