recursive sub length - the longest series possible of ascending integers - c

Question

I'm trying to write a recursive function that receives an array and it's size and some other variables (of my choice). The function returns the length of the longest series possible of ascending integers in the array. The limitation is not using loops and not calling other functions or using pointers or other libraries.
This is the code I wrote, which unfortunately isn't working and I don't understand why!
length4 = max_set(arr4, size4, 1, 0, 1, 1, 0);
int max_set(int arr[], int size, int max, int index1, int index2, int
currentMax, int i) {
int path1, path2;
if (index1 == size)
return currentMax;
if (index2 == size){
if (currentMax < max)
currentMax = max;
index1 = i + 1;
index2 = index1 + 1;
max = 1;
}
if (arr[index2]> arr[index1]){
path1 = max_set(arr, size, max + 1, index1, index2 + 1, currentMax, i);
path2 = max_set(arr, size, max + 1, index1 + 1, index2 + 1, currentMax, i);
}
path1 = max_set(arr, size, max, index1, index2 + 1, currentMax, i);
path2 = max_set(arr, size, max, index1 + 1, index2 + 1, currentMax,i);
if (path1 > path2)
return path1;
else
return path2;
}
Thank you!

Answer 1

I found the original code more complicated than it needs to be for the task at hand, so rather than try and fix it, I just simplified it:
#include <stdio.h>
#include <stdlib.h>
/*
* Determine maximum ascending sequence length using length so far.
* #arr points to first element of array.
* #size is length of array.
* #pos is position of remaining entries in array.
* #maxval is the maximum value included the sequence so far (if len > 0).
* #len is sequence length so far.
*
* Returns maximum ascending sequence length.
*/
int max_set_recurse(int arr[], int size, int pos, int maxval, int len)
{
int path1, path2, newlen;
if (size <= pos) {
/* Nothing left, so return sequence length so far. */
return len;
}
/* Try skipping the first remaining entry. */
path1 = max_set_recurse(arr, size, pos + 1, maxval, len);
if (len && arr[pos] <= maxval) {
/* First remaining entry is no larger than maximum value. */
/* Try beginning sequence at first remaining entry. */
newlen = 0;
} else {
/* Try extending the sequence with first remaining entry. */
newlen = len + 1;
}
path2 = max_set_recurse(arr, size, pos + 1, arr[pos], newlen);
/* Return the longest ascending sequence length of the two we tried. */
return path2 > path1 ? path2 : path1;
}
/*
* Determine maximum ascending sequence length
* #arr points to entries.
* #size is number of entries.
*
* Returns maximum ascending sequence length.
*/
int max_set(int arr[], int size)
{
return max_set_recurse(arr, size, 0, 0, 0);
}
int main(int argc, char *argv[])
{
int arr[argc - 1];
int i;
for (i = 1; i < argc; i++) {
arr[i - 1] = atoi(argv[i]);
}
printf("Longest ascending sequence length = %d\n", max_set(arr, argc - 1));
return 0;
}
(EDITED to comply with "no pointers" rule as far as possible in C, i.e. no overt use of pointers, given that arrays are passed as pointers, and array indexing is actually pointer arithmetic and pointer dereferencing in disguise!)
The max_set_recurse function is called with the remaining portion of the array to be checked (from pos onwards), the maximum value in the partial maximum ascending sequence so far (if any), and the length of the partial maximum ascending sequence so far (possibly zero).
If the remaining portion of the array is empty (size <= pos), just return the length of the sequence so far.
Otherwise, we can determine two sequence lengths, one that excludes the first remaining entry in the array (arr[pos]), and one that includes it. The function will return the maximum of these two sequence lengths.
For the recursion path that excludes the first remaining entry in the array, the recursion call will skip the first remaining entry and pass through the previous maximum value and sequence length.
For the recursion path that includes the first remaining entry in the array, the recursion call will skip the first remaining entry, use the value of the first remaining entry as the maximum value, and set the sequence length as follows:
if the previous length is zero, or the first remaining entry is greater than the previous maximum value, use the previous sequence length plus one;
otherwise, use a sequence length of zero.
The demo program is called with a sequence of numbers on the command line. It will print the length of the longest ascending sequence that can be found by skipping or including each element.
Here are some example command lines and outputs. I have marked the input numbers that form part of the longest sequence in bold, although the program does not report which numbers are part of the longest ascending sequence:
./ascend 3 23 2 45 0 21 80
Longest ascending sequence length = 4
./ascend 10 3 5 23 2 45 0 21 80
Longest ascending sequence length = 5
./ascend 10 3 5 23 2 45 21 80 20 21 22 23
Longest ascending sequence length = 6