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

Thanks, can you add the expected output as well? – walnut Nov 16 '19 at 18:42 — walnut, Nov 16 '19 at 18:42

ggorlen · Answer 1 · 2019-11-16T19:13:26.850

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];
        }
    }
}

Your indexes are off by one. The actual output when compiled will result in first line being 0, and each following line having a trailing 0. — Lev M., Nov 16 '19 at 18:53
The OP has hardcoded the first line to be at index 0, 0 of the array, but you removed his edge case. In your code, when n == 1 the result will be placed at index 1, 0 of the array. But OP original loop in `main` prints from 0, 0 — Lev M., Nov 16 '19 at 19:01
I see what you mean--I changed the loop in `main` inadvertently which adjusted the print incorrectly and forgot I'd done so. Will update momentarily and thanks for pointing this out. — ggorlen, Nov 16 '19 at 19:03

Why is this Pascal Triangle implementation giving me trailing zeroes?

1 Answers1