# Leetcode Pascal's Triangle problem solution

In this Leetcode Pascal's Triangle problem solution we have Given an integer numRows, return the first numRows of Pascal's triangle. In Pascal's triangle, each number is the sum of the two numbers directly above it.

## Problem solution in Python.

```def generate(self, numRows):
result=[]
for i in range(numRows):
if(i ==0):
row = [1]
result.append(row)
else:
row1 = [1]
j = 1
while(j < i):
row1.append(row[j-1] + row[j])
j+=1
row1.append(1)
result.append(row1)
row = row1
return result
```

## Problem solution in Java.

```class Solution {
public List<List<Integer>> generate(int numRows) {
List<List<Integer>> res = new ArrayList();
if (numRows < 1) return res;
List<Integer> initial = new ArrayList();
for (int i = 1; i < numRows; i++) {
List<Integer> cur = new ArrayList();
List<Integer> prev = res.get(i - 1);
for (int j = 0; j <= i; j++) {
int tmp = (j > 0 ? prev.get(j - 1) : 0) + (j < i ? prev.get(j) : 0);
}
}
return res;
}
}
```

## Problem solution in C++.

```vector<vector<int>> generate(int numRows) {
vector<vector<int>> result(numRows);
for(int i=0;i<numRows;i++)
{
result[i].resize(i+1);
for(int j=0;j<=i;j++)
{
if(j==0 or j==i)
result[i][j]=1;
else
result[i][j]=result[i-1][j-1]+result[i-1][j];
}
}
return result;
}
```

## Problem solution in C.

```int** generate(int numRows, int* returnSize, int** returnColumnSizes){
*returnSize = numRows;
*returnColumnSizes = (int *) malloc (sizeof(int) * numRows);
for (int i = 0; i < numRows; i++)
(*returnColumnSizes)[i] = i + 1;

int **pascal = (int**)malloc(numRows*sizeof(int*));
for (int i=0; i<numRows; i++){
pascal[i] = (int*)malloc((i+1)*sizeof(int));
pascal[i][0] = 1;
pascal[i][i] = 1;
if (i >1 ){
for (int j=1; j<i; j++){
pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j] ;
}
}
}
return pascal;
}
```