Why is this Pascal Triangle implementation giving me trailing zeroes?

Question

I tried to implement it recursively (iteratively seemed less elegant, but please do correct me if I am wrong).But the output seems to be giving me trailing zeroes and the first few rows are unexpected.I have checked the base cases and the recursive cases , but they seem to be all right.The problem is definitely within the function.

#include <iostream>
unsigned long long p[1005][1005];
void pascal(int n)
{
    if (n == 1)
    {
        p[0][0] = 1;
        return;
    }
    else if (n == 2)
    {
        p[0][0] = 1; p[0][1] = 1;
        return;
    }
    p[n][0] = 1;
    p[n][n-1] = 1;
    pascal(n-1);
    for (int i = 1; i < n;++i)
    {
        p[n][i] = p[n-1][i-1] + p[n-1][i];
    }
    return;
}
int main()
{
    int n;
    std::cin >> n;
    pascal(n);
    for (int i = 0 ; i < n ; ++i)
    {
        for (int j = 0 ;j < i+1 ; ++j)
        {
            std::cout << p[i][j] << " ";
        }
        std::cout << "\n";
    }
}

Output: (I enter)15

1
0 0
0 0 0
1 0 0 0
1 1 0 0 0
1 2 1 0 0 0
1 3 3 1 0 0 0
1 4 6 4 1 0 0 0
1 5 10 10 5 1 0 0 0
1 6 15 20 15 6 1 0 0 0
1 7 21 35 35 21 7 1 0 0 0
1 8 28 56 70 56 28 8 1 0 0 0
1 9 36 84 126 126 84 36 9 1 0 0 0
1 10 45 120 210 252 210 120 45 10 1 0 0 0
1 11 55 165 330 462 462 330 165 55 11 1 0 0 0

Answer 1

The base cases n = 1 and n = 2 are too aggressive (1 is never reached for a normal input like 10 because 2 breaks the recursion prematurely, leaving untouched zeroes in the array). These values for n should be covered automatically by the recursive case. Our real base case where we do nothing is when n < 0.

void pascal(int n)
{   
    if (n < 0) return;

    p[n][0] = 1;
    pascal(n - 1);

    for (int i = 1; i <= n; ++i)
    {
        p[n][i] = p[n-1][i-1] + p[n-1][i];
    }
}

Output for n = 15:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1

Having said this, it's poor practice to hard code the size of the array. Consider using vectors and passing parameters to the functions so that they don't mutate global state.

We can also write it iteratively in (to me) a more intuitive way:

void pascal(int n)
{   
    for (int i = 0; i < n; ++i)
    {
        p[i][0] = 1;

        for (int j = 1; j <= i; ++j)
        {
            p[i][j] = p[i-1][j-1] + p[i-1][j];
        }
    }
}