Array size changed after sorting

I'm currently working on an assignment which tells me to get the largest count number on a sequence in a array (ex: arr[] = {1,2,3,4,5}, valid sequence is {1,2},{2,3},{5}, or {2,3,4,5}. I've used an algorithm that finds the largest value of an array without sorting it, but, the online judge considers it wrong because it ran for too long (Time Limit Error). So I've changed my code to use a sorting algorithm.

I'm trying to find the largest value in an array by sorting it first, then printing the last value (biggest) of the array, which worked if I input this:

Input:
1 // cases
3 2
2 2 2
Output:
SIZE of Array is: 3
UNSORTED countArr:
0. 1
1. 1
2. 1
(after sorting) SORTED countArr:
0. 1
1. 1
2. 1

However, if I try to have to input multiple "cases" I would get:

Input:
2 // cases
4 11
2 9 1 1
3 2
2 2 2
Output:
SIZE of Array is: 4
UNSORTED countArr:
0. 2
1. 3
2. 2
3. 1
(after sorting) SORTED countArr:
0. 1
1. 2
2. 2
3. 3
SIZE of Array is: 4  //why did the array size become 4, instead of 3
UNSORTED countArr:
0. 1
1. 1
2. 1
3. 3  // and what is this 3 doing here? it should have ended at number 2.
(after sorting) SORTED countArr:
0. 1
1. 1
2. 1
3. 3  // same as above

If anyone could help, could you tell me where I'm wrong? Source code:

#include <stdio.h>

// all function is for quicksort
void swap(int* a, int* b) { 
    int temp = *a; 
    *a = *b; 
    *b = temp; 
} 

int partition (int arr [], int low, int high) { 
    int pivot = arr [high];    
    int i = (low - 1);  
    for (int j = low; j <= high- 1; j++) { 
        if (arr [j] < pivot) { 
            i++;    
            swap (&arr [i], &arr [j]); 
        } 
    } 
    swap (&arr [i + 1], &arr [high]); 
    return (i + 1); 
} 


void quickSort (int arr[], int low, int high) { 
    if (low < high) { 
        int pi = partition (arr, low, high); 
        quickSort (arr, low, pi - 1); 
        quickSort (arr, pi + 1, high); 
    } 
} 

int main () {

    int cases, numofElement;
    int limit, set [5001], sum = 0, count = 0, countArr [100001], size = 0, largest;
    int i, j, k, l, m;

    scanf ("%d", &cases);
    for (i = 0; i < cases; i++) {
        scanf ("%d %d", &numofElement, &limit);
        for (j = 0; j < numofElement; j++) {
            scanf ("%d", &set [j]);
        }
        // so the program knows if the array 'set []' is reaching its last digit
        set [numofElement] = -2;
        for (k = 0; k < numofElement; k++) {
            if (set [k] > limit) {
                // to skip over or (if all sequence is invalid) to print "-1"
                countArr [k] = -1;
                continue;
            }
            for (l = k; l < numofElement; l++) {
                sum += set [l];
                count += 1;
                if ((sum <= limit) && (sum + set [l + 1] > limit || set [l + 1] == -2)) {
                    countArr [k] = count;
                    sum = 0;
                    count = 0;
                    break;
                }
            }
        }
        // count how many number there are in 'countArr []', so we can find its largest value
        size = 0;
        l = 0;
        while (countArr [l] != 0) {
            size += 1;
            l++;
        }
        printf ("SIZE of Array is: %d\n", size);
        printf ("UNSORTED countArr:\n");
        for (j = 0; j < size; j++) {
            printf ("%d. %d\n", j, countArr [j]);
        }
        // sort the 'temp []' array, and output its largest value
        quickSort (countArr, 0, size - 1);
        printf ("(after sorting) SORTED countArr:\n");
        for (j = 0; j < size; j++) {
            printf ("%d. %d\n", j, countArr [j]);
        }
    }

    return 0;
}

Solution

Is a simple error, you don't reset the element of countArr array to 0 at the beginning of the first for cycle. If you fix this your program should work.

After this istruction you need to add the reset to zero :

for (i = 0; i < cases; i++){
... reset to zero countArr
... rest of the programm
}