 Open in App
Not now

# Permute the elements of an array following given order

• Difficulty Level : Medium
• Last Updated : 25 May, 2022

A permutation is a rearrangement of members of a sequence into a new sequence. For example, there are 24 permutations of [a, b, c, d]. Some of them are [b, a, d, c], [d, a, b, c] and [a, d, b, c]
A permutation can be specified by an array P[] where P[i] represents the location of the element at index i in the permutation.
For example, the array [3, 2, 1, 0] represents the permutation that maps the element at index 0 to index 3, the element at index 1 to index 2, the element at index 2 to index 1 and the element at index 3 to index 0.
Given the array arr[] of N elements and a permutation array P[], the task is to permute the given array arr[] based on the permutation array P[].
Examples:

Input: arr[] = {1, 2, 3, 4}, P[] = {3, 2, 1, 0}
Output: 4 3 2 1
Input: arr[] = {11, 32, 3, 42}, P[] = {2, 3, 0, 1}
Output: 3 42 11 32

Approach: Every permutation can be represented by a collection of independent permutations, each of which is cyclic i.e. it moves all the elements by a fixed offset wrapping around. To find and apply the cycle that indicates entry i, just keep going forward (from i to P[i]) till we get back at i. After completing the current cycle, find another cycle that has not yet been applied. To check this, subtract n from P[i] after applying it. This means that if an entry in P[i] is negative, we have performed the corresponding move.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to permute the given``// array based on the given conditions``int` `permute(``int` `A[], ``int` `P[], ``int` `n)``{``    ``// For each element of P``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `next = i;` `        ``// Check if it is already``        ``// considered in cycle``        ``while` `(P[next] >= 0) {` `            ``// Swap the current element according``            ``// to the permutation in P``            ``swap(A[i], A[P[next]]);``            ``int` `temp = P[next];` `            ``// Subtract n from an entry in P``            ``// to make it negative which indicates``            ``// the corresponding move``            ``// has been performed``            ``P[next] -= n;``            ``next = temp;``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``int` `A[] = { 5, 6, 7, 8 };``    ``int` `P[] = { 3, 2, 1, 0 };``    ``int` `n = ``sizeof``(A) / ``sizeof``(``int``);` `    ``permute(A, P, n);` `    ``// Print the new array after``    ``// applying the permutation``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << A[i] << ``" "``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// Function to permute the given``// array based on the given conditions``static` `void` `permute(``int` `A[], ``int` `P[], ``int` `n)``{``    ``// For each element of P``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `next = i;` `        ``// Check if it is already``        ``// considered in cycle``        ``while` `(P[next] >= ``0``)``        ``{` `            ``// Swap the current element according``            ``// to the permutation in P``            ``swap(A, i, P[next]);``            ``int` `temp = P[next];` `            ``// Subtract n from an entry in P``            ``// to make it negative which indicates``            ``// the corresponding move``            ``// has been performed``            ``P[next] -= n;``            ``next = temp;``        ``}``    ``}``}` `static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ``return` `arr;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``5``, ``6``, ``7``, ``8` `};``    ``int` `P[] = { ``3``, ``2``, ``1``, ``0` `};``    ``int` `n = A.length;` `    ``permute(A, P, n);` `    ``// Print the new array after``    ``// applying the permutation``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``System.out.print(A[i]+ ``" "``);` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 implementation of the approach` `# Function to permute the given``# array based on the given conditions``def` `permute(A, P, n):``    ` `    ``# For each element of P``    ``for` `i ``in` `range``(n):``        ``next` `=` `i` `        ``# Check if it is already``        ``# considered in cycle``        ``while` `(P[``next``] >``=` `0``):``            ` `            ``# Swap the current element according``            ``# to the permutation in P``            ``t ``=` `A[i]``            ``A[i] ``=` `A[P[``next``]]``            ``A[P[``next``]] ``=` `t``            ` `            ``temp ``=` `P[``next``]` `            ``# Subtract n from an entry in P``            ``# to make it negative which indicates``            ``# the corresponding move``            ``# has been performed``            ``P[``next``] ``-``=` `n``            ``next` `=` `temp` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``A ``=` `[``5``, ``6``, ``7``, ``8``]``    ``P ``=` `[``3``, ``2``, ``1``, ``0``]``    ``n ``=` `len``(A)` `    ``permute(A, P, n)` `    ``# Print the new array after``    ``# applying the permutation``    ``for` `i ``in` `range``(n):``        ``print``(A[i], end ``=` `" "``)``        ` `# This code is contributed by Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `    ``// Function to permute the given``    ``// array based on the given conditions``    ``static` `void` `permute(``int` `[]A, ``int` `[]P, ``int` `n)``    ``{``        ``// For each element of P``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``int` `next = i;``    ` `            ``// Check if it is already``            ``// considered in cycle``            ``while` `(P[next] >= 0)``            ``{``    ` `                ``// Swap the current element according``                ``// to the permutation in P``                ``swap(A, i, P[next]);``                ``int` `temp = P[next];``    ` `                ``// Subtract n from an entry in P``                ``// to make it negative which indicates``                ``// the corresponding move``                ``// has been performed``                ``P[next] -= n;``                ``next = temp;``            ``}``        ``}``    ``}``    ` `    ``static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``        ``return` `arr;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]A = { 5, 6, 7, 8 };``        ``int` `[]P = { 3, 2, 1, 0 };``        ``int` `n = A.Length;``    ` `        ``permute(A, P, n);``    ` `        ``// Print the new array after``        ``// applying the permutation``        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(A[i]+ ``" "``);``    ` `    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`8 7 6 5`

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

My Personal Notes arrow_drop_up