Recursive length of largest ascending consecutive subarray (C++) - c++

Question

I have an assignment in the university to write a recursive function in C++ that finds the length of the longest ascending consecutive sub array of an array or integers. In addition, I have a code skeleton that I must use for my code and the function must not contain loops & more function.
For example, for the array 1,2,4,6,4,21,21,22,0,1,3,5,100,7
The result will be 5 (because 0 to 100 are 5 numbers).
The skeleton is:
#include <stdio.h>
#define MAX_SIZE 1000
int get_max_series(int a[], int size);
int main() {
int i, size_array, array[MAX_SIZE];
scanf("%d", &size_array);
for (i = 0; i < size_array; i++)
scanf("%d", &array[i]);
printf("%d", get_max_series(array, size_array));
return 0;
}
int get_max_series(int a[], int size) {
// My code should be here
}
I've succeeded to write a function that counts the number of ascending pairs, but failed in reseting the counter when the pair is descending. The code is below:
#include <stdio.h>
#define MAX_SIZE 1000
int get_max_series(int a[], int size);
int main() {
int i, size_array, array[MAX_SIZE];
scanf("%d", &size_array);
for (i = 0; i < size_array; i++)
scanf("%d", &array[i]);
printf("%d", get_max_series(array, size_array));
return 0;
}
int get_max_series(int a[], int size) {
if (size == 1)
return 1;
if (a[0] < a[1])
return 1 + get_max_series(&a[1], size - 1);
return get_max_series(&a[1], size - 1);
}
I'll be happy to get some advice how to get my code work for this scenario, or change the code entirely.
Thanks !

Answer 1

If you don't want to use static/global variables, or a helper function, you can use the following reduction for an array of size > 1 (it will be slow, though, since it does two recursive calls):
If a[0]>=a[1] then we cannot have a[0] in the maximal ascending subarray since it violates our notion of ascendancy so we return get_max_series(a+1, size - 1) like you have on your code.
When a[0]<a[1] we have two cases:
If get_max_series(a+1,size-1)==size-1, then the whole subarray a[1],...,a[size-1] is ascending. This implies a[0],a[1],...,a[size-1] is also ascending so we can return 1 + get_max_series(&a[1], size-1) in this case.
HOWEVER if get_max_series(a+1,size-1)!=size-1 that means that the subarray a[1],...,a[size-1] isn't ascending, so the maximal subarray cannot contain both a[1] and a[size-1] (by contiguity it would have to include everything in between, which would make it non-ascending).
Therefore, you return max(1+get_max_series(&a[0], size-1), get_max_series(&a[1], size-1)).
NOTE that here you do two calls to get_max_series, so your computational cost quickly grows(basically the same inefficiencies that appear when you do the naive recursive implementation of the fibonacci function).
The function would be something like
int get_max_series(int a[], int size) {
if (size <= 1)
return size;
int max_sub = get_max_series(&a[1], size - 1);
if (a[0] >= a[1])
return max_sub;
else{
if (max_sub==(size-1))
return size;
else
return std::max(get_max_series(&a[0], size-1), max_sub);
}
}
I'm using std::max here, but if you don't want to use the algorithm library you can find the maximum of two numbers using if-else.

Answer 2

Here's an O(n) routine that seems to follow your rules (the variable names should help explain what's going on):
#include <stdio.h>
#define MAX_SIZE 1000
int get_max_series(int a[], int size);
int main() {
int i, size_array, array[MAX_SIZE];
scanf("%d", &size_array);
for (i = 0; i < size_array; i++)
scanf("%d", &array[i]);
printf("%d", get_max_series(array, size_array));
return 0;
}
int get_max_series(int a[], int size) {
int i = size - 1;
if (i < 2){
if (a[1] > a[0])
return a[0] = 2;
else
return a[0] = 1;
}
int max = get_max_series(a, i);
int max_up_to_i = a[i - 2];
if (a[i] > a[i - 1]){
a[i - 1] = 1 + max_up_to_i;
if (a[i - 1] > max)
max = a[i - 1];
} else {
a[i - 1] = 1;
}
return max;
}

Answer 3

The longest ascending subarray does not necessarily start at the beginning of the array. Therefore,
return 1 + get_max_series(&a[1], size - 1);
is incorrect. I don't see how you can salvage the approach relying on inspecting just one character, at least within a given signature. Consider finding the longest ascending sequence at the beginning of the array, then recursing into the rest, along the lines of:
int get_max_series(int a[], int size)
{
int n = get_longest_acsending_prefix(a, size);
if (n == size)
return n;
return max(n, get_longest_ascending_prefix(a + n, size - n));
}
That said, I don't see a point of recursion here.