[Project Euler] Problem 15 in C

Problem: Project Euler Problem 15

Starting in the top left corner of a 22 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.

How many such routes are there through a 2020 grid?

About the Problem
This is a problem where it asks us to create Pascal's Triangle (Please click on the link for more details) and add them all together to converge at one point.
So, I have created a Pascal's Triangle into one array of integers and added them all up to arrive at my answer.

Solving the Problem
Since I am only looking for the 20th level of the Pascal's Triangle, I could have used binomial theorem to arrive at 20th level of the Pascal's Triangle.
However, I have refrained myself from solving the problem in using binomial theorem because it felt slower to me since I need to calculate factorials of numbers up to 20. If I were to use this method for numbers over 100, I would need a much larger data (more than uint64 datatype probably) for accurately calculating the factorials.
Therefore, I had to choose with conventional way of constructing a Pascal's Triangle: series of additions.

There were two things I kept in mind while coding:
1) Minimal memory
        As a challenge to myself, instead of creating two dimensional array to store all the pascal's triangle values, I have limited myself into using only one array to sequentially go through each level of the triangle. In reality, the cost of writing the complex code outweighs the cost of memory but this is just for fun and practice :)

2) Modularity
        In case, I need to use Pascal's triangle in the future, I have tried to write the code in a clear manner as possible.      

I believe I have achieved these.
Code:

#include <stdio.h>
#include <stdlib.h>


    #define LEVEL 20
    int createPascalTriangle(int *pTriangle, int level);
    int increasePascalTriangleOneLevel(int *pTriangle);

    int main()
    {
        int *pTriangle = (int*)malloc(sizeof(int)*(LEVEL+1));
        int i;

        for (i = 0; i < LEVEL+1; i++)
            pTriangle[i] = 0;

        createPascalTriangle(pTriangle, LEVEL);

        long long int sum = 0;

        for(i = 0; i < LEVEL+1; i++)
            sum += (long long int) pTriangle[i] * pTriangle[i];

        free(pTriangle);
        printf("%lld\n", sum);

        return 0;
    }

    int createPascalTriangle(int *pTriangle, int level){
        if (level <= 0)
            return 0;
        pTriangle[0] = 1;
        pTriangle[1] = 1;
        int i;
        for ( i = 2; i <= level; i++)
            increasePascalTriangleOneLevel(pTriangle);

        return 1;
    }

    int increasePascalTriangleOneLevel(int *pTriangle){
        int i = 1, c;
        int temp[2] = {0};

        temp[0] = pTriangle[0];
        while (pTriangle[i] != 0){
            temp[i % 2] = pTriangle[i];
            pTriangle[i] = temp[i % 2 ? 0 : 1] + pTriangle[i];
            i++;
        }
        pTriangle[i] = 1;

        return 1;
    }

Challenges Faced (Logic behind Code)
The biggest challenge was figuring out a general pattern for adding the numbers using only one array.
So, the function that was hardest for me to write was increasePascalTriangleOneLevel(). The purpose of the function was to take an array of integers and add adjacent elements to place it in its respectable positions of the array. I found this particular hard because I needed to store its original elements without creating another array with the same size.

Naturally, in our mind, we would think
pTriangle[1] = pTriangle[0] + pTriangle[1]
pTriangle[2] = pTriangle[1] + pTriangle[2]
...
pTriangle[n] = pTriangle[n-1] + pTriangle[n+1]

However, this is exactly the problem I was discussing about.
Here is the picture to show the problem

Iteration 0	1	3	3	1	0
Iteration 1	1	4	3	1	0
Iteration 2	1	4	7	1	0
Iteration 3	1	4	7	8	0
Iteration 4	1	4	7	8	1

You can see from iteration 2, due to lack of storing the original elements, it has given us completely wrong answers.

To prevent this from happening again, I needed to find a generalized way of adding for next level of Pascal's Triangle. Here it is:
temp[0] = pTriangle[0];  //exception of pattern at the start
temp[1] = pTriangle[1];
pTriangle[1] = temp[0] + pTriangle[1];
temp[0] = pTriangle[2];
pTriangle[2] = temp[1] + pTriangle[2];
temp[1] = pTriangle[3];
pTriangle[3] = temp[0] + pTriangle[3];
...
temp[n % 2] = pTriangle[n];
pTriangle[n] = temp[opposite value of n % 2] + pTriangle[n];
Note: opposite value of n % 2 means when n % 2 = 0, the result would be 1 or when n % 2 = 1, the result would be 0.

Therefore, putting all this together, I arrived at increasePascalTriangleOneLevel(); function without a problem!

By using this method, creating a 20 level pascal's triangle only resulted in 0.007s!
However, I was reminded that we have yet to add all the elements of the Pascal's Triangle to arrive at a true answer. This was easy.
All we needed to do was square each element and add them all together.

Another problem I came along, I needed to ask on stackoverflow.
I had forgotten initialize the last element of the array 0 so the code traversed outside the array giving me a hard time.
I will probably never make the same mistake again since it bothered the heck out of me all day!

Next Step
N/A

Questions
N/A

__________________________________________________________________
Best Execution Time: 0.007s
Answer:

137846528820