Arrange the array such that upon performing given operations an increasing order is obtained

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:  

  1. Take the first (0th index) element, remove it from the array and print it.
  2. If there are still elements left in the array, move the next top element to the end of the array.
  3. 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.  

  1. The given array is sorted and the queue is prepared by adding array indexes.
  2. 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.
  3. 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:  



filter_none

edit
close

play_arrow

link
brightness_4
code

#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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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] + " ");
    }
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 = ' ')
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

Output
1 5 2 7 3 6 4 8 




Time Complexity: O(NlogN)
Another Approach: 

If you closely observe it then you will find that here it is following a pattern.

Just Think Reverse.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 thr 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 thr 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
chevron_right

Output
1 5 2 4 3 
1 12 2 10 4 16 6 





Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :
Practice Tags :