Related Articles

# Program to print an array in Pendulum Arrangement with constant space

• Difficulty Level : Medium
• Last Updated : 12 May, 2021

Given an array arr[] of integers, the task is to arrange them in a way similar to the to-and-fro movement of a Pendulum without using any extra space.
Pendulum Arrangement

• The minimum element out of the list of integers must come in the center position of the array.
• The number in the ascending order next to the minimum, goes to the right, the next higher number goes to the left of minimum number and it continues.
• As higher numbers are reached, one goes to one side in a to-and-fro manner similar to that of a Pendulum.

Examples:

Input: arr[] = {2, 3, 5, 1, 4}
Output: 5 3 1 2 4
The minimum element is 1, so it is moved to the middle.
The next higher element 2 is moved to the right of the
middle element while the next higher element 3 is
moved to the left of the middle element and
this process is continued.
Input: arr[] = {11, 2, 4, 55, 6, 8}
Output: 11 6 2 4 8 55

Approach: An approach which uses an auxiliary array has been discussed in this article. Here’s an approach without using extra space:

1. Sort the given array.
2. Move all the odd position element in the right side of the array.
3. Reverse the element from 0 to (n-1)/2 position of the array.

For example, let arr[] = {2, 3, 5, 1, 4}
Sorted array will be arr[] = {1, 2, 3, 4, 5}.
After moving all odd index position elements to the right,
arr[] = {1, 3, 5, 2, 4} (1 and 3 are the odd index positions)
After reversing elements from 0 to (n – 1) / 2,
arr[] = {5, 3, 1, 2, 4} which is the required array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the Pendulum``// arrangement of the given array``void` `pendulumArrangement(``int` `arr[], ``int` `n)``{``    ``// Sort the array``    ``sort(arr, arr + n);` `    ``int` `odd, temp, in, pos;` `    ``// pos stores the index of``    ``// the last element of the array``    ``pos = n - 1;` `    ``// odd stores the last odd index in the array``    ``if` `(n % 2 == 0)``        ``odd = n - 1;``    ``else``        ``odd = n - 2;` `    ``// Move all odd index positioned``    ``// elements to the right``    ``while` `(odd > 0) {``        ``temp = arr[odd];``        ``in = odd;` `        ``// Shift the elements by one position``        ``// from odd to pos``        ``while` `(in != pos) {``            ``arr[in] = arr[in + 1];``            ``in++;``        ``}``        ``arr[in] = temp;``        ``odd = odd - 2;``        ``pos = pos - 1;``    ``}` `    ``// Reverse the element from 0 to (n - 1) / 2``    ``int` `start = 0, end = (n - 1) / 2;` `    ``for` `(; start < end; start++, end--) {``        ``temp = arr[start];``        ``arr[start] = arr[end];``        ``arr[end] = temp;``    ``}` `    ``// Printing the pendulum arrangement``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 11, 2, 4, 55, 6, 8 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``pendulumArrangement(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.Arrays;``import` `java.io.*;` `class` `GFG {` `    ``// Function to print the Pendulum``    ``// arrangement of the given array``    ``static` `void` `pendulumArrangement(``int` `arr[], ``int` `n)``    ``{``        ``// Sort the array``        ``// sort(arr, arr + n);` `        ``Arrays.sort(arr);` `        ``int` `odd, temp, in, pos;` `        ``// pos stores the index of``        ``// the last element of the array``        ``pos = n - ``1``;` `        ``// odd stores the last odd index in the array``        ``if` `(n % ``2` `== ``0``)``            ``odd = n - ``1``;``        ``else``            ``odd = n - ``2``;` `        ``// Move all odd index positioned``        ``// elements to the right``        ``while` `(odd > ``0``) {``            ``temp = arr[odd];``            ``in = odd;` `            ``// Shift the elements by one position``            ``// from odd to pos``            ``while` `(in != pos) {``                ``arr[in] = arr[in + ``1``];``                ``in++;``            ``}``            ``arr[in] = temp;``            ``odd = odd - ``2``;``            ``pos = pos - ``1``;``        ``}` `        ``// Reverse the element from 0 to (n - 1) / 2``        ``int` `start = ``0``, end = (n - ``1``) / ``2``;` `        ``for` `(; start < end; start++, end--) {``            ``temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``        ``}` `        ``// Printing the pendulum arrangement``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `arr[] = { ``11``, ``2``, ``4``, ``55``, ``6``, ``8` `};``        ``int` `n = arr.length;` `        ``pendulumArrangement(arr, n);``    ``}``}` `// This code is contributed by akt_mit`

## Python3

 `# Python 3 implementation of the approach` `# Function to print the Pendulum``# arrangement of the given array``def` `pendulumArrangement(arr, n):``    ` `    ``# Sort the array``    ``arr.sort(reverse ``=` `False``)` `    ``# pos stores the index of``    ``# the last element of the array``    ``pos ``=` `n ``-` `1` `    ``# odd stores the last odd index in the array``    ``if` `(n ``%` `2` `=``=` `0``):``        ``odd ``=` `n ``-` `1``    ``else``:``        ``odd ``=` `n ``-` `2` `    ``# Move all odd index positioned``    ``# elements to the right``    ``while` `(odd > ``0``):``        ``temp ``=` `arr[odd]``        ``in1 ``=` `odd` `        ``# Shift the elements by one position``        ``# from odd to pos``        ``while` `(in1 !``=` `pos):``            ``arr[in1] ``=` `arr[in1 ``+` `1``]``            ``in1 ``+``=` `1` `        ``arr[in1] ``=` `temp``        ``odd ``=` `odd ``-` `2``        ``pos ``=` `pos ``-` `1` `    ``# Reverse the element from 0 to (n - 1) / 2``    ``start ``=` `0``    ``end ``=` `int``((n ``-` `1``) ``/` `2``)` `    ``while``(start < end):``        ``temp ``=` `arr[start]``        ``arr[start] ``=` `arr[end]``        ``arr[end] ``=` `temp``        ``start ``+``=` `1``        ``end ``-``=` `1` `    ``# Printing the pendulum arrangement``    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``11``, ``2``, ``4``, ``55``, ``6``, ``8``]``    ``n ``=` `len``(arr)` `    ``pendulumArrangement(arr, n)` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to print the Pendulum``    ``// arrangement of the given array``    ``static` `void` `pendulumArrangement(``int``[] arr, ``int` `n)``    ``{``        ``// Sort the array``        ``// sort(arr, arr + n);` `        ``Array.Sort(arr);` `        ``int` `odd, temp, p, pos;` `        ``// pos stores the index of``        ``// the last element of the array``        ``pos = n - 1;` `        ``// odd stores the last odd index in the array``        ``if` `(n % 2 == 0)``            ``odd = n - 1;``        ``else``            ``odd = n - 2;` `        ``// Move all odd index positioned``        ``// elements to the right``        ``while` `(odd > 0)``        ``{``            ``temp = arr[odd];``            ``p = odd;` `            ``// Shift the elements by one position``            ``// from odd to pos``            ``while` `(p != pos)``            ``{``                ``arr[p] = arr[p + 1];``                ``p++;``            ``}``            ``arr[p] = temp;``            ``odd = odd - 2;``            ``pos = pos - 1;``        ``}` `        ``// Reverse the element from 0 to (n - 1) / 2``        ``int` `start = 0, end = (n - 1) / 2;` `        ``for` `(; start < end; start++, end--)``        ``{``            ``temp = arr[start];``            ``arr[start] = arr[end];``            ``arr[end] = temp;``        ``}` `        ``// Printing the pendulum arrangement``        ``for` `(``int` `i = 0; i < n; i++)``            ``Console.Write(arr[i] + ``" "``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 11, 2, 4, 55, 6, 8 };``        ``int` `n = arr.Length;` `        ``pendulumArrangement(arr, n);``    ``}``}` `// This code is contributed by ChitraNayal`

## PHP

 ` 0)``    ``{``        ``\$temp` `= ``\$arr``[``\$odd``];``        ``\$in` `= ``\$odd``;` `        ``// Shift the elements by one position``        ``// from odd to pos``        ``while` `(``\$in` `!= ``\$pos``)``        ``{``            ``\$arr``[``\$in``] = ``\$arr``[``\$in` `+ 1];``            ``\$in``++;``        ``}``        ``\$arr``[``\$in``] = ``\$temp``;``        ``\$odd` `= ``\$odd` `- 2;``        ``\$pos` `= ``\$pos` `- 1;``    ``}` `    ``// Reverse the element from 0 to (n - 1) / 2``    ``\$start` `= 0;``    ``\$end` `= ``floor``((``\$n` `- 1) / 2);` `    ``for` `(; ``\$start` `< ``\$end``; ``\$start``++, ``\$end``--)``    ``{``        ``\$temp` `= ``\$arr``[``\$start``];``        ``\$arr``[``\$start``] = ``\$arr``[``\$end``];``        ``\$arr``[``\$end``] = ``\$temp``;``    ``}` `    ``// Printing the pendulum arrangement``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``        ``echo` `\$arr``[``\$i``], ``" "``;``}` `// Driver code``\$arr` `= ``array``( 11, 2, 4, 55, 6, 8 );``\$n` `= ``count``(``\$arr``);` `pendulumArrangement(``\$arr``, ``\$n``);` `// This code is contributed by AnkitRai01` `?>`

## Javascript

 ``
Output:
`11 6 2 4 8 55`

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up