Оставить без изменения последовательность, если она упорядочена

int arr[100];

std::vector<int> arr;

bool issorted = arr.is_sorted(arr.begin(), arr.end());

if (issorted)
    // делать что-то
else
    // делать что-то иное

for (size_t i = 0; i < arr.size(); ++i)
{
    if (!((i+1)%4))
    {
         arr.erase(arr.begin() + i);
    }
}
arr.shrink_to_fit();

#include "stdafx.h"
#include <iostream>
using namespace std;
int main()
{
    int arr[100];
    int b;
    cout << "N= ";
    cin >> N;
    for (size_t i = 0; i < arr.size(); ++i)
    {
        if (!((i + 1) % 4))
        {
            arr.erase(arr.begin() + i);
        }
    }
    arr.shrink_to_fit();
    system("pause");
    return 0;
}

#include <iostream>     // для ввода-вывода
#include <ctime>        // для функции time()
#include <cstdlib>      // для функции srand() и rand()
#include <windows.h>    // для функции Sleep()
#include <algorithm>    // для функции сортировки std::sort()
 
// с помощью ключевого слова typedef зададим псевдоним для типа int:
typedef int Item;   // теперь Item то же самое, что и int
 
// то же самое для типа указатель на int:
typedef Item * Iter; // теперь Iter - то же самое, что и int*
 
// глобальная константа используется в функции show_sequence():
const int STEP = 10;
 
// прототипы для наших самодельных функций (прототипы нужны для
// компилятора, чтобы он знал тип возвращаемого из функции значения
// и  тип и количество аргументов, передаваемых в функцию):
void fill_range_rand(Iter beg, Iter end, Item fromNum, Item toNum);
void show_sequence(Iter beg, Iter end);
 
// главная функция:
int main()
{
    std::cout << "Please enter the size of the array: ";
    int arrSize;
    std::cin >> arrSize;
    
    // динамически выделяем память под наш массив
    int * arr = new int[arrSize];
    
    // заполняем наш массив псевдослучайными числами от 10 до 99:
    fill_range_rand(arr, arr + arrSize, 10, 99);
    
    // создаём переменную булева типа - она у нас будет показывать
    // сортирован массив или нет (библиотечная функция is_sorted
    // прекрасно решит эту задачу за нас):
    bool issorted = std::is_sorted(arr, arr + arrSize);
    
    // отобразим массив на экране с помощью самодельной функции
    // show_sequence() - в качестве аргументов передаём в функцию
    // указатели на первый элемент массива и элемент следующий за
    // последним элементом (в духе STL):
    show_sequence(arr, arr + arrSize);
    
    // если массив сортирован, выведем на экран сообщение об этом
    if (issorted)
        std::cout << "\nThe array is sorted.\n";
    
    // а если нет, сообщим, что нет:
    else
        std::cout << "\nThe array is not sorted.\n";
    
    // освобождаем память:
    delete [] arr;
 
    return 0;
}
 
// определение (реализация) функции fill_range_rand():
void fill_range_rand(Iter beg, Iter end, Item fromNum, Item toNum)
{
    Sleep(800); // делаем небольшую задержку
    srand(time(0));
    for ( ; beg != end; ++beg)
        *beg = fromNum + rand()%(toNum - fromNum);
}
 
// определение (реализация) функции show_sequence():
void show_sequence(Iter beg, Iter end)
{
    char delim;
    for (int i = 1; beg != end; ++beg, ++i)
    {
        if (i%STEP)
            delim = ' ';
        else
            delim = '\n';
        std::cout << *beg << delim;
    }
}

#include "stdafx.h"
#include <iostream>     
#include <ctime>        
#include <cstdlib>      
#include <windows.h>    
#include <algorithm>    
typedef int Item;  
typedef Item * Iter; 
const int STEP = 10;
void fill_range_rand(Iter beg, Iter end, Item fromNum, Item toNum);
void show_sequence(Iter beg, Iter end);
int main()
{
    std::cout << "Please enter the size of the array: ";
    int arrSize;
    int arrSize2;
    std::cin >> arrSize;
int * arr = new int[arrSize];
fill_range_rand(arr, arr + arrSize, 10, 99);
bool issorted = std::is_sorted(arr, arr + arrSize);
show_sequence(arr, arr + arrSize);
int * arr = new int[arrSize];
delete[] arr;
int * arr2 = new int[arrSize2];
public:
    static void Copy(
        arrSize^ sourceArray,
        int sourceIndex,
        Array^ destinationArray,
        int destinationIndex,
        int length
        )
        if (arrSize %10!=4&&issorted)
            std::cout << "\nThe array is sorted.\n";
        else
            std::cout << "\nThe array is not sorted.\n";
system("pause");
    return 0;
}
void fill_range_rand(Iter beg, Iter end, Item fromNum, Item toNum)
{
    Sleep(800); 
    srand(time(0));
    for (; beg != end; ++beg)
        *beg = fromNum + rand() % (toNum - fromNum);
}
void show_sequence(Iter beg, Iter end)
{
    char delim;
    for (int i = 1; beg != end; ++beg, ++i)
    {
        if (i%STEP)
            delim = ' ';
        else
            delim = '\n';
        std::cout << *beg << delim;
    }
}

#include <iostream>
#include <ctime>
#include <cstdlib>
 
using namespace std;
 
/*ФУНЦИЯ ЗАПОЛНЕНИЯ*/
void fill_rand_arr(int *&Arr, const unsigned &Row){
    for (unsigned i=0;i<Row;i++)  Arr[i] = rand()%50-25;
}
 
/*ФУНКЦИЯ ВЫВОДА НА ЭКРАН*/
void print_arr(int *&Arr, const unsigned &Row){
    for (unsigned i=0;i<Row;i++){
           cout << Arr[i] << "  ";
    }
}
 
/*ФУНКЦИЯ ВЫДЕЛЕНИЯ ПАМЯТИ*/
void create_arr(int *&Arr, const unsigned &Row){
    Arr = new int[Row];
}
 
/*ФУНЦИЯ ОЧИСТКИ ПАМЯТИ*/
void destroy_arr(int *&Arr, const unsigned &Row){
    delete []Arr;
    Arr = NULL;
}
 
/*ФУНКЦИЯ ПРОВЕРКИ УПОРЯДОЧЕННОСТИ ОБОИХ ВИДОВ*/
bool is_sorted(int *&Arr, const unsigned &Row){
    bool up, down;
    int i;
 
    for ( i = 0; i<Row-1; i++){
        up = Arr[i] < Arr[i+1];
        if (!up) break;
    }
 
    for ( i = 0 ; i<Row-1; i++){
        down = Arr[i] > Arr[i+1];
        if (!down) break;
    }
    return (up || down);
}
 
/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО МАССИВА*/
void arr_transform(int *&Arr, int &Row){
    int temp1 = Row-1;
    int temp2 = Row;
    Row = (Row - Row/4) - 1; //Считаем число элементов без элементов на позициях кратных 4
 
    int *A = new int[Row];  //Создаем новый массив
    int i=0; //Индекс массива A
 
    cout << "\n";
    while (temp1>=0){
      if (0 != (temp2 - temp1 -1)%4) {  //Проверяем кратность позиции
            A[i++] = Arr[temp2 - temp1 -1]; //Записываем подходящие значения в массив
      }
       temp1--;
    }
    delete []Arr; //Очищаем память от старого
    Arr=A; //Делаем старый массив новым массивом
 
 
}
 
int main(){
    srand(time(NULL));
 
 
for (unsigned z=0;z<3;z++){
     bool f = false;
    while (!f){
    f=false;
    int Row(0);
    int *Arr = NULL;
        Row = rand()%20+3;  //Можно указывать число элементов в массиве.
       
        create_arr(Arr,Row); //Выделение памяти
        fill_rand_arr(Arr,Row); //Заполнение
        print_arr(Arr,Row); //Вывод на жкран
 
        /*Тут задача*/
          f = (is_sorted(Arr,Row)); //Проверяем упорядоченность
          if (!f) { //Если массив не отсортирован, то создавайте новый массив
           arr_transform(Arr,Row);  //Преобразование согласно задаче.
           cout <<"Array transformed: \n";
           print_arr(Arr,Row);
           cout << "\n\n=============\n\n";
          } else {
            cout << "Array is ordered\n";
          }
        /**************/
        destroy_arr(Arr,Row);
    delete []Arr;
 
    }
cout << "Press Enter\n";
cin.get();
}
 
}

#include <iostream>
 
using namespace std;
 
template <class ForwardIterator, class UnaryPredicate>
  ForwardIterator remove_if_ (ForwardIterator first, ForwardIterator last,
                             UnaryPredicate pred)
{
  ForwardIterator result = first;
  while (first!=last) {
    if (!pred(*first)) {
      *result = *first;
      --result;
    }
    --first;
  }
  return result;
}
 
int main()
{
    const int N=20;
    int *Arr= new int[N]{ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 };  //N=20
    //int *Arr= new int[N]{ 1,2,3,4,5,6,7,8,9,10};  //Поменять N, N=10
 
 
 
    for (int i=0;i<N;i++) cout << Arr[i] << "  ";
    cout << "\n";
 
    remove_if_(Arr+N,Arr,[](const int &x){return x%2;});
 
    for (int i=N/2;i<N;i++) cout << Arr[i] << "\n";
 
}