## Pascal's Triangle for Python

pascal unit
pascal language
pascal philosophy
pascal to newton
pascal tangled
pascal medicine
pascal name

As a learning experience for Python, I am trying to code my own version of Pascal's triangle. It took me a few hours (as I am just starting), but I came out with this code:

```pascals_triangle = []

def blank_list_gen(x):
while len(pascals_triangle) < x:
pascals_triangle.append()

def pascals_tri_gen(rows):
blank_list_gen(rows)
for element in range(rows):
count = 1
while count < rows - element:
pascals_triangle[count + element].append(0)
count += 1
for row in pascals_triangle:
row.insert(0, 1)
row.append(1)
pascals_triangle.insert(0, [1, 1])
pascals_triangle.insert(0, )

pascals_tri_gen(6)

for row in pascals_triangle:
print(row)
```

which returns

```
[1, 1]
[1, 0, 1]
[1, 0, 0, 1]
[1, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 1]
```

However, I have no idea where to go from here. I have been banging my head against the wall for hours. I want to emphasize that I do NOT want you to do it for me; just push me in the right direction. As a list, my code returns

```[, [1, 1], [1, 0, 1], [1, 0, 0, 1], [1, 0, 0, 0, 1], [1, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1]]
```

Thanks.

EDIT: I took some good advice, and I completely rewrote my code, but I am now running into another problem. Here is my code.

```import math

pascals_tri_formula = []

def combination(n, r):
return int((math.factorial(n)) / ((math.factorial(r)) * math.factorial(n - r)))

def for_test(x, y):
for y in range(x):
return combination(x, y)

def pascals_triangle(rows):
count = 0
while count <= rows:
for element in range(count + 1):
[pascals_tri_formula.append(combination(count, element))]
count += 1

pascals_triangle(3)

print(pascals_tri_formula)
```

However, I am finding that the output is a bit undesirable:

```[1, 1, 1, 1, 2, 1, 1, 3, 3, 1]
```

How can I fix this?

OK code review:

```import math

# pascals_tri_formula = [] # don't collect in a global variable.

def combination(n, r): # correct calculation of combinations, n choose k
return int((math.factorial(n)) / ((math.factorial(r)) * math.factorial(n - r)))

def for_test(x, y): # don't see where this is being used...
for y in range(x):
return combination(x, y)

def pascals_triangle(rows):
result = [] # need something to collect our results in
# count = 0 # avoidable! better to use a for loop,
# while count <= rows: # can avoid initializing and incrementing
for count in range(rows): # start at 0, up to but not including rows number.
# this is really where you went wrong:
row = [] # need a row element to collect the row in
for element in range(count + 1):
# putting this in a list doesn't do anything.
# [pascals_tri_formula.append(combination(count, element))]
row.append(combination(count, element))
result.append(row)
# count += 1 # avoidable
return result

# now we can print a result:
for row in pascals_triangle(3):
print(row)
```

prints:

```
[1, 1]
[1, 2, 1]
```

##### Explanation of Pascal's triangle:

This is the formula for "n choose k" (i.e. how many different ways (disregarding order), from an ordered list of n items, can we choose k items):

```from math import factorial

def combination(n, k):
"""n choose k, returns int"""
return int((factorial(n)) / ((factorial(k)) * factorial(n - k)))
```

A commenter asked if this is related to itertools.combinations - indeed it is. "n choose k" can be calculated by taking the length of a list of elements from combinations:

```from itertools import combinations

def pascals_triangle_cell(n, k):
"""n choose k, returns int"""
result = len(list(combinations(range(n), k)))
# our result is equal to that returned by the other combination calculation:
assert result == combination(n, k)
return result
```

Let's see this demonstrated:

```from pprint import pprint

ptc = pascals_triangle_cell

>>> pprint([[ptc(0, 0),],
[ptc(1, 0), ptc(1, 1)],
[ptc(2, 0), ptc(2, 1), ptc(2, 2)],
[ptc(3, 0), ptc(3, 1), ptc(3, 2), ptc(3, 3)],
[ptc(4, 0), ptc(4, 1), ptc(4, 2), ptc(4, 3), ptc(4, 4)]],
width = 20)
[,
[1, 1],
[1, 2, 1],
[1, 3, 3, 1],
[1, 4, 6, 4, 1]]
```

We can avoid repeating ourselves with a nested list comprehension:

```def pascals_triangle(rows):
return [[ptc(row, k) for k in range(row + 1)] for row in range(rows)]

>>> pprint(pascals_triangle(15))
[,
[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],
[1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1]]
```
##### Recursively defined:

We can define this recursively (a less efficient, but perhaps more mathematically elegant definition) using the relationships illustrated by the triangle:

``` def choose(n, k): # note no dependencies on any of the prior code
if k in (0, n):
return 1
return choose(n-1, k-1) + choose(n-1, k)
```

And for fun, you can see each row take progressively longer to execute, because each row has to recompute nearly each element from the prior row twice each time:

```for row in range(40):
for k in range(row + 1):
# flush is a Python 3 only argument, you can leave it out,
# but it lets us see each element print as it finishes calculating
print(choose(row, k), end=' ', flush=True)
print()

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
1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1
1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1
1 16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120 16 1
1 17 136 680 2380 6188 12376 19448 24310 24310 19448 12376 6188 2380 680 136 17 1
1 18 153 816 3060 8568 18564 31824 43758 48620 43758 31824 18564 8568 3060 816 ...
```

Ctrl-C to quit when you get tired of watching it, it gets very slow very fast...

Pascal (unit), Pascal, Pascal's or PASCAL may refer to: Contents. 1 People and fictional characters; 2 Places; 3 Science and technology; 4 Other uses; 5 See also. People and  Pascal’s life to the Port-Royal years. Pascal’s father, Étienne Pascal, was presiding judge of the tax court at Clermont-Ferrand.His mother died in 1626, and in 1631 the family moved to Paris. Étienne, who was respected as a mathematician, devoted himself henceforth to the education of his children.

I know you want to implement yourself, but the best way for me to explain is to walk through an implementation. Here's how I would do it, and this implementation relies on my fairly complete knowledge of how Python's functions work, so you probably won't want to use this code yourself, but it may get you pointed in the right direction.

```def pascals_triangle(n_rows):
results = [] # a container to collect the rows
for _ in range(n_rows):
row =  # a starter 1 in the row
if results: # then we're in the second row or beyond
last_row = results[-1] # reference the previous row
# this is the complicated part, it relies on the fact that zip
# stops at the shortest iterable, so for the second row, we have
# nothing in this list comprension, but the third row sums 1 and 1
# and the fourth row sums in pairs. It's a sliding window.
row.extend([sum(pair) for pair in zip(last_row, last_row[1:])])
# finally append the final 1 to the outside
row.append(1)
results.append(row) # add the row to the results.
return results
```

usage:

```>>> for i in pascals_triangle(6):
...     print(i)
...

[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
```

Pascal, Blaise Pascal, French mathematician, physicist, religious philosopher, and author of Pensees and the Provincial Letters. Pascal definition is - a unit of pressure in the meter-kilogram-second system equivalent to one newton per square meter.

Without using zip, but using generator:

```def gen(n,r=[]):
for x in range(n):
l = len(r)
r = [1 if i == 0 or i == l else r[i-1]+r[i] for i in range(l+1)]
yield r
```

example:

```print(list(gen(15)))
```

output:

```[, [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], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1]]
```

DISPLAY AS TRIANGLE

To draw it in beautiful triangle(works only for n < 7, beyond that it gets distroted. ref draw_beautiful for n>7)

for n < 7

```def draw(n):
for p in gen(n):
print(' '.join(map(str,p)).center(n*2)+'\n')
```

eg:

`draw(10`)

output:

```      1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1
```

for any size

since we need to know the max width, we can't make use of generator

```def draw_beautiful(n):
ps = list(gen(n))
max = len(' '.join(map(str,ps[-1])))
for p in ps:
print(' '.join(map(str,p)).center(max)+'\n')
```

example (2) : works for any number:

```draw_beautiful(100)
``` Blaise Pascal (Stanford Encyclopedia of Philosophy), Free Pascal is a 32, 64 and 16 bit professional Pascal compiler. It can target many processor architectures: Intel x86 (including 8086), AMD64/x86-64, PowerPC,  Pascal definition, the standard unit of pressure or stress in the International System of Units(SI), equal to one newton per square meter. Abbreviation: Pa See more.

Blaise Pascal | Biography, Facts, & Inventions, Blaise Pascal was a French mathematician, physicist and religious philosopher who laid the foundation for the modern theory of probabilities. Blaise Pascal was a French mathematician, physicist and religious philosopher who laid the foundation for the modern theory of probabilities.

```# combining the insights from Aaron Hall and Hai Vu,
# we get:

def pastri(n):
rows = []
for _ in range(1, n+1):
rows.append( +
[sum(pair) for pair in zip(rows[-1], rows[-1][1:])] +
)
return rows

# thanks! learnt that "shape shifting" data,
# can yield/generate elegant solutions.
```

Free Pascal, The pascal (pronounced pass-KAL and abbreviated Pa) is the International System of Units (SI) unit of pressure or stress. It is named after the scientist Blaise​  Pascal is Rapunzel's pet chameleon and a major character in Disney's 2010 animated feature film, Tangled. As an infant, a small and defenseless Pascal would remain by his mother's loving side at all times. On a dark and stormy night, the two chameleons were attacked by a venomous snake. Though Pascal's mother was killed while fending off the snake, the sacrifice allowed Pascal time to reach

Blaise Pascal - Education, Pensées & Religion, Blaise's mother died when he was only three years old. In 1632 the Pascal family, Étienne and his four children, left Clermont and settled in Paris. Blaise Pascal's  Atmospheric pressure often gives a sense of the kind of weather to expect; dropping pressure usually implies wind and rain, while rising pressure implies fair skies. This pressure is measured in atm, mm Hg (also called torr), pounds per square inch, bars (psi) and Pascal (Pa) units.

What is pascal (unit of pressure or stress)?, Free Pascal (aka FPK Pascal) is a 32 bit Pascal compiler. The language syntax is semantically compatible with TP 7.0 as well as most versions of Delphi (classes, rtti, exceptions, ansistrings

Pascal | Animal Crossing Wiki, Free Pascal is a 32, 64 and 16 bit professional Pascal compiler. It can target many processor architectures: Intel x86 (including 8086), AMD64/x86-64, PowerPC, PowerPC64, SPARC, ARM, AArch64, MIPS and the JVM.