# Pascal's triangle

Pascal's triangle
You are encouraged to solve this task according to the task description, using any language you may know.
Pascal's triangle is an arithmetic and geometric figure first imagined by Blaise Pascal.

Its first few rows look like this:

```   1
1 1
1 2 1
1 3 3 1
```

where each element of each row is either 1 or the sum of the two elements right above it. For example, the next row would be 1 (since the first element of each row doesn't have two elements above it), 4 (1 + 3), 6 (3 + 3), 4 (3 + 1), and 1 (since the last element of each row doesn't have two elements above it). Each row n (starting with row 0 at the top) shows the coefficients of the binomial expansion of (x + y)n.

Write a function that prints out the first n rows of the triangle (with f(1) yielding the row consisting of only the element 1). This can be done either by summing elements from the previous rows or using a binary coefficient or combination function. Behavior for n <= 0 does not need to be uniform, but should be noted.

## 360 Assembly

Translation of: PL/I
`*        Pascal's triangle         25/10/2015PASCAL   CSECT         USING  PASCAL,R15         set base register         LA     R7,1               n=1LOOPN    C      R7,=A(M)           do n=1 to m         BH     ELOOPN             if n>m then goto          MVC    U,=F'1'            u(1)=1         LA     R8,PG              pgi=@pg         LA     R6,1               i=1LOOPI    CR     R6,R7              do i=1 to n         BH     ELOOPI             if i>n then goto          LR     R1,R6              i         SLA    R1,2               i*4         L      R3,T-4(R1)         t(i)         L      R4,T(R1)           t(i+1)         AR     R3,R4              t(i)+t(i+1)         ST     R3,U(R1)           u(i+1)=t(i)+t(i+1)         LR     R1,R6              i         SLA    R1,2               i*4         L      R2,U-4(R1)         u(i)         XDECO  R2,XD              edit u(i)         MVC    0(4,R8),XD+8       output u(i):4         LA     R8,4(R8)           pgi=pgi+4         LA     R6,1(R6)           i=i+1         B      LOOPI              end iELOOPI   MVC    T((M+1)*(L'T)),U   t=u         XPRNT  PG,80              print         LA     R7,1(R7)           n=n+1         B      LOOPN              end nELOOPN   XR     R15,R15            set return code         BR     R14                return to callerM        EQU    11                 <== inputT        DC     (M+1)F'0'          t(m+1) init 0U        DC     (M+1)F'0'          u(m+1) init 0PG       DC     CL80' '            pg     init ' 'XD       DS     CL12               temp         YREGS         END    PASCAL`
Output:
```   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
```

## 8th

One way, using array operations:

` \ print the array : .arr \ a -- a   ( . space ) a:each ; : pasc \ a --  \ print the row  .arr cr  dup   \ create two rows from the first, one with a leading the other with a trailing 0  [0] 0 a:insert swap 0 a:push  \ add the arrays together to make the new one  ' n:+ a:op ; \ print the first 16 rows:[1] ' pasc 16 times `

Another way, using the relation between element 'n' and element 'n-1' in a row:

` : ratio \ m n -- num denom  tuck n:- n:1+ swap ; \ one item in the row: n m: pascitem \ n m -- n	r@ swap 	ratio 	n:*/ n:round int	dup . space ; \ One row of Pascal's triangle: pascline \ n --	>r 1 int dup . space 	' pascitem 	1 r@ loop rdrop drop cr ; \ Calculate the first 'n' rows of Pascal's triangle:: pasc \ n 	' pascline 0 rot loop cr ; 15 pasc `

The specification of auxiliary package "Pascal". "First_Row" outputs a row with a single "1", "Next_Row" computes the next row from a given row, and "Length" gives the number of entries in a row. The package is also used for the Catalan numbers solution [[1]]

`package Pascal is    type Row is array (Natural range <>) of Natural;    function Length(R: Row) return Positive;    function First_Row(Max_Length: Positive) return Row;    function Next_Row(R: Row) return Row; end Pascal;`

The implementation of that auxiliary package "Pascal":

`package body Pascal is    function First_Row(Max_Length: Positive) return Row is      R: Row(0 .. Max_Length) := (0 | 1 => 1, others => 0);   begin      return R;   end First_Row;    function Next_Row(R: Row) return Row is      S: Row(R'Range);   begin      S(0) := Length(R)+1;      S(Length(S)) := 1;      for J in reverse 2 .. Length(R) loop         S(J) := R(J)+R(J-1);      end loop;      S(1) := 1;      return S;   end Next_Row;    function Length(R: Row) return Positive is   begin      return R(0);   end Length; end Pascal;`

The main program, using "Pascal". It prints the desired number of rows. The number is read from the command line.

`with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Command_Line, Pascal; use Pascal; procedure Triangle is    Number_Of_Rows: Positive := Integer'Value(Ada.Command_Line.Argument(1));   Row: Pascal.Row := First_Row(Number_Of_Rows); begin   loop      -- print one row      for J in 1 .. Length(Row) loop	 Ada.Integer_Text_IO.Put(Row(J), 5);      end loop;      Ada.Text_IO.New_Line;      exit when Length(Row) >= Number_Of_Rows;      Row := Next_Row(Row);   end loop;end Triangle;`
Output:
```>./triangle 12
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```

## ALGOL 68

`PRIO MINLWB = 8, MAXUPB = 8;OP MINLWB = ([]INT a,b)INT: (LWB a<LWB b|LWB a|LWB b),   MAXUPB = ([]INT a,b)INT: (UPB a>UPB b|UPB a|UPB b); OP + = ([]INT a,b)[]INT:(  [a MINLWB b:a MAXUPB b]INT out; FOR i FROM LWB out TO UPB out DO out[i]:= 0 OD;  out[LWB a:UPB a] := a; FOR i FROM LWB b TO UPB b DO out[i]+:= b[i] OD;  out); INT width = 4, stop = 9;FORMAT centre = \$n((stop-UPB row+1)*width OVER 2)(q)\$; FLEX[1]INT row := 1; # example of rowing #FOR i WHILE  printf((centre, \$g(-width)\$, row, \$l\$));# WHILE # i < stop DO  row := row[AT 1] + row[AT 2]OD`
Output:
```                     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
```

## APL

Pascal' s triangle of order ⍵

` {A←0,⍳⍵ ⋄ ⍉A∘.!A} `

example

` {A←0,⍳⍵ ⋄ ⍉A∘.!A} 3 `
```1 0 0 0
1 1 0 0
1 2 1 0
1 3 3 1
```

## AutoHotkey

ahk forum: discussion

`n := 8, p0 := "1"        ; 1+n rows of Pascal's triangleLoop %n% {   p := "p" A_Index, %p% := v := 1, q := "p" A_Index-1   Loop Parse, %q%, %A_Space%      If (A_Index > 1)         %p% .= " " v+A_LoopField, v := A_LoopField   %p% .= " 1"}                         ; Triangular Formatted outputVarSetCapacity(tabs,n,Asc("`t"))t .= tabs "`t1"Loop %n% {   t .= "`n" SubStr(tabs,A_Index)   Loop Parse, p%A_Index%, %A_Space%      t .= A_LoopField "`t`t"}Gui Add, Text,, %t%      ; Show result in a GUIGui ShowReturn GuiClose:  ExitApp`
Alternate
Works with: AutoHotkey L
`Msgbox % format(pascalstriangle())Return format(o) ; converts object to string{	For k, v in o		s .= IsObject(v) ? format(v) "`n" : v " "	Return s}pascalstriangle(n=7) ; n rows of Pascal's triangle{	p := Object(), z:=Object()	Loop, % n		Loop, % row := A_Index			col := A_Index			, p[row, col] := row = 1 and col = 1 				? 1 				: (p[row-1, col-1] = "" ; math operations on blanks return blanks; I want to assume zero					? 0 					: p[row-1, col-1])				+ (p[row-1, col] = "" 					? 0 					: p[row-1, col]) 	Return p}`

n <= 0 returns empty

## AWK

`\$ awk 'BEGIN{for(i=0;i<6;i++){c=1;r=c;for(j=0;j<i;j++){c*=(i-j)/(j+1);r=r" "c};print r}}'`
Output:
```
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

```

## BASIC

### Summing from Previous Rows

Works with: FreeBASIC

This implementation uses an array to store one row of the triangle. DIM initializes the array values to zero. For first row, "1" is then stored in the array. To calculate values for next row, the value in cell (i-1) is added to each cell (i). This summing is done from right to left so that it can be done on-place, without using a tmp buffer. Because of symmetry, the values can be displayed from left to right.

Space for max 5 digit numbers is reserved when formatting the display. The maximum size of triangle is 100 rows, but in practice it is limited by screen space. If the user enters value less than 1, the first row is still always displayed.

`DIM i             AS IntegerDIM row           AS IntegerDIM nrows         AS IntegerDIM values(100)   AS Integer INPUT "Number of rows: "; nrowsvalues(1) = 1PRINT TAB((nrows)*3);"  1"FOR row = 2 TO nrows    PRINT TAB((nrows-row)*3+1);    FOR i = row TO 1 STEP -1        values(i) = values(i) + values(i-1)        PRINT USING "##### "; values(i);    NEXT i    PRINTNEXT row`

## Batch File

Based from the Fortran Code.

`@echo offsetlocal enabledelayedexpansion::The Main Thing...clsecho.set row=15call :pascalecho.pauseexit /b 0::/The Main Thing.::The Functions...:pascal	set /a prev=%row%-1	for /l %%I in (0,1,%prev%) do (		set c=1&set r=		for /l %%K in (0,1,%row%) do (			if not !c!==0 (				call :numstr !c!				set r=!r!!space!!c!			)			set /a c=!c!*^(%%I-%%K^)/^(%%K+1^)		)		echo !r!	)goto :EOF :numstr	::This function returns the number of whitespaces to be applied on each numbers.	set cnt=0&set proc=%1&set space=	:loop	set currchar=!proc:~%cnt%,1!	if not "!currchar!"=="" set /a cnt+=1&goto loop	set /a numspaces=5-!cnt!	for /l %%A in (1,1,%numspaces%) do set "space=!space! "goto :EOF::/The Functions.`
Output:
```    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

Press any key to continue . . .```

## BBC BASIC

`      nrows% = 10       colwidth% = 4      @% = colwidth% : REM Set column width      FOR row% = 1 TO nrows%        PRINT SPC(colwidth%*(nrows% - row%)/2);        acc% = 1        FOR element% = 1 TO row%          PRINT acc%;          acc% = acc% * (row% - element%) / element% + 0.5        NEXT        PRINT      NEXT row%`
Output:
```                     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```

## Befunge

`0" :swor fo rebmuN">:#,_&> 55+, vv01*p00-1:g00.:<1p011p00:\-1_v#:<>g:1+10p/48*,:#^_\$ 55+,1+\: ^>\$\$@`
Output:
```Number of rows: 10

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  ```

## Bracmat

`( out\$"Number of rows? "& get':?R& -1:?I&   whl  ' ( 1+!I:<!R:?I    & 1:?C    & -1:?K    & !R+-1*!I:?tabs    & whl'(!tabs+-1:>0:?tabs&put\$\t)    &   whl      ' ( 1+!K:~>!I:?K        & put\$(!C \t\t)        & !C*(!I+-1*!K)*(!K+1)^-1:?C        )    & put\$\n    )&)`
Output:
```Number of rows?
7
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```

## Burlesque

` blsq ) {1}{1 1}{^^2CO{p^?+}m[1+]1[+}15E!#s<-spbx#S11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 11 7 21 35 35 21 7 11 8 28 56 70 56 28 8 11 9 36 84 126 126 84 36 9 11 10 45 120 210 252 210 120 45 10 11 11 55 165 330 462 462 330 165 55 11 11 12 66 220 495 792 924 792 495 220 66 12 11 13 78 286 715 1287 1716 1716 1287 715 286 78 13 11 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 11 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 11 16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120 16 1 `

## C

Translation of: Fortran
`#include <stdio.h> void pascaltriangle(unsigned int n){  unsigned int c, i, j, k;   for(i=0; i < n; i++) {    c = 1;    for(j=1; j <= 2*(n-1-i); j++) printf(" ");    for(k=0; k <= i; k++) {      printf("%3d ", c);      c = c * (i-k)/(k+1);    }    printf("\n");  }} int main(){  pascaltriangle(8);  return 0;}`

### Recursive

`#include <stdio.h> #define D 32int pascals(int *x, int *y, int d){	int i;	for (i = 1; i < d; i++)		printf("%d%c", y[i] = x[i - 1] + x[i],			i < d - 1 ? ' ' : '\n'); 	return D > d ? pascals(y, x, d + 1) : 0;} int main(){	int x[D] = {0, 1, 0}, y[D] = {0};	return pascals(x, y, 0);}`

`void triangleC(int nRows) {    if (nRows <= 0) return;    int *prevRow = NULL;    for (int r = 1; r <= nRows; r++) {        int *currRow = malloc(r * sizeof(int));        for (int i = 0; i < r; i++) {            int val = i==0 || i==r-1 ? 1 : prevRow[i-1] + prevRow[i];            currRow[i] = val;            printf(" %4d", val);        }        printf("\n");        free(prevRow);        prevRow = currRow;    }    free(prevRow);}`

## C++

`#include <iostream>#include <algorithm>#include<cstdio>using namespace std;void Pascal_Triangle(int size) { 	int a[100][100];	int i, j; 	//first row and first coloumn has the same value=1	for (i = 1; i <= size; i++) {		a[i][1] = a[1][i] = 1;	} 	//Generate the full Triangle	for (i = 2; i <= size; i++) {		for (j = 2; j <= size - i; j++) {			if (a[i - 1][j] == 0 || a[i][j - 1] == 0) {				break;			}			a[i][j] = a[i - 1][j] + a[i][j - 1];		}	} 	/* 	  1 1 1 1	  1 2 3	  1 3	  1 	first print as above format--> 	for (i = 1; i < size; i++) {		for (j = 1; j < size; j++) {			if (a[i][j] == 0) {					break;			}				printf("%8d",a[i][j]);		}			cout<<"\n\n";	}*/ 	// standard Pascal Triangle Format  	int row,space;	for (i = 1; i < size; i++) {		space=row=i;		j=1; 		while(space<=size+(size-i)+1){			 cout<<" ";			 space++;		 } 		while(j<=i){			if (a[row][j] == 0){				   break;			   } 			if(j==1){				printf("%d",a[row--][j++]);			}			else				printf("%6d",a[row--][j++]);		}			cout<<"\n\n";	} } int main(){	//freopen("out.txt","w",stdout); 	int size;	cin>>size;	Pascal_Triangle(size);} }`

### C++11 (with dynamic and semi-static vectors)

Constructs the whole triangle in memory before printing it. Uses vector of vectors as a 2D array with variable column size. Theoretically, semi-static version should work a little faster.

`// Compile with -std=c++11#include<iostream>#include<vector>using namespace std;void print_vector(vector<int> dummy){	for (vector<int>::iterator i = dummy.begin(); i != dummy.end(); ++i)		cout<<*i<<" ";	cout<<endl;}void print_vector_of_vectors(vector<vector<int>> dummy){	for (vector<vector<int>>::iterator i = dummy.begin(); i != dummy.end(); ++i)		print_vector(*i);	cout<<endl;}vector<vector<int>> dynamic_triangle(int dummy){	vector<vector<int>> result;	if (dummy > 0){ // if the argument is 0 or negative exit immediately		vector<int> row;		// The first row		row.push_back(1);		result.push_back(row);		// The second row		if (dummy > 1){			row.clear();			row.push_back(1); row.push_back(1);			result.push_back(row);		}		// The other rows		if (dummy > 2){			for (int i = 2; i < dummy; i++){				row.clear();				row.push_back(1);				for (int j = 1; j < i; j++)					row.push_back(result.back().at(j - 1) + result.back().at(j));				row.push_back(1);				result.push_back(row);			}		}	}	return result;}vector<vector<int>> static_triangle(int dummy){	vector<vector<int>> result;	if (dummy > 0){ // if the argument is 0 or negative exit immediately		vector<int> row;		result.resize(dummy); // This should work faster than consecutive push_back()s		// The first row		row.resize(1);		row.at(0) = 1;		result.at(0) = row;		// The second row		if (result.size() > 1){			row.resize(2);			row.at(0) = 1; row.at(1) = 1;			result.at(1) = row;		}		// The other rows		if (result.size() > 2){			for (int i = 2; i < result.size(); i++){				row.resize(i + 1); // This should work faster than consecutive push_back()s				row.front() = 1;				for (int j = 1; j < row.size() - 1; j++)					row.at(j) = result.at(i - 1).at(j - 1) + result.at(i - 1).at(j);				row.back() = 1;				result.at(i) = row;			}		}	}	return result;}int main(){	vector<vector<int>> triangle;	int n;	cout<<endl<<"The Pascal's Triangle"<<endl<<"Enter the number of rows: ";	cin>>n;	// Call the dynamic function	triangle = dynamic_triangle(n);	cout<<endl<<"Calculated using dynamic vectors:"<<endl<<endl;	print_vector_of_vectors(triangle);	// Call the static function	triangle = static_triangle(n);	cout<<endl<<"Calculated using static vectors:"<<endl<<endl;	print_vector_of_vectors(triangle);	return 0;}  `

### C++11 (with a class)

A full fledged example with a class definition and methods to retrieve data, worthy of the title object-oriented.

`// Compile with -std=c++11#include<iostream>#include<vector>using namespace std;class pascal_triangle{	vector<vector<int>> data; // This is the actual data	void print_row(vector<int> dummy){		for (vector<int>::iterator i = dummy.begin(); i != dummy.end(); ++i)			cout<<*i<<" ";		cout<<endl;	}public:	pascal_triangle(int dummy){ // Everything is done on the construction phase		if (dummy > 0){ // if the argument is 0 or negative exit immediately			vector<int> row;			data.resize(dummy); // Theoretically this should work faster than consecutive push_back()s			// The first row			row.resize(1);			row.at(0) = 1;			data.at(0) = row;			// The second row			if (data.size() > 1){				row.resize(2);				row.at(0) = 1; row.at(1) = 1;				data.at(1) = row;			}			// The other rows			if (data.size() > 2){				for (int i = 2; i < data.size(); i++){					row.resize(i + 1); // Theoretically this should work faster than consecutive push_back()s					row.front() = 1;					for (int j = 1; j < row.size() - 1; j++)						row.at(j) = data.at(i - 1).at(j - 1) + data.at(i - 1).at(j);					row.back() = 1;					data.at(i) = row;				}			}		}	}	~pascal_triangle(){		for (vector<vector<int>>::iterator i = data.begin(); i != data.end(); ++i)			i->clear(); // I'm not sure about the necessity of this loop!		data.clear();	}	void print_row(int dummy){		if (dummy < data.size())			for (vector<int>::iterator i = data.at(dummy).begin(); i != data.at(dummy).end(); ++i)				cout<<*i<<" ";		cout<<endl;	}	void print(){		for (int i = 0; i < data.size(); i++)			print_row(i);	}	int get_coeff(int dummy1, int dummy2){		int result = 0;		if ((dummy1 < data.size()) && (dummy2 < data.at(dummy1).size()))				result = data.at(dummy1).at(dummy2);		return result;	}	vector<int> get_row(int dummy){		vector<int> result;		if (dummy < data.size())			result = data.at(dummy);		return result;	}};int main(){	int n;	cout<<endl<<"The Pascal's Triangle with a class!"<<endl<<endl<<"Enter the number of rows: ";	cin>>n;	pascal_triangle myptri(n);	cout<<endl<<"The whole triangle:"<<endl;	myptri.print();	cout<<endl<<"Just one row:"<<endl;	myptri.print_row(n/2);	cout<<endl<<"Just one coefficient:"<<endl;	cout<<myptri.get_coeff(n/2, n/4)<<endl<<endl;	return 0;}  `

## C#

Translation of: Fortran

Produces no output when n is less than or equal to zero.

`using System; namespace RosettaCode {     class PascalsTriangle {         public static void CreateTriangle(int n) {            if (n > 0) {                for (int i = 0; i < n; i++) {                    int c = 1;                    Console.Write(" ".PadLeft(2 * (n - 1 - i)));                    for (int k = 0; k <= i; k++) {                        Console.Write("{0}", c.ToString().PadLeft(3));                        c = c * (i - k) / (k + 1);                    }                    Console.WriteLine();                }            }        }         public static void Main() {            CreateTriangle(8);        }    }}`

## Clojure

For n < 1, prints nothing, always returns nil. Copied from the Common Lisp implementation below, but with local functions and explicit tail-call-optimized recursion (recur).

`(defn pascal [n]  (let [newrow (fn newrow [lst ret]                   (if lst                       (recur (rest lst)                              (conj ret (+ (first lst) (or (second lst) 0))))                       ret))        genrow (fn genrow [n lst]                   (when (< 0 n)                     (do (println lst)                         (recur (dec n) (conj (newrow lst []) 1)))))]    (genrow n [1])))(pascal 4)`

And here's another version, using the partition function to produce the sequence of pairs in a row, which are summed and placed between two ones to produce the next row:

` (defn nextrow [row]  (vec (concat [1] (map #(apply + %) (partition 2 1 row)) [1] ))) (defn pascal [n]  (assert (and (integer? n) (pos? n)))  (let [triangle (take n (iterate nextrow [1]))]    (doseq [row triangle]      (println row)))) `

The assert form causes the pascal function to throw an exception unless the argument is (integral and) positive.

Here's a third version using the iterate function

` (def pascal  (iterate    (fn [prev-row]      (->>        (concat [[(first prev-row)]] (partition 2 1 prev-row) [[(last prev-row)]])        (map (partial apply +) ,,,)))     [1])) `

Another short version which returns an infinite pascal triangle as a list, using the iterate function.

` (def pascal   (iterate #(concat [1]                     (map + % (rest %))                     [1])            [1])) `

One can then get the first n rows using the take function

` (take 10 pascal) ; returns a list of the first 10 pascal rows `

Also, one can retrieve the nth row using the nth function

` (nth pascal 10) ;returns the nth row `

## CoffeeScript

This version assumes n is an integer and n >= 1. It efficiently computes binomial coefficients.

` pascal = (n) ->  width = 6  for r in [1..n]    s = ws (width/2) * (n-r) # center row    output = (n) -> s += pad width, n    cell = 1    output cell    # Compute binomial coefficients as you go    # across the row.    for c in [1...r]      cell *= (r-c) / c      output cell    console.log s ws = (n) ->  s = ''  s += ' ' for i in [0...n]  s pad = (cnt, n) ->  s = n.toString()  # There is probably a better way to do this.  cnt -= s.length  right = Math.floor(cnt / 2)  left = cnt - right  ws(left) + s + ws(right) pascal(7)  `
Output:
```> coffee pascal.coffee
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
```

## Common Lisp

To evaluate, call (pascal n). For n < 1, it simply returns nil.

`(defun pascal (n)   (genrow n '(1))) (defun genrow (n l)   (when (< 0 n)       (print l)       (genrow (1- n) (cons 1 (newrow l))))) (defun newrow (l)   (if (> 2 (length l))      '(1)      (cons (+ (car l) (cadr l)) (newrow (cdr l)))))`

## D

### Less functional Version

`int[][] pascalsTriangle(in int rows) pure nothrow {    auto tri = new int[][rows];    foreach (r; 0 .. rows) {        int v = 1;        foreach (c; 0 .. r+1) {            tri[r] ~= v;            v = (v * (r - c)) / (c + 1);        }    }    return tri;} void main() {    immutable t = pascalsTriangle(10);    assert(t == [[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]]);}`

### More functional Version

`import std.stdio, std.algorithm, std.range; auto pascal() pure nothrow {    return [1].recurrence!q{ zip(a[n - 1] ~ 0, 0 ~ a[n - 1])                             .map!q{ a[0] + a[1] }                             .array };} void main() {    pascal.take(5).writeln;}`
Output:
`[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]`

### Alternative Version

There is similarity between Pascal's triangle and Sierpinski triangle. Their difference are the initial line and the operation that act on the line element to produce next line. The following is a generic pascal's triangle implementation for positive number of lines output (n).

`import std.stdio, std.string, std.array, std.format; string Pascal(alias dg, T, T initValue)(int n) {    string output;     void append(in T[] l) {        output ~= " ".replicate((n - l.length + 1) * 2);        foreach (e; l)            output ~= format("%4s", format("%4s", e));        output ~= "\n";    }     if (n > 0) {        T[][] lines = [[initValue]];        append(lines[0]);        foreach (i; 1 .. n) {            lines ~= lines[i - 1] ~ initValue; // length + 1            foreach (int j; 1 .. lines[i-1].length)                lines[i][j] = dg(lines[i-1][j], lines[i-1][j-1]);            append(lines[i]);        }    }    return output;} string delegate(int n) genericPascal(alias dg, T, T initValue)() {    mixin Pascal!(dg, T, initValue);    return &Pascal;} void main() {    auto pascal = genericPascal!((int a, int b) => a + b, int, 1)();    static char xor(char a, char b) { return a == b ? '_' : '*'; }    auto sierpinski = genericPascal!(xor, char, '*')();     foreach (i; [1, 5, 9])        writef(pascal(i));    // an order 4 sierpinski triangle is a 2^4 lines generic    // Pascal triangle with xor operation    foreach (i; [16])        writef(sierpinski(i));}`
Output:
```     1
1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
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
*
*   *
*   _   *
*   *   *   *
*   _   _   _   *
*   *   _   _   *   *
*   _   *   _   *   _   *
*   *   *   *   *   *   *   *
*   _   _   _   _   _   _   _   *
*   *   _   _   _   _   _   _   *   *
*   _   *   _   _   _   _   _   *   _   *
*   *   *   *   _   _   _   _   *   *   *   *
*   _   _   _   *   _   _   _   *   _   _   _   *
*   *   _   _   *   *   _   _   *   *   _   _   *   *
*   _   *   _   *   _   *   _   *   _   *   _   *   _   *
*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *```

## Delphi

`program PascalsTriangle; procedure Pascal(r:Integer);var  i, c, k:Integer;begin  for i := 0 to r - 1 do  begin    c := 1;    for k := 0 to i do    begin      Write(c:3);      c := c * (i - k) div (k + 1);    end;    Writeln;  end;end; begin  Pascal(9);end.`

## DWScript

Doesn't print anything for negative or null values.

`procedure Pascal(r : Integer);var   i, c, k : Integer;begin   for i:=0 to r-1 do begin      c:=1;      for k:=0 to i do begin         Print(Format('%4d', [c]));         c:=(c*(i-k)) div (k+1);      end;      PrintLn('');   end;end; Pascal(9);`
Output:
```   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```

## E

So as not to bother with text layout, this implementation generates a HTML fragment. It uses a single mutable array, appending one 1 and adding to each value the preceding value.

`def pascalsTriangle(n, out) {    def row := [].diverge(int)    out.print("<table style='text-align: center; border: 0; border-collapse: collapse;'>")    for y in 1..n {        out.print("<tr>")        row.push(1)        def skip := n - y        if (skip > 0) {            out.print(`<td colspan="\$skip"></td>`)        }        for x => v in row {            out.print(`<td>\$v</td><td></td>`)        }        for i in (1..!y).descending() {            row[i] += row[i - 1]        }        out.println("</tr>")    }    out.print("</table>")}`
`def out := <file:triangle.html>.textWriter()try {    pascalsTriangle(15, out)} finally {    out.close()}makeCommand("yourFavoriteWebBrowser")("triangle.html")`

## Eiffel

` note	description    : "Prints pascal's triangle"	output         : "[    			   Per requirements of the RosettaCode example, execution will print the first n rows of pascal's triangle    			  ]"	date           : "19 December 2013"	authors        : "Sandro Meier", "Roman Brunner"	revision       : "1.0"	libraries      : "Relies on HASH_TABLE from EIFFEL_BASE library"	implementation : "[			   Recursive implementation to calculate the n'th row.			 ]"	warning        : "[				Will not work for large n's (INTEGER_32)		         ]" class	APPLICATION inherit	ARGUMENTS create	make feature {NONE} -- Initialization 	make		local			n:INTEGER		do			create {HASH_TABLE[ARRAY[INTEGER],INTEGER]}pascal_lines.make (n) --create the hash_table object			io.new_line			n:=25			draw(n)		endfeature	line(n:INTEGER):ARRAY[INTEGER]		--Calculates the n'th line	local		upper_line:ARRAY[INTEGER]		i:INTEGER	do		if	n=1 then	--trivial case first line			create Result.make_filled (0, 1, n+2)			Result.put (0, 1)			Result.put (1, 2)			Result.put (0, 3)		elseif pascal_lines.has (n) then	--checks if the result was already calculated			Result := pascal_lines.at (n)		else	--calculates the n'th line recursively			create Result.make_filled(0,1,n+2) --for caluclation purposes add a 0 at the beginning of each line			Result.put (0, 1)			upper_line:=line(n-1)			from				i:=1			until				i>upper_line.count-1			loop				Result.put(upper_line[i]+upper_line[i+1],i+1)				i:=i+1			end			Result.put (0, n+2)	--for caluclation purposes add a 0 at the end of each line			pascal_lines.put (Result, n)		end	end 	draw(n:INTEGER)		--draw n lines of pascal's triangle	local		space_string:STRING		width, i:INTEGER 	do		space_string:=" "		--question of design: add space_string at the beginning of each line		width:=line(n).count		space_string.multiply (width)		from			i:=1		until			i>n		loop			space_string.remove_tail (1)			io.put_string (space_string)			across line(i) as c			loop				if					c.item/=0				then					io.put_string (c.item.out+" ")				end			end			io.new_line			i:=i+1		end	end feature --Access	pascal_lines:HASH_TABLE[ARRAY[INTEGER],INTEGER]		--Contains all already calculated linesend `

## Elixir

`defmodule Pascal do  def triangle(n), do: triangle(n,[1])   def triangle(0,list), do: list  def triangle(n,list) do    IO.inspect list    new_list = Enum.zip([0]++list, list++[0]) |> Enum.map(fn {a,b} -> a+b end)    triangle(n-1,new_list)  endend Pascal.triangle(8)`
Output:
```[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]
```

## Erlang

` -import(lists).-export([pascal/1]). pascal(1)-> [[1]];pascal(N) ->    L = pascal(N-1),    [H|_] = L,    [lists:zipwith(fun(X,Y)->X+Y end,[0]++H,H++[0])|L]. `
Output:
```  Eshell V5.5.5  (abort with ^G)
1> pascal:pascal(5).
[[1,4,6,4,1],[1,3,3,1],[1,2,1],[1,1],[1]]
```

## ERRE

` PROGRAM PASCAL_TRIANGLE PROCEDURE PASCAL(R%)  LOCAL I%,C%,K%    FOR I%=0 TO R%-1 DO      C%=1      FOR K%=0 TO I% DO        WRITE("###";C%;)        C%=(C%*(I%-K%)) DIV (K%+1)      END FOR      PRINT   END FOREND PROCEDURE BEGIN  PASCAL(9)END PROGRAM `

Output:

```  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
```

## Euphoria

### Summing from Previous Rows

`sequence rowrow = {}for m = 1 to 10 do    row = row & 1    for n = length(row)-1 to 2 by -1 do        row[n] += row[n-1]    end for    print(1,row)    puts(1,'\n')end for`
Output:
``` {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}
```

## F#

`let rec nextrow l =    match l with    | []      -> []    | h :: [] -> [1]    | h :: t  -> h + t.Head :: nextrow t let pascalTri n = List.scan(fun l i -> 1 :: nextrow l) [1] [1 .. n] for row in pascalTri(10) do    for i in row do        printf "%s" (i.ToString() + ", ")    printfn "%s" "\n" `

## Factor

This implementation works by summing the previous line content. Result for n < 1 is the same as for n == 1.

`USING: grouping kernel math sequences ; : (pascal) ( seq -- newseq )    dup last 0 prefix 0 suffix 2 <clumps> [ sum ] map suffix ; : pascal ( n -- seq )    1 - { { 1 } } swap [ (pascal) ] times ;`

It works as:

`5 pascal .{ { 1 } { 1 1 } { 1 2 1 } { 1 3 3 1 } { 1 4 6 4 1 } }`

## Fantom

` class Main{  Int[] next_row (Int[] row)  {    new_row := [1]    (row.size-1).times |i|    {      new_row.add (row[i] + row[i+1])    }    new_row.add (1)     return new_row  }   Void print_pascal (Int n)  // no output for n <= 0  {    current_row := [1]    n.times     {      echo (current_row.join(" "))      current_row = next_row (current_row)    }  }   Void main ()  {    print_pascal (10)  }} `

## Forth

`: init ( n -- )  here swap cells erase  1 here ! ;: .line ( n -- )  cr here swap 0 do dup @ . cell+ loop drop ;: next ( n -- )  here swap 1- cells here + do    i @ i cell+ +!  -1 cells +loop ;: pascal ( n -- )      dup init   1  .line  1 ?do i next i 1+ .line loop ;`

This is a bit more efficient.

Translation of: C
`: PascTriangle  cr dup 0  ?do     1 over 1- i - 2* spaces i 1+ 0 ?do dup 4 .r j i - * i 1+ / loop cr drop  loop drop; 13 PascTriangle`

## Fortran

Works with: Fortran version 90 and later

Prints nothing for n<=0. Output formatting breaks down for n>20

`PROGRAM Pascals_Triangle   CALL Print_Triangle(8) END PROGRAM Pascals_Triangle SUBROUTINE Print_Triangle(n)   IMPLICIT NONE  INTEGER, INTENT(IN) :: n  INTEGER :: c, i, j, k, spaces   DO i = 0, n-1     c = 1     spaces = 3 * (n - 1 - i)     DO j = 1, spaces        WRITE(*,"(A)", ADVANCE="NO") " "     END DO     DO k = 0, i        WRITE(*,"(I6)", ADVANCE="NO") c        c = c * (i - k) / (k + 1)     END DO     WRITE(*,*)  END DO END SUBROUTINE Print_Triangle`

## FunL

###  Summing from Previous Rows

Translation of: Scala
`import lists.zip def  pascal( 1 ) = [1]  pascal( n ) = [1] + map( (a, b) -> a + b, zip(pascal(n-1), pascal(n-1).tail()) ) + [1]`

###  Combinations

`import integers.choose def pascal( n ) = [choose( n - 1, k ) | k <- 0..n-1]`

###  Pascal's Triangle

`def triangle( height ) =  width = max( map(a -> a.toString().length(), pascal(height)) )   if 2|width    width++   for n <- 1..height    print( ' '*((width + 1)\2)*(height - n) )    println( map(a -> format('%' + width + 'd ', a), pascal(n)).mkString() ) triangle( 10 )`
Output:
```                    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
```

## GAP

`Pascal := function(n)	local i, v;	v := [1];	for i in [1 .. n] do		Display(v);		v := Concatenation([0], v) + Concatenation(v, [0]);	od;end; Pascal(9);  # [ 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 ]`

## Go

No output for n < 1. Otherwise, output formatted left justified.

` package main import "fmt" func printTriangle(n int) {    // degenerate cases    if n <= 0 {        return    }    fmt.Println(1)    if n == 1 {        return    }    // iterate over rows, zero based    a := make([]int, (n+1)/2)    a[0] = 1    for row, middle := 1, 0; row < n; row++ {        // generate new row        even := row&1 == 0        if even {            a[middle+1] = a[middle] * 2        }        for i := middle; i > 0; i-- {            a[i] += a[i-1]        }        // print row        for i := 0; i <= middle; i++ {            fmt.Print(a[i], " ")        }        if even {            middle++        }        for i := middle; i >= 0; i-- {            fmt.Print(a[i], " ")        }        fmt.Println("")    }} func main() {    printTriangle(4)} `

Output:

```1
1 1
1 2 1
1 3 3 1
```

## Groovy

###  Recursive

In the spirit of the Haskell "think in whole lists" solution here is a list-driven, minimalist solution:

`def pascal = { n -> (n <= 1) ? [1] : GroovyCollections.transpose([[0] + pascal(n - 1), pascal(n - 1) + [0]]).collect { it.sum() } }`

However, this solution is horribly inefficient (O(n**2)). It slowly grinds to a halt on a reasonably powerful PC after about line 25 of the triangle.

Test program:

`def count = 15(1..count).each { n ->    printf ("%2d:", n); (0..(count-n)).each { print "    " }; pascal(n).each{ printf("%6d  ", it) }; println ""}`

Output:

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

## GW-BASIC

`10 INPUT "Number of rows? ",R20 FOR I=0 TO R-130 C=140 FOR K=0 TO I50 PRINT USING "####";C;60 C=C*(I-K)/(K+1)70 NEXT80 PRINT90 NEXT`

Output:

```Number of rows? 7
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
```

An approach using the "think in whole lists" principle: Each row in the triangle can be calculated from the previous row by adding a shifted version of itself to it, keeping the ones at the ends. The Prelude function zipWith can be used to add two lists, but it won't keep the old values when one list is shorter. So we need a similar function

`zapWith :: (a -> a -> a) -> [a] -> [a] -> [a]zapWith f xs [] = xszapWith f [] ys = yszapWith f (x:xs) (y:ys) = f x y : zapWith f xs ys`

Now we can shift a list and add it to itself, extending it by keeping the ends:

`extendWith f [] = []extendWith f xs@(x:ys) = x : zapWith f xs ys`

And for the whole (infinite) triangle, we just iterate this operation, starting with the first row:

`pascal = iterate (extendWith (+)) [1]`

For the first n rows, we just take the first n elements from this list, as in

`*Main> take 6 pascal[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]`

A shorter approach, plagiarized from [2]

`-- generate next row from current rownextRow row = zipWith (+) ([0] ++ row) (row ++ [0]) -- returns the first n rowspascal = iterate nextRow [1]`

With binomial coefficients:

`fac = product . enumFromTo 1 binCoef n k = (fac n) `div` ((fac k) * (fac \$ n - k)) pascal n = map (binCoef \$ n - 1) [0..n-1]`

Example:

`*Main> putStr \$ unlines \$ map unwords \$ map (map show) \$ pascal 1011 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 11 7 21 35 35 21 7 11 8 28 56 70 56 28 8 11 9 36 84 126 126 84 36 9 1 `

## HicEst

`   CALL Pascal(30) SUBROUTINE Pascal(rows)   CHARACTER fmt*6   WRITE(Text=fmt, Format='"i", i5.5') 1+rows/4    DO row = 0, rows-1     n = 1     DO k = 0, row       col = rows*(rows-row+2*k)/4       WRITE(Row=row+1, Column=col, F=fmt) n       n = n * (row - k) / (k + 1)     ENDDO   ENDDOEND`

## Icon and Unicon

The code below is slightly modified from the library version of pascal which prints 0's to the full width of the carpet. It also presents the data as an isoceles triangle.

`link math procedure main(A)every n := !A do  {    # for each command line argument    n := integer(\n) | &null   pascal(n)   }end procedure pascal(n)		#: Pascal triangle   /n := 16   write("width=", n, " height=", n)	# carpet header   fw := *(2 ^ n)+1   every i := 0 to n - 1 do {      writes(repl(" ",fw*(n-i)/2))      every j := 0 to n - 1 do         writes(center(binocoef(i, j),fw) | break)      write()      }end`
Sample output:
```->pascal 1 4 8
width=1 height=1
1
width=4 height=4
1
1  1
1  2  1
1  3  3  1
width=8 height=8
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
->```

## IDL

`Pro Pascal, n;n is the number of lines of the triangle to be displayed r=[1] print, r  for i=0, (n-2) do begin    pascalrow,r  endforEnd Pro PascalRow, r  for i=0,(n_elements(r)-2) do begin     r[i]=r[i]+r[i+1]  endforr= [1, r]print, r End`

## J

`   !~/~ i.51 0 0 0 01 1 0 0 01 2 1 0 01 3 3 1 01 4 6 4 1`
`   ([: ":@-.&0"1 !~/~)@i. 51        1 1      1 2 1    1 3 3 1  1 4 6 4 1`
`   (-@|. |."_1 [: ":@-.&0"1 !~/~)@i. 5     1        1 1      1 2 1    1 3 3 1  1 4 6 4 1`

See the talk page for explanation of earlier version

## Java

### Summing from Previous Rows

Works with: Java version 1.5+
`import java.util.ArrayList;...//class definition, etc.public static void genPyrN(int rows){	if(rows < 0) return;	//save the last row here	ArrayList<Integer> last = new ArrayList<Integer>();	last.add(1);	System.out.println(last);	for(int i= 1;i <= rows;++i){		//work on the next row		ArrayList<Integer> thisRow= new ArrayList<Integer>();		thisRow.add(last.get(0)); //beginning		for(int j= 1;j < i;++j){//loop the number of elements in this row			//sum from the last row			thisRow.add(last.get(j - 1) + last.get(j));		}		thisRow.add(last.get(0)); //end		last= thisRow;//save this row		System.out.println(thisRow);	}}`

### Combinations

This method is limited to 21 rows because of the limits of long. Calling pas with an argument of 22 or above will cause intermediate math to wrap around and give false answers.

`public class Pas{	public static void main(String[] args){		//usage		pas(20);	} 	public static void pas(int rows){		for(int i = 0; i < rows; i++){			for(int j = 0; j <= i; j++){				System.out.print(ncr(i, j) + " ");			}			System.out.println();		}	} 	public static long ncr(int n, int r){		return fact(n) / (fact(r) * fact(n - r));	} 	public static long fact(int n){		long ans = 1;		for(int i = 2; i <= n; i++){			ans *= i;		}		return ans;	}}`

### Using arithmetic calculation of each row element

This method is limited to 30 rows because of the limits of integer calculations (probably when calculating the multiplication). If m is declared as long then 62 rows can be printed.

` public class Pascal {	private static void printPascalLine (int n) {		if (n < 1)			return;		int m = 1;		System.out.print("1 ");		for (int j=1; j<n; j++) {			m = m * (n-j)/j;			System.out.print(m);			System.out.print(" ");		}		System.out.println();	} 	public static void printPascal (int nRows) {		for(int i=1; i<=nRows; i++)			printPascalLine(i);	}} `

## JavaScript

### Imperative

Works with: SpiderMonkey
Works with: V8
`// Pascal's triangle objectfunction pascalTriangle (rows) { 	// Number of rows the triangle contains	this.rows = rows; 	// The 2D array holding the rows of the triangle	this.triangle = new Array();	for (var r = 0; r < rows; r++) {		this.triangle[r] = new Array();		for (var i = 0; i <= r; i++) {			if (i == 0 || i == r)				this.triangle[r][i] = 1;			else				this.triangle[r][i] = this.triangle[r-1][i-1]+this.triangle[r-1][i];		}	} 	// Method to print the triangle	this.print = function(base) {		if (!base)			base = 10; 		// Private method to calculate digits in number		var digits = function(n,b) {			var d = 0;			while (n >= 1) {				d++;				n /= b;			}			return d;		} 		// Calculate max spaces needed		var spacing = digits(this.triangle[this.rows-1][Math.round(this.rows/2)],base); 		// Private method to add spacing between numbers		var insertSpaces = function(s) {			var buf = "";			while (s > 0) {				s--;				buf += " ";			}			return buf;		} 		// Print the triangle line by line		for (var r = 0; r < this.triangle.length; r++) {			var l = "";			for (var s = 0; s < Math.round(this.rows-1-r); s++) {				l += insertSpaces(spacing);			}			for (var i = 0; i < this.triangle[r].length; i++) {				if (i != 0)					l += insertSpaces(spacing-Math.ceil(digits(this.triangle[r][i],base)/2));				l += this.triangle[r][i].toString(base);				if (i < this.triangle[r].length-1)					l += insertSpaces(spacing-Math.floor(digits(this.triangle[r][i],base)/2));			}			print(l);		}	} } // Display 4 row triangle in base 10var tri = new pascalTriangle(4);tri.print();// Display 8 row triangle in base 16tri = new pascalTriangle(8);tri.print(16);`

Output:

```\$ d8 pascal.js
1
1 1
1 2 1
1 3 3 1
1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5   a   a   5   1
1   6   f   14  f   6   1
1   7   15  23  23  15  7   1
```

### Functional (ES5)

`(function (n) {   // A Pascal triangle of n rows  // n --> [[n]]  function pascalTriangle(n) {     // Sums of each consecutive pair of numbers    // [n] --> [n]    function pairSums(lst) {      return lst.reduce(function (acc, n, i, l) {        var iPrev = i ? i - 1 : 0;        return i ? acc.concat(l[iPrev] + l[i]) : acc      }, []);    }     // Next line in a Pascal triangle series    // [n] --> [n]    function nextPascal(lst) {      return lst.length ? [1].concat(        pairSums(lst)      ).concat(1) : [1];    }     // Each row is a function of the preceding row    return n ? Array.apply(null, Array(n - 1)).reduce(      function (a, _, i) {        return a.concat([nextPascal(a[i])]);      }, [[1]]) : [];  }   // TEST  var lstTriangle = pascalTriangle(n);    // FORMAT OUTPUT AS WIKI TABLE   // [[a]] -> bool -> s -> s  function wikiTable(lstRows, blnHeaderRow, strStyle) {    return '{| class="wikitable" ' + (      strStyle ? 'style="' + strStyle + '"' : ''    ) + lstRows.map(function (lstRow, iRow) {      var strDelim = ((blnHeaderRow && !iRow) ? '!' : '|');       return '\n|-\n' + strDelim + ' ' + lstRow.map(function (v) {        return typeof v === 'undefined' ? ' ' : v;      }).join(' ' + strDelim + strDelim + ' ');    }).join('') + '\n|}';  }   var lstLastLine = lstTriangle.slice(-1)[0],    lngBase = (lstLastLine.length * 2) - 1,    nWidth = lstLastLine.reduce(function (a, x) {      var d = x.toString().length;      return d > a ? d : a;    }, 1) * lngBase;   return [    wikiTable(      lstTriangle.map(function (lst) {        return lst.join(';;').split(';');      }).map(function (line, i) {        var lstPad = Array((lngBase - line.length) / 2);        return lstPad.concat(line).concat(lstPad);      }),      false,      'text-align:center;width:' + nWidth + 'em;height:' + nWidth +      'em;table-layout:fixed;'    ),     JSON.stringify(lstTriangle)  ].join('\n\n');})(7);`

Output:

 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],[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]]`

## jq

Works with: jq version 1.4

pascal(n) as defined here produces a stream of n arrays, each corresponding to a row of the Pascal triangle. The implementation avoids any arithmetic except addition.

`# pascal(n) for n>=0; pascal(0) emits an empty stream.def pascal(n):  def _pascal:  # input: the previous row    . as \$in    | .,      if length >= n then empty      else        reduce range(0;length-1) as \$i          ([1]; . + [ \$in[\$i] + \$in[\$i + 1] ]) + [1] | _pascal      end;  if n <= 0 then empty else [1] | _pascal end ;`

Example:

```pascal(5)
```
Output:
`\$ jq -c -n -f pascal_triangle.jq[1][1,1][1,2,1][1,3,3,1][1,4,6,4,1]`

Using recurse/1

Here is an equivalent implementation that uses the built-in filter, recurse/1, instead of the inner function.

`def pascal(n):  if n <= 0 then empty  else [1]  | recurse( if length >= n then empty             else . as \$in              | reduce range(0;length-1) as \$i                 ([1]; . + [ \$in[\$i] + \$in[\$i + 1] ]) + [1]             end)  end;`

## K

` pascal:{(x-1){+':x,0}\1}pascal 6(1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1)`

## Kotlin

`fun pas(rows: Int) {    for (i in 0..rows - 1) {        for (j in 0..i)            print(ncr(i, j).toString() + " ")        println()    }} fun ncr(n: Int, r: Int) = fact(n) / (fact(r) * fact(n - r)) fun fact(n: Int) : Long {    var ans = 1.toLong()    for (i in 2..n)        ans *= i    return ans} fun main(args: Array<String>) = pas(args[0].toInt())`

## Liberty BASIC

`input "How much rows would you like? "; ndim a\$(n) for i=  0 to n       c = 1       o\$ =""       for k =0 to i             o\$ =o\$ ; c; " "             c =c *(i-k)/(k+1)       next k       a\$(i)=o\$next i maxLen = len(a\$(n))for i=  0 to n    print space\$((maxLen-len(a\$(i)))/2);a\$(i)next i end`

## Locomotive Basic

`10 CLS20 INPUT "Number of rows? ", rows:GOSUB 4030 END40 FOR i=0 TO rows-150 c=160 FOR k=0 TO i70 PRINT USING "####";c;80 c=c*(i-k)/(k+1)90 NEXT100 PRINT110 NEXT120 RETURN`

Output:

```Number of rows? 7
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
```

## Logo

`to pascal :n  if :n = 1 [output [1]]  localmake "a pascal :n-1  output (sentence first :a (map "sum butfirst :a butlast :a) last :a)end for [i 1 10] [print pascal :i]`

## Lua

` function nextrow(t)  local ret = {}  t[0], t[#t+1] = 0, 0  for i = 1, #t do ret[i] = t[i-1] + t[i] end  return retend function triangle(n)  t = {1}  for i = 1, n do    print(unpack(t))    t = nextrow(t)  endend `

## Mathematica

`Column[StringReplace[ToString /@ Replace[MatrixExp[SparseArray[{Band[{2,1}] -> Range[n-1]},{n,n}]],{x__,0..}->{x},2] ,{"{"|"}"|","->" "}], Center]`

## MATLAB / Octave

A matrix containing the pascal triangle can be obtained this way:

`pascal(n);`
```>> pascal(6)
ans =

1     1     1     1     1     1
1     2     3     4     5     6
1     3     6    10    15    21
1     4    10    20    35    56
1     5    15    35    70   126
1     6    21    56   126   252

```

The binomial coefficients can be extracted from the Pascal triangle in this way:

`  binomCoeff = diag(rot90(pascal(n)))', `
```>> for k=1:6,diag(rot90(pascal(k)))', end
ans =  1
ans =

1   1

ans =

1   2   1

ans =

1   3   3   1

ans =

1   4   6   4   1

ans =

1    5   10   10    5    1

```

Another way to get a formated pascals triangle is to use the convolution method:

```>>
x = [1  1] ;
y = 1;
for k=8:-1:1
fprintf(['%', num2str(k), 'c'], zeros(1,3)),
fprintf('%6d', y), fprintf('\n')
y = conv(y,x);

end
```

The result is:

```>>

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
```

## Maxima

`sjoin(v, j) := apply(sconcat, rest(join(makelist(j, length(v)), v)))\$ display_pascal_triangle(n) := for i from 0 thru 6 do disp(sjoin(makelist(binomial(i, j), j, 0, i), " ")); display_pascal_triangle(6);/* "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" */`

## Metafont

(The formatting starts to be less clear when numbers start to have more than two digits)

`vardef bincoeff(expr n, k) =save ?;? := (1 for i=(max(k,n-k)+1) upto n: * i endfor )     / (1 for i=2 upto min(k, n-k): * i endfor); ?enddef; def pascaltr expr c =  string s_;  for i := 0 upto (c-1):    s_ := "" for k=0 upto (c-i): & "  " endfor;    s_ := s_ for k=0 upto i: & decimal(bincoeff(i,k))             & "  " if bincoeff(i,k)<9: & " " fi endfor;    message s_;  endforenddef; pascaltr(4);end`

## NetRexx

`/* NetRexx */options replace format comments java crossref symbols nobinary numeric digits 1000 -- allow very large numbersparse arg rows .if rows = '' then rows = 11 -- default to 11 rowsprintPascalTriangle(rows)return -- -----------------------------------------------------------------------------method printPascalTriangle(rows = 11) public static  lines = ''  mx = (factorial(rows - 1) / factorial(rows % 2) / factorial(rows - 1 - rows % 2)).length() -- width of widest number   loop row = 1 to rows    n1 = 1.center(mx)    line = n1    loop col = 2 to row      n2 = col - 1      n1 = n1 * (row - n2) / n2      line = line n1.center(mx)      end col    lines[row] = line.strip()    end row   -- display triangle  ml = lines[rows].length() -- length of longest line  loop row = 1 to rows    say lines[row].centre(ml)    end row   return -- -----------------------------------------------------------------------------method factorial(n) public static  fac = 1  loop n_ = 2 to n    fac = fac * n_    end n_  return fac /*calc. factorial*/ `
Output:
```                    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
```

## Nial

Like J

(pascal.nial)

`factorial is recur [ 0 =, 1 first, pass, product, -1 +]combination is fork [ > [first, second], 0 first,    / [factorial second, * [factorial - [second, first], factorial first] ]]pascal is transpose each combination cart [pass, pass] tell`

Using it

`|loaddefs 'pascal.nial'|pascal 5`

## Nim

`import sequtils proc pascal(n: int) =  var row = @[1]  for r in 1..n:    echo row    row = zip(row & @[0], @[0] & row).mapIt(int, it[0] + it[1]) pascal(10)`

## OCaml

`(* generate next row from current row *)let next_row row =  List.map2 (+) ([0] @ row) (row @ [0]) (* returns the first n rows *)let pascal n =  let rec loop i row =    if i = n then []    else row :: loop (i+1) (next_row row)  in loop 0 [1]`

## Octave

`function pascaltriangle(h)  for i = 0:h-1    for k = 0:h-i      printf("  ");    endfor    for j = 0:i      printf("%3d ", bincoeff(i, j));    endfor    printf("\n");  endforendfunction pascaltriangle(4);`

## Oforth

No result if n <= 0

`func: pascal(n) { [ 1 ] #[ dup println dup 0 + 0 rot + zipWith(#+) ] times(n) drop }`
Output:
```pascal(10)
[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]
```

## Oz

`declare  fun {NextLine Xs}     {List.zip 0|Xs {Append Xs [0]}      fun {\$ Left Right}         Left + Right      end}  end   fun {Triangle N}     {List.take {Iterate [1] NextLine} N}  end   fun lazy {Iterate I F}     I|{Iterate {F I} F}  end   %% Only works nicely for N =< 5.  proc {PrintTriangle T}     N = {Length T}  in     for        Line in T        Indent in N-1..0;~1     do        for _ in 1..Indent do {System.printInfo " "} end        for L in Line do {System.printInfo L#" "} end        {System.printInfo "\n"}     end  endin  {PrintTriangle {Triangle 5}}`

For n = 0, prints nothing. For negative n, throws an exception.

## PARI/GP

`pascals_triangle(N)= {my(row=[],prevrow=[]);for(x=1,N,    if(x>5,break(1));         row=eval(Vec(Str(11^(x-1))));         print(row));prevrow=row;for(y=6,N,   for(p=2,#prevrow,         row[p]=prevrow[p-1]+prevrow[p]);         row=concat(row,1);         prevrow=row;         print(row);     );}`

## Pascal

`Program PascalsTriangle(output); procedure Pascal(r : Integer);  var    i, c, k : Integer;  begin    for i := 0 to r-1 do    begin      c := 1;      for k := 0 to i do      begin        write(c:3);        c := (c * (i-k)) div (k+1);      end;      writeln;   end;end; begin  Pascal(9)end.`

Output:

```% ./PascalsTriangle
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
```

## Perl

These functions perform as requested in the task: they print out the first n lines. If n <= 0, they print nothing. The output is simple (no fancy formatting).

`sub pascal {  my \$rows = shift;  my @next = (1);  for my \$n (1 .. \$rows) {    print "@next\n";    @next = (1, (map \$next[\$_]+\$next[\$_+1], 0 .. \$n-2), 1);  }}`

If you want more than 68 rows, then use either "use bigint" or "use Math::GMP qw/:constant/" inside the function to enable bigints. We can also use a binomial function which will expand to bigints if many rows are requested:

Library: ntheory
`use ntheory qw/binomial/;sub pascal {  my \$rows = shift;  for my \$n (0 .. \$rows-1) {    print join(" ", map { binomial(\$n,\$_) } 0 .. \$n), "\n";  }}`

Here is a non-obvious version using bignum, which is limited to the first 23 rows because of the algorithm used:

`use bignum;sub pascal_line { \$_[0] ? unpack "A(A6)*", 1000001**\$_[0] : 1 }sub pascal { print "@{[map -+-\$_, pascal_line \$_]}\n" for 0..\$_[0]-1 }`

## Perl 6

Works with: rakudo version 2015-10-03

###  using a lazy sequence generator

The following routine returns a lazy list of lines using the sequence operator (...). With a lazy result you need not tell the routine how many you want; you can just use a slice subscript to get the first N lines:

`sub pascal { [1], -> \$prev { [0, |\$prev Z+ |\$prev, 0] } ... * } .say for pascal[^10];`

One problem with the routine above is that it might recalculate the sequence each time you call it. Slightly more idiomatic would be to define the sequence as a lazy constant. Here we use the @ sigil to indicate that the sequence should cache its values for reuse:

`constant @pascal = [1], -> \$prev { [0, |\$prev Z+ |\$prev, 0] } ... *; .say for @pascal[^10];`

Since we use ordinary subscripting, non-positive inputs throw an index-out-of-bounds error.

###  recursive

`multi sub pascal (1) { \$[1] }multi sub pascal (Int \$n where 2..*) {    my @rows = pascal \$n - 1;    |@rows, [0, |@rows[*-1] Z+ |@rows[*-1], 0 ];} .say for pascal 10;`

Non-positive inputs throw a multiple-dispatch error.

###  iterative

Translation of: Perl
`sub pascal (\$n where \$n >= 1) {   say my @last = 1;   for 1 .. \$n - 1 -> \$row {       @last = 1, |map({ @last[\$_] + @last[\$_ + 1] }, 0 .. \$row - 2), 1;       say @last;   }} pascal 10;`

Non-positive inputs throw a type check error.

Output:
```[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]```

## Phix

`sequence row = {}for m = 1 to 13 do    row = row & 1    for n=length(row)-1 to 2 by -1 do        row[n] += row[n-1]    end for    printf(1,repeat(' ',(13-m)*2))    for i=1 to length(row) do        printf(1," %3d",row[i])    end for    puts(1,'\n')end for`
Output:
```                           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
```

## PHP

`function pascalsTriangle(\$num){	\$c = 1;	\$triangle = Array();	for(\$i=0;\$i<=\$num;\$i++){		\$triangle[\$i] = Array();		if(!isset(\$triangle[\$i-1])){			\$triangle[\$i][] = \$c;		}else{			for(\$j=0;\$j<count(\$triangle[\$i-1])+1;\$j++){				\$triangle[\$i][] = (isset(\$triangle[\$i-1][\$j-1]) && isset(\$triangle[\$i-1][\$j])) ? \$triangle[\$i-1][\$j-1] + \$triangle[\$i-1][\$j] : \$c;			}		}	}	return \$triangle;} \$tria = pascalsTriangle(8);foreach(\$tria as \$val){	foreach(\$val as \$value){		echo \$value . ' ';	}	echo '<br>';}`
```                                       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
```

## PL/I

` declare (t, u)(40) fixed binary;declare (i, n) fixed binary; t,u = 0;get (n);if n <= 0 then return; do n = 1 to n;   u(1) = 1;   do i = 1 to n;      u(i+1) = t(i) + t(i+1);   end;   put skip edit ((u(i) do i = 1 to n)) (col(40-2*n), (n+1) f(4));   t = u;end; `
`                                         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 `

## PicoLisp

Translation of: C
`(de pascalTriangle (N)   (for I N      (space (* 2 (- N I)))      (let C 1         (for K I            (prin (align 3 C) " ")            (setq C (*/ C (- I K) K)) ) )      (prinl) ) )`

## PowerShell

` \$Infinity = 1\$NewNumbers = \$null\$Numbers = \$null\$Result = \$null\$Number = \$null\$Power = \$args[0] Write-Host \$Power For(   \$i=0;   \$i -lt \$Infinity;   \$i++   )   {    \$Numbers = New-Object Object[] 1    \$Numbers[0] = \$Power   For(      \$k=0;      \$k -lt \$NewNumbers.Length;      \$k++      )      {       \$Numbers = \$Numbers + \$NewNumbers[\$k]      }   If(     \$i -eq 0     )     {      \$Numbers = \$Numbers + \$Power     }    \$NewNumbers = New-Object Object[] 0   Try   {   For(      \$j=0;      \$j -lt \$Numbers.Length;      \$j++      )      {       \$Result = \$Numbers[\$j] + \$Numbers[\$j+1]       \$NewNumbers = \$NewNumbers + \$Result      }   }   Catch [System.Management.Automation.RuntimeException]   {    Write-Warning "Value was too large for a Decimal. Script aborted."    Break;   }   Foreach(          \$Number in \$Numbers          )          {          If(            \$Number.ToString() -eq "+unendlich"            )            {             Write-Warning "Value was too large for a Decimal. Script aborted."             Exit            }          }    Write-Host \$Numbers    \$Infinity++   } `

Save the above code to a .ps1 script file and start it by calling its name and providing N.

```PS C:\> & '.\Pascals Triangle.ps1' 1

----

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
```

## Prolog

Difference-lists are used to make quick append.

`pascal(N) :-	pascal(1, N, [1], [[1]|X]-X, L),	maplist(my_format, L). pascal(Max, Max, L, LC, LF) :-	!,	make_new_line(L, NL),	append_dl(LC, [NL|X]-X, LF-[]). pascal(N, Max, L, NC, LF) :-	build_new_line(L, NL),	append_dl(NC, [NL|X]-X, NC1),	N1 is N+1,	pascal(N1, Max, NL, NC1, LF). build_new_line(L, R) :-	build(L, 0, X-X, R). build([], V, RC, RF) :-	append_dl(RC, [V|Y]-Y, RF-[]). build([H|T], V, RC, R) :-	V1 is V+H,	append_dl(RC, [V1|Y]-Y, RC1),	build(T, H, RC1, R). append_dl(X1-X2, X2-X3, X1-X3). % to have a correct output !my_format([H|T]) :-	write(H),	maplist(my_writef, T),	nl. my_writef(X) :-	writef(' %5r', [X]). `

Output :

` ?- pascal(15).11     11     2     11     3     3     11     4     6     4     11     5    10    10     5     11     6    15    20    15     6     11     7    21    35    35    21     7     11     8    28    56    70    56    28     8     11     9    36    84   126   126    84    36     9     11    10    45   120   210   252   210   120    45    10     11    11    55   165   330   462   462   330   165    55    11     11    12    66   220   495   792   924   792   495   220    66    12     11    13    78   286   715  1287  1716  1716  1287   715   286    78    13     11    14    91   364  1001  2002  3003  3432  3003  2002  1001   364    91    14     11    15   105   455  1365  3003  5005  6435  6435  5005  3003  1365   455   105    15     1true. `

## PureBasic

`Procedure pascaltriangle( n.i)   For i=  0 To  n       c = 1       For k=0 To i             Print(Str( c)+" ")         c = c * (i-k)/(k+1);        Next ;k    PrintN(" "); nächste zeile  Next ;i EndProcedure OpenConsole()Parameter.i = Val(ProgramParameter(0))pascaltriangle(Parameter);Input()`

## Python

`def pascal(n):   """Prints out n rows of Pascal's triangle.   It returns False for failure and True for success."""   row = [1]   k = [0]   for x in range(max(n,0)):      print row      row=[l+r for l,r in zip(row+k,k+row)]   return n>=1`

Or, by creating a scan function:

`def scan(op, seq, it):  a = []  result = it  a.append(it)  for x in seq:    result = op(result, x)    a.append(result)  return a def pascal(n):    def nextrow(row, x):        return [l+r for l,r in zip(row+[0,],[0,]+row)]     return scan(nextrow, range(n-1), [1,]) for row in pascal(4):    print(row)`

## q

` pascal:{(x-1){0+':x,0}\1}pascal 511 11 2 11 3 3 11 4 6 4 1 `

## Qi

` (define iterate  _ _ 0 -> []  F V N -> [V|(iterate F (F V) (1- N))]) (define next-row  R -> (MAPCAR + [0|R] (append R [0]))) (define pascal  N -> (iterate next-row [1] N)) `

## R

Translation of: Octave
`pascalTriangle <- function(h) {  for(i in 0:(h-1)) {    s <- ""    for(k in 0:(h-i)) s <- paste(s, "  ", sep="")    for(j in 0:i) {      s <- paste(s, sprintf("%3d ", choose(i, j)), sep="")    }    print(s)  }}`

Here's an R version:

`pascalTriangle <- function(h) {  lapply(0:h, function(i) choose(i, 0:i))}`

## Racket

Iterative version by summing rows up to n.

`#lang racket (define (pascal n)  (define (next-row current-row)    (map + (cons 0 current-row)           (append current-row '(0))))  (let-values       ([(previous-rows final-row)       (for/fold ([triangle null]                  [row '(1)])          ([row-number (in-range 1 n)])         (values (cons row triangle)                 (next-row row)))])    (reverse (cons final-row previous-rows))))  `

## RapidQ

### Summing from Previous Rows

Translation of: BASIC

The main difference to BASIC implementation is the output formatting. RapidQ does not support PRINT USING. Instead, function FORMAT\$() is used. TAB() is not supported, so SPACE\$() was used instead.

Another difference is that in RapidQ, DIM does not clear array values to zero. But if dimensioning is done with DEF..., you can give the initial values in curly braces. If less values are given than there are elements in the array, the remaining positions are initialized to zero. RapidQ does not require simple variables to be declared before use.

`DEFINT values(100) = {0,1} INPUT "Number of rows: "; nrowsPRINT SPACE\$((nrows)*3);"  1"FOR row = 2 TO nrows    PRINT SPACE\$((nrows-row)*3+1);    FOR i = row TO 1 STEP -1        values(i) = values(i) + values(i-1)        PRINT FORMAT\$("%5d ", values(i));    NEXT i    PRINTNEXT row`

### Using binary coefficients

Translation of: BASIC
`INPUT "Number of rows: "; nrowsFOR row = 0 TO nrows-1    c = 1    PRINT SPACE\$((nrows-row)*3);    FOR i = 0 TO row        PRINT FORMAT\$("%5d ", c);        c = c * (row - i) / (i+1)    NEXT i    PRINTNEXT row`

## Retro

`2 elements i j: pascalTriangle  cr dup  [ dup !j 1 swap 1+ [ !i dup putn space @j @i - * @i 1+ / ] iter cr drop ] iter drop;13 pascalTriangle`

## REXX

There is no practical limit for this REXX version, triangles up to 46 rows have been generated (without wrapping) in a screen window with a width of 620 characters.

If the number (of rows) specified is negative, the output is written to a (disk) file instead.   Triangles with over a 1,000 rows have easily been created.   The output file created (that is written to disk) is named     PASCALS.n     where   n   is the absolute value of the number entered.

`/*REXX program displays Pascal's triangle (centered/formatted); also known as:*//*────────── Yang Hui's, Khayyam─Pascal, Kyayyam, and/or Tartaglia's triangle.*/numeric digits 3000                    /*be able to handle gihugeic triangles.*/parse arg nn .;  if nn==''  then nn=10 /*use default if  NN  wasn't specified.*/N=abs(nn)                              /*N  is the number of rows in triangle.*/@.=1;    \$.=@.                         /*default value for rows and for lines.*/w=length(!(N-1) / !(N%2) / !(N-1-N%2)) /*W  is the width of the biggest number*/                                       /* [↓]  build rows of Pascals' triangle*/  do   r=1  for N;     rm=r-1          /*Note:  the first column is always  1.*/    do c=2  to rm;     cm=c-1          /*build the rest of the columns in row.*/    @.r.c= @.rm.cm + @.rm.c            /*assign value to a specific row & col.*/    \$.r  = \$.r     right(@.r.c, w)     /*and construct a line for output (row)*/    end   /*c*/                        /* [↑]    C  is the column being built.*/  if r\==1  then \$.r=\$.r right(1, w)   /*for most rows, append a trailing "1".*/  end     /*r*/                        /* [↑]    R  is the  row   being built.*/                                       /* [↑]  WIDTH: for nicely looking line.*/width=length(\$.N)                      /*width of the last (output) line (row)*/                                       /*if NN<0, output is written to a file.*/        do r=1  for N                  /*show│write lines (rows) of triangle. */        if nn>0  then say  center(\$.r, width)                        /*SAY, or*/                 else call lineout  'PASCALS.'n, center(\$.r, width)  /*write. */        end   /*r*/exit                                   /*stick a fork in it,  we're all done. *//*──────────────────────────────────! subroutine  (factorial)─────────────────*/!: procedure;  parse arg x;  !=1;     do j=2  to x;  !=!*j;  end;       return !`

output when the input was given as:   11

```                    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
```

output when the input was given as: 22

```                                                                         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    153     18      1
1     19    171    969   3876  11628  27132  50388  75582  92378  92378  75582  50388  27132  11628   3876    969    171     19      1
1     20    190   1140   4845  15504  38760  77520 125970 167960 184756 167960 125970  77520  38760  15504   4845   1140    190     20      1
1     21    210   1330   5985  20349  54264 116280 203490 293930 352716 352716 293930 203490 116280  54264  20349   5985   1330    210     21      1
```

## Ruby

`def pascal(n)  raise ArgumentError, "must be positive." if n < 1  yield ar = [1]  (n-1).times do    ar.unshift(0).push(0) # tack a zero on both ends    yield ar = ar.each_cons(2).map{|a, b| a + b }   endend pascal(8){|row| puts row.join(" ").center(20)}`
Output:
```         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
```

Or for more or less a translation of the two line Haskell version (with inject being abused a bit I know):

`def next_row(row) ([0] + row).zip(row + [0]).collect {|l,r| l + r } end def pascal(n) n.times.inject([1]) {|x,_| next_row x } end 8.times{|i| p pascal(i)}`
Output:
```[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]
```

## Run BASIC

`input "number of rows? ";rfor i = 0 to r - 1  c = 1  print left\$("                          ",(r*2)-(i*2));  for k = 0 to i    print using("####",c);    c = c*(i-k)/(k+1)  next  printnext`
Output:
```Number of rows? ?5
1
1   1
1   2   1
1   3   3   1
1   4   6   4   1```

## Scala

Simple recursive row definition:

` def tri(row:Int):List[Int] = { row match {  case 1 => List(1)  case n:Int => List(1) ::: ((tri(n-1) zip tri(n-1).tail) map {case (a,b) => a+b}) ::: List(1)  }} `

Function to pretty print n rows:

` def prettytri(n:Int) = (1 to n) foreach {i=>print(" "*(n-i)); tri(i) map (c=>print(c+" ")); println}prettytri(5) `

Outputs:

```    1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
```

## Scheme

Works with: Scheme version R5RS
`(define (next-row row)  (map + (cons 0 row) (append row '(0)))) (define (triangle row rows)  (if (= rows 0)      '()      (cons row (triangle (next-row row) (- rows 1))))) (triangle (list 1) 5) `

Output:

`((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1))`

## Seed7

`\$ include "seed7_05.s7i"; const proc: main is func  local    var integer: numRows is 0;    var array integer: values is [] (0, 1);    var integer: row is 0;    var integer: index is 0;  begin    write("Number of rows: ");    readln(numRows);    writeln("1" lpad succ(numRows) * 3);    for row range 2 to numRows do      write("" lpad (numRows - row) * 3);      values &:= [] 0;      for index range succ(row) downto 2 do        values[index] +:= values[pred(index)];        write(" " <& values[index] lpad 5);      end for;      writeln;    end for;  end func;`

## Sidef

`func pascal(rows) {    var row = [1];    { | n|        say row.join(' ');        row = [1, 0..(n-2).map {|i| row[i] + row[i+1] }..., 1];    } * rows;} pascal(10);`

## Tcl

### Summing from Previous Rows

`proc pascal_iterative n {    if {\$n < 1} {error "undefined behaviour for n < 1"}    set row [list 1]    lappend rows \$row        set i 1    while {[incr i] <= \$n} {        set prev \$row        set row [list 1]        for {set j 1} {\$j < [llength \$prev]} {incr j} {            lappend row [expr {[lindex \$prev [expr {\$j - 1}]] + [lindex \$prev \$j]}]        }        lappend row 1        lappend rows \$row    }    return \$rows} puts [join [pascal_iterative 6] \n]`
```1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1```

### Using binary coefficients

Translation of: BASIC
`proc pascal_coefficients n {    if {\$n < 1} {error "undefined behaviour for n < 1"}    for {set i 0} {\$i < \$n} {incr i} {        set c 1        set row [list \$c]        for {set j 0} {\$j < \$i} {incr j} {            set c [expr {\$c * (\$i - \$j) / (\$j + 1)}]            lappend row \$c        }        lappend rows \$row    }    return \$rows} puts [join [pascal_coefficients 6] \n]`

### Combinations

Translation of: Java

Thanks to Tcl 8.5's arbitrary precision integer arithmetic, this solution is not limited to a couple of dozen rows. Uses a caching factorial calculator to improve performance.

`package require Tcl 8.5 proc pascal_combinations n {    if {\$n < 1} {error "undefined behaviour for n < 1"}    for {set i 0} {\$i < \$n} {incr i} {        set row [list]        for {set j 0} {\$j <= \$i} {incr j} {            lappend row [C \$i \$j]        }        lappend rows \$row    }    return \$rows} proc C {n k} {    expr {[ifact \$n] / ([ifact \$k] * [ifact [expr {\$n - \$k}]])}} set fact_cache {1 1}proc ifact n {    global fact_cache    if {\$n < [llength \$fact_cache]} {        return [lindex \$fact_cache \$n]    }    set i [expr {[llength \$fact_cache] - 1}]    set sum [lindex \$fact_cache \$i]    while {\$i < \$n} {        incr i        set sum [expr {\$sum * \$i}]        lappend fact_cache \$sum    }    return \$sum} puts [join [pascal_combinations 6] \n]`

### Comparing Performance

`set n 100puts "calculate \$n rows:"foreach proc {pascal_iterative pascal_coefficients pascal_combinations} {    puts "\$proc: [time [list \$proc \$n] 100]"}`
Output:
```calculate 100 rows:
pascal_iterative: 2800.14 microseconds per iteration
pascal_coefficients: 8760.98 microseconds per iteration
pascal_combinations: 38176.66 microseconds per iteration```

## TI-83 BASIC

### Using Addition of Previous Rows

`PROGRAM:PASCALTR:Lbl IN:ClrHome:Disp "NUMBER OF ROWS":Input N:If N < 1:Goto IN:{N,N}→dim([A]):"CHEATING TO MAKE IT FASTER":For(I,1,N):1→[A](1,1):End:For(I,2,N):For(J,2,I):[A](I-1,J-1)+[A](I-1,J)→[A](I,J):End:End:[A]`

### Using nCr Function

`PROGRAM:PASCALTR:Lbl IN:ClrHome:Disp "NUMBER OF ROWS":Input N:If N < 1:Goto IN:{N,N}→dim([A]):For(I,2,N):For(J,2,I):(I-1) nCr (J-1)→[A](I,J):End:End:[A]`

## Turing

` procedure pascal (n : int)    for i : 0 .. n        var c : int        c := 1        for k : 0 .. i            put intstr(c) + " " ..            c := c * (i - k) div (k + 1)        end for        put ""    end forend pascal pascal(5)`

## uBasic/4tH

`Input "Number Of Rows: "; N@(1) = 1Print Tab((N+1)*3);"1" For R = 2 To N    Print Tab((N-R)*3+1);    For I = R To 1 Step -1        @(I) = @(I) + @(I-1)        Print Using "______";@(i);    NextNext PrintEnd`

Output:

```Number Of Rows: 10
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

0 OK, 0:380
```

## UNIX Shell

Works with: Bourne Again SHell

Any n <= 1 will print the "1" row.

`#! /bin/bashpascal() {    local -i n=\${1:-1}    if (( n <= 1 )); then        echo 1    else        local output=\$( \$FUNCNAME \$((n - 1)) )        set -- \$( tail -n 1 <<<"\$output" )   # previous row        echo "\$output"        printf "1 "        while [[ -n \$1 ]]; do            printf "%d " \$(( \$1 + \${2:-0} ))            shift        done        echo    fi}pascal "\$1"`

## Ursala

Zero maps to the empty list. Negatives are inexpressible. This solution uses a library function for binomial coefficients.

`#import std#import nat pascal = choose**ziDS+ iota*t+ iota+ successor`

This solution uses direct summation. The algorithm is to insert zero at the head of a list (initially the unit list <1>), zip it with its reversal, map the sum over the list of pairs, iterate n times, and return the trace.

`#import std#import nat pascal "n" = (next"n" sum*NiCixp) <1>`

test program:

`#cast %nLL example = pascal 10`
Output:
```<
<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>>```

## VBScript

Derived from the BASIC version.

`Pascal_Triangle(WScript.Arguments(0))Function Pascal_Triangle(n)	Dim values(100)	values(1) = 1	WScript.StdOut.Write values(1)	WScript.StdOut.WriteLine	For row = 2 To n		For i = row To 1 Step -1			values(i) = values(i) + values(i-1)			WScript.StdOut.Write values(i) & " "		Next		WScript.StdOut.WriteLine	NextEnd Function`
Output:

Invoke from a command line.

```F:\VBScript>cscript /nologo rosettacode-pascals_triangle.vbs 6
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
```

## Vedit macro language

### Summing from Previous Rows

Translation of: BASIC

Vedit macro language does not have actual arrays (edit buffers are normally used for storing larger amounts of data). However, a numeric register can be used as index to access another numeric register. For example, if #99 contains value 2, then #@99 accesses contents of numeric register #2.

`#100 = Get_Num("Number of rows: ", STATLINE)#0=0; #1=1Ins_Char(' ', COUNT, #100*3-2) Num_Ins(1)for (#99 = 2; #99 <= #100; #99++) {    Ins_Char(' ', COUNT, (#100-#99)*3)    #@99 = 0    for (#98 = #99; #98 > 0; #98--) {	#97 = #98-1	#@98 += #@97	Num_Ins(#@98, COUNT, 6)    }    Ins_Newline}`

### Using binary coefficients

Translation of: BASIC
`#1 = Get_Num("Number of rows: ", STATLINE)for (#2 = 0; #2 < #1; #2++) {    #3 = 1    Ins_Char(' ', COUNT, (#1-#2-1)*3)    for (#4 = 0; #4 <= #2; #4++) {	Num_Ins(#3, COUNT, 6)	#3 = #3 * (#2-#4) / (#4+1)    }    Ins_Newline}`

## Visual Basic

Works with: Visual Basic version VB6 Standard
`Sub pascaltriangle()    'Pascal's triangle    Const m = 11    Dim t(40) As Integer, u(40) As Integer    Dim i As Integer, n As Integer, s As String, ss As String    ss = ""    For n = 1 To m        u(1) = 1        s = ""        For i = 1 To n            u(i + 1) = t(i) + t(i + 1)            s = s & u(i) & " "            t(i) = u(i)        Next i        ss = ss & s & vbCrLf    Next n    MsgBox ss, , "Pascal's triangle"End Sub 'pascaltriangle`
Output:
```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
```

## XPL0

`include c:\cxpl\codes; proc Pascal(N);         \Display the first N rows of Pascal's triangleint  N;                 \if N<=0 then nothing is displayedint  Row, I, Old(40), New(40);[for Row:= 0 to N-1 do        [New(0):= 1;        for I:= 1 to Row do New(I):= Old(I-1) + Old(I);        for I:= 1 to (N-Row-1)*2 do ChOut(0, ^ );        for I:= 0 to Row do                [if New(I)<100 then ChOut(0, ^ );                IntOut(0, New(I));                if New(I)<10 then ChOut(0, ^ );                ChOut(0, ^ );                ];        New(Row+1):= 0;        I:= Old;  Old:= New;  New:= I;        CrLf(0);        ];]; Pascal(13)`
Output:
```                         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
```

## zkl

Translation of: C
`fcn pascalTriangle(n){ // n<=0-->""   foreach i in (n){      c := 1;      print(" "*(2*(n-1-i)));      foreach k in (i+1){         print("%3d ".fmt(c));         c = c * (i-k)/(k+1);      }      println();   }} pascalTriangle(8);`
Output:
```                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
```