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++ implementation of the approach #include <bits/stdc++.h> 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 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 |
# 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# 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 |
<script> // JavaScript implementation of the approach // Function to permute the given // array based on the given conditions function permute(A, P, n) {
// For each element of P
for (let i = 0; i < n; i++) {
let next = i;
// Check if it is already
// considered in cycle
while (P[next] >= 0) {
// Swap the current element according
// to the permutation in P
let x = A[i];
A[i] = A[P[next]];
A[P[next]] = x;
let 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 let A = [5, 6, 7, 8]; let P = [3, 2, 1, 0]; let n = A.length; permute(A, P, n); // Print the new array after // applying the permutation for (let i = 0; i < n; i++)
document.write(A[i] + " " );
</script> |
8 7 6 5
Time Complexity: O(n)
Space Complexity : O(1)