Inverse Permutation

Given an array of size n of integers in range from 1 to n, we need to find the inverse permutation of that array.

An inverse permutation is a permutation which you will get by inserting position of an element at the position specified by the element value in the array. For better understanding, consider the following example: 

Suppose we found element 4 at position 3 in an array, then in reverse permutation, we insert 3 (position of element 4 in the array) in position 4 (element value). 

Basically, An inverse permutation is a permutation in which each number and the number of the place which it occupies is exchanged.

The array should contain element from 1 to array_size.

Example 1 :

Input  = {1, 4, 3, 2}
Output = {1, 4, 3, 2}

In this, For element 1 we insert position of 1 from arr1 i.e 1 at position 1 in arr2. For element 4 in arr1, we insert 2 from arr1 at position 4 in arr2. Similarly, for element 2 in arr1, we insert position of 2 i.e 4 in arr2. 

Example 2 :
Input  = {2, 3, 4, 5, 1}
Output = {5, 1, 2, 3, 4}

In this example, for element 2 we insert position of 2 from arr1 in arr2 at position 2. similarly, we find the inverse permutation of other elements.
Consider an array arr having elements 1 to n.

Method 1: In this method, we take element one by one and check elements in increasing order and print the position of the element where we find that element. 

Implementation:

C++

// Naive CPP Program to find inverse permutation.
#include <bits/stdc++.h>
using namespace std;

// C++ function to find inverse permutations
void inversePermutation(int arr[], int size) {

  // Loop to select Elements one by one
  for (int i = 0; i < size; i++) {

    // Loop to print position of element
    // where we find an element
    for (int j = 0; j < size; j++) {

      // checking the element in increasing order
      if (arr[j] == i + 1) {

        // print position of element where
        // element is in inverse permutation
        cout << j + 1 << " ";
        break;
      }
    }
  }
}

// Driver program to test above function
int main() {
  int arr[] = {2, 3, 4, 5, 1};
  int size = sizeof(arr) / sizeof(arr[0]);
  inversePermutation(arr, size);
  return 0;
}

Java

// Naive java Program to find inverse permutation.
import java.io.*;

class GFG {

    // java function to find inverse permutations
    static void inversePermutation(int arr[], int size)
    {
        int i ,j;
        // Loop to select Elements one by one
        for ( i = 0; i < size; i++)
        {

            // Loop to print position of element
            // where we find an element
            for ( j = 0; j < size; j++)
            {

                // checking the element in
                // increasing order
                if (arr[j] == i + 1)
                {
                    // print position of element
                    // where element is in inverse
                    // permutation
                    System.out.print( j + 1 + " ");
                    break;
                }
            }
        }
    }

    // Driver program to test above function


    public static void main (String[] args)
    {
        int arr[] = {2, 3, 4, 5, 1};
        int size = arr.length;
        inversePermutation(arr, size);

    }
}

// This code is contributed by vt_m

Python3

# Naive Python3 Program to
# find inverse permutation.

# Function to find inverse permutations
def inversePermutation(arr, size):

    # Loop to select Elements one by one
    for i in range(0, size):

        # Loop to print position of element
        # where we find an element
        for j in range(0, size):

        # checking the element in increasing order
            if (arr[j] == i + 1):

                # print position of element where
                # element is in inverse permutation
                print(j + 1, end = " ")
                break

# Driver Code
arr = [2, 3, 4, 5, 1]
size = len(arr)

inversePermutation(arr, size)

#This code is contributed by Smitha Dinesh Semwal

C#

// Naive C# Program to find inverse permutation.
using System;

class GFG {

    // java function to find inverse permutations
    static void inversePermutation(int []arr, int size)
    {
        int i ,j;
        // Loop to select Elements one by one
        for ( i = 0; i < size; i++)
        {

            // Loop to print position of element
            // where we find an element
            for ( j = 0; j < size; j++)
            {

                // checking the element in
                // increasing order
                if (arr[j] == i + 1)
                {
                    // print position of element
                    // where element is in inverse
                    // permutation
                    Console.Write( j + 1 + " ");
                    break;
                }
            }
        }
    }

    // Driver program to test above function


    public static void Main ()
    {
        int []arr = {2, 3, 4, 5, 1};
        int size = arr.Length;
        inversePermutation(arr, size);

    }
}

// This code is contributed by vt_m

PHP

<?php
// Naive PHP Program to
// find inverse permutation.

// Function to find
// inverse permutations
function inversePermutation($arr, $size)
{
for ( $i = 0; $i < $size; $i++)
{

    // Loop to print position of element
    // where we find an element
    for ($j = 0; $j < $size; $j++)
    {

    // checking the element
    // in increasing order
    if ($arr[$j] == $i + 1)
    {

        // print position of element
        // where element is in
        // inverse permutation
        echo $j + 1 , " ";
        break;
    }
    }
}
}

// Driver Code
$arr = array(2, 3, 4, 5, 1);
$size = sizeof($arr);
inversePermutation($arr, $size);

// This code is contributed by aj_36
?>

Javascript

<script>

// Naive JavaScript program to find inverse permutation.

// JavaScript function to find inverse permutations
    function inversePermutation(arr, size)
    {
        let i ,j;

        // Loop to select Elements one by one
        for ( i = 0; i < size; i++)
        {

            // Loop to print position of element
            // where we find an element
            for ( j = 0; j < size; j++)
            {

                // checking the element in
                // increasing order
                if (arr[j] == i + 1)
                {
                    // print position of element
                    // where element is in inverse
                    // permutation
                    document.write( j + 1 + " ");
                    break;
                }
            }
        }
    }

// Driver code

        let arr = [2, 3, 4, 5, 1];
        let size = arr.length;
        inversePermutation(arr, size);

</script>

Output

5 1 2 3 4 

Time Complexity: O(n*n)
Auxiliary Space: O(1)

Method 2: The idea is to use another array to store index and element mappings 

Implementation:

C++

// Efficient CPP Program to find inverse permutation.
#include <bits/stdc++.h>
using namespace std;

// C++ function to find inverse permutations
void inversePermutation(int arr[], int size) {

  // to store element to index mappings
  int arr2[size];

  // Inserting position at their
  // respective element in second array
  for (int i = 0; i < size; i++)
    arr2[arr[i] - 1] = i + 1;

  for (int i = 0; i < size; i++)
    cout << arr2[i] << " ";
}

// Driver program to test above function
int main() {
  int arr[] = {2, 3, 4, 5, 1};
  int size = sizeof(arr) / sizeof(arr[0]);
  inversePermutation(arr, size);
  return 0;
}

// The code is contributed by Nidhi goel.

Java

// Efficient Java Program to find
// inverse permutation.
import java.io.*;

class GFG {

// function to find inverse permutations
static void inversePermutation(int arr[], int size) {

    // to store element to index mappings
    int arr2[] = new int[size];

    // Inserting position at their
    // respective element in second array
    for (int i = 0; i < size; i++)
    arr2[arr[i] - 1] = i + 1;

    for (int i = 0; i < size; i++)
    System.out.print(arr2[i] + " ");
}

// Driver program to test above function
public static void main(String args[]) {
    int arr[] = {2, 3, 4, 5, 1};
    int size = arr.length;
    inversePermutation(arr, size);
}
}

// This code is contributed by Nikita Tiwari.

Python3

# Efficient Python 3 Program to find
# inverse permutation.

# function to find inverse permutations
def inversePermutation(arr, size) :

    # To store element to index mappings
    arr2 = [0] *(size)

    # Inserting position at their
    # respective element in second array
    for i in range(0, size) :
        arr2[arr[i] - 1] = i + 1

    for i in range(0, size) :
        print( arr2[i], end = " ")

# Driver program
arr = [2, 3, 4, 5, 1]
size = len(arr)

inversePermutation(arr, size)

# This code is contributed by Nikita Tiwari.

C#

// Efficient C# Program to find
// inverse permutation.
using System;

class GFG {

// function to find inverse permutations
static void inversePermutation(int []arr, int size) {

    // to store element to index mappings
    int []arr2 = new int[size];

    // Inserting position at their
    // respective element in second array
    for (int i = 0; i < size; i++)
    arr2[arr[i] - 1] = i + 1;

    for (int i = 0; i < size; i++)
    Console.Write(arr2[i] + " ");
}

// Driver program to test above function
public static void Main() {
    int []arr = {2, 3, 4, 5, 1};
    int size = arr.Length;
    inversePermutation(arr, size);
}
}

// This code is contributed by vt_m.

Javascript

// function to find inverse permutations
function inversePermutation(arr, size) {

    // to store element to index mappings
    let arr2 = [];

    // Inserting position at their
    // respective element in second array
    for (let i = 0; i < size; i++)
    arr2[arr[i] - 1] = i + 1;

    for (let i = 0; i < size; i++)
    console.log(arr2[i] + " ");
}

    // Driver program to test above function
    let arr = [2, 3, 4, 5, 1];
    let size = arr.length;
    inversePermutation(arr, size);

    // This code is contributed by aadityaburujwale.

Output

5 1 2 3 4 

Time Complexity: O(n)
Auxiliary Space: O(n)