Дан массив действительных чисел. Удалить все фрагменты массива, которые образуют возрастающую последовательность. - C++ - Ответ 2253227

#include <limits>
#include <cstdlib>
#include <ctime>
 
template<typename T>
T random(T lower = std::numeric_limits<T>::min(), T upper = std::numeric_limits<T>::max())
{
    return static_cast<T>(lower + (upper - lower) * (static_cast<double>(rand()) / RAND_MAX));
}
 
template<typename T>
T *allocate(size_t size)
{
    return new T [size]();
}
 
template<typename T>
void release(T *arr)
{
    delete [] arr;
}
 
template<typename T>
void reallocate(T *&arr, size_t new_size)
{
    T *new_arr = allocate<T>(new_size);
 
    for (size_t i = 0; i < new_size; ++i)
        new_arr[i] = arr[i];
 
    release(arr);
 
    arr = new_arr;
}
 
template<typename T>
T *create_array(size_t size, T lower = std::numeric_limits<T>::min(), T upper = std::numeric_limits<T>::max())
{
    T *arr = allocate<T>(size);
 
    for (size_t i = 0; i < size; ++i)
        arr[i] = random(lower, upper);
    
    return arr;
}
 
template<typename T>
void delete_array(T *arr)
{
    release(arr);
}
 
template<typename T>
void print_array(const T *arr, size_t size)
{
    for (size_t i = 0; i < size; ++i)
        std::cout << arr[i] << "  ";
 
    std::cout << std::endl;
}
 
template<typename T>
bool array_insert(T *&arr, size_t size, size_t pos, const T &value)
{
    if (pos > size)
        return false;
 
    reallocate(arr, size + 1);
 
    for (size_t i = size; i > pos; --i)
        arr[i] = arr[i - 1];
 
    arr[pos] = value;
 
    return true;
}
 
template<typename T>
bool array_insert(T *&arr, size_t size, size_t pos, T *insert_arr, size_t insert_size)
{
    if (pos > size)
        return false;
 
    reallocate(arr, size + insert_size);
 
    for (size_t i = size + insert_size - 1; i > pos + insert_size; --i)
        arr[i] = arr[i - insert_size];
 
    for (size_t i = 0; i < insert_size; ++i)
        arr[i + pos] = insert_arr[i];
 
    return true;
}
 
template<typename T>
void array_push_back(T *&arr, size_t size, const T &value)
{
    array_insert(arr, size, size, value);
}
 
template<typename T>
void array_push_back(T *&arr, size_t size, T *insert_arr, size_t insert_size)
{
    array_insert(arr, size, size, insert_arr, insert_size);
}
 
template<typename T>
bool array_erase(T *&arr, size_t size, size_t pos1, size_t count)
{
    size_t pos2 = count + pos1 - 1;
 
    if (pos1 >= size || pos2 >= size)
        return false;
 
    size_t diff = pos2 - pos1 + 1;
 
    for (size_t i = pos1; i < size - diff; ++i)
        arr[i] = arr[i + diff];
 
    reallocate(arr, size - diff);
 
    return true;
}
 
template<typename T>
bool array_erase(T *&arr, size_t size, size_t pos)
{
    return array_erase(arr, size, pos, 1);
}