Counting bounded slice codility

Question

I have recently attended a programming test in codility, and the question is to find the Number of bounded slice in an array..

I am just giving you breif explanation of

Answer 1

Finally a code that works according to the below mentioned idea. This outputs 9. (The code is in C++. You can change it for Java)

#include 

using namespace std;

int main()
{
    int A[] = {3,5,6,7,3};
    int K = 2;

    int i = 0;
    int j = 0;
    int minValue = A[0];
    int maxValue = A[0];
    int minIndex = 0;
    int maxIndex = 0;
    int length = sizeof(A)/sizeof(int);
    int count = 0;
    bool stop = false;
    int prevJ = 0;

    while ( (i < length || j < length) && !stop ) {
        if ( maxValue - minValue <= K ) {
            if ( j < length-1 ) {
                j++;
                if ( A[j] > maxValue ) {
                    maxValue = A[j];
                    maxIndex = j;
                }
                if ( A[j] < minValue ) {
                    minValue = A[j];
                    minIndex = j;
                }
            } else {
                count += j - i + 1;
                stop = true;
            }
        } else {
            if ( j > 0 ) {
                int range = j - i;
                int count1 = range * (range + 1) / 2; // Choose 2 from range with repitition.
                int rangeRep = prevJ - i; // We have to subtract already counted ones.
                int count2 = rangeRep * (rangeRep + 1) / 2;
                count += count1 - count2;
                prevJ = j;
            }
            if ( A[j] == minValue ) {

                // first reach the first maxima
                while ( A[i] - minValue <= K )
                    i++;

                // then come down to correct level.
                while ( A[i] - minValue > K )
                    i++;
                maxValue = A[i];
            } else {//if ( A[j] == maxValue ) {
                while ( maxValue - A[i] <= K )
                    i++;
                while ( maxValue - A[i] > K )
                    i++;
                minValue = A[i];
            }
        }
    }
    cout << count << endl;
    return 0;
}

Algorithm (minor tweaking done in code):

Keep two pointers i & j and maintain two values minValue and maxValue..  
1. Initialize i = 0, j = 0, and minValue = maxValue = A[0];   
2. If maxValue - minValue <= K,   
   - Increment count.  
   - Increment j. 
   - if new A[j] > maxValue, maxValue = A[j].  
   - if new A[j] < minValue, minValue = A[j].  
3. If maxValue - minValue > K, this can only happen iif 
   - the new A[j] is either maxValue or minValue. 
   - Hence keep incrementing i untill abs(A[j] - A[i]) <= K. 
   - Then update the minValue and maxValue and proceed accordingly.
4. Goto step 2 if ( i < length-1 || j < length-1 )