//Returns the sorted vector after performing SlowSort
//It is a sorting algorithm that is of humorous nature and not useful.
//It's based on the principle of multiply and surrender, a tongue-in-cheek joke of divide and conquer.
//It was published in 1986 by Andrei Broder and Jorge Stolfi in their paper Pessimal Algorithms and Simplexity Analysis.
//This algorithm multiplies a single problem into multiple subproblems
//It is interesting because it is provably the least efficient sorting algorithm that can be built asymptotically,
//and with the restriction that such an algorithm, while being slow, must still all the time be working towards a result.

#include <iostream>
using namespace std;

void SlowSort(int a[], int i, int j)
{
  if (i >= j)
    return;
  int m = i + (j - i) / 2; //midpoint, implemented this way to avoid overflow
  int temp;
  SlowSort(a, i, m);
  SlowSort(a, m + 1, j);
  if (a[j] < a[m])
  {
    temp = a[j]; //swapping a[j] & a[m]
    a[j] = a[m];
    a[m] = temp;
  }
  SlowSort(a, i, j - 1);
}

//Sample Main function

int main()
{
  int size;
  cout << "\nEnter the number of elements : ";

  cin >> size;

  int arr[size];

  cout << "\nEnter the unsorted elements : ";

  for (int i = 0; i < size; ++i)
  {
    cout << "\n";
    cin >> arr[i];
  }

  SlowSort(arr, 0, size);

  cout << "Sorted array\n";

  for (int i = 0; i < size; ++i)
  {
    cout << arr[i] << " ";
  }
  return 0;
}