Определение возможности сортировки массива удалением одного элемента

///////////////////////////////////////////////////////////////////////////////
//8.
///////////////////////////////////////////////////////////////////////////////
//На входе есть не менее 4 целых чисел, нужно определить, можно ли удалив
//не более одного элемента получить невозрастающий или неубывающий массив.
//Может кто-либо реализовать это, или дать описание наиболее быстрого способа?
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iterator>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < int   >   T_numbers;
///////////////////////////////////////////////////////////////////////////////
T_numbers   make_rand_numbers()
{
    T_numbers   res{ 1, 2, 3, 4 };
 
    std::random_shuffle
        (
            res.begin   (),
            res.end     ()
        );
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
bool    sequence_is_monotone_except_may_be_one_element( T_numbers    const   &   numbers )
{
    bool    bool_res    =   numbers.size()  <=  3;
 
    if( bool_res )
    {
        return  bool_res;
    }
 
    int     diff_prev           {};
    int     diff                {};
 
    int     count_pos           {};
    int     count_neg           {};
    int     count_min           {};
 
    int     pos_pos             {};
    int     pos_neg             {};
 
    int     bad_pos_adj_count   {};
    int     bad_neg_adj_count   {};
 
    for( size_t  i{1}; i < numbers.size(); ++i )
    {
        diff    =   numbers[i]
                -   numbers[i - 1];
 
        if  (
                    i                   ==  pos_pos     +   1
                &&  count_pos           ==  1
                &&  abs( diff_prev )    >   abs( diff )
            )
        {
            ++bad_pos_adj_count;
 
            if( bad_pos_adj_count   ==  2 )
            {
                ++count_pos;
            }
        }//if
 
        if  (
                    i                   ==  pos_neg     +   1
                &&  count_neg           ==  1
                &&  abs( diff_prev )    >   abs( diff )
            )
        {
            ++bad_neg_adj_count;
 
            if( bad_neg_adj_count   ==  2 )
            {
                ++count_neg;
            }
        }//if
 
        if( !diff )
        {
            continue;
        }
 
        if( diff    >   0 )
        {
            if( ++count_pos ==  1 )
            {
                pos_pos     =   i;
 
                if  (
                            i   >   1
 
                        &&      abs( diff       )
                            >   abs( diff_prev  )
                    )
                {
                    ++bad_pos_adj_count;
                }
            }//if
        }
        else
        {
            if( ++count_neg ==  1 )
            {
                pos_neg     =   i;
 
                if  (
                            i   >   1
 
                        &&      abs( diff       )
                            >   abs( diff_prev  )
                    )
                {
                    ++bad_neg_adj_count;
                }
            }//if
        }//else
 
        count_min   =   std::min    (
                                        count_pos,
                                        count_neg
                                    );
 
        bool_res    =       count_min
                        <=  1;
 
        if( !bool_res )
        {
            break;
        }
 
        diff_prev   =   diff;
    }//for
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    srand(unsigned(time(0)));
 
    for(;;)
    {
        auto    numbers     =   make_rand_numbers                               ();
        bool    bool_res    =   sequence_is_monotone_except_may_be_one_element  ( numbers );
 
        if( !bool_res )
        {
            std::copy
                (
                    numbers.begin               (),
                    numbers.end                 (),
                    std::ostream_iterator<int>  ( std::cout,    "\t" )
                );
 
            std::cout   <<  std::boolalpha
                        <<  bool_res
                        <<  std::endl;
 
            system("pause");
        }//if
    }//for
}