Doubt in another approach

#1

Can you explain this approach?I can’t understand exactly how this works.

int bitonic(int *A, int n)
{
// if A is empty
if (n == 0)
return 0;

// initializing max_len 
int maxLen=1; 
      
int start=0; 
int nextStart=0; 
      
int j =0; 
while (j < n-1) 
{  
    // look for end of ascent        
    while (j<n-1 && A[j]<=A[j+1]) 
        j++; 
          
    // look for end of descent        
    while (j<n-1 && A[j]>=A[j+1]){ 
              
        // adjusting nextStart; 
        // this will be necessarily executed at least once, 
        // when we detect the start of the descent 
        if (j<n-1 && A[j]>A[j+1]) 
            nextStart=j+1; 
              
        j++; 
    } 
          
    // updating maxLen, if required 
    maxLen = max(maxLen,j-(start-1)); 
          
    start=nextStart; 
} 
      
return maxLen;

}

#2

@priyeshant1104 Hey in this first we are calculating incrementing j till we are encountering increasing sequence of equal value, now as soon as we encounter a decreasing value we intialize our nextstart, and keep updating it at positions where we are getting the situation that two numbers are strictly decreasing.
Now why we are doing this is because, if numbers are not decreasing we can count them in the next sequence also,
Eg
1 2 3 4 5 5 5 4 46
In this example, as you can see nextStart will be first 4, then it will be 7
Now we will calculate the next sequence length starting from 7 index it would be (4 4 6)
After this we are just seeing if current length is more than previous length.
If this resolves your doubt mark it as resolved.

#3

In the example you provided

#4

In the example you provided nextstart =0 initially,but it will change to 7 ? How it will become 4 ?

#5

yes you are right, j starts at zero after the first while loop it will become 6
then it comes in the second while loop nexstart becomes 7 then j becomes 7 and this while loop ends

#6

@priyeshant1104 increasing loop will end at 3, now the next while loop will run and j will be 3 at this point, now A[j]>A[j+1] will be true as A[3]=3, A[4]=4 so now the nextStart =j+1 (j==3)
I would suggest to do a dry run yourself then only you would get it properly.
If this resolves your doubt mark it as resolved.