Given an array arr[] of size N, the task is to print the arrangement of the array such that upon performing the following operations on this arrangement, increasing order is obtained as the output:
- Take the first (0th index) element, remove it from the array and print it.
- If there are still elements left in the array, move the next top element to the end of the array.
- Repeat the above steps until the array is not empty.
Examples:
Input: arr = {1, 2, 3, 4, 5, 6, 7, 8}
Output: {1, 5, 2, 7, 3, 6, 4, 8}
Explanation:
Let initial array be {1, 5, 2, 7, 3, 6, 4, 8}, where 1 is the top of the array.
1 is printed, and 5 is moved to the end. The array is now {2, 7, 3, 6, 4, 8, 5}.
2 is printed, and 7 is moved to the end. The array is now {3, 6, 4, 8, 5, 7}.
3 is printed, and 6 is moved to the end. The array is now {4, 8, 5, 7, 6}.
4 is printed, and 8 is moved to the end. The array is now {5, 7, 6, 8}.
5 is printed, and 7 is moved to the end. The array is now {6, 8, 7}.
6 is printed, and 8 is moved to the end. The array is now {7, 8}.
7 is printed, and 8 is moved to the end. The array is now {8}.
8 is printed.
The printing order is 1, 2, 3, 4, 5, 6, 7, 8 which is increasing.
Input: arr = {3, 2, 25, 2, 3, 1, 2, 6, 5, 45, 4, 89, 5}
Output: {1, 45, 2, 5, 2, 25, 2, 5, 3, 89, 3, 6, 4}
Approach:
The idea is to simulate the given process. For this a queue data structure is used.
- The given array is sorted and the queue is prepared by adding array indexes.
- Then the given array is traversed and for each element, the index from the front of the queue is popped and add the current array element is added at the popped index in the resultant array.
- If the queue is still not empty, then the next index (in the queue front) is moved to the back of the queue.
Below is the implementation of the above approach:
#include <bits/stdc++.h> #define mod 1000000007 using namespace std;
// Function to print the arrangement vector< int > arrangement(vector< int > arr)
{ // Sorting the list
sort(arr.begin(), arr.end());
// Finding Length of the List
int length = arr.size();
// Initializing the result array
vector< int > ans(length, 0);
// Initializing the Queue
deque< int > Q;
for ( int i = 0; i < length; i++)
Q.push_back(i);
// Adding current array element to the
// result at an index which is at the
// front of the Q and then if still
// elements are left then putting the next
// top element the bottom of the array.
for ( int i = 0; i < length; i++)
{
int j = Q.front();
Q.pop_front();
ans[j] = arr[i];
if (Q.size() != 0)
{
j = Q.front();
Q.pop_front();
Q.push_back(j);
}
}
return ans;
} // Driver code int main()
{ vector< int > arr = { 1, 2, 3, 4, 5, 6, 7, 8 };
vector< int > answer = arrangement(arr);
for ( int i : answer)
cout << i << " " ;
} // This code is contributed by mohit kumar 29 |
// Java implementation of the above approach import java.util.*;
public class GfG
{ // Function to find the array
// arrangement
static public int [] arrayIncreasing( int [] arr)
{
// Sorting the array
Arrays.sort(arr);
// Finding size of array
int length = arr.length;
// Empty array to store resultant order
int answer[] = new int [length];
// Doubly Ended Queue to
// simulate the process
Deque<Integer> dq = new LinkedList<>();
// Loop to initialize queue with indexes
for ( int i = 0 ; i < length; i++) {
dq.add(i);
}
// Adding current array element to the
// result at an index which is at the
// front of the queue and then if still
// elements are left then putting the next
// top element the bottom of the array.
for ( int i = 0 ; i < length; i++)
{
answer[dq.pollFirst()] = arr[i];
if (!dq.isEmpty())
dq.addLast(dq.pollFirst());
}
// Returning the resultant order
return answer;
}
// Driver code
public static void main(String args[])
{
int A[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 };
// Calling the function
int ans[] = arrayIncreasing(A);
// Printing the obtained pattern
for ( int i = 0 ; i < A.length; i++)
System.out.print(ans[i] + " " );
}
} |
# Python3 Code for the approach # Importing Queue from Collections Module from collections import deque
# Function to print the arrangement def arrangement(arr):
# Sorting the list
arr.sort()
# Finding Length of the List
length = len (arr)
# Initializing the result array
answer = [ 0 for x in range ( len (arr))]
# Initializing the Queue
queue = deque()
for i in range (length):
queue.append(i)
# Adding current array element to the
# result at an index which is at the
# front of the queue and then if still
# elements are left then putting the next
# top element the bottom of the array.
for i in range (length):
answer[queue.popleft()] = arr[i]
if len (queue) ! = 0 :
queue.append(queue.popleft())
return answer
# Driver code arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ]
answer = arrangement(arr)
# Printing the obtained result print ( * answer, sep = ' ' )
|
// C# implementation of the above approach using System;
using System.Collections.Generic;
class GfG
{ // Function to find the array
// arrangement
static public int [] arrayIncreasing( int [] arr)
{
// Sorting the array
Array.Sort(arr);
// Finding size of array
int length = arr.Length;
// Empty array to store resultant order
int []answer = new int [length];
// Doubly Ended Queue to
// simulate the process
List< int > dq = new List< int >();
// Loop to initialize queue with indexes
for ( int i = 0; i < length; i++)
{
dq.Add(i);
}
// Adding current array element to the
// result at an index which is at the
// front of the queue and then if still
// elements are left then putting the next
// top element the bottom of the array.
for ( int i = 0; i < length; i++)
{
answer[dq[0]] = arr[i];
dq.RemoveAt(0);
if (dq.Count != 0)
{
dq.Add(dq[0]);
dq.RemoveAt(0);
}
}
// Returning the resultant order
return answer;
}
// Driver code
public static void Main(String []args)
{
int []A = { 1, 2, 3, 4, 5, 6, 7, 8 };
// Calling the function
int []ans = arrayIncreasing(A);
// Printing the obtained pattern
for ( int i = 0; i < A.Length; i++)
Console.Write(ans[i] + " " );
}
} // This code is contributed by 29AjayKumar |
<script> // Javascript implementation of the above approach
// Function to find the array
// arrangement
function arrayIncreasing(arr)
{
// Sorting the array
arr.sort( function (a, b){ return a - b});
// Finding size of array
let length = arr.length;
// Empty array to store resultant order
let answer = new Array(length);
// Doubly Ended Queue to
// simulate the process
let dq = [];
// Loop to initialize queue with indexes
for (let i = 0; i < length; i++)
{
dq.push(i);
}
// Adding current array element to the
// result at an index which is at the
// front of the queue and then if still
// elements are left then putting the next
// top element the bottom of the array.
for (let i = 0; i < length; i++)
{
answer[dq[0]] = arr[i];
dq.shift();
if (dq.length != 0)
{
dq.push(dq[0]);
dq.shift(0);
}
}
// Returning the resultant order
return answer;
}
let A = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
// Calling the function
let ans = arrayIncreasing(A);
// Printing the obtained pattern
for (let i = 0; i < A.length; i++)
document.write(ans[i] + " " );
// This code is contributed by decode2207.
</script> |
1 5 2 7 3 6 4 8
Time Complexity: O(NlogN)
Auxiliary Space: O(N) because it is using extra space for deque q
Another Approach:
If you closely observe it then you will find that here it is following a pattern.
Just Think Reverse.
- Sort the input array and try to reach the previous stage from the given steps.
- Iterate from i=N-1 to 1, by decreasing i by 1 in every step.
- Delete the last element from an array and insert it at ith position.
- Repeat the above two-step till reach to i=1
- After reach i=1 , you will get the final resultant array.
Below is the implementation of the above approach:
// C++ program to find the desired output // after performing given operations #include <bits/stdc++.h> using namespace std;
// Function to arrange array in such a way // that after performing given operation // We get increasing sorted array void Desired_Array(vector< int >& v)
{ // Size of given array
int n = v.size();
// Sort the given array
sort(v.begin(), v.end());
// Start erasing last element and place it at
// ith index
int i = n - 1;
// While we reach at starting
while (i > 0) {
// Store last element
int p = v[n - 1];
// Shift all elements by 1 position in right
for ( int j = n - 1; j >= i; j--)
{
v[j + 1] = v[j];
}
// insert last element at ith position
v[i] = p;
i--;
}
// print desired Array
for ( auto x : v)
cout << x << " " ;
cout << "\n" ;
} // Driver Code int main()
{ // Given Array
vector< int > v = { 1, 2, 3, 4, 5 };
Desired_Array(v);
vector< int > v1 = { 1, 12, 2, 10, 4, 16, 6 };
Desired_Array(v1);
return 0;
} // Contributed by ajaykr00kj |
// Java program to find the // desired output after // performing given operations import java.util.Arrays;
class Main{
// Function to arrange array in // such a way that after performing // given operation We get increasing // sorted array public static void Desired_Array( int v[])
{ // Size of given array
int n = v.length;
// Sort the given array
Arrays.sort(v);
// Start erasing last element
// and place it at ith index
int i = n - 1 ;
// While we reach at starting
while (i > 0 )
{
// Store last element
int p = v[n - 1 ];
// Shift all elements by
// 1 position in right
for ( int j = n - 1 ;
j >= i; j--)
{
v[j] = v[j - 1 ];
}
// insert last element at
// ith position
v[i] = p;
i--;
}
// Print desired Array
for ( int x = 0 ; x < v.length; x++)
{
System.out.print(v[x] + " " );
}
System.out.println();
} // Driver code public static void main(String[] args)
{ // Given Array
int v[] = { 1 , 2 , 3 , 4 , 5 };
Desired_Array(v);
int v1[] = { 1 , 12 , 2 , 10 , 4 , 16 , 6 };
Desired_Array(v1);
} } // This code is contributed by divyeshrabadiya07 |
# Python3 program to find the desired output # after performing given operations # Function to arrange array in such a way # that after performing given operation # We get increasing sorted array def Desired_Array(v):
# Size of given array
n = len (v)
# Sort the given array
v.sort()
# Start erasing last element and place it at
# ith index
i = n - 1
# While we reach at starting
while (i > 0 ) :
# Store last element
p = v[n - 1 ]
# Shift all elements by 1 position in right
for j in range (n - 1 , i - 1 , - 1 ) :
v[j] = v[j - 1 ]
# insert last element at ith position
v[i] = p
i - = 1
# print desired Array
for x in v :
print (x, end = " " )
print ()
# Given Array v = [ 1 , 2 , 3 , 4 , 5 ]
Desired_Array(v) v1 = [ 1 , 12 , 2 , 10 , 4 , 16 , 6 ]
Desired_Array(v1) # This code is contributed by divyesh072019 |
// C# program to find the desired // output after performing given // operations using System;
class GFG{
// Function to arrange array in // such a way that after performing // given operation We get increasing // sorted array public static void Desired_Array( int [] v)
{ // Size of given array
int n = v.Length;
// Sort the given array
Array.Sort(v);
// Start erasing last element
// and place it at ith index
int i = n - 1;
// While we reach at starting
while (i > 0)
{
// Store last element
int p = v[n - 1];
// Shift all elements by
// 1 position in right
for ( int j = n - 1;
j >= i; j--)
{
v[j] = v[j - 1];
}
// Insert last element at
// ith position
v[i] = p;
i--;
}
// Print desired Array
for ( int x = 0; x < v.Length; x++)
{
Console.Write(v[x] + " " );
}
Console.WriteLine();
} // Driver code static public void Main()
{ // Given Array
int [] v = { 1, 2, 3, 4, 5 };
Desired_Array(v);
int [] v1 = { 1, 12, 2, 10, 4, 16, 6 };
Desired_Array(v1);
} } // This code is contributed by offbeat |
<script> // Javascript program to find the desired
// output after performing given
// operations
// Function to arrange array in
// such a way that after performing
// given operation We get increasing
// sorted array
function Desired_Array(v)
{
// Size of given array
let n = v.length;
// Sort the given array
v.sort( function (a, b){ return a - b});
// Start erasing last element
// and place it at ith index
let i = n - 1;
// While we reach at starting
while (i > 0)
{
// Store last element
let p = v[n - 1];
// Shift all elements by
// 1 position in right
for (let j = n - 1; j >= i; j--)
{
v[j] = v[j - 1];
}
// Insert last element at
// ith position
v[i] = p;
i--;
}
// Print desired Array
for (let x = 0; x < v.length; x++)
{
document.write(v[x] + " " );
}
document.write( "</br>" );
}
// Given Array
let v = [ 1, 2, 3, 4, 5 ];
Desired_Array(v);
let v1 = [ 1, 12, 2, 10, 4, 16, 6 ];
Desired_Array(v1);
</script> |
1 5 2 4 3 1 12 2 10 4 16 6
Time Complexity: O(n2)
Auxiliary Space: O(1)