Encuentre todos los pares posibles de la array dada

Dada una array arr[] de N enteros, la tarea es encontrar todos los pares posibles de la array dada. 
Nota: 
 

1. (arr[i], arr[i]) también se considera un par válido.
2. (arr[i], arr[j]) y (arr[j], arr[i]) se consideran dos pares diferentes.

Ejemplos: 
 

Entrada: arr[] = {1, 2} 
Salida: (1, 1), (1, 2), (2, 1), (2, 2).
Entrada: arr[] = {1, 2, 3} 
Salida: (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3) , (3, 1), (3, 2), (3, 3) 
 

Enfoque: 
para encontrar todos los pares posibles de la array , necesitamos recorrer la array y seleccionar el primer elemento del par. Luego, debemos emparejar este elemento con todos los elementos de la array desde el índice 0 hasta el N-1. 
A continuación se muestra el enfoque paso a paso: 
 

• Recorra la array y seleccione un elemento en cada recorrido.
• Para cada elemento seleccionado, recorra la array con la ayuda de otro bucle y forme el par de este elemento con cada elemento de la array del segundo bucle.
• La array en el segundo bucle se ejecutará desde su primer elemento hasta su último elemento, es decir, desde el índice 0 hasta el N-1.
• Imprime cada par formado.

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

// C++ implementation to find all
// Pairs possible from the given Array
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print all possible
// pairs from the array
void printPairs(int arr[], int n)
{
 
    // Nested loop for all possible pairs
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << "(" << arr[i] << ", "
                 << arr[j] << ")"
                 << ", ";
        }
    }
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    printPairs(arr, n);
 
    return 0;
}

// Java implementation to find all
// Pairs possible from the given Array
class GFG{
  
// Function to print all possible
// pairs from the array
static void printPairs(int arr[], int n)
{
  
    // Nested loop for all possible pairs
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            System.out.print("(" +  arr[i]+ ", "
                 + arr[j]+ ")"
                + ", ");
        }
    }
}
  
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2 };
    int n = arr.length;
  
    printPairs(arr, n);
  
}
}
 
// This code is contributed by PrinciRaj1992

# Python3 implementation to find all
# Pairs possible from the given Array
 
# Function to print all possible
# pairs from the array
def printPairs(arr, n):
 
    # Nested loop for all possible pairs
    for i in range(n):
        for j in range(n):
            print("(",arr[i],",",arr[j],")",end=", ")
 
# Driver code
 
arr=[1, 2]
n = len(arr)
 
printPairs(arr, n)
 
# This code is contributed by mohit kumar 29

// C# implementation to find all
// Pairs possible from the given Array
using System;
 
class GFG{
  
// Function to print all possible
// pairs from the array
static void printPairs(int []arr, int n)
{
  
    // Nested loop for all possible pairs
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            Console.Write("(" +  arr[i]+ ", "
                 + arr[j]+ ")"
                + ", ");
        }
    }
}
  
// Driver code
public static void Main(string[] args)
{
    int []arr = { 1, 2 };
    int n = arr.Length;
  
    printPairs(arr, n);
}
}
 
// This code is contributed by AnkitRai01

<script>
 
// Javascript implementation to find all
// Pairs possible from the given Array
 
// Function to print all possible
// pairs from the array
function printPairs(arr, n)
{
    // Nested loop for all possible pairs
    for (var i = 0; i < n; i++) {
        for (var j = 0; j < n; j++) {
            document.write("(" + arr[i] + ", "
                 + arr[j] + ")"
                 + ", ");
        }
    }
}
 
// Driver code
var arr = [ 1, 2 ];
var n = arr.length;
printPairs(arr, n);
 
// This code is contributed by rutvik_56.
</script>

(1, 1), (1, 2), (2, 1), (2, 2), 

Complejidad del tiempo: O(N ² )

Espacio Auxiliar: O(1)
 

Uso de la ordenación por combinación 

Acercarse : 

Durante la operación de combinación en el ordenamiento por combinación podemos obtener todos los pares y podemos almacenar esos pares en un vector de pares. 

Con solo hacer algunos cambios en el algoritmo de clasificación por combinación, podemos obtener todos los pares.

/*
    This code was submitted by : Chirag Mittal from IIIT Dharwad ( username : iitjeechirag )
    storing all the pairs while merging
    Time Complexity : O(N logN)
    Space Complexity : O(N) + O(Number Of Pairs)
 
    using Merge Sort Algorithm
*/
 
#include<bits/stdc++.h>
using namespace std;
void getPairsMerge(int arr[],int l,int r,int mid,vector<pair<int,int>>&p){
    int b[l+r+1],i=l,k=l,j=mid+1;
    while(i<=mid && j<=r){
        if(arr[i]>arr[j]){
            b[k]=arr[j];
            p.push_back({arr[i],arr[j]});
            p.push_back({arr[j],arr[i]});
            p.push_back({arr[j],arr[j]});
            k++;
            j++;
        }
        else{
            p.push_back({arr[i],arr[j]});
            p.push_back({arr[j],arr[i]});
            p.push_back({arr[i],arr[i]});
            b[k]=arr[i];
            i++;
            k++;
        }
    }
 
    while(i<=mid){
        b[k]=arr[i];
        p.push_back({arr[i],arr[i]});
        i++;
        k++;
    }
    while(j<=r){
        b[k]=arr[j];
        p.push_back({arr[j],arr[j]});
        j++;
        k++;
    }
 
    for(int x=l;x<=r;x++){
        arr[x]=b[x];
    }
}
 
void getAllPairs(int arr[],int l,int r,vector<pair<int,int>>&p){
    if(l<r){
        int mid=(l+r)/2;
        getAllPairs(arr,l,mid,p);
        getAllPairs(arr,mid+1,r,p);
        getPairsMerge(arr,l,r,mid,p);
    }
}
 
int main(){
    int n=2;
    int arr[n]={1,2};
    vector<pair<int,int>>p;
    getAllPairs(arr,0,n-1,p);
    for(auto it:p){
        cout<<it.first<<" "<<it.second<<endl;
    }
}

1 2
2 1
1 1
2 2

Complejidad de tiempo: O (N LogN)

Espacio Auxiliar: O(l + r)