Rearrange an array such that ‘arr[j]’ becomes ‘i’ if ‘arr[i]’ is ‘j’ | Set 1
Given an array of size n where all elements are distinct and in the range from 0 to n-1, change the contents of arr[] so that arr[i] = j is changed to arr[j] = i.
Examples:
Example 1:
Input: arr[] = {1, 3, 0, 2};
Output: arr[] = {2, 0, 3, 1};
Explanation for the above output.
Since arr[0] is 1, arr[1] is changed to 0
Since arr[1] is 3, arr[3] is changed to 1
Since arr[2] is 0, arr[0] is changed to 2
Since arr[3] is 2, arr[2] is changed to 3
Example 2:
Input: arr[] = {2, 0, 1, 4, 5, 3};
Output: arr[] = {1, 2, 0, 5, 3, 4};
Example 3:
Input: arr[] = {0, 1, 2, 3};
Output: arr[] = {0, 1, 2, 3};
Example 4:
Input: arr[] = {3, 2, 1, 0};
Output: arr[] = {3, 2, 1, 0};
A Simple Solution is to create a temporary array and one by one copy ‘i’ to ‘temp[arr[i]]’ where i varies from 0 to n-1.
Below is the implementation of the above idea.
C++
#include <bits/stdc++.h>
using namespace std;
void rearrangeNaive( int arr[], int n)
{
int temp[n], i;
for (i = 0; i < n; i++)
temp[arr[i]] = i;
for (i = 0; i < n; i++)
arr[i] = temp[i];
}
void printArray( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
cout << ( "%d " , arr[i]);
cout << ( "\n" );
}
int main()
{
int arr[] = { 1, 3, 0, 2 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << ( "Given array is \n" );
printArray(arr, n);
rearrangeNaive(arr, n);
cout << ( "Modified array is \n" );
printArray(arr, n);
return 0;
}
|
C
#include <stdio.h>
void rearrangeNaive( int arr[], int n)
{
int temp[n], i;
for (i = 0; i < n; i++)
temp[arr[i]] = i;
for (i = 0; i < n; i++)
arr[i] = temp[i];
}
void printArray( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
printf ( "%d " , arr[i]);
printf ( "\n" );
}
int main()
{
int arr[] = { 1, 3, 0, 2 };
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "Given array is \n" );
printArray(arr, n);
rearrangeNaive(arr, n);
printf ( "Modified array is \n" );
printArray(arr, n);
return 0;
}
|
Java
import java.io.*;
class RearrangeArray {
void rearrangeNaive( int arr[], int n)
{
int temp[] = new int [n];
int i;
for (i = 0 ; i < n; i++)
temp[arr[i]] = i;
for (i = 0 ; i < n; i++)
arr[i] = temp[i];
}
void printArray( int arr[], int n)
{
int i;
for (i = 0 ; i < n; i++) {
System.out.print(arr[i] + " " );
}
System.out.println( "" );
}
public static void main(String[] args)
{
RearrangeArray arrange = new RearrangeArray();
int arr[] = { 1 , 3 , 0 , 2 };
int n = arr.length;
System.out.println( "Given array is " );
arrange.printArray(arr, n);
arrange.rearrangeNaive(arr, n);
System.out.println( "Modified array is " );
arrange.printArray(arr, n);
}
}
|
Python3
def rearrangeNaive(arr, n):
temp = [ 0 ] * n
for i in range ( 0 , n):
temp[arr[i]] = i
for i in range ( 0 , n):
arr[i] = temp[i]
def printArray(arr, n):
for i in range ( 0 , n):
print (arr[i], end = " " )
arr = [ 1 , 3 , 0 , 2 ]
n = len (arr)
print ( "Given array is" , end = " " )
printArray(arr, n)
rearrangeNaive(arr, n)
print ( "\nModified array is" , end = " " )
printArray(arr, n)
|
C#
using System;
class RearrangeArray {
void rearrangeNaive( int [] arr, int n)
{
int [] temp = new int [n];
int i;
for (i = 0; i < n; i++)
temp[arr[i]] = i;
for (i = 0; i < n; i++)
arr[i] = temp[i];
}
void printArray( int [] arr, int n)
{
int i;
for (i = 0; i < n; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine( "" );
}
public static void Main()
{
RearrangeArray arrange = new RearrangeArray();
int [] arr = { 1, 3, 0, 2 };
int n = arr.Length;
Console.WriteLine( "Given array is " );
arrange.printArray(arr, n);
arrange.rearrangeNaive(arr, n);
Console.WriteLine( "Modified array is " );
arrange.printArray(arr, n);
}
}
|
Javascript
<script>
function rearrangeNaive(arr, n)
{
let temp = new Array(n), i;
for (i = 0; i < n; i++)
temp[arr[i]] = i;
for (i = 0; i < n; i++)
arr[i] = temp[i];
}
function printArray(arr, n)
{
let i;
for (i = 0; i < n; i++)
document.write( " " + arr[i]);
document.write( "<br>" );
}
let arr = [ 1, 3, 0, 2 ];
let n = arr.length;
document.write( "Given array is <br>" );
printArray(arr, n);
rearrangeNaive(arr, n);
document.write( "Modified array is <br>" );
printArray(arr, n);
</script>
|
Output
Given array is
1302
Modified array is
2031
Time complexity: O(n)
Auxiliary space :O(n)
Can we solve this in O(n) time and O(1) auxiliary space?
The idea is based on the fact that the modified array is basically a permutation of the input array. We can find the target permutation by storing the next item before updating it.
Let us consider array ‘{1, 3, 0, 2}’ for example. We start with i = 0, arr[i] is 1. So we go to arr[1] and change it to 0 (because i is 0). Before we make the change, we store the old value of arr[1] as the old value is going to be our new index i. In the next iteration, we have i = 3, arr[3] is 2, so we change arr[2] to 3. Before making the change we store next i as old value of arr[2].
The below code gives idea about this approach.
// This function works only when output is a permutation
// with one cycle.
void rearrangeUtil(int arr[], int n)
{
// 'val' is the value to be stored at 'arr[i]'
int val = 0; // The next value is determined
// using current index
int i = arr[0]; // The next index is determined
// using current value
// While all elements in cycle are not processed
while (i != 0)
{
// Store value at index as it is going to be
// used as next index
int new_i = arr[i];
// Update arr[]
arr[i] = val;
// Update value and index for next iteration
val = i;
i = new_i;
}
arr[0] = val; // Update the value at arr[0]
}
The above function doesn’t work for inputs like {2, 0, 1, 4, 5, 3}; as there are two cycles. One cycle is (2, 0, 1) and other cycle is (4, 5, 3).
How to handle multiple cycles with the O(1) space constraint?
The idea is to process all cycles one by one. To check whether an element is processed or not, we change the value of processed items arr[i] as -arr[i]. Since 0 can not be made negative, we first change all arr[i] to arr[i] + 1. In the end, we make all values positive and subtract 1 to get old values back.
C++
#include <iostream>
using namespace std;
void rearrangeUtil( int arr[], int n, int i)
{
int val = -(i + 1);
i = arr[i] - 1;
while (arr[i] > 0)
{
int new_i = arr[i] - 1;
arr[i] = val;
val = -(i + 1);
i = new_i;
}
}
void rearrange( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
arr[i]++;
for (i = 0; i < n; i++)
{
if (arr[i] > 0)
rearrangeUtil(arr, n, i);
}
for (i = 0; i < n; i++)
arr[i] = (-arr[i]) - 1;
}
void printArray( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = { 2, 0, 1, 4, 5, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Given array is " << endl;
printArray(arr, n);
rearrange(arr, n);
cout << "Modified array is " << endl;
printArray(arr, n);
return 0;
}
|
C
#include <stdio.h>
void rearrangeUtil( int arr[], int n, int i)
{
int val = -(i + 1);
i = arr[i] - 1;
while (arr[i] > 0) {
int new_i = arr[i] - 1;
arr[i] = val;
val = -(i + 1);
i = new_i;
}
}
void rearrange( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
arr[i]++;
for (i = 0; i < n; i++) {
if (arr[i] > 0)
rearrangeUtil(arr, n, i);
}
for (i = 0; i < n; i++)
arr[i] = (-arr[i]) - 1;
}
void printArray( int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
printf ( "%d " , arr[i]);
printf ( "\n" );
}
int main()
{
int arr[] = { 2, 0, 1, 4, 5, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "Given array is \n" );
printArray(arr, n);
rearrange(arr, n);
printf ( "Modified array is \n" );
printArray(arr, n);
return 0;
}
|
Java
import java.io.*;
class RearrangeArray {
void rearrangeUtil( int arr[], int n, int i)
{
int val = -(i + 1 );
i = arr[i] - 1 ;
while (arr[i] > 0 ) {
int new_i = arr[i] - 1 ;
arr[i] = val;
val = -(i + 1 );
i = new_i;
}
}
void rearrange( int arr[], int n)
{
int i;
for (i = 0 ; i < n; i++)
arr[i]++;
for (i = 0 ; i < n; i++) {
if (arr[i] > 0 )
rearrangeUtil(arr, n, i);
}
for (i = 0 ; i < n; i++)
arr[i] = (-arr[i]) - 1 ;
}
void printArray( int arr[], int n)
{
int i;
for (i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
System.out.println( "" );
}
public static void main(String[] args)
{
RearrangeArray arrange = new RearrangeArray();
int arr[] = { 2 , 0 , 1 , 4 , 5 , 3 };
int n = arr.length;
System.out.println( "Given array is " );
arrange.printArray(arr, n);
arrange.rearrange(arr, n);
System.out.println( "Modified array is " );
arrange.printArray(arr, n);
}
}
|
Python3
def rearrangeUtil(arr, n, i):
val = - (i + 1 )
i = arr[i] - 1
while (arr[i] > 0 ):
new_i = arr[i] - 1
arr[i] = val
val = - (i + 1 )
i = new_i
def rearrange(arr, n):
for i in range (n):
arr[i] + = 1
for i in range (n):
if (arr[i] > 0 ):
rearrangeUtil(arr, n, i)
for i in range (n):
arr[i] = ( - arr[i]) - 1
def printArray(arr, n):
for i in range (n):
print (arr[i], end = " " )
print ()
arr = [ 2 , 0 , 1 , 4 , 5 , 3 ]
n = len (arr)
print ( "Given array is " )
printArray(arr, n)
rearrange(arr, n)
print ( "Modified array is " )
printArray(arr, n)
|
C#
using System;
class GFG {
void rearrangeNaive( int [] arr,
int n)
{
int [] temp = new int [n];
int i;
for (i = 0; i < n; i++)
temp[arr[i]] = i;
for (i = 0; i < n; i++)
arr[i] = temp[i];
}
void printArray( int [] arr, int n)
{
int i;
for (i = 0; i < n; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine( "" );
}
public static void Main()
{
GFG arrange = new GFG();
int [] arr = { 2, 0, 1, 4, 5, 3 };
int n = arr.Length;
Console.WriteLine( "Given array is " );
arrange.printArray(arr, n);
arrange.rearrangeNaive(arr, n);
Console.WriteLine( "Modified array is " );
arrange.printArray(arr, n);
}
}
|
Javascript
<script>
function rearrangeUtil(arr,n,i)
{
let val = -(i + 1);
i = arr[i] - 1;
while (arr[i] > 0) {
let new_i = arr[i] - 1;
arr[i] = val;
val = -(i + 1);
i = new_i;
}
}
function rearrange(arr,n)
{
let i;
for (i = 0; i < n; i++)
arr[i]++;
for (i = 0; i < n; i++) {
if (arr[i] > 0)
rearrangeUtil(arr, n, i);
}
for (i = 0; i < n; i++)
arr[i] = (-arr[i]) - 1;
}
function printArray(arr,n)
{
let i;
for (i = 0; i < n; i++)
document.write(arr[i] + " " );
document.write( "<br>" );
}
let arr=[2, 0, 1, 4, 5, 3];
let n = arr.length;
document.write( "Given array is <br>" );
printArray(arr, n);
rearrange(arr, n);
document.write( "Modified array is <br>" );
printArray(arr, n);
</script>
|
Output
Given array is
2 0 1 4 5 3
Modified array is
1 2 0 5 3 4
The time complexity of this method seems to be more than O(n) at first look. If we take a closer look, we can notice that no element is processed more than a constant number of times.
Another Method: The idea is to store each element’s new and old value as quotient and remainder of n, respectively (n being the size of the array).
For example, Suppose an element’s new value is 2, the old value is 1 and n is 3, then the element’s value is stored as 1 + 2*3 = 7. We can retrieve its old value by 7%3 = 1 and its new value by 7/3 = 2.
Thanks, Prateek Oraon for suggesting this method.
C++
#include <bits/stdc++.h>
using namespace std;
void rearrange( int arr[], int n)
{
for ( int i = 0; i < n; i++) {
arr[arr[i] % n] += i * n;
}
for ( int i = 0; i < n; i++) {
arr[i] /= n;
}
}
void printArray( int arr[], int n)
{
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int arr[] = { 2, 0, 1, 4, 5, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Given array is : " << endl;
printArray(arr, n);
rearrange(arr, n);
cout << "Modified array is :" << endl;
printArray(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG {
static void rearrange( int arr[], int n)
{
for ( int i = 0 ; i < n; i++) {
arr[arr[i] % n] += i * n;
}
for ( int i = 0 ; i < n; i++) {
arr[i] /= n;
}
}
static void printArray( int arr[], int n)
{
for ( int i = 0 ; i < n; i++) {
System.out.print(arr[i] + " " );
}
System.out.println();
}
public static void main(String[] args)
{
int arr[] = { 2 , 0 , 1 , 4 , 5 , 3 };
int n = arr.length;
System.out.println( "Given array is : " );
printArray(arr, n);
rearrange(arr, n);
System.out.println( "Modified array is :" );
printArray(arr, n);
}
}
|
Python3
def rearrange(arr, n):
for i in range (n):
arr[arr[i] % n] + = i * n
for i in range (n):
arr[i] / / = n
def printArray(arr, n):
for i in range (n):
print (arr[i], end = " " )
print ()
arr = [ 2 , 0 , 1 , 4 , 5 , 3 ]
n = len (arr)
print ( "Given array is : " )
printArray(arr, n)
rearrange(arr, n)
print ( "Modified array is :" )
printArray(arr, n)
|
C#
using System;
class GFG{
static void rearrange( int [] arr, int n)
{
for ( int i = 0; i < n; i++) {
arr[arr[i] % n] += i * n;
}
for ( int i = 0; i < n; i++) {
arr[i] /= n;
}
}
static void printArray( int [] arr, int n)
{
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
static public void Main ()
{
int [] arr = { 2, 0, 1, 4, 5, 3 };
int n = arr.Length;
Console.WriteLine( "Given array is : " );
printArray(arr, n);
rearrange(arr, n);
Console.WriteLine( "Modified array is :" );
printArray(arr, n);
}
}
|
Javascript
<script>
function rearrange(arr , n)
{
for (i = 0; i < n; i++) {
arr[arr[i] % n] += i * n;
}
for (i = 0; i < n; i++) {
arr[i] = parseInt(arr[i]/n);
}
}
function printArray(arr , n)
{
for (i = 0; i < n; i++) {
document.write(arr[i] + " " );
}
document.write();
}
var arr = [ 2, 0, 1, 4, 5, 3 ];
var n = arr.length;
document.write( "Given array is : " + "<br>" );
printArray(arr, n);
rearrange(arr, n);
document.write( "<br>" )
document.write( "Modified array is : " + "<br>" );
printArray(arr, n);
</script>
|
Output
Given array is :
2 0 1 4 5 3
Modified array is :
1 2 0 5 3 4
Time Complexity : O(n)
Auxiliary Space : O(1)
Last Updated :
09 Dec, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...