#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define ERROR -1
#define OK 0
#define CORRECT_SCAN 1
#define QUANTITY_OF_MU2 3
#define MIN_SIZE_OF_N 1
#define MIN_SIZE_OF_P 0

void task_one(double *array, double **array_end, double mu)
{
    double *ptr = array;
    int flag = 0;
    double temp;
    while (ptr < *array_end)
    {
        if (fabs(*ptr) < fabs(mu))
        {
            flag = 1;
            /*printf("task done %lf %lf \n ", *ptr, mu);*/
            double *swap_ptr = ptr;
            while (swap_ptr < *array_end)
            {
                temp = *(swap_ptr + 1);
                *(swap_ptr + 1) = *swap_ptr;
                *swap_ptr = temp;
                swap_ptr++;
            }
            --(*array_end);
        }
        if (flag == 0)
        {
            ptr++;
        }
        else
        { flag = 0; }
    }
}

void task_two(double *array, double *array_end, double mu_2, int p)
{
    double *ptr = (array_end - QUANTITY_OF_MU2);
    *(array_end - 1) = mu_2;
    double temp;
    double temp_2;
    double old_ptr;
    while (ptr > array)
    {
        *ptr = *(ptr - 1);
        ptr--;
    }
    *(array) = mu_2;
    ptr = array;
    int position = 0;
    while (ptr < array_end)
    {
        if (position == p)
        {
            old_ptr = *ptr;
            *ptr = mu_2;
            temp = *(ptr + 1);
            *(ptr + 1) = old_ptr;
            ptr++;
            while (ptr < (array_end - 2))
            {
                temp_2 = *(ptr + 1);
                *(ptr + 1) = temp;
                temp = temp_2;
                ptr++;
            }
            break;
        }
        ptr++;
        position++;
    }
}

double average_cubic_modules(double *array, double *array_end)
{
    double mu = 0;
    int length = array_end - array;
    for (double *ptr = array; ptr < array_end - 1; ptr++)
    {
        mu += pow(fabs(*ptr), 3) / length;
        /*printf("mu = %lf \n", mu);*/
    }
    mu = cbrt(mu);
    return mu;
}

double min_element_of_array(double *array, double *array_end)
{
    double mu_2 = *array;
    for (double *ptr = array; ptr < array_end; ptr++)
    {
        if (*ptr < mu_2)
        {
            mu_2 = *ptr;
        }
    }
    return mu_2;
}

int input_array(double *array, double *array_end)
{
    printf("Please input array elements:");
    if (array)
    {
        for (double *ptr = array; ptr < array_end; ptr++)
        {
            if (scanf("%lf", ptr) != CORRECT_SCAN)
            {
                return ERROR;
            }
        }
    }
    else
    {
        return ERROR;
    }
    return OK;
}

int main()
{
    printf("Please input n:");
    int n;
    if ((scanf("%d", &n) != CORRECT_SCAN) || ((n < MIN_SIZE_OF_N)))
    {
        return ERROR;
    }

    double *array = malloc(n * sizeof(double));
    if (array == NULL)
    {
        free(array);
        return ERROR;
    }
    double *array_end = array + n;
    if (input_array(array, array_end) == ERROR)
    {
        free(array);
        return ERROR;
    }

    double mu = average_cubic_modules(array, array_end);
    /*printf("mu = %lf \n", mu);*/
    task_one(array, &array_end, mu);
    printf("\n");
    /*for (double *ptr = array; ptr < array_end; ptr++)
    {
        printf("%lf ", *ptr);
    }*/

    double mu_2 = min_element_of_array(array, array_end);
    /*printf("\n");
    printf("mu2 = %lf \n", mu_2);*/

    printf("Please input p:");
    int p;
    if ((scanf("%d", &p) != CORRECT_SCAN) || (p < MIN_SIZE_OF_P) || ((array_end - array) < (p + 1)))
    {
        free(array);
        return ERROR;
    }
    int length = array_end - array + QUANTITY_OF_MU2;
    if (array != NULL)
    {
        double *array_new = realloc(array, length * sizeof(double));
        if (array_new != NULL)
        {
            array = array_new;
            array_new = NULL;
        }
    }
    array_end = array + length;
    task_two(array, array_end, mu_2, p);
    for (double *ptr = array; ptr < array_end; ptr++)
    {
        printf("%lf ", *ptr);
    }
    free(array);
    return OK;
}