Нужны задачи для решения

/////////////////////////////////////////////////////////////////////////////////////////
//Одномерный массив рендомно заполняется (длина от 20) числами от 0 до 9. На этот массив 
//якобы сверху льется вода и останьте только в "ямах". Найти объем воды.
//Условия - можно использовать:
//- 1 одномерный массив
//- 1 Цикл
//- Неограничено переменных. (в рамках разумного)
/////////////////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
#include <ctime>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   int     VAL_MAX     =   9;
    const   int     ARR_SIZE    =   7;
 
    srand(unsigned(time(0)));
 
    int     arr[ ARR_SIZE ];
 
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl;
 
    for( int  i = 0; i < ARR_SIZE; ++i )
    {
        arr[i] = rand() % VAL_MAX + 1;
    }
 
    for( int  i = 0; i < ARR_SIZE; ++i )
    {
        std::cout   <<  arr[i]
                    <<  '\t';
    }
 
    std::cout   <<  std::endl;
 
    bool    _1_is_active    =   false;
    bool    _2_is_active    =   false;
    bool    _3_is_active    =   false;
 
    bool    _4_is_active    =   false;
    bool    _5_is_active    =   false;
    bool    _6_is_active    =   false;
 
    bool    _7_is_active    =   false;
    bool    _8_is_active    =   false;
    bool    _9_is_active    =   false;
 
    int     _1_counter      =   0;
    int     _2_counter      =   0;
    int     _3_counter      =   0;
 
    int     _4_counter      =   0;
    int     _5_counter      =   0;
    int     _6_counter      =   0;
 
    int     _7_counter      =   0;
    int     _8_counter      =   0;
    int     _9_counter      =   0;
 
    int     water           =   0;
 
    for( int  i = 0; i < ARR_SIZE; ++i )
    {
        switch( arr[i] )
        {
        case    0   :   if( _1_is_active )    { ++_1_counter; }
        case    1   :   if( _2_is_active )    { ++_2_counter; }
        case    2   :   if( _3_is_active )    { ++_3_counter; }
 
        case    3   :   if( _4_is_active )    { ++_4_counter; }
        case    4   :   if( _5_is_active )    { ++_5_counter; }
        case    5   :   if( _6_is_active )    { ++_6_counter; }
 
        case    6   :   if( _7_is_active )    { ++_7_counter; }
        case    7   :   if( _8_is_active )    { ++_8_counter; }
        case    8   :   if( _9_is_active )    { ++_9_counter; }
        default     :   ;
        }//switch
 
        if( i > 0 )
        {
            switch( arr[i] )
            {
            case    9   :   if( _9_is_active    &&  arr[i - 1] < 9 )    { water += _9_counter;  _9_is_active = false; }
            case    8   :   if( _8_is_active    &&  arr[i - 1] < 8 )    { water += _8_counter;  _8_is_active = false; }
            case    7   :   if( _7_is_active    &&  arr[i - 1] < 7 )    { water += _7_counter;  _7_is_active = false; }
 
            case    6   :   if( _6_is_active    &&  arr[i - 1] < 6 )    { water += _6_counter;  _6_is_active = false; }
            case    5   :   if( _5_is_active    &&  arr[i - 1] < 5 )    { water += _5_counter;  _5_is_active = false; }
            case    4   :   if( _4_is_active    &&  arr[i - 1] < 4 )    { water += _4_counter;  _4_is_active = false; }
 
            case    3   :   if( _3_is_active    &&  arr[i - 1] < 3 )    { water += _3_counter;  _3_is_active = false; }
            case    2   :   if( _2_is_active    &&  arr[i - 1] < 2 )    { water += _2_counter;  _2_is_active = false; }
            case    1   :   if( _1_is_active    &&  arr[i - 1] < 1 )    { water += _1_counter;  _1_is_active = false; }
            default     :   ;
            }//switch
        }//if
 
        if( i < ARR_SIZE - 1 )
        {
            switch( arr[i] )
            {
            case    9   :   if( arr[i + 1] < 9 )    { _9_is_active  =   true;   _9_counter  =   0;  }
            case    8   :   if( arr[i + 1] < 8 )    { _8_is_active  =   true;   _8_counter  =   0;  }
            case    7   :   if( arr[i + 1] < 7 )    { _7_is_active  =   true;   _7_counter  =   0;  }
 
            case    6   :   if( arr[i + 1] < 6 )    { _6_is_active  =   true;   _6_counter  =   0;  }
            case    5   :   if( arr[i + 1] < 5 )    { _5_is_active  =   true;   _5_counter  =   0;  }
            case    4   :   if( arr[i + 1] < 4 )    { _4_is_active  =   true;   _4_counter  =   0;  }
 
            case    3   :   if( arr[i + 1] < 3 )    { _3_is_active  =   true;   _3_counter  =   0;  }
            case    2   :   if( arr[i + 1] < 2 )    { _2_is_active  =   true;   _2_counter  =   0;  }
            case    1   :   if( arr[i + 1] < 1 )    { _1_is_active  =   true;   _1_counter  =   0;  }
            default     :   ;
            }//switch
        }//if
    }//for
 
    std::cout   <<  water
                <<  std::endl;
 
    system("pause");
}

int a=0;
while(n)
{
 if(n&1)
   a++;
n/=2;
}

            // 0 1  2 3  4  5  6   7  8 9 10 11 12 13 14 15
int arr[16]={0,1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3,  3,  4};
int a=arr[n&0xF]+arr[(n/16)&0x0F];