write a C++ program for constructing a heap (max heap) with integers and printing it in the rotated form.

Here is a C++ program that constructs a max heap with integers and prints it in the rotated form:

#include <iostream>
#include <vector>

using namespace std;

// function to swap two integers
void swap(int& a, int& b) 
{
    int temp = a;
    a = b;
    b = temp;
}

// function to heapify the given vector
void heapify(vector<int>& arr, int n, int i)
{
    int largest = i;  // initialize largest as root
    int left = 2*i + 1;  // left child index
    int right = 2*i + 2;  // right child index

    // if left child is larger than root
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // if right child is larger than largest so far
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // if largest is not root
    if (largest != i) 
    {
        // swap the root with largest element
        swap(arr[i], arr[largest]);
        // recursively heapify the affected sub-tree
        heapify(arr, n, largest);
    }
}

// function to build max heap
void buildMaxHeap(vector<int>& arr, int n)
{
    // start from the last non-leaf node and heapify each node
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
}

// function to print the heap in the rotated form
void printRotatedHeap(vector<int>& arr, int n)
{
    int height = log2(n) + 1; // height of the heap
    int index = 0; // current index in the heap
    int spaces = pow(2, height - 1) - 1; // number of spaces before the first element of the current level

    // print each level of the heap in the rotated form
    for (int i = 0; i < height; i++) 
    {
        // print the spaces before the first element of the current level
        for (int j = 0; j < spaces; j++)
            cout << " ";

        // print the elements of the current level
        for (int j = 0; j < pow(2, i) && index < n; j++) 
        {
            cout << arr[index++] << " ";
            // print the spaces between elements of the current level
            for (int k = 0; k < 2 * spaces + 1; k++)
                cout << " ";
        }

        // move to the next line and adjust the number of spaces for the next level
        cout << endl;
        spaces /= 2;
    }
}

int main() 
{
    int n;
    cout << "Enter the number of elements: ";
    cin >> n;

    vector<int> arr(n);
    cout << "Enter the elements: ";
    for (int i = 0; i < n; i++)
        cin >> arr[i];

    // build max heap
    buildMaxHeap(arr, n);

    // print the heap in the rotated form
    cout << "Max heap in the rotated form:\n";
    printRotatedHeap(arr, n);

    return 0;
}

In this program, we first define a `swap` function to swap two integers, and a `heapify` function to heapify the sub-tree rooted at a given index `i` in the given vector `arr`. We then define a `buildMaxHeap` function to build the max heap from the given vector `arr`. Finally, we define a `printRotatedHeap` function to print the max heap in the rotated form.

In the `main` function, we first read the number of elements and the elements themselves from the user using `cin`. We then build the max heap using `buildMaxHeap` function, and print the heap in the rotated form using `printRotatedHeap` function.

The `printRotatedHeap` function uses the height of the heap to determine the number of levels, and the number of spaces before the first element of each level. It then prints each level of the heap in the rotated form, by printing the elements of the level followed by the spaces between elements.