# Program to print an array in Pendulum Arrangement

• Difficulty Level : Easy
• Last Updated : 08 Jun, 2022

Write a program to input a list of integers in an array and arrange them in a way similar to the to-and-fro movement of a Pendulum.

• The minimum element out of the list of integers, must come in center position of 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 : 1   3   2   5   4
Output :5   3   1   2   4
Explanation:
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 : 11   12   31   14   5
Output :31   12   5   11   14```

The idea is to sort the array first. Once the array is sorted, use an auxiliary array to store elements one by one.

## C++

 `// C++ program for pendulum arrangement of numbers``#include ``using` `namespace` `std;`` ` `// Prints pendulum arrangement of arr[]``void` `pendulumArrangement(``int` `arr[], ``int` `n)``{``    ``// sorting the elements``    ``sort(arr, arr+n);`` ` `    ``// Auxiliary array to store output``    ``int` `op[n];`` ` `    ``// calculating the middle index``    ``int` `mid = (n-1)/2;`` ` `    ``// storing the minimum element in the middle``    ``// i is index for output array and j is for``    ``// input array.``    ``int` `j = 1, i = 1;``    ``op[mid] = arr;``    ``for` `(i = 1; i <= mid; i++)``    ``{``        ``op[mid+i] = arr[j++];``        ``op[mid-i] = arr[j++];``    ``}`` ` `    ``// adjustment for when no. of elements is even``    ``if` `(n%2 == 0)``        ``op[mid+i] = arr[j];`` ` ` ` `    ``// Printing the pendulum arrangement``    ``cout << ``"Pendulum arrangement:"` `<< endl;``    ``for` `(i = 0 ; i < n; i++)``        ``cout << op[i] << ``" "``;`` ` `    ``cout << endl;``}`` ` `// Driver function``int` `main()``{``    ``//input Array``    ``int` `arr[] = {14, 6, 19, 21, 12};`` ` `    ``// calculating the length of array A``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);`` ` `    ``// calling pendulum function``    ``pendulumArrangement(arr, n);`` ` `    ``return` `0;``}`

## Java

 `// Java program for pendulum arrangement of numbers`` ` `import` `java.util.Arrays;`` ` `class` `Test``{``    ``// Prints pendulum arrangement of arr[]``    ``static` `void` `pendulumArrangement(``int` `arr[], ``int` `n)``    ``{``        ``// sorting the elements``        ``Arrays.sort(arr);``      ` `        ``// Auxiliary array to store output``        ``int` `op[] = ``new` `int``[n];``      ` `        ``// calculating the middle index``        ``int` `mid = (n-``1``)/``2``;``      ` `        ``// storing the minimum element in the middle``        ``// i is index for output array and j is for``        ``// input array.``        ``int` `j = ``1``, i = ``1``;``        ``op[mid] = arr[``0``];``        ``for` `(i = ``1``; i <= mid; i++)``        ``{``            ``op[mid+i] = arr[j++];``            ``op[mid-i] = arr[j++];``        ``}``      ` `        ``// adjustment for when no. of elements is even``        ``if` `(n%``2` `== ``0``)``            ``op[mid+i] = arr[j];``      ` `      ` `        ``// Printing the pendulum arrangement``        ``System.out.println(``"Pendulum arrangement:"``);``        ``for` `(i = ``0` `; i < n; i++)``            ``System.out.print(op[i] + ``" "``);``      ` `        ``System.out.println();``    ``}``     ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``//input Array``        ``int` `arr[] = {``14``, ``6``, ``19``, ``21``, ``12``};``        ` `        ``// calling pendulum function``        ``pendulumArrangement(arr, arr.length);``    ``}``}`

## Python3

 `# Python 3 program for pendulum``# arrangement of numbers`` ` `# Prints pendulum arrangement of arr[]``def` `pendulumArrangement(arr, n):`` ` `    ``# sorting the elements``    ``arr.sort()`` ` `    ``# Auxiliary array to store output``    ``op ``=` `[``0``] ``*` `n`` ` `    ``# calculating the middle index``    ``mid ``=` `int``((n``-``1``)``/``2``)`` ` `    ``# storing the minimum``        ``# element in the middle``    ``# i is index for output``        ``# array and j is for``    ``# input array.``    ``j ``=` `1``    ``i ``=` `1``    ``op[mid] ``=` `arr[``0``]``    ``for` `i ``in` `range``(``1``,mid``+``1``):``     ` `        ``op[mid``+``i] ``=` `arr[j]``        ``j``+``=``1``        ``op[mid``-``i] ``=` `arr[j]``        ``j``+``=``1``     ` ` ` `    ``# adjustment for when no.``        ``# of elements is even``    ``if` `(``int``(n``%``2``) ``=``=` `0``):``        ``op[mid``+``i] ``=` `arr[j]`` ` ` ` `    ``# Printing the pendulum arrangement``    ``print``(``"Pendulum arrangement:"``)``    ``for` `i ``in` `range``(``0``,n):``        ``print``(op[i],end``=``" "``)`` ` `# Driver function``# input Array``arr ``=` `[``14``, ``6``, ``19``, ``21``, ``12``]`` ` `# calculating the length of array A``n ``=` `len``(arr)`` ` `# calling pendulum function``pendulumArrangement(arr, n)`` ` `# This code is contributed by``# Smitha Dinesh Semwal`

## C#

 `// C# program for pendulum ``// arrangement of numbers``using` `System;`` ` `class` `Test {``     ` `    ``// Prints pendulum arrangement of arr[]``    ``static` `void` `pendulumArrangement(``int` `[]arr, ``                                    ``int` `n)``    ``{``         ` `        ``// sorting the elements``        ``Array.Sort(arr);``     ` `        ``// Auxiliary array to store output``        ``int` `[]op = ``new` `int``[n];``     ` `        ``// calculating the middle index``        ``int` `mid = (n - 1) / 2;``     ` `        ``// storing the minimum element in ``        ``// the middle i is index for output ``        ``// array and j is for input array.``        ``int` `j = 1, i = 1;``        ``op[mid] = arr;``        ``for` `(i = 1; i <= mid; i++)``        ``{``            ``op[mid + i] = arr[j++];``            ``op[mid - i] = arr[j++];``        ``}``     ` `        ``// adjustment for when no. ``        ``// of elements is even``        ``if` `(n % 2 == 0)``            ``op[mid + i] = arr[j];``     ` `     ` `        ``// Printing the pendulum arrangement``        ``Console.Write(``"Pendulum arrangement:"``);``        ``for` `(i = 0 ; i < n; i++)``            ``Console.Write(op[i] + ``" "``);``     ` `        ``Console.WriteLine();``    ``}``     ` `    ``// Driver code``    ``public` `static` `void` `Main() ``    ``{``         ` `        ``//input Array``        ``int` `[]arr = {14, 6, 19, 21, 12};``         ` `        ``// calling pendulum function``        ``pendulumArrangement(arr, arr.Length);``    ``}``}`` ` `// This code is contributed by Nitin Mittal.`

## PHP

 ``

## Javascript

 ``

Output:

```Pendulum arrangement:
21 14 6 12 19```

Time Complexity: O(n*log(n)) where n is the size of the array.
Auxiliary Space: O(n)
This article is contributed by Nitin Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.