Pascal's triangle is an arithmetic and geometric figure often associated with the name ofBlaise Pascal, but also studied centuries earlier in India, Persia, China and elsewhere.
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 of the triangle would be:
So the triangle now looks like this:
1 1 1 1 2 1 1 3 3 11 4 6 4 1
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 element1).
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.
F pascal(n) V row = [1] V k = [0] L 0 .< max(n, 0) print(row.join(‘ ’).center(16)) row = zip(row [+] k, k [+] row).map((l, r) -> l + r)pascal(7)
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 11 6 15 20 15 6 1
* 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
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
One way, using array operations:
\ print the array:.arr\ a -- a( . space )a:each;:pasc\ a --\ print the row.arrcrdup\ create two rows from the first, one with a leading the other with a trailing 0[0]0a:insertswap0a:push\ add the arrays together to make the new one'n:+a:op;\ print the first 16 rows:[1]'pasc16times
Another way, using the relation between element 'n' and element 'n-1' in a row:
:ratio\ m n -- num denomtuckn:-n:1+swap;\ one item in the row: n m:pascitem\ n m -- nr@swapration:*/n:roundintdup.space;\ One row of Pascal's triangle:pascline\ n -->r1intdup.space'pascitem1r@looprdropdropcr;\ Calculate the first 'n' rows of Pascal's triangle::pasc\ n'pascline0rotloopcr;15pasc
PROC Main() BYTE count=[10],row,item CHAR ARRAY s(5) INT v FOR row=0 TO count-1 DO v=1 FOR item=0 TO row DO StrI(v,s) Position(2*(count-row)+4*item-s(0),row+1) Print(s) v=v*(row-item)/(item+1) OD PutE() ODRETURN
Screenshot from Atari 8-bit computer
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 11 9 36 84 126 126 84 36 9 1
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]]
packagePascalistypeRowisarray(Naturalrange<>)ofNatural;functionLength(R:Row)returnPositive;functionFirst_Row(Max_Length:Positive)returnRow;functionNext_Row(R:Row)returnRow;endPascal;
The implementation of that auxiliary package "Pascal":
packagebodyPascalisfunctionFirst_Row(Max_Length:Positive)returnRowisR:Row(0..Max_Length):=(0|1=>1,others=>0);beginreturnR;endFirst_Row;functionNext_Row(R:Row)returnRowisS:Row(R'Range);beginS(0):=Length(R)+1;S(Length(S)):=1;forJinreverse2..Length(R)loopS(J):=R(J)+R(J-1);endloop;S(1):=1;returnS;endNext_Row;functionLength(R:Row)returnPositiveisbeginreturnR(0);endLength;endPascal;
The main program, using "Pascal". It prints the desired number of rows. The number is read from the command line.
withAda.Text_IO,Ada.Integer_Text_IO,Ada.Command_Line,Pascal;usePascal;procedureTriangleisNumber_Of_Rows:Positive:=Integer'Value(Ada.Command_Line.Argument(1));Row:Pascal.Row:=First_Row(Number_Of_Rows);beginloop-- print one rowforJin1..Length(Row)loopAda.Integer_Text_IO.Put(Row(J),5);endloop;Ada.Text_IO.New_Line;exitwhenLength(Row)>=Number_Of_Rows;Row:=Next_Row(Row);endloop;endTriangle;
>./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
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
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
begin % prints the first n lines of Pascal's triangle lines % % if n is <= 0, no output is produced % procedure printPascalTriangle( integer value n ) ; if n > 0 then begin integer array pascalLine ( 1 :: n ); pascalLine( 1 ) := 1; for line := 1 until n do begin for i := line - 1 step - 1 until 2 do pascalLine( i ) := pascalLine( i - 1 ) + pascalLine( i ); pascalLine( line ) := 1; write( s_w := 0, " " ); for i := line until n do writeon( s_w := 0, " " ); for i := 1 until line do writeon( i_w := 6, s_w := 0, pascalLine( i ) ) end for_line ; end printPascalTriangle ; printPascalTriangle( 8 )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
#include <jambo.h>#define Mulbyandmoveto(_X_) Mul by '_X_', Move to '_X_'Main filas=0, Get arg numeric '2', Move to 'filas' i=0, r="" Loop if( var 'i' Is less than 'filas' ) c=1, j=0 Set 'c' To str, Move to 'r' Loop if ( var 'j' Is less than 'i' ) Set 'i' Minus 'j', Plus one 'j', Div it; Mul by and move to 'c' Multi cat ' r, "\t", Str(c) '; Move to 'r' ++j Back Printnl 'r' ++i BackEnd
$ hopper jm/pascal.jambo 141 111211331146411510105116152015611721353521711828567056288119368412612684369111045120210252210120451011115516533046246233016555111112662204957929247924952206612111378286715128717161716128771528678131
Pascal' s triangle of order ⍵
{⍕0~¨⍨(-⌽A)⌽↑,/0,¨⍉A∘.!A←0,⍳⍵}
example
{⍕0~¨⍨(-⌽A)⌽↑,/0,¨⍉A∘.!A←0,⍳⍵}5
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
GNU APL doesn't allow multiple statements within lambdas so the solution is phrased differently:
{{⍉⍵∘.!⍵}0,⍳⍵}
example
{{⍉⍵∘.!⍵}0,⍳⍵}3
1 0 0 01 1 0 01 2 1 01 3 3 1
Drawing n rows from a generator:
-------------------- PASCAL'S TRIANGLE --------------------- pascal :: Generator [[Int]]onpascal()scriptnextRowon|λ|(row)zipWith(myplus,{0}&row,row&{0})end|λ|endscriptiterate(nextRow,{1})endpascal--------------------------- TEST -------------------------onrunshowPascal(take(7,pascal()))endrun------------------------ FORMATTING ------------------------ showPascal :: [[Int]] -> StringonshowPascal(xs)setwtolengthofintercalate(" ",item-1ofxs)scriptalignon|λ|(x)|center|(w,space,intercalate(" ",x))end|λ|endscriptunlines(map(align,xs))endshowPascal------------------------- GENERIC -------------------------- center :: Int -> Char -> String -> Stringon|center|(n,cFiller,strText)setlngFillton-(lengthofstrText)iflngFill>0thensetstrPadtoreplicate(lngFilldiv2,cFiller)astextsetstrCentertostrPad&strText&strPadiflngFillmod2>0thencFiller&strCenterelsestrCenterendifelsestrTextendifend|center|-- intercalate :: String -> [String] -> Stringonintercalate(sep,xs)set{dlm,mytext item delimiters}to¬{mytext item delimiters,sep}setstoxsastextsetmytext item delimiterstodlmreturnsendintercalate-- iterate :: (a -> a) -> a -> Generator [a]oniterate(f,x)scriptpropertyv:missing valuepropertyg:mReturn(f)'s|λ|on|λ|()ifmissing valueisvthensetvtoxelsesetvtog(v)endifreturnvend|λ|endscriptenditerate-- length :: [a] -> Inton|length|(xs)setctoclassofxsiflistiscorstringiscthenlengthofxselse2^30-- (simple proxy for non-finite)endifend|length|-- map :: (a -> b) -> [a] -> [b]onmap(f,xs)tellmReturn(f)setlngtolengthofxssetlstto{}repeatwithifrom1tolngsetendoflstto|λ|(itemiofxs,i,xs)endrepeatreturnlstendtellendmap-- min :: Ord a => a -> a -> aonmin(x,y)ify<xthenyelsexendifendmin-- mReturn :: First-class m => (a -> b) -> m (a -> b)onmReturn(f)-- 2nd class handler function lifted into 1st class script wrapper.ifscriptisclassoffthenfelsescriptproperty|λ|:fendscriptendifendmReturn-- plus :: Num -> Num -> Numonplus(a,b)a+bendplus-- Egyptian multiplication - progressively doubling a list, appending-- stages of doubling to an accumulator where needed for binary-- assembly of a target length-- replicate :: Int -> a -> [a]onreplicate(n,a)setoutto{}ifn<1thenreturnoutsetdblto{a}repeatwhile(n>1)if(nmod2)>0thensetouttoout&dblsetnto(ndiv2)setdblto(dbl&dbl)endrepeatreturnout&dblendreplicate-- take :: Int -> [a] -> [a]-- take :: Int -> String -> Stringontake(n,xs)setctoclassofxsiflistiscthenif0<nthenitems1thrumin(n,lengthofxs)ofxselse{}endifelseifstringiscthenif0<nthentext1thrumin(n,lengthofxs)ofxselse""endifelseifscriptiscthensetysto{}repeatwithifrom1tonsetendofystoxs's|λ|()endrepeatreturnyselsemissing valueendifendtake-- unlines :: [String] -> Stringonunlines(xs)set{dlm,mytext item delimiters}to¬{mytext item delimiters,linefeed}setstrtoxsastextsetmytext item delimiterstodlmstrendunlines-- unwords :: [String] -> Stringonunwords(xs)set{dlm,mytext item delimiters}to¬{mytext item delimiters,space}setstoxsastextsetmytext item delimiterstodlmreturnsendunwords-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]onzipWith(f,xs,ys)setlngtomin(|length|(xs),|length|(ys))if1>lngthenreturn{}setxs_totake(lng,xs)-- Allow for non-finitesetys_totake(lng,ys)-- generators like cycle etcsetlstto{}tellmReturn(f)repeatwithifrom1tolngsetendoflstto|λ|(itemiofxs_,itemiofys_)endrepeatreturnlstendtellendzipWith
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
pascalTriangle:function[n][triangle:new[[1]]loop1..decn'x['triangle++@[mapcouple(last triangle)++[0][0]++(last triangle)'x->x\[0]+x\[1]]]returntriangle]looppascalTriangle10'row[printpad.centerjoin.with:" "mapto[:string]row'x->pad.centerx560]
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
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-1LoopParse,%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)LoopParse,p%A_Index%,%A_Space%t.=A_LoopField"`t`t"}GuiAdd,Text,,%t% ; Show result in a GUIGuiShowReturnGuiClose:ExitApp
Alternate
Msgbox%format(pascalstriangle())Returnformat(o) ; converts object to string{Fork,vinos.=IsObject(v)?format(v)"`n":v" "Returns}pascalstriangle(n=7) ; n rows of Pascal's triangle{p:=Object(),z:=Object()Loop,%nLoop,%row:=A_Indexcol:=A_Index,p[row,col]:=row=1andcol=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])Returnp}
n <= 0 returns empty
$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}}'
11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1
// Create a Pascal's triangle with a given number of rows.// Returns an empty array for row_nr <= 0.fun pascals_triangle(row_nr i32) [][]i32 {mut rows := [][]i32// Iterate over all rowsfor r := 0; r < row_nr; r += 1 {// Store the row above the current onemut above := rows[r - 1]// Fill the current row. It contains r + 1 numbersfor i := 0; i <= r; i += 1 {// First number is always 1if i == 0 {rows.push([1]) // Push new row}// Last number is always 1else if i == r {rows[r].push(1)}// Other numbers are the sum of the two numbers above themelse {rows[r].push(above[i - 1] + above[i])}}}return rows}// Helper function to pretty print triangles.// It still get's ugly once numbers have >= 2 digits.fun print_triangle(triangle [][]i32) {for i, row in triangle {// Create string with leading spacesmut s := ' '.repeat(triangle.length - i - 1)// Add each number to the stringfor n in row {s += n.str() + ' '}// Print and trim the extra trailing spaceprintln(s.trim_right(' '))}}fun main() {print_triangle(pascals_triangle(7))}1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 11 6 15 20 15 6 1
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.
DIMiASIntegerDIMrowASIntegerDIMnrowsASIntegerDIMvalues(100)ASIntegerINPUT"Number of rows: ";nrowsvalues(1)=1PRINTTAB((nrows)*3);" 1"FORrow=2TOnrowsPRINTTAB((nrows-row)*3+1);FORi=rowTO1STEP-1values(i)=values(i)+values(i-1)PRINTUSING"##### ";values(i);NEXTiPRINTNEXTrow
10letrow=1220fori=0torow30letc=140printtab(37-i*3);50fork=0toi60printusing" #### ";c;70letc=c*(i-k)/(k+1)80next90print100next
10INPUT"Number of rows? ";R20FORI=0TOR-130LETC=140FORK=0TOI50PRINTUSING"####";C;60LETC=C*(I-K)/(K+1)70NEXTK80PRINT90NEXTI
Same code asBASIC
Same code asBASIC
input"Number of rows? "rfori=0tor-1c=1fork=0toiprintcusing"####";c=c*(i-k)/(k+1)nextprintnext
Based from the Fortran Code.
@echo offsetlocal enabledelayedexpansion::The Main Thing...clsecho.setrow=15call:pascalecho.pauseexit /b 0::/The Main Thing.::The Functions...:pascalset/aprev=%row%-1for/l%%Iin(0,1,%prev%)do(setc=1&setr=for/l%%Kin(0,1,%row%)do(ifnot!c!==0(call:numstr!c!setr=!r!!space!!c!)set/ac=!c!*^(%%I-%%K^)/^(%%K+1^))echo!r!)goto:EOF:numstr::This function returns the number of whitespaces to be applied on each numbers.setcnt=0&setproc=%1&setspace=:loopsetcurrchar=!proc:~%cnt%,1!ifnot"!currchar!"==""set/acnt+=1&gotoloopset/anumspaces=5-!cnt!for/l%%Ain(1,1,%numspaces%)doset"space=!space! "goto:EOF::/The Functions.
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 1Press any key to continue . . .
nrows%=10colwidth%=4@%=colwidth%:REM Set column widthFORrow%=1TOnrows%PRINTSPC(colwidth%*(nrows%-row%)/2);acc%=1FORelement%=1TOrow%PRINTacc%;acc%=acc%*(row%-element%)/element%+0.5NEXTPRINTNEXTrow%
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
get "libhdr"let pascal(n) be for i=0 to n-1 $( let c = 1 for j=1 to 2*(n-1-i) do wrch(' ') for k=0 to i $( writef("%I3 ",c) c := c*(i-k)/(k+1) $) wrch('*N') $) let start() be pascal(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
0" :swor fo rebmuN">:#,_&>55+,vv01*p00-1:g00.:<1p011p00:\-1_v#:<>g:1+10p/48*,:#^_$55+,1+\:^>$$@
Number of rows: 101 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
Displays n rows.
Pascal←{(0⊸∾+∾⟜0)⍟(↕𝕩)⋈1}•Show¨Pascal6
⟨ 1 ⟩⟨ 1 1 ⟩⟨ 1 2 1 ⟩⟨ 1 3 3 1 ⟩⟨ 1 4 6 4 1 ⟩⟨ 1 5 10 10 5 1 ⟩
( 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 )&)
Number of rows?7 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 11 6 15 20 15 6 1
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#include<stdio.h>voidpascaltriangle(unsignedintn){unsignedintc,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");}}intmain(){pascaltriangle(8);return0;}
#include<stdio.h>#define D 32intpascals(int*x,int*y,intd){inti;for(i=1;i<d;i++)printf("%d%c",y[i]=x[i-1]+x[i],i<d-1?' ':'\n');returnD>d?pascals(y,x,d+1):0;}intmain(){intx[D]={0,1,0},y[D]={0};returnpascals(x,y,0);}
voidtriangleC(intnRows){if(nRows<=0)return;int*prevRow=NULL;for(intr=1;r<=nRows;r++){int*currRow=malloc(r*sizeof(int));for(inti=0;i<r;i++){intval=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);}
Produces no output when n is less than or equal to zero.
usingSystem;namespaceRosettaCode{classPascalsTriangle{publicstaticvoidCreateTriangle(intn){if(n>0){for(inti=0;i<n;i++){intc=1;Console.Write(" ".PadLeft(2*(n-1-i)));for(intk=0;k<=i;k++){Console.Write("{0}",c.ToString().PadLeft(3));c=c*(i-k)/(k+1);}Console.WriteLine();}}}publicstaticvoidMain(){CreateTriangle(8);}}}
usingSystem;usingSystem.Linq;usingSystem.Numerics;usingSystem.Collections.Generic;namespaceRosettaCode{publicstaticclassPascalsTriangle{publicstaticIEnumerable<BigInteger[]>GetTriangle(intquantityOfRows){IEnumerable<BigInteger>range=Enumerable.Range(0,quantityOfRows).Select(num=>newBigInteger(num));returnrange.Select(num=>GetRow(num).ToArray());}publicstaticIEnumerable<BigInteger>GetRow(BigIntegerrowNumber){BigIntegerdenominator=1;BigIntegernumerator=rowNumber;BigIntegercurrentValue=1;for(BigIntegercounter=0;counter<=rowNumber;counter++){yieldreturncurrentValue;currentValue=BigInteger.Multiply(currentValue,numerator--);currentValue=BigInteger.Divide(currentValue,denominator++);}yieldbreak;}publicstaticstringFormatTriangleString(IEnumerable<BigInteger[]>triangle){intmaxDigitWidth=triangle.Last().Max().ToString().Length;IEnumerable<string>rows=triangle.Select(arr=>string.Join(" ",arr.Select(array=>CenterString(array.ToString(),maxDigitWidth))));intmaxRowWidth=rows.Last().Length;returnstring.Join(Environment.NewLine,rows.Select(row=>CenterString(row,maxRowWidth)));}privatestaticstringCenterString(stringtext,intwidth){intspaces=width-text.Length;intpadLeft=(spaces/2)+text.Length;returntext.PadLeft(padLeft).PadRight(width);}}}
Example:
staticvoidMain(){IEnumerable<BigInteger[]>triangle=PascalsTriangle.GetTriangle(20);stringoutput=PascalsTriangle.FormatTriangleString(triangle)Console.WriteLine(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 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
#include<iostream>#include<algorithm>#include<cstdio>usingnamespacestd;voidPascal_Triangle(intsize){inta[100][100];inti,j;//first row and first coloumn has the same value=1for(i=1;i<=size;i++){a[i][1]=a[1][i]=1;}//Generate the full Trianglefor(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 1first 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 Formatintrow,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++]);}elseprintf("%6d",a[row--][j++]);}cout<<"\n\n";}}intmain(){//freopen("out.txt","w",stdout);intsize;cin>>size;Pascal_Triangle(size);}}
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>usingnamespacestd;voidprint_vector(vector<int>dummy){for(vector<int>::iteratori=dummy.begin();i!=dummy.end();++i)cout<<*i<<" ";cout<<endl;}voidprint_vector_of_vectors(vector<vector<int>>dummy){for(vector<vector<int>>::iteratori=dummy.begin();i!=dummy.end();++i)print_vector(*i);cout<<endl;}vector<vector<int>>dynamic_triangle(intdummy){vector<vector<int>>result;if(dummy>0){// if the argument is 0 or negative exit immediatelyvector<int>row;// The first rowrow.push_back(1);result.push_back(row);// The second rowif(dummy>1){row.clear();row.push_back(1);row.push_back(1);result.push_back(row);}// The other rowsif(dummy>2){for(inti=2;i<dummy;i++){row.clear();row.push_back(1);for(intj=1;j<i;j++)row.push_back(result.back().at(j-1)+result.back().at(j));row.push_back(1);result.push_back(row);}}}returnresult;}vector<vector<int>>static_triangle(intdummy){vector<vector<int>>result;if(dummy>0){// if the argument is 0 or negative exit immediatelyvector<int>row;result.resize(dummy);// This should work faster than consecutive push_back()s// The first rowrow.resize(1);row.at(0)=1;result.at(0)=row;// The second rowif(result.size()>1){row.resize(2);row.at(0)=1;row.at(1)=1;result.at(1)=row;}// The other rowsif(result.size()>2){for(inti=2;i<result.size();i++){row.resize(i+1);// This should work faster than consecutive push_back()srow.front()=1;for(intj=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;}}}returnresult;}intmain(){vector<vector<int>>triangle;intn;cout<<endl<<"The Pascal's Triangle"<<endl<<"Enter the number of rows: ";cin>>n;// Call the dynamic functiontriangle=dynamic_triangle(n);cout<<endl<<"Calculated using dynamic vectors:"<<endl<<endl;print_vector_of_vectors(triangle);// Call the static functiontriangle=static_triangle(n);cout<<endl<<"Calculated using static vectors:"<<endl<<endl;print_vector_of_vectors(triangle);return0;}
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>usingnamespacestd;classpascal_triangle{vector<vector<int>>data;// This is the actual datavoidprint_row(vector<int>dummy){for(vector<int>::iteratori=dummy.begin();i!=dummy.end();++i)cout<<*i<<" ";cout<<endl;}public:pascal_triangle(intdummy){// Everything is done on the construction phaseif(dummy>0){// if the argument is 0 or negative exit immediatelyvector<int>row;data.resize(dummy);// Theoretically this should work faster than consecutive push_back()s// The first rowrow.resize(1);row.at(0)=1;data.at(0)=row;// The second rowif(data.size()>1){row.resize(2);row.at(0)=1;row.at(1)=1;data.at(1)=row;}// The other rowsif(data.size()>2){for(inti=2;i<data.size();i++){row.resize(i+1);// Theoretically this should work faster than consecutive push_back()srow.front()=1;for(intj=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>>::iteratori=data.begin();i!=data.end();++i)i->clear();// I'm not sure about the necessity of this loop!data.clear();}voidprint_row(intdummy){if(dummy<data.size())for(vector<int>::iteratori=data.at(dummy).begin();i!=data.at(dummy).end();++i)cout<<*i<<" ";cout<<endl;}voidprint(){for(inti=0;i<data.size();i++)print_row(i);}intget_coeff(intdummy1,intdummy2){intresult=0;if((dummy1<data.size())&&(dummy2<data.at(dummy1).size()))result=data.at(dummy1).at(dummy2);returnresult;}vector<int>get_row(intdummy){vector<int>result;if(dummy<data.size())result=data.at(dummy);returnresult;}};intmain(){intn;cout<<endl<<"The Pascal's Triangle with a class!"<<endl<<endl<<"Enter the number of rows: ";cin>>n;pascal_trianglemyptri(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;return0;}
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).
(defnpascal[n](let[newrow(fnnewrow[lstret](iflst(recur(restlst)(conjret(+(firstlst)(or(secondlst)0))))ret))genrow(fngenrow[nlst](when(<0n)(do(printlnlst)(recur(decn)(conj(newrowlst[])1)))))](genrown[1])))(pascal4)
And here's another version, using thepartition function to produce the sequence of pairs in a row, which are summed and placed between two ones to produce the next row:
(defnnextrow[row](vec(concat[1](map#(apply+%)(partition21row))[1])))(defnpascal[n](assert(and(integer?n)(pos?n)))(let[triangle(taken(iteratenextrow[1]))](doseq[rowtriangle](printlnrow))))
Theassert form causes thepascal function to throw an exception unless the argument is (integral and) positive.
Here's a third version using theiterate function
(defpascal(iterate(fn[prev-row](->>(concat[[(firstprev-row)]](partition21prev-row)[[(lastprev-row)]])(map(partialapply+),,,)))[1]))
Another short version which returns an infinite pascal triangle as a list, using the iterate function.
(defpascal(iterate#(concat[1](map+%(rest%))[1])[1]))
One can then get the first n rows using the take function
(take10pascal); returns a list of the first 10 pascal rows
Also, one can retrieve the nth row using the nth function
(nthpascal10);returns the nth row
This version assumes n is an integer and n >= 1. It efficiently computes binomial coefficients.
pascal=(n) ->width=6forrin[1..n]s=ws(width/2)*(n-r)# center rowoutput=(n) ->s+=padwidth,ncell=1outputcell# Compute binomial coefficients as you go# across the row.forcin[1...r]cell*=(r-c)/coutputcellconsole.logsws=(n) ->s=''s+=' 'foriin[0...n]spad=(cnt, n) ->s=n.toString()# There is probably a better way to do this.cnt-=s.lengthright=Math.floor(cnt/2)left=cnt-rightws(left)+s+ws(right)pascal(7)
> 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
10INPUT"HOW MANY";N20IFN<1THENEND30DIMC(N)40DIMD(N)50LETC(1)=160LETD(1)=170FORJ=1TON80FORI=1TON-J+190PRINT" ";100NEXTI110FORI=1TOJ120PRINTC(I)" ";130NEXTI140PRINT150IFJ=NTHENEND160C(J+1)=1170D(J+1)=1180FORI=1TOJ-1190D(I+1)=C(I)+C(I+1)200NEXTI210FORI=1TOJ220C(I)=D(I)230NEXTI240NEXTJ
Output:
RUNHOW MANY? 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 1 8 28 56 70 56 28 8 1READY.
To evaluate, call (pascal n). For n < 1, it simply returns nil.
(defunpascal(n)(genrown'(1)))(defungenrow(nl)(when(pluspn)(printl)(genrow(1-n)(cons1(newrowl)))))(defunnewrow(l)(if(null(restl))'(1)(cons(+(firstl)(secondl))(newrow(restl)))))
An iterative solution withloop, usingnconc instead ofcollect to keep track of the lastcons. Otherwise, it would be necessary to traverse the list to do a(rplacd (last a) (list 1)).
(defunpascal-next-row(a)(loop:forq:ina:andp=0:thenq:ass=(list(+pq)):nconcs:intoa:finally(rplacds(list1))(returna)))(defunpascal(n)(loop:fora=(list1):then(pascal-next-rowa):repeatn:collecta))
Another iterative solution, this time using pretty-printing to automatically print the triangle in the shape of a triangle in the terminal. The print-pascal-triangle function computes and uses the length of the printed last row to decide how wide the triangle should be.
(defunnext-pascal-triangle-row(list)`(1,.(mapcar#'+list(restlist))1))(defunpascal-triangle(number-of-rows)(looprepeatnumber-of-rowsforrow='(1)then(next-pascal-triangle-rowrow)collectrow))(defunprint-pascal-triangle(number-of-rows)(let*((triangle(pascal-trianglenumber-of-rows))(max-row-length(length(write-to-string(first(lasttriangle))))))(formatt(formatnil"~~{~~~D:@<~~{~~A ~~}~~>~~%~~}"max-row-length)triangle)))
For example:
(print-pascal-triangle4)
1 1 1 1 2 1 1 3 3 1
(print-pascal-triangle8)
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
MODULEPascalTriangle;IMPORTStdLog,DevCommanders,TextMappers;TYPEExpansion*=POINTERTOARRAYOFLONGINT;PROCEDUREShow*(e:Expansion);VARi:INTEGER;BEGINi:=0;WHILE(i<LEN(e))&(e[i]#0)DOStdLog.Int(e[i]);INC(i)END;StdLog.LnENDShow;PROCEDUREGenFor*(p:LONGINT):Expansion;VARexpA,expB:Expansion;i,j:LONGINT;PROCEDURESwap(VARx,y:Expansion);VARswap:Expansion;BEGINswap:=x;x:=y;y:=swapENDSwap;BEGINASSERT(p>=0);NEW(expA,p+2);NEW(expB,p+2);FORi:=0TOpDOIFi=0THENexpA[0]:=1ELSEFORj:=0TOiDOIFj=0THENexpB[j]:=expA[j]ELSEexpB[j]:=expA[j-1]+expA[j]ENDEND;Swap(expA,expB)END;END;expB:=NIL;(* for the GC *)RETURNexpAENDGenFor;PROCEDUREDo*;VARs:TextMappers.Scanner;exp:Expansion;BEGINs.ConnectTo(DevCommanders.par.text);s.SetPos(DevCommanders.par.beg);s.Scan;WHILE(~s.rider.eot)DOIF(s.type=TextMappers.char)&(s.char='~')THENRETURNELSIF(s.type=TextMappers.int)THENexp:=GenFor(s.int);Show(exp)END;s.ScanENDENDDo;ENDPascalTriangle.
Execute: ^Q PascalTriangle.Do 0 1 2 3 4 5 6 7 8 9 10 11 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 1 12 66 220 495 792 924 792 495 220 66 12 1
int[][]pascalsTriangle(inintrows)purenothrow{autotri=newint[][rows];foreach(r;0..rows){intv=1;foreach(c;0..r+1){tri[r]~=v;v=(v*(r-c))/(c+1);}}returntri;}voidmain(){immutablet=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]]);}
importstd.stdio,std.algorithm,std.range;autopascal()purenothrow{return[1].recurrence!q{zip(a[n-1]~0,0~a[n-1]).map!q{a[0]+a[1]}.array};}voidmain(){pascal.take(5).writeln;}
[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
There is similarity between Pascal's triangle andSierpinski 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).
importstd.stdio,std.string,std.array,std.format;stringPascal(aliasdg,T,TinitValue)(intn){stringoutput;voidappend(inT[]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 + 1foreach(intj;1..lines[i-1].length)lines[i][j]=dg(lines[i-1][j],lines[i-1][j-1]);append(lines[i]);}}returnoutput;}stringdelegate(intn)genericPascal(aliasdg,T,TinitValue)(){mixinPascal!(dg,T,initValue);return&Pascal;}voidmain(){autopascal=genericPascal!((inta,intb)=>a+b,int,1)();staticcharxor(chara,charb){returna==b?'_':'*';}autosierpinski=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 operationforeach(i;[16])writef(sierpinski(i));}
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 * * * * _ * * * * * * _ _ _ * * * _ _ * * * _ * _ * _ * * * * * * * * * * _ _ _ _ _ _ _ * * * _ _ _ _ _ _ * * * _ * _ _ _ _ _ * _ * * * * * _ _ _ _ * * * * * _ _ _ * _ _ _ * _ _ _ * * * _ _ * * _ _ * * _ _ * * * _ * _ * _ * _ * _ * _ * _ * * * * * * * * * * * * * * * * *
import'dart:io';pascal(n){if(n<=0)print("Not defined");elseif(n==1)print(1);else{List<List<int>>matrix=newList<List<int>>();matrix.add(newList<int>());matrix.add(newList<int>());matrix[0].add(1);matrix[1].add(1);matrix[1].add(1);for(vari=2;i<n;i++){List<int>list=newList<int>();list.add(1);for(varj=1;j<i;j++){list.add(matrix[i-1][j-1]+matrix[i-1][j]);}list.add(1);matrix.add(list);}for(vari=0;i<n;i++){for(varj=0;j<=i;j++){stdout.write(matrix[i][j]);stdout.write(' ');}stdout.write('\n');}}}voidmain(){pascal(0);pascal(1);pascal(3);pascal(6);}
programPascalsTriangle;procedurePascal(r:Integer);vari,c,k:Integer;beginfori:=0tor-1dobeginc:=1;fork:=0toidobeginWrite(c:3);c:=c*(i-k)div(k+1);end;Writeln;end;end;beginPascal(9);end.
createorreplacefunctionpascal_triangle(n)astable(withrecursivecteas(SELECT0asi,[1]::BIGINT[]asrow,UNIONALLSELECTi+1asi,([1]||list_transform(row,(x,ix)->x+(coalesce(row[ix+1],0))))asrowFROMcteWHEREi<n)selectrowas"pascal_triangle"FROMcteorderbyi);.printTheresultsforalln<=0arethesame:select*as"pascal_triangle(0)"frompascal_triangle(0);frompascal_triangle(4)_("pascal_triangle(4)");
The results for all n<=0 are the same:┌────────────────────┐│ pascal_triangle(0) ││ int64[] │├────────────────────┤│ [1] │└────────────────────┘┌────────────────────┐│ pascal_triangle(4) ││ int64[] │├────────────────────┤│ [1] ││ [1, 1] ││ [1, 2, 1] ││ [1, 3, 3, 1] ││ [1, 4, 6, 4, 1] │└────────────────────┘
Doesn't print anything for negative or null values.
procedurePascal(r:Integer);vari,c,k:Integer;beginfori:=0tor-1dobeginc:=1;fork:=0toidobeginPrint(Format('%4d',[c]));c:=(c*(i-k))div(k+1);end;PrintLn('');end;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
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")numfmt 0 4proc pascal n . . r[] = [ 1 ] for i to n rn[] = [ ] l = 0 for j to n - len r[] write " " . for r in r[] write r rn[] &= l + r l = r . print "" rn[] &= l swap r[] rn[] ..pascal 13
notedescription:"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) ]"classAPPLICATIONinheritARGUMENTScreatemakefeature{NONE}-- Initializationmakelocaln:INTEGERdocreate{HASH_TABLE[ARRAY[INTEGER],INTEGER]}pascal_lines.make(n)--create the hash_table objectio.new_linen:=25draw(n)endfeatureline(n:INTEGER):ARRAY[INTEGER]--Calculates the n'th linelocalupper_line:ARRAY[INTEGER]i:INTEGERdoifn=1then--trivial case first linecreateResult.make_filled(0,1,n+2)Result.put(0,1)Result.put(1,2)Result.put(0,3)elseifpascal_lines.has(n)then--checks if the result was already calculatedResult:=pascal_lines.at(n)else--calculates the n'th line recursivelycreateResult.make_filled(0,1,n+2)--for caluclation purposes add a 0 at the beginning of each lineResult.put(0,1)upper_line:=line(n-1)fromi:=1untili>upper_line.count-1loopResult.put(upper_line[i]+upper_line[i+1],i+1)i:=i+1endResult.put(0,n+2)--for caluclation purposes add a 0 at the end of each linepascal_lines.put(Result,n)endenddraw(n:INTEGER)--draw n lines of pascal's trianglelocalspace_string:STRINGwidth,i:INTEGERdospace_string:=" "--question of design: add space_string at the beginning of each linewidth:=line(n).countspace_string.multiply(width)fromi:=1untili>nloopspace_string.remove_tail(1)io.put_string(space_string)acrossline(i)ascloopifc.item/=0thenio.put_string(c.item.out+" ")endendio.new_linei:=i+1endendfeature--Accesspascal_lines:HASH_TABLE[ARRAY[INTEGER],INTEGER]--Contains all already calculated linesend
defmodulePascaldodeftriangle(n),do:triangle(n,[1])deftriangle(0,list),do:listdeftriangle(n,list)doIO.inspectlistnew_list=Enum.zip([0]++list,list++[0])|>Enum.map(fn{a,b}->a+bend)triangle(n-1,new_list)endendPascal.triangle(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]
(require'cl-lib)(defunnext-row(row)(cl-mapcar#'+(cons0row)(appendrow'(0))))(defuntriangle(rowrows)(if(=rows0)'()(consrow(triangle(next-rowrow)(-rows1)))))
Call the function from the REPL, IELM:
ELISP> (triangle (list 1) 6)((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1) (1 5 10 10 5 1))
(defunpascal(r)(dotimes(ir)(let((c1))(dotimes(k(+i1))(princ(format"%d "c))(setqc(/(*c(-ik))(+k1))))(terpri))))
From the REPL:
ELISP> (princ (pascal 6))1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
Same as the translation from Pascal, but now returning a string.
(defunpascal(r)(let((out""))(dotimes(ir)(let((c1))(dotimes(k(+i1))(setqout(concatout(format"%d "c)))(setqc(/(*c(-ik))(+k1))))(setqout(concatout"\n"))))out))
Now, since this one returns a string, it is possible to insert the result in the current buffer:
(insert (pascal 6))1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
-import(lists).-export([pascal/1]).pascal(1)->[[1]];pascal(N)->L=pascal(N-1),[H|_]=L,[lists:zipwith(fun(X,Y)->X+Yend,[0]++H,H++[0])|L].
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]]
PROGRAM PASCAL_TRIANGLEPROCEDURE 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 PROCEDUREBEGIN PASCAL(9)END PROGRAMOutput:
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
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 {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}Binding the names PASCAL and BINCOEFF to the following lambda expressions in the Name Manager of the Excel WorkBook, to define Pascal's triangle in terms of binomial coefficients:
(SeeLAMBDA: The ultimate Excel worksheet function)
PASCAL=LAMBDA(n,BINCOEFF(n-1)(SEQUENCE(1,n,0,1)))BINCOEFF=LAMBDA(n,LAMBDA(k,QUOTIENT(FACT(n),FACT(k)*FACT(n-k))))
| fx | =PASCAL(A2) | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| A | B | C | D | E | F | G | H | I | J | K | ||
| 1 | Row number | PASCAL's TRIANGLE | ||||||||||
| 2 | 1 | 1 | ||||||||||
| 3 | 2 | 1 | 1 | |||||||||
| 4 | 3 | 1 | 2 | 1 | ||||||||
| 5 | 4 | 1 | 3 | 3 | 1 | |||||||
| 6 | 5 | 1 | 4 | 6 | 4 | 1 | ||||||
| 7 | 6 | 1 | 5 | 10 | 10 | 5 | 1 | |||||
| 8 | 7 | 1 | 6 | 15 | 20 | 15 | 6 | 1 | ||||
| 9 | 8 | 1 | 7 | 21 | 35 | 35 | 21 | 7 | 1 | |||
| 10 | 9 | 1 | 8 | 28 | 56 | 70 | 56 | 28 | 8 | 1 | ||
| 11 | 10 | 1 | 9 | 36 | 84 | 126 | 126 | 84 | 36 | 9 | 1 | |
Or defining the whole triangle as a single grid, by binding the name TRIANGLE to an additional lambda:
TRIANGLE=LAMBDA(n,LET(ixs,SEQUENCE(n,n,0,1),x,MOD(ixs,n),y,QUOTIENT(ixs,n),IF(x<=y,BINCOEFF(y)(x),"")))
| fx | =TRIANGLE(10) | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| A | B | C | D | E | F | G | H | I | J | K | ||
| 1 | PASCAL's TRIANGLE | |||||||||||
| 2 | 1 | |||||||||||
| 3 | 1 | 1 | ||||||||||
| 4 | 1 | 2 | 1 | |||||||||
| 5 | 1 | 3 | 3 | 1 | ||||||||
| 6 | 1 | 4 | 6 | 4 | 1 | |||||||
| 7 | 1 | 5 | 10 | 10 | 5 | 1 | ||||||
| 8 | 1 | 6 | 15 | 20 | 15 | 6 | 1 | |||||
| 9 | 1 | 7 | 21 | 35 | 35 | 21 | 7 | 1 | ||||
| 10 | 1 | 8 | 28 | 56 | 70 | 56 | 28 | 8 | 1 | |||
| 11 | 1 | 9 | 36 | 84 | 126 | 126 | 84 | 36 | 9 | 1 | ||
letrecnextrowl=matchlwith|[]->[]|h::[]->[1]|h::t->h+t.Head::nextrowtletpascalTrin=List.scan(funli->1::nextrowl)[1][1..n]forrowinpascalTri(10)doforiinrowdoprintf"%s"(i.ToString()+", ")printfn"%s""\n"
This implementation works by summing the previous line content. Result for n < 1 is the same as for n == 1.
USING:groupingkernelmathsequences;:(pascal)(seq--newseq)duplast0prefix0suffix2<clumps>[sum]mapsuffix;:pascal(n--seq)1-{{1}}swap[(pascal)]times;
It works as:
5pascal.{{1}{1 1}{1 2 1}{1 3 3 1}{1 4 6 4 1}}
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) }}1.1 S OLD(1)=1; T %4.0, 1, !1.2 F N=1,10; D 21.3 Q2.1 S NEW(1)=12.2 F X=1,N; S NEW(X+1)=OLD(X)+OLD(X+1)2.3 F X=1,N+1; D 32.4 T !3.1 S OLD(X)=NEW(X)3.2 T %4.0, OLD(X)
= 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
:init( n -- )hereswapcellserase1here!;:.line( n -- )crhereswap0dodup@.cell+loopdrop;:next( n -- )hereswap1-cellshere+doi@icell++!-1cells+loop;:pascal( n -- )dupinit1.line1?doinexti1+.lineloop;
This is a bit more efficient.
:PascTrianglecrdup0?do1over1-i-2*spacesi1+0?dodup4.rji-*i1+/loopcrdroploopdrop;13PascTriangle
Prints nothing for n<=0. Output formatting breaks down for n>20
PROGRAMPascals_TriangleCALLPrint_Triangle(8)END PROGRAMPascals_TriangleSUBROUTINEPrint_Triangle(n)IMPLICIT NONEINTEGER,INTENT(IN)::nINTEGER::c,i,j,k,spacesDOi=0,n-1c=1spaces=3*(n-1-i)DOj=1,spacesWRITE(*,"(A)",ADVANCE="NO")" "END DO DOk=0,iWRITE(*,"(I6)",ADVANCE="NO")cc=c*(i-k)/(k+1)END DO WRITE(*,*)END DOEND SUBROUTINEPrint_Triangle
' FB 1.05.0 Win64SubpascalTriangle(nAsUInteger)Ifn=0ThenReturnDimprevRow(1Ton)AsUIntegerDimcurrRow(1Ton)AsUIntegerDimstart(1Ton)AsUInteger''stores starting column for each rowstart(n)=1ForiAsInteger=n-1To1Step-1start(i)=start(i+1)+3NextprevRow(1)=1PrintTab(start(1));Print1UForiAsUInteger=2TonForjAsUInteger=1ToiIfj=1ThenPrintTab(start(i));"1";currRow(1)=1ElseIfj=iThenPrint" 1"currRow(i)=1ElsecurrRow(j)=prevRow(j-1)+prevRow(j)PrintUsing"######";currRow(j);" ";EndIfNextjForjAsUInteger=1ToiprevRow(j)=currRow(j)NextjNextiEndSubpascalTriangle(14)PrintPrint"Press any key to quit"Sleep
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 11 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
This version takes a little effort to automatically format the tree based upon the width of the largest numbers in the bottom row. It automatically calculates this easily using Frink's builtin function for efficiently calculating (even large) binomial coefficients with cached factorials and binary splitting.
pascal[rows] :={ widest = length[toString[binomial[rows-1, (rows-1) div 2]]] for row = 0 to rows-1 { line = repeat[" ", round[(rows-row)* (widest+1)/2]] for col = 0 to row line = line + padRight[binomial[row, col], widest+1, " "] println[line] }}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
import lists.zipdef pascal( 1 ) = [1] pascal( n ) = [1] + map( (a, b) -> a + b, zip(pascal(n-1), pascal(n-1).tail()) ) + [1]
import integers.choosedef pascal( n ) = [choose( n - 1, k ) | k <- 0..n-1]
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 )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
include "NSLog.incl"NSLogSetTitle( @"Pascal's Triangle" )NSLogSetTextAlignment( NSTextAlignmentCenter )clear local fn pyramid( n as int ) int v( 20, 20 ) v( 0, 1 ) = 1 nslog( @"\n 1 " ) for int y = 1 to n -1 for int x = 1 to y + 1 v( y, x ) = v( y - 1, x - 1 ) + v( y - 1, x ) nslog( @"%4d \b", v( y, x ) ) next nslog( @"" ) nextend fnfn pyramid( 15 )handleevents
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in itswebsite.
Inthis page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
Test case
Pascal:=function(n)locali,v;v:=[1];foriin[1..n]doDisplay(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 ]
No output for n < 1. Otherwise, output formatted left justified.
packagemainimport"fmt"funcprintTriangle(nint){// degenerate casesifn<=0{return}fmt.Println(1)ifn==1{return}// iterate over rows, zero baseda:=make([]int,(n+1)/2)a[0]=1forrow,middle:=1,0;row<n;row++{// generate new roweven:=row&1==0ifeven{a[middle+1]=a[middle]*2}fori:=middle;i>0;i--{a[i]+=a[i-1]}// print rowfori:=0;i<=middle;i++{fmt.Print(a[i]," ")}ifeven{middle++}fori:=middle;i>=0;i--{fmt.Print(a[i]," ")}fmt.Println("")}}funcmain(){printTriangle(4)}
Output:
11 11 2 11 3 3 1
{[1]\{.p.(;[\\]zip);{~+}%1\+1+}*}:pas;5 pas;[1][1 1][1 2 1][1 3 3 1][1 4 6 4 1]
In the spirit of the Haskell "think in whole lists" solution here is a list-driven, minimalist solution:
defpascalpascal={n->(n<=1)?[1]:[[0]+pascal(n-1),pascal(n-1)+[0]].transpose().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:
defcount=15(1..count).each{n->printf("%2d:",n);(0..(count-n)).each{print" "};pascal(n).each{printf("%6d ",it)};println""}
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
10INPUT"Number of rows? ",R20FORI=0TOR-130C=140FORK=0TOI50PRINTUSING"####";C;60C=C*(I-K)/(K+1)70NEXT80PRINT90NEXT
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 inthe triangle can be calculated from the previous row by adding ashifted version of itself to it, keeping the ones at the ends. ThePrelude functionzipWith can be used to add two lists, but itwon't keep the old values when one list is shorter. So we need asimilar function
zapWith::(a->a->a)->[a]->[a]->[a]zapWithfxs[]=xszapWithf[]ys=yszapWithf(x:xs)(y:ys)=fxy:zapWithfxsys
Now we can shift a list and add it to itself, extending it by keepingthe ends:
extendWithf[]=[]extendWithfxs@(x:ys)=x:zapWithfxsys
And for the whole (infinite) triangle, we just iterate this operation,starting with the first row:
pascal=iterate(extendWith(+))[1]
For the firstn rows, we just take the firstn elements from thislist, as in
*Main>take6pascal[[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 rownextRowrow=zipWith(+)([0]++row)(row++[0])-- returns the first n rowspascal=iteratenextRow[1]
Or rewriting nextRow applicatively, and avoiding (++) where we can use (:)
nextRow=(zipWith(+).(0:))<*>(<>[0])
Which we can also express in terms of reverse:
nextRow=(zipWith(+)<*>reverse).(0:)
Alternatively, using list comprehensions:
pascal::[[Integer]]pascal=(1:[0|_<-headpascal]):[zipWith(+)(0:row)row|row<-pascal]
*Pascal>take5<$>(take5$triangle)[[1,0,0,0,0],[1,1,0,0,0],[1,2,1,0,0],[1,3,3,1,0],[1,4,6,4,1]]
With binomial coefficients:
fac=product.enumFromTo1binCoefnk=facn`div`(fack*fac(n-k))pascal=((fmap.binCoef)<*>enumFromTo0).pred
Example:
*Main>putStr$unlines$mapunwords$map(mapshow)$pascal1011112113311464115101051161520156117213535217118285670562881193684126126843691
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
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.
linkmathproceduremain(A)everyn:=!Ado{# for each command line argumentn:=integer(\n)|&nullpascal(n)}endprocedurepascal(n)#: Pascal triangle/n:=16write("width=",n," height=",n)# carpet headerfw:=*(2^n)+1everyi:=0ton-1do{writes(repl(" ",fw*(n-i)/2))everyj:=0ton-1dowrites(center(binocoef(i,j),fw)|break)write()}end
math provides binocoefmath provides the original version of pascal
Sample output:
->pascal 1 4 8width=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 ->
ProPascal,n;n is the number of lines of the triangle to be displayedr=[1]print,rfori=0,(n-2)dobeginpascalrow,rendforEndProPascalRow,rfori=0,(n_elements(r)-2)dobeginr[i]=r[i]+r[i+1]endforr=[1,r]print,rEnd
100 PROGRAM "PascalTr.bas"110 TEXT 80120 LET ROW=12130 FOR I=0 TO ROW140 LET C=1150 PRINT TAB(37-I*3);160 FOR K=0 TO I170 PRINT USING " #### ":C;180 LET C=C*(I-K)/(K+1)190 NEXT200 PRINT210 NEXT
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
op pascal N = transp (0 , iota N) o.! -1 , iota Npascal 5 1 0 0 0 0 0 1 1 0 0 0 0 1 2 1 0 0 0 1 3 3 1 0 0 1 4 6 4 1 0 1 5 10 10 5 1
!~/~i.51000011000121001331014641
([:":@-.&0"1!~/~)@i.5111121133114641
(-@|.|."_1[:":@-.&0"1!~/~)@i.5111121133114641
However, multi-digit numbers take up additional space, which looks slightly odd. But we can work around that by adding additional padding and shifting the lines a bit more:
(|."_1~0-3*i.@-@#);@((<'%6d')sprintfeach-.&0)"1!~/~i.1011112113311464115101051161520156117213535217118285670562881193684126126843691
Also... when we mix positive and negative numbers it stops being a triangle:
i:5_5_4_3_2_1012345!~/~i:5100001_515_3570_126_410001_410_2035_566_31001_36_1015_21_43_2101_23_45_61_11_111_11_11_100000100000000001100000000012100000000133100000001464100000015101051!/~i:51_46_4100000001_33_1000000001_210000000001_10000000000100000011111111111_5_4_3_2_101234515106310013610_35_20_10_4_1000141070351551000015_126_56_21_6_1000001
See thetalk page for explanation of earlier version
See alsoPascal matrix generation andSierpinski triangle.
importjava.util.ArrayList;...//class definition, etc.publicstaticvoidgenPyrN(introws){if(rows<0)return;//save the last row hereArrayList<Integer>last=newArrayList<Integer>();last.add(1);System.out.println(last);for(inti=1;i<=rows;++i){//work on the next rowArrayList<Integer>thisRow=newArrayList<Integer>();thisRow.add(last.get(0));//beginningfor(intj=1;j<i;++j){//loop the number of elements in this row//sum from the last rowthisRow.add(last.get(j-1)+last.get(j));}thisRow.add(last.get(0));//endlast=thisRow;//save this rowSystem.out.println(thisRow);}}
This method is limited to 21 rows because of the limits oflong. Callingpas with an argument of 22 or above will cause intermediate math to wrap around and give false answers.
publicclassPas{publicstaticvoidmain(String[]args){//usagepas(20);}publicstaticvoidpas(introws){for(inti=0;i<rows;i++){for(intj=0;j<=i;j++){System.out.print(ncr(i,j)+" ");}System.out.println();}}publicstaticlongncr(intn,intr){returnfact(n)/(fact(r)*fact(n-r));}publicstaticlongfact(intn){longans=1;for(inti=2;i<=n;i++){ans*=i;}returnans;}}
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.
publicclassPascal{privatestaticvoidprintPascalLine(intn){if(n<1)return;intm=1;System.out.print("1 ");for(intj=1;j<n;j++){m=m*(n-j)/j;System.out.print(m);System.out.print(" ");}System.out.println();}publicstaticvoidprintPascal(intnRows){for(inti=1;i<=nRows;i++)printPascalLine(i);}}
// Pascal's triangle objectfunctionpascalTriangle(rows){// Number of rows the triangle containsthis.rows=rows;// The 2D array holding the rows of the trianglethis.triangle=newArray();for(varr=0;r<rows;r++){this.triangle[r]=newArray();for(vari=0;i<=r;i++){if(i==0||i==r)this.triangle[r][i]=1;elsethis.triangle[r][i]=this.triangle[r-1][i-1]+this.triangle[r-1][i];}}// Method to print the trianglethis.print=function(base){if(!base)base=10;// Private method to calculate digits in numbervardigits=function(n,b){vard=0;while(n>=1){d++;n/=b;}returnd;}// Calculate max spaces neededvarspacing=digits(this.triangle[this.rows-1][Math.round(this.rows/2)],base);// Private method to add spacing between numbersvarinsertSpaces=function(s){varbuf="";while(s>0){s--;buf+=" ";}returnbuf;}// Print the triangle line by linefor(varr=0;r<this.triangle.length;r++){varl="";for(vars=0;s<Math.round(this.rows-1-r);s++){l+=insertSpaces(spacing);}for(vari=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 10vartri=newpascalTriangle(4);tri.print();// Display 8 row triangle in base 16tri=newpascalTriangle(8);tri.print(16);
Output:
$ d8 pascal.js 1 1 1 1 2 11 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 11 7 15 23 23 15 7 1
(function (n) { 'use strict'; // PASCAL TRIANGLE -------------------------------------------------------- // pascal :: Int -> [[Int]] function pascal(n) { return foldl(function (a) { var xs = a.slice(-1)[0]; // Previous row return append(a, [zipWith( function (a, b) { return a + b; }, append([0], xs), append(xs, [0]) )]); }, [ [1] // Initial seed row ], enumFromTo(1, n - 1)); }; // GENERIC FUNCTIONS ------------------------------------------------------ // (++) :: [a] -> [a] -> [a] function append(xs, ys) { return xs.concat(ys); }; // enumFromTo :: Int -> Int -> [Int] function enumFromTo(m, n) { return Array.from({ length: Math.floor(n - m) + 1 }, function (_, i) { return m + i; }); }; // foldl :: (b -> a -> b) -> b -> [a] -> b function foldl(f, a, xs) { return xs.reduce(f, a); }; // foldr (a -> b -> b) -> b -> [a] -> b function foldr(f, a, xs) { return xs.reduceRight(f, a); }; // map :: (a -> b) -> [a] -> [b] function map(f, xs) { return xs.map(f); }; // min :: Ord a => a -> a -> a function min(a, b) { return b < a ? b : a; }; // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] function zipWith(f, xs, ys) { return Array.from({ length: min(xs.length, ys.length) }, function (_, i) { return f(xs[i], ys[i]); }); }; // TEST and FORMAT -------------------------------------------------------- var lstTriangle = pascal(n); // [[a]] -> bool -> s -> s function wikiTable(lstRows, blnHeaderRow, strStyle) { return '{| ' + (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);| 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]]
(() => { "use strict"; // ---------------- PASCAL'S TRIANGLE ---------------- // pascal :: Generator [[Int]] const pascal = () => iterate( xs => zipWith( a => b => a + b )( [0, ...xs] )( [...xs, 0] ) )([1]); // ---------------------- TEST ----------------------- // main :: IO () const main = () => showPascal( take(10)( pascal() ) ); // showPascal :: [[Int]] -> String const showPascal = xs => { const w = last(xs).join(" ").length; return xs.map( ys => center(w)(" ")(ys.join(" ")) ) .join("\n"); }; // ---------------- GENERIC FUNCTIONS ---------------- // center :: Int -> Char -> String -> String const center = n => // Size of space -> filler Char -> // String -> Centered String c => s => { const gap = n - s.length; return 0 < gap ? (() => { const margin = c.repeat(Math.floor(gap / 2)), dust = c.repeat(gap % 2); return `${margin}${s}${margin}${dust}`; })() : s; }; // iterate :: (a -> a) -> a -> Gen [a] const iterate = f => // An infinite list of repeated // applications of f to x. function* (x) { let v = x; while (true) { yield v; v = f(v); } }; // last :: [a] -> a const last = xs => 0 < xs.length ? xs.slice(-1)[0] : undefined; // take :: Int -> [a] -> [a] // take :: Int -> String -> String const take = n => // The first n elements of a list, // string of characters, or stream. xs => "GeneratorFunction" !== xs .constructor.constructor.name ? ( xs.slice(0, n) ) : Array.from({ length: n }, () => { const x = xs.next(); return x.done ? [] : [x.value]; }).flat(); // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] const zipWith = f => // A list constructed by zipping with a // custom function, rather than with the // default tuple constructor. xs => ys => xs.map( (x, i) => f(x)(ys[i]) ).slice( 0, Math.min(xs.length, ys.length) ); // MAIN --- return main();})();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
const aux = n => { if(n <= 1) return [1] const prevLayer = aux(n - 1) const shifted = [0, ...prevLayer] return shifted.map((x, i) => (prevLayer[i] || 0) + x)}const pascal = n => { for(let i = 1; i <= n; i++) { console.log(aux(i).join(' ')) }}pascal(8)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 1
const aux = (() => { const layers = [[1], [1]] return n => { if(layers[n]) return layers[n] const prevLayer = aux(n - 1) const shifted = [0, ...prevLayer] layers[n] = shifted.map((x, i) => (prevLayer[i] || 0) + x) return layers[n] }})()const pascal = n => { for(let i = 1; i <= n; i++) { console.log(aux(i).join(' ')) }}pascal(8)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)
$ 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;
function pascal(n) if n<=0 print("n has to have a positive value") end x=0 while x<=n for a=0:x print(binomial(x,a)," ") end println("") x+=1 endendpascal(5)1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
Another solution using matrix exponentiation.
iround(x) = round(Int64, x)triangle(n) = iround.(exp(diagm(-1=> 1:n)))function pascal(n) t=triangle(n) println.(join.([filter(!iszero, t[i,:]) for i in 1:(n+1)], " "))end
pascal(5)11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1
Yet another solution using a static vector
function pascal(n) (n<=0) && error("Pascal trinalge can not have zero or negative rows") r=Vector{Int}(undef,n) pr=Vector{Int}(undef,n) pr[1]=r[1]=1 println(@view pr[1]) for i=2:n r[1]=r[i]=1 for j=2:i-1 r[j]=pr[j-1]+pr[j] end println(join(view(r,1:i), " ")) r,pr=pr,r endendpascal(8)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 1
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)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())1) Based on this expression of pascalian binomial: Cnp = [n*(n-1)...(n-p+1)]/[p*(p-1)...2*1]2) we define the following function:{def C {lambda {:n :p} {/ {* {S.serie :n {- :n :p -1} -1}} {* {S.serie :p 1 -1}}}}}{C 16 8}-> 128703) Writing1{S.map {lambda {:n} {br}1 {S.map {C :n} {S.serie 1 {- :n 1}}} 1} {S.serie 2 16}}displays: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 1input "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 imaxLen = len(a$(n))for i= 0 to n print space$((maxLen-len(a$(i)))/2);a$(i)next iend
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
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)endfor [i 1 10] [print pascal :i]
Our implementation will have an objectpascals with work done in the methodtriangle/2. We will be caching results for time efficiency at the cost of space efficiency,and thereset/0 method will flush that cache should it grow to be a problem. The resulting object looks like this:
:- object(pascals). :- uses(integer, [plus/3, succ/2]). :- public(reset/0). reset :- retractall(triangle_(_,_,_)). :- private(triangle_/3). :- dynamic(triangle_/3). :- public(triangle/2). triangle(N, Lines) :- triangle(N, _, DiffLines), difflist::as_list(DiffLines, Lines). % Shortcut with cached value if it exists. triangle(N, Line, DiffLines) :- triangle_(N, Line, DiffLines), !. triangle(N, Line, DiffLines) :- succ(N0, N), triangle(N0, Line0, DiffLines0), ZL = [0|Line0], list::append(Line0, [0], ZR), meta::map(plus, ZL, ZR, Line), difflist::add(Line, DiffLines0, DiffLines), asserta(triangle_(N, Line, DiffLines)). triangle(1, [1], [[1]|X]-X).:- end_object.
Using the SWI-Prolog back-end:
?- logtalk_load([meta(loader), types(loader), pascals], [optimize(on)]).% messages elidedtrue.?- pascals::triangle(17, Ls), logtalk::print_message(information, user, Ls).% - [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]Ls = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4|...], [1, 5, 10|...], [1, 6|...], [1|...], [...|...]|...].?-
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 retendfunction triangle(n) t = {1} for i = 1, n do print(unpack(t)) t = nextrow(t) endendf:=n->seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1);f(3);
1 1 1 1 2 1
n=7;Column[StringReplace[ToString /@ Replace[MatrixExp[SparseArray[{Band[{2,1}] -> Range[n-1]},{n,n}]],{x__,0..}->{x},2] ,{"{"|"}"|","->" "}], Center]
A more graphical output with arrows would involve the plotting functionality with Graph[]:
nmax := 10;pascal[nmax_] := Module[ {vals = Table[Binomial[n, k], {n, 0, nmax}, {k, 0, n}], ids = Table[{n, k}, {n, 0, nmax}, {k, 0, n}], labels, left, right, leftright, edgeLabels }, labels = Flatten[Thread /@ (Thread[ids -> vals]), 1]; left = DeleteCases[Flatten[Flatten[ids, 1] /. {n_, k_} /; (n >= k + 1) :> {{n, k + 1} -> {n + 1, k + 1}}, 1], _?NumberQ]; right = DeleteCases[Flatten[Flatten[ids, 1] /. {n_, k_} /; (n > k) :> {{n, k} -> {n + 1, k + 1}}, 1], _?NumberQ]; leftright = DeleteCases[left \[Union] right, _ -> {b_, _} /; b > nmax]; edgeLabels = (# -> Style["+", Medium] & /@ leftright); Graph[Flatten[ids, 1], leftright , VertexLabels -> MapAt[Placed[#, Center] &, labels, {All, 2}] , GraphLayout -> "SpringEmbedding" , VertexSize -> 0.8, EdgeLabels -> edgeLabels , PlotLabel -> "Pascal's Triangle" ] ];pascal[nmax]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)))', endans = 1ans = 1 1ans = 1 2 1ans = 1 3 3 1ans = 1 4 6 4 1ans = 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); endThe 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
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" */
(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
TextWindow.Write("Number of rows? ")r = TextWindow.ReadNumber()For i = 0 To r - 1 c = 1 For k = 0 To i TextWindow.CursorLeft = (k + 1) * 4 - Text.GetLength(c) TextWindow.Write(c) c = c * (i - k) / (k + 1) EndFor TextWindow.WriteLine("")EndForOutput:
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
MODULE Pascal;FROM FormatString IMPORT FormatString;FROM Terminal IMPORT WriteString,WriteLn,ReadChar;PROCEDURE PrintLine(n : INTEGER);VAR buf : ARRAY[0..63] OF CHAR; m,j : INTEGER;BEGIN IF n<1 THEN RETURN END; m := 1; WriteString("1 "); FOR j:=1 TO n-1 DO m := m * (n - j) DIV j; FormatString("%i ", buf, m); WriteString(buf) END; WriteLnEND PrintLine;PROCEDURE Print(n : INTEGER);VAR i : INTEGER;BEGIN FOR i:=1 TO n DO PrintLine(i) ENDEND Print;BEGIN Print(10); ReadCharEND Pascal./* NetRexx */options replace format comments java crossref symbols nobinarynumeric 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*/
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 11 10 45 120 210 252 210 120 45 10 1
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
import sequtils, strutilsproc printPascalTriangle(n: int) = ## Print a Pascal triangle. # Build the triangle. var triangle: seq[seq[int]] triangle.add @[1] for _ in 1..<n: triangle.add zip(triangle[^1] & @[0], @[0] & triangle[^1]).mapIt(it[0] + it[1]) # Build the lines to display. let length = len($max(triangle[^1])) # Maximum length of number. var lines: seq[string] for row in triangle: lines.add row.mapIt(($it).center(length)).join(" ") # Display the lines. let lineLength = lines[^1].len # Length of largest line (the last one). for line in lines: echo line.center(lineLength)printPascalTriangle(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
A more optimized solution that doesn't require importing, but produces, naturally, uglier output, would look like this:
const ROWS = 10const TRILEN = toInt(ROWS * (ROWS + 1) / 2) # Sum of arth progressionvar triangle = newSeqOfCap[Natural](TRILEN) # Avoid reallocationsproc printPascalTri(row: Natural, result: var seq[Natural]) = add(result, 1) for i in 2..row-1: add(result, result[^row] + result[^(row-1)]) add(result, 1) echo result[^row..^1] if row + 1 <= ROWS: printPascalTri(row + 1, result)printPascalTri(1, triangle)
@[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]
(* 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]
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"); endforendfunctionpascaltriangle(4);No result if n <= 0
: pascal(n) [ 1 ] #[ dup println dup 0 + 0 rot + zipWith(#+) ] times(n) drop ;
10 pascal[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]
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.
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); );}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
SeePascal.
These functions perform as requested in the task: they print out the firstn lines. Ifn <= 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:
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 }This triangle is build using the 'sock' or 'hockey stick' pattern property. Here I use the word tartaglia and not pascal because in my country it's called after the Niccolò Fontana, known also as Tartaglia. A full graphical implementation of 16 properties that can be found in the triangle can be found at mineTartaglia's triangle
#!/usr/bin/perluse strict;use warnings; { my @tartaglia ; sub tartaglia { my ($x,$y) = @_; if ($x == 0 or $y == 0) { $tartaglia[$x][$y]=1 ; return 1}; my $ret ; foreach my $yps (0..$y){ $ret += ( $tartaglia[$x-1][$yps] || tartaglia($x-1,$yps) ); } $tartaglia[$x][$y] = $ret; return $ret; }}sub tartaglia_row { my $y = shift; my $x = 0; my @row; $row[0] = &tartaglia($x,$y+1); foreach my $pos (0..$y-1) {push @row, tartaglia(++$x,--$y)} return @row;}for (0..5) {print join ' ', tartaglia_row($_),"\n"}print "\n\n";print tartaglia(3,3),"\n";my @third = tartaglia_row(5);print "@third\n";which output
11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1201 5 10 10 5 1
Four different ways to do it:
withjavascript_semanticssequencerow,rows={}functioncheck(integeri,stringname)-- helper routinestrings=join(row,fmt:="%d")ifs!=rows[i+1]thenprintf(1,"%s: goes wrong on line %d\n",{name,i+1})returnfalseendifreturntrueendfunctionproceduresum_prior()-- First methodrow={}-- (using just one row)fori=0to119dorow&=1forn=length(row)-1to2by-1dorow[n]+=row[n-1]endforifnotcheck(i,"sum_prior")thenexitendifendforendprocedureprocedurealgebraic()-- Second methodfori=0to119doatomc=1row={1}forj=0toi-1do-- c *= (i-j)/(j+1) -- NO: precedence differs, and eg 5*(1/5) inexactc=c*(i-j)/(j+1)-- ..whereas (5*1)/5 is exactrow&=cendforifnotcheck(i,"algebraic")thenexitendifendforendprocedure-- Aside: error with c was self-evident and more relevant when it was an integer, --- but I made it an atom to get past the 33/63 limits that imposed.procedurebuiltin()-- Third methodfori=0to119dorow={}forj=0toidorow&=choose(i,j)endforifnotcheck(i,"builtin")thenexitendifendforendprocedureincludempfr.eprocedurearbitrary_precision()-- Fourth method, but run first -- perfectly accurate until you -- run out of memory or patience.mpzz=mpz_init()fori=0to119dorow={}forj=0toidompz_bin_uiui(z,i,j)row=append(row,mpz_get_str(z))endforstrings=join(row)ifi<=19thenprintf(1,"%=96s\n",s)endif-- to check the others against:rows=append(rows,s)endforprintf(1,"\n")endprocedurearbitrary_precision()sum_prior()algebraic()builtin()
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 11 19 171 969 3876 11628 27132 50388 75582 92378 92378 75582 50388 27132 11628 3876 969 171 19 1sum_prior: goes wrong on line 70algebraic: goes wrong on line 68builtin: goes wrong on line 68
Above results from 64-bit, on 32-bit the last 3 lines are 58/56/56.
"Reflected" Pascal's triangle, it uses symmetry property to "mirror" second part. It determines even and odd strings. automatically.
<?php //Author Ivan Gavryshin @dcc0function tre($n) { $ck=1; $kn=$n+1; if($kn%2==0) { $kn=$kn/2; $i=0; } else { $kn+=1; $kn=$kn/2; $i= 1;} for ($k = 1; $k <= $kn-1; $k++) { $ck = $ck/$k*($n-$k+1); $arr[] = $ck; echo "+" . $ck ; } if ($kn>1) { echo $arr[i]; $arr=array_reverse($arr); for ($i; $i<= $kn-1; $i++) { echo "+" . $arr[$i] ; } } } //set amount of strings here while ($n<=20) { ++$n; echo tre($n); echo "<br/>";} ?>==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
%Author: Petar Kabashkispatr([]) = [].spatr([_|T]) = A, T = [] => A = [].spatr([H|T]) = A, T = [TH|_] => A = [H+TH] ++ spatr(T).tablepatr(0) = [1].patr(1) = [1, 1].patr(N) = A, N > 1 => Apre = patr(N-1), A = [1] ++ spatr(Apre) ++ [1].foreach(I in 0 .. 10) println(patr(I)) 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]
(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) ) )
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
printpascal = (n) : if (n < 1) : 1 print (1) . else : prev = printpascal(n - 1) prev append(0) curr = (1) n times (i): curr append(prev(i) + prev(i + 1)) . "\n" print curr join(", ") print curr ..printpascal(read number integer)$Infinity = 1$NewNumbers = $null$Numbers = $null$Result = $null$Number = $null$Power = $args[0]Write-Host $PowerFor( $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----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 1
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.
The above use of difference lists is a really innovative example of late binding. Here's an alternative source which, while possibly not as efficient (or as short) as the previous example, may be a little easier to read and understand.
%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~% Produce a pascal's triangle of depth N%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~% Prolog is declarative. The predicate pascal/3 below says that to produce% a row of depth N, we can do so by first producing the row at depth(N-1),% and then adding the paired values in that row. The triangle is produced% by prepending the row at N-1 to the preceding rows as recursion unwinds.% The triangle produced by pascal/3 is upside down and lacks the last row,% so pascal/2 prepends the last row to the triangle and reverses it.% Finally, pascal/1 produces the triangle, iterates each row and prints it.%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pascal_row([V], [V]). % No more value pairs to addpascal_row([V0, V1|T], [V|Rest]) :- % Add values from preceding row V is V0 + V1, !, pascal_row([V1|T], Rest). % Drops initial value (1).pascal(1, [1], []). % at depth 1, this row is [1] and no preceding rows.pascal(N, [1|ThisRow], [Last|Preceding]) :- % Produce a row of depth N succ(N0, N), % N is the successor to N0 pascal(N0, Last, Preceding), % Get the previous row !, pascal_row(Last, ThisRow). % Calculate this row from the previouspascal(N, Triangle) :- pascal(N, Last, Rows), % Retrieve row at depth N and preceding rows !, reverse([Last|Rows], Triangle). % Add last row to triangle and reverse orderpascal(N) :- pascal(N, Triangle), member(Row, Triangle), % Iterate and write each row write(Row), nl, fail.pascal(_).
?- pascal(5).[1][1,1][1,2,1][1,3,3,1][1,4,6,4,1]
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 ;iEndProcedure OpenConsole()Parameter.i = Val(ProgramParameter(0))pascaltriangle(Parameter);Input()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 adef 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)
Deriving finite and non-finite lists of pascal rows from a simplenextPascal step function:
'''Pascal's triangle'''from itertools import (accumulate, chain, islice)from operator import (add)# nextPascal :: [Int] -> [Int]def nextPascal(xs): '''A row of Pascal's triangle derived from a preceding row.''' return list( map(add, [0] + xs, xs + [0]) )# pascalTriangle :: Generator [[Int]]def pascalTriangle(): '''A non-finite stream of Pascal's triangle rows.''' return iterate(nextPascal)([1])# finitePascalRows :: Int -> [[Int]]def finitePascalRows(n): '''The first n rows of Pascal's triangle.''' return accumulate( chain( [[1]], range(1, n) ), lambda a, _: nextPascal(a) )# ------------------------ TESTS -------------------------# main :: IO ()def main(): '''Test of two different approaches: - taking from a non-finite stream of rows, - or constructing a finite list of rows.''' print('\n'.join(map( showPascal, [ islice( pascalTriangle(), # Non finite, 7 ), finitePascalRows(7) # finite. ] )))# showPascal :: [[Int]] -> Stringdef showPascal(xs): '''Stringification of a list of Pascal triangle rows.''' ys = list(xs) def align(w): return lambda ns: center(w)( ' ' )(' '.join(map(str, ns))) w = len(' '.join((map(str, ys[-1])))) return '\n'.join(map(align(w), ys))# ----------------------- GENERIC ------------------------# center :: Int -> Char -> String -> Stringdef center(n): '''String s padded with c to approximate centre, fitting in but not truncated to width n.''' def go(c, s): qr = divmod(n - len(s), 2) q = qr[0] return (q * c) + s + ((q + qr[1]) * c) return lambda c: lambda s: go(c, s)# iterate :: (a -> a) -> a -> Gen [a]def iterate(f): '''An infinite list of repeated applications of f to x. ''' def go(x): v = x while True: yield v v = f(v) return go# MAIN ---if __name__ == '__main__': main()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
pascal:{(x-1){0+':x,0}\1}pascal 511 11 2 11 3 3 11 4 6 4 1(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))
The behaviour ofpascal for values less than 1 is the same as its behaviour for 1.
[ over size - space swap of swap join ] is justify ( $ n --> ) [ witheach [ number$ 5 justify echo$ ] cr ] is echoline ( [ --> ) [ [] 0 rot 0 join witheach [ tuck + rot join swap ] drop ] is nextline ( [ --> [ ) [ ' [ 1 ] swap 1 - times [ dup echoline nextline ] echoline ] is pascal ( n --> ) 16 pascal
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
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))}Iterative version by summing rows up to.
#lang racket(define (pascal n) (define (next-row current-row) (map + (cons 0 current-row) (append current-row '(0)))) (reverse (for/fold ([triangle '((1))]) ([row (in-range 1 n)]) (cons (next-row (first triangle)) triangle))))
(formerly Perl 6)
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], { [0, |$_ Z+ |$_, 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, and use an explicit parameter$prev for variety:
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.
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.
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.
[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]
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 rowINPUT "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 rowRed[]pascal-triangle: function [ n [ integer! ] "number of rows" ][ row: make vector! [ 1 ] loop n [ print row left: copy row right: copy row insert left 0 append right 0 row: left + right ]]
Output:
pascal-triangle 711 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 1
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
There is no practical limit for this REXX version, triangles up to 46 rows have beengenerated (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) fileinstead. Triangles with over a 1,000 rows have been easily created.
The output file created (that is written to disk) is named PASCALS.n where n is the absolute value of the number entered.
Note: Pascal's triangle is also known as:
/*REXX program displays (or writes to a file) Pascal's triangle (centered/formatted).*/numeric digits 3000 /*be able to handle gihugeic triangles.*/parse arg nn . /*obtain the optional argument from CL.*/if nn=='' | nn=="," then nn= 10 /*Not specified? Then use the default.*/n= abs(nn) /*N is the number of rows in triangle.*/w= length( !(n-1) % !(n%2) % !(n - 1 - n%2)) /*W: the width of biggest integer. */ww= (n-1) * (W + 1) + 1 /*WW: " " " triangle's last row.*/@.= 1; $.= @.; unity= right(1, w) /*defaults rows & lines; aligned unity.*/ /* [↓] 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 unity /*for rows≥2, append a trailing "1".*/ end /*r*/ /* [↑] R is the row being built.*/ /* [↑] WIDTH: for nicely looking line.*/ do r=1 for n; $$= center($.r, ww) /*center this particular Pascals' row. */ if nn>0 then say $$ /*SAY if NN is positive, else */ else call lineout 'PASCALS.'n, $$ /*write this Pascal's row ───► a file.*/ end /*r*/exit /*stick a fork in it, we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/!: procedure; !=1; do j=2 to arg(1); != !*j; end /*j*/; return ! /*compute factorial*/
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 11 10 45 120 210 252 210 120 45 10 1
(Output shown at 4/5 size.)
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 11 21 210 1330 5985 20349 54264 116280 203490 293930 352716 352716 293930 203490 116280 54264 20349 5985 1330 210 21 1
row = 5for i = 0 to row - 1 col = 1 see left(" ",row-i) for k = 0 to i see "" + col + " " col = col*(i-k)/(k+1) next see nlnextOutput:
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1
« 0 SWAPFOR n "" 0 nFOR p n p COMB + " " +NEXT n 1 + DISPNEXT 7 FREEZE» 'PASCAL' STO8PASCAL1 1 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 …
RPL screens are limited to 22 characters.
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(&:sum) endend pascal(8){|row| puts row.join(" ").center(20)}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 } enddef pascal(n) n.times.inject([1]) {|x,_| next_row x } end8.times{|i| p pascal(i)}[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]
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 printnextOutput:
Number of rows? ?5 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1
fn pascal_triangle(n: u64){ for i in 0..n { let mut c = 1; for _j in 1..2*(n-1-i)+1 { print!(" "); } for k in 0..i+1 { print!("{:2} ", c); c = c * (i-k)/(k+1); } println!(); }} def tri(row: Int): List[Int] = row match { case 1 => List(1) case n: Int => 1 +: ((tri(n - 1) zip tri(n - 1).tail) map { case (a, b) => a + b }) :+ 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)1 1 1 1 2 1 1 3 3 11 4 6 4 1
object Blaise extends App { def pascalTriangle(): Stream[Vector[Int]] = Vector(1) #:: Stream.iterate(Vector(1, 1))(1 +: _.sliding(2).map(_.sum).toVector :+ 1) val output = pascalTriangle().take(15).map(_.mkString(" ")) val longest = output.last.length println("Pascal's Triangle") output.foreach(line => println(s"${" " * ((longest - line.length) / 2)}$line"))}See it in running in your browser byScalaFiddle (JavaScript) or byScastie (JVM).
(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))
$ 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;func pascal(rows) { var row = [1] { | n| say row.join(' ') row = [1, {|i| row[i] + row[i+1] }.map(0 .. n-2)..., 1] } << 1..rows} pascal(10)First, a few ways to compute a "Pascal matrix". With the first, the upper triangle is made of missing values (zeros with the other two).
function pascal1(n) {return(comb(J(1,n,0::n-1),J(n,1,0..n-1)))}function pascal2(n) {a = I(n)a[.,1] = J(n,1,1)for (i=3; i<=n; i++) {a[i,2..i-1] = a[i-1,2..i-1]+a[i-1,1..i-2]}return(a)}function pascal3(n) {a = J(n,n,0)for (i=1; i<n; i++) {a[i+1,i] = i}s = p = I(n)k = 1for (i=0; i<n; i++) {p = p*a/k++s = s+p}return(s)}Now print the Pascal triangle.
function print_pascal_triangle(n) {a = pascal1(n)for (i=1; i<=n; i++) {for (j=1; j<=i; j++) {printf("%10.0f",a[i,j])}printf("\n")}}print_pascal_triangle(5) 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1func pascal(n:Int)->[Int]{ if n==1{ let a=[1] print(a) return a } else{ var a=pascal(n:n-1) var temp=a for i in 0..<a.count{ if i+1==a.count{ temp.append(1) break } temp[i+1] = a[i]+a[i+1] } a=temp print(a) return a }}let waste = pascal(n:10)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]11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1
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]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.5proc 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]set n 100puts "calculate $n rows:"foreach proc {pascal_iterative pascal_coefficients pascal_combinations} { puts "$proc: [time [list $proc $n] 100]"}calculate 100 rows:pascal_iterative: 2800.14 microseconds per iterationpascal_coefficients: 8760.98 microseconds per iterationpascal_combinations: 38176.66 microseconds per iteration
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]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]proc pascal (n : int) for i : 0 .. n var c := 1 for k : 0 .. i put c : 4 .. c := c * (i - k) div (k + 1) end for put "" end forend pascalpascal(5)
Output:
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
// Pascal's trianglefunction pascal(n: number): void { // Display the first n rows of Pascal's triangle // if n<=0 then nothing is displayed var ld: number[] = new Array(40); // Old var nw: number[] = new Array(40); // New for (var row = 0; row < n; row++) { nw[0] = 1; for (var i = 1; i <= row; i++) nw[i] = ld[i - 1] + ld[i]; process.stdout.write(" ".repeat((n - row - 1) * 2)); for (var i = 0; i <= row; i++) { if (nw[i] < 100) process.stdout.write(" "); process.stdout.write(nw[i].toString()); if (nw[i] < 10) process.stdout.write(" "); process.stdout.write(" "); } nw[row + 1] = 0; // We do not copy data from nw to ld // but we work with references. var tmp = ld; ld = nw; nw = tmp; console.log(); }} pascal(13);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
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); NextNextPrintEnd
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 10 OK, 0:380
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"Zero maps to the empty list. Negatives are inexpressible.This solution uses a library function for binomial coefficients.
#import std#import natpascal = choose**ziDS+ iota*t+ iota+ successor
This solution uses direct summation. The algorithm is toinsert 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 natpascal "n" = (next"n" sum*NiCixp) <1>
test program:
#cast %nLLexample = 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>>
Option Base 1Private Sub pascal_triangle(n As Integer) Dim odd() As String Dim eve() As String ReDim odd(1) ReDim eve(2) odd(1) = " 1" For i = 1 To n If i Mod 2 = 1 Then Debug.Print String$(2 * n - 2 * i, " ") & Join(odd, " ") eve(1) = " 1" ReDim Preserve eve(i + 1) For j = 2 To i eve(j) = Format(CStr(Val(odd(j - 1)) + Val(odd(j))), "@@@") Next j eve(i + 1) = " 1" Else Debug.Print String$(2 * n - 2 * i, " ") & Join(eve, " ") odd(1) = " 1" ReDim Preserve odd(i + 1) For j = 2 To i odd(j) = Format(CStr(Val(eve(j - 1)) + Val(eve(j))), "@@@") Next j odd(i + 1) = " 1" End If Next iEnd SubPublic Sub main() pascal_triangle 13End Sub
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
Derived from the BASIC version.
Pascal_Triangle(WScript.Arguments(0))Function Pascal_Triangle(n)Dim values(100)values(1) = 1WScript.StdOut.Write values(1)WScript.StdOut.WriteLineFor row = 2 To nFor i = row To 1 Step -1values(i) = values(i) + values(i-1)WScript.StdOut.Write values(i) & " "NextWScript.StdOut.WriteLineNextEnd Function
Invoke from a command line.
F:\VBScript>cscript /nologo rosettacode-pascals_triangle.vbs 611 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1
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 += #@97Num_Ins(#@98, COUNT, 6) } Ins_Newline}#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}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
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
Imports System.NumericsModule Module1 Iterator Function GetRow(rowNumber As BigInteger) As IEnumerable(Of BigInteger) Dim denominator As BigInteger = 1 Dim numerator = rowNumber Dim currentValue As BigInteger = 1 For counter = 0 To rowNumber Yield currentValue currentValue = currentValue * numerator numerator = numerator - 1 currentValue = currentValue / denominator denominator = denominator + 1 Next End Function Function GetTriangle(quantityOfRows As Integer) As IEnumerable(Of BigInteger()) Dim range = Enumerable.Range(0, quantityOfRows).Select(Function(num) New BigInteger(num)) Return range.Select(Function(num) GetRow(num).ToArray()) End Function Function CenterString(text As String, width As Integer) Dim spaces = width - text.Length Dim padLeft = (spaces / 2) + text.Length Return text.PadLeft(padLeft).PadRight(width) End Function Function FormatTriangleString(triangle As IEnumerable(Of BigInteger())) As String Dim maxDigitWidth = triangle.Last().Max().ToString().Length Dim rows = triangle.Select(Function(arr) String.Join(" ", arr.Select(Function(array) CenterString(array.ToString(), maxDigitWidth)))) Dim maxRowWidth = rows.Last().Length Return String.Join(Environment.NewLine, rows.Select(Function(row) CenterString(row, maxRowWidth))) End Function Sub Main() Dim triangle = GetTriangle(20) Dim output = FormatTriangleString(triangle) Console.WriteLine(output) End SubEnd Module1 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
fn main() {rows(5)}fn rows(height int) [][]int {mut ret := [][]int{}mut cnum := 0for level := 1; level <= height; level++ {ret << []int{}cnum = 1for i := 1; i <= level; i++ {ret[level - 1] << cnumcnum = (cnum * (level - i)) / i}println(ret[level - 1])}return ret}[1][1, 1][1, 2, 1][1, 3, 3, 1][1, 4, 6, 4, 1]
import "./fmt" for Fmtimport "./math" for Intvar pascalTriangle = Fn.new { |n| if (n <= 0) return for (i in 0...n) { System.write(" " * (n-i-1)) for (j in 0..i) { Fmt.write("$3d ", Int.binomial(i, j)) } System.print() }}pascalTriangle.call(13)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
uses: io.inc - Macro library from SASM
%include "io.inc"section .textglobal CMAINCMAIN:mov ebx, 7 ;sizecall mloopretmloop:mov edx, 0 ;edx stands for the nth linelooping:push ebxpush edxcall linepop edxpop ebxinc edxcmp edx, ebxjl loopingxor eax, eaxretline:mov ecx, 0 ;ecx stands for the nth character in each linemlp:push ecx push edxcall nCk pop edxpop ecxPRINT_DEC 4, eax ;print returned number PRINT_STRING " "inc ecxcmp ecx, edx ;ifjle mlpNEWLINEretnCk:;ecx : j;edx : imov esi, edxcall fac ;i!push eax ;save i!mov esi, ecxcall fac ;j!push eax ;save j!mov ebx, edxsub ebx, ecx ;(i-j)mov esi, ebxcall fac ;(i-j)!pop ebx ;(i-j)! is in eaxmul ebx ;(i-j)! * j!mov ecx, eaxpop eax ; get i!div ecx ; ; last step : i! divided by (i-j)! * j!retfac:push ecx push edxmov eax, 1mov ecx, esicmp ecx, 0 ; 0! returns 1je faczlp:mul ecx ;multiplies eax by ecx and then decrements ecx until ecx is 0dec ecxcmp ecx, 0jg lpjmp endfacz:mov eax, 1end: pop edxpop ecxret
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
PROGRAM "pascal"VERSION "0.0001"DECLARE FUNCTION Entry()FUNCTION Entry() r@@ = UBYTE(INLINE$("Number of rows? ")) FOR i@@ = 0 TO r@@ - 1 c%% = 1 FOR k@@ = 0 TO i@@ PRINT FORMAT$("####", c%%); c%% = c%% * (i@@ - k@@) / (k@@ + 1) NEXT k@@ PRINT NEXT i@@END FUNCTIONEND PROGRAMNumber 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
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)
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
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);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
In edit mode insert:
10 INPUT "How many rows? ";n 15 IF n<1 THEN GO TO 210 20 DIM c(n) 25 DIM d(n) 30 LET c(1)=1 35 LET d(1)=1 40 FOR r=1 TO n 50 FOR i=1 TO (n-r) 60 PRINT " "; 70 NEXT i 80 FOR i=1 TO r 90 PRINT c(i);" ";100 NEXT i110 PRINT120 IF r>=n THEN GO TO 140130 LET d(r+1)=1140 FOR i=2 TO r150 LET d(i)=c(i-1)+c(i)160 NEXT i 165 IF r>=n THEN GO TO 200170 FOR i=1 TO r+1180 LET c(i)=d(i)190 NEXT i200 NEXT r
Then in command mode (basically don't put a number in front):
RUN
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