Pascal's triangle: Difference between revisions

[[wp:Pascal's triangle|Pascal's triangle]] is an arithmetic and geometric figure often associated with the name of [[wp:Blaise Pascal|Blaise Pascal]], but also studied centuries earlier in India, Persia, China and elsewhere.

 

1

1 1

1 2 1

where each element of each row is either 1 or the sum of the two elements right above it.

 

:::   '''1'''   (since the last element of each row doesn't have two elements above it)

 

1

1 1

1 2 1

1 3 3 1

 

Each row &nbsp; <tt> n </tt> &nbsp; (starting with row &nbsp; 0 &nbsp; at the top) shows the coefficients of the binomial expansion of &nbsp; <big><big> (x + y)ⁿ. </big></big>

* [[Evaluate binomial coefficients]]

<br><br>

 

=={{header|360 Assembly}}==

{{trans|PL/I}}

PASCAL CSECT

USING PASCAL,R15 set base register

XD DS CL12 temp

YREGS

{{out}}

<pre>

=={{header|8th}}==

One way, using array operations:

\ print the array

: .arr \ a -- a

\ print the first 16 rows:

[1] ' pasc 16 times

 

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

: ratio \ m n -- num denom

tuck n:- n:1+ swap ;

 

15 pasc

 

=={{header|Ada}}==

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 [[http://rosettacode.org/wiki/Catalan_numbers/Pascal%27s_triangle]]

 

type Row is array (Natural range <>) of Natural;

function Next_Row(R: Row) return Row;

 

The implementation of that auxiliary package "Pascal":

 

function First_Row(Max_Length: Positive) return Row is

end Length;

 

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

 

 

procedure Triangle is

Row := Next_Row(Row);

end loop;

 

{{out}}

 

=={{header|ALGOL 68}}==

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);

# WHILE # i < stop DO

row := row[AT 1] + row[AT 2]

{{Out}}

<pre>

 

=={{header|ALGOL W}}==

% prints the first n lines of Pascal's triangle lines %

% if n is <= 0, no output is produced %

printPascalTriangle( 8 )

 

{{out}}

<pre>

1 6 15 20 15 6 1

1 7 21 35 35 21 7 1

</pre>

 

=={{header|APL}}==

Pascal' s triangle of order ⍵

 

 

example

 

 

<pre>

1 3 3 1

</pre>

 

=={{header|AppleScript}}==

Drawing n rows from a generator:

 

-- pascal :: Generator [[Int]]

on pascal()

 

 

on run

showPascal(take(7, pascal()))

end run

 

 

-- showPascal :: [[Int]] -> String

 

 

 

-- center :: Int -> Char -> String -> String

end if

end |center|

 

-- intercalate :: String -> [String] -> String

on intercalate(sep, xs)

set s to xs as text

set my text item delimiters to dlm

return s

end intercalate

 

-- iterate :: (a -> a) -> a -> Generator [a]

end script

end iterate

 

-- length :: [a] -> Int

end if

end |length|

 

-- map :: (a -> b) -> [a] -> [b]

end tell

end map

 

-- min :: Ord a => a -> a -> a

end min

 

-- mReturn :: First-class m => (a -> b) -> m (a -> b)

on mReturn(f)

f

else

end if

end mReturn

 

-- plus :: Num -> Num -> Num

a + b

end plus

 

-- Egyptian multiplication - progressively doubling a list, appending

return out & dbl

end replicate

 

-- take :: Int -> [a] -> [a]

end if

end take

 

-- unlines :: [String] -> String

str

end unlines

 

-- unwords :: [String] -> String

on unwords(xs)

set s to xs as text

set my text item delimiters to dlm

return s

end unwords

 

-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

return lst

end tell

{{Out}}

<pre> 1

1 5 10 10 5 1

1 6 15 20 15 6 1</pre>

 

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/viewtopic.php?p=276617#276617 discussion]

Loop %n% {

p := "p" A_Index, %p% := v := 1, q := "p" A_Index-1

 

GuiClose:

 

Alternate {{works with|AutoHotkey L}}

Return

 

: p[row-1, col])

Return p

n <= 0 returns empty

 

=={{header|AWK}}==

{{Out}}<pre>

1

1 5 10 10 5 1

</pre>

 

=={{header|BASIC}}==

If the user enters value less than 1, the first row is still always displayed.

 

DIM row AS Integer

DIM nrows AS Integer

NEXT i

PRINT

 

=={{header|Batch File}}==

Based from the Fortran Code.

setlocal enabledelayedexpansion

 

for /l %%A in (1,1,%numspaces%) do set "space=!space! "

goto :EOF

{{Out}}

<pre> 1

 

=={{header|BBC BASIC}}==

colwidth% = 4

NEXT

PRINT

{{Out}}

<pre> 1

1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1</pre>

 

=={{header|Befunge}}==

v01*p00-1:g00.:<1p011p00:\-1_v#:<

{{Out}}

<pre>Number of rows: 10

1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1 </pre>

 

=={{header|Bracmat}}==

& get':?R

& -1:?I

)

&

{{Out}}

<pre>Number of rows?

=={{header|Burlesque}}==

 

blsq ) {1}{1 1}{^^2CO{p^?+}m[1+]1[+}15E!#s<-spbx#S

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

 

=={{header|C}}==

{{trans|Fortran}}

 

 

void pascaltriangle(unsigned int n)

pascaltriangle(8);

return 0;

 

===Recursive===

 

#define D 32

int x[D] = {0, 1, 0}, y[D] = {0};

return pascals(x, y, 0);

 

===Adding previous row values===

 

if (nRows <= 0) return;

int *prevRow = NULL;

}

free(prevRow);

 

=={{header|C++}}==

#include <algorithm>

#include<cstdio>

}

 

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

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

#include<iostream>

#include<vector>

}

 

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

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

#include<iostream>

#include<vector>

}

 

 

=={{header|Clojure}}==

 

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

(let [newrow (fn newrow [lst ret]

(if lst

(recur (dec n) (conj (newrow lst []) 1)))))]

(genrow n [1])))

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

(defn nextrow [row]

(vec (concat [1] (map #(apply + %) (partition 2 1 row)) [1] )))

(doseq [row triangle]

(println row))))

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

 

Here's a third version using the ''iterate'' function

(def pascal

(iterate

(map (partial apply +) ,,,)))

[1]))

 

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

 

(def pascal

(iterate #(concat [1]

[1])

[1]))

 

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

 

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

 

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

 

(nth pascal 10) ;returns the nth row

 

=={{header|CoffeeScript}}==

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

pascal = (n) ->

width = 6

pascal(7)

 

 

{{Out}}

 

=={{header|Commodore BASIC}}==

20 IF N<1 THEN END

30 DIM C(N)

220 C(I)=D(I)

230 NEXT I

 

Output:

HOW MANY? 8

1

1 8 28 56 70 56 28 8 1

READY.

 

=={{header|Common Lisp}}==

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

 

 

(defun genrow (n l)

 

(defun newrow (l)

'(1)

 

An iterative solution with ''loop'', using ''nconc'' instead of ''collect'' to keep track of the last ''cons''. Otherwise, it would be necessary to traverse the list to do a ''(rplacd (last a) (list 1))''.

 

 

(defun pascal (n)

 

 

1))

 

 

For example:

 

 

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

MODULE PascalTriangle;

IMPORT StdLog, DevCommanders, TextMappers;

 

END PascalTriangle.

<pre>Execute: ^Q PascalTriangle.Do 0 1 2 3 4 5 6 7 8 9 10 11 12~</pre>

{{out}}

1 12 66 220 495 792 924 792 495 220 66 12 1

</pre>

=={{header|D}}==

===Less functional Version===

auto tri = new int[][rows];

foreach (r; 0 .. rows) {

[1, 8, 28, 56, 70, 56, 28, 8, 1],

[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]]);

===More functional Version===

 

auto pascal() pure nothrow {

void main() {

pascal.take(5).writeln;

{{out}}

<pre>[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]</pre>

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).

 

string Pascal(alias dg, T, T initValue)(int n) {

foreach (i; [16])

writef(sierpinski(i));

{{out}}

<pre> 1

 

=={{header|Dart}}==

import 'dart:io';

 

 

 

 

=={{header|Delphi}}==

 

procedure Pascal(r:Integer);

begin

Pascal(9);

 

=={{header|DWScript}}==

Doesn't print anything for negative or null values.

var

i, c, k : Integer;

end;

 

{{Out}}

<pre> 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 row := [].diverge(int)

out.print("<table style='text-align: center; border: 0; border-collapse: collapse;'>")

}

out.print("</table>")

 

try {

pascalsTriangle(15, out)

out.close()

}

 

=={{header|Eiffel}}==

 

note

description : "Prints pascal's triangle"

--Contains all already calculated lines

end

 

=={{header|Elixir}}==

def triangle(n), do: triangle(n,[1])

end

 

 

{{out}}

[1, 6, 15, 20, 15, 6, 1]

[1, 7, 21, 35, 35, 21, 7, 1]

</pre>

 

=={{header|Erlang}}==

 

-import(lists).

-export([pascal/1]).

[H|_] = L,

[lists:zipwith(fun(X,Y)->X+Y end,[0]++H,H++[0])|L].

 

{{Out}}

 

=={{header|ERRE}}==

PROGRAM PASCAL_TRIANGLE

 

PASCAL(9)

END PROGRAM

Output:

<pre>

=={{header|Euphoria}}==

===Summing from Previous Rows===

row = {}

for m = 1 to 10 do

print(1,row)

puts(1,'\n')

 

{{Out}}

{1,9,36,84,126,126,84,36,9,1}

</pre>

 

=={{header|F Sharp|F#}}==

match l with

| [] -> []

printf "%s" (i.ToString() + ", ")

printfn "%s" "\n"

 

=={{header|Factor}}==

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

 

 

: (pascal) ( seq -- newseq )

 

: pascal ( n -- seq )

 

It works as:

 

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

 

 

 

=={{header|Forth}}==

here swap cells erase 1 here ! ;

: .line ( n -- )

: pascal ( n -- )

dup init 1 .line

This is a bit more efficient.

{{trans|C}}

cr dup 0

?do

;

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

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

 

CALL Print_Triangle(8)

END DO

 

 

=={{header|FreeBASIC}}==

 

Sub pascalTriangle(n As UInteger)

Print

Print "Press any key to quit"

 

{{out}}

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

</pre>

 

=== Summing from Previous Rows ===

{{trans|Scala}}

 

def

pascal( 1 ) = [1]

 

=== Combinations ===

{{trans|Haskell}}

 

 

=== Pascal's Triangle ===

width = max( map(a -> a.toString().length(), pascal(height)) )

 

println( map(a -> format('%' + width + 'd ', a), pascal(n)).mkString() )

 

 

{{out}}

1 9 36 84 126 126 84 36 9 1

</pre>

 

=={{header|GAP}}==

local i, v;

v := [1];

# [ 1, 6, 15, 20, 15, 6, 1 ]

# [ 1, 7, 21, 35, 35, 21, 7, 1 ]

 

=={{header|Go}}==

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

package main

 

printTriangle(4)

}

Output:

<pre>

=== Recursive ===

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

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:

(1..count).each { n ->

printf ("%2d:", n); (0..(count-n)).each { print " " }; pascal(n).each{ printf("%6d ", it) }; println ""

 

{{out}}

 

=={{header|GW-BASIC}}==

20 FOR I=0 TO R-1

30 C=1

70 NEXT

80 PRINT

 

Output:

similar function

 

zapWith f xs [] = xs

zapWith f [] ys = ys

 

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

the ends:

 

 

And for the whole (infinite) triangle, we just iterate this operation,

starting with the first row:

 

 

For the first ''n'' rows, we just take the first ''n'' elements from this

list, as in

 

 

A shorter approach, plagiarized from [http://www.haskell.org/haskellwiki/Blow_your_mind]

nextRow row = zipWith (+) ([0] ++ row) (row ++ [0])

 

-- returns the first n rows

 

Alternatively, using list comprehensions:

 

pascal :: [[Integer]]

pascal =

(1 : [ 0 | _ <- head pascal])

: [zipWith (+) (0:row) row | row <- pascal]

 

*Pascal> take 5 <$> (take 5 $ 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:

 

 

 

Example:

1

1 1

1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1

 

=={{header|HicEst}}==

 

SUBROUTINE Pascal(rows)

ENDDO

ENDDO

=={{header|Icon}} and {{header|Unicon}}==

The code below is slightly modified from the library version of pascal which prints 0's to the full width of the carpet.

It also presents the data as an isoceles triangle.

procedure main(A)

write()

}

 

{{libheader|Icon Programming Library}}

 

=={{header|IDL}}==

;n is the number of lines of the triangle to be displayed

r=[1]

print, r

 

 

=={{header|IS-BASIC}}==

110 TEXT 80

120 LET ROW=12

190 NEXT

200 PRINT

 

{{out}}

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</pre>

 

=={{header|J}}==

1 0 0 0 0

1 1 0 0 0

1 2 1 0 0

1 3 3 1 0

 

1

1 1

1 2 1

1 3 3 1

 

1

1 1

1 2 1

1 3 3 1

 

See the [[Talk:Pascal's_triangle#J_Explanation|talk page]] for explanation of earlier version

===Summing from Previous Rows===

{{works with|Java|1.5+}}

...//class definition, etc.

public static void genPyrN(int rows){

System.out.println(thisRow);

}

 

===Combinations===

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

public static void main(String[] args){

//usage

return ans;

}

 

===Using arithmetic calculation of each row element ===

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

public class Pascal {

private static void printPascalLine (int n) {

}

}

 

=={{header|JavaScript}}==

{{works with|SpiderMonkey}}

{{works with|V8}}

function pascalTriangle (rows) {

 

// Display 8 row triangle in base 16

tri = new pascalTriangle(8);

Output:

<pre>$ d8 pascal.js

====Functional====

{{Trans|Haskell}}

'use strict';

 

}), false, 'text-align:center;width:' + nWidth + 'em;height:' + nWidth +

'em;table-layout:fixed;'), JSON.stringify(lstTriangle)].join('\n\n');

{{Out}}

{| class="wikitable" style="text-align:center;width:26em;height:26em;table-layout:fixed;"

|}

 

 

===ES6===

 

 

// pascal :: Generator [[Int]]

iterate(

xs => zipWith(

);

 

// showPascal :: [[Int]] -> String

const showPascal = xs => {

};

 

 

 

 

 

 

 

 

 

// last :: [a] -> a

0 < xs.length ? xs.slice(-1)[0] : undefined;

 

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

length: n

}, () => {

const x = xs.next();

return x.done ? [] : [x.value];

 

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

each corresponding to a row of the Pascal triangle.

The implementation avoids any arithmetic except addition.

def pascal(n):

def _pascal: # input: the previous row

([1]; . + [ $in[$i] + $in[$i + 1] ]) + [1] | _pascal

end;

'''Example''':

pascal(5)

{{ Out }}

[1]

[1,1]

[1,2,1]

[1,3,3,1]

 

'''Using recurse/1'''

 

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

if n <= 0 then empty

else [1]

([1]; . + [ $in[$i] + $in[$i + 1] ]) + [1]

end)

=={{header|Julia}}==

 

while x<=n

for a=0:x

end

println("")

end

<pre>

</pre>

 

Another solution using matrix exponentiation.

 

iround(x) = round(Int64, x)

 

 

function pascal(n)

end

 

{{Out}}

1 4 6 4 1

1 5 10 10 5 1

</pre>

 

=={{header|K}}==

pascal:{(x-1){+':x,0}\1}

pascal 6

1 3 3 1

1 4 6 4 1

 

=={{header|Kotlin}}==

for (i in 0..rows - 1) {

for (j in 0..i)

}

 

 

=={{header|Liberty BASIC}}==

dim a$(n)

 

next i

 

 

=={{header|Locomotive Basic}}==

 

20 INPUT "Number of rows? ", rows:GOSUB 40

30 END

100 PRINT

110 NEXT

 

Output:

 

=={{header|Logo}}==

if :n = 1 [output [1]]

localmake "a pascal :n-1

end

 

=={{header|Lua}}==

function nextrow(t)

local ret = {}

end

end

 

=={{header|Maple}}==

 

1

1 1

1 2 1

 

 

=={{header|MATLAB}} / {{header|Octave}}==

 

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

 

<pre>>> pascal(6)

 

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

 

<pre>>> for k=1:6,diag(rot90(pascal(k)))', end

 

=={{header|Maxima}}==

 

display_pascal_triangle(n) := for i from 0 thru 6 do disp(sjoin(makelist(binomial(i, j), j, 0, i), " "));

"1 4 6 4 1"

"1 5 10 10 5 1"

 

=={{header|Metafont}}==

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

 

save ?;

? := (1 for i=(max(k,n-k)+1) upto n: * i endfor )

 

pascaltr(4);

 

=={{header|Microsoft Small Basic}}==

{{trans|GW-BASIC}}

TextWindow.Write("Number of rows? ")

r = TextWindow.ReadNumber()

TextWindow.WriteLine("")

EndFor

 

Output:

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

end n_

return fac /*calc. factorial*/

{{out}}

<pre>

 

(pascal.nial)

combination is fork [ > [first, second], 0 first,

/ [factorial second, * [factorial - [second, first], factorial first] ]

]

Using it

 

=={{header|Nim}}==

 

 

 

=={{header|OCaml}}==

 

let next_row row =

List.map2 (+) ([0] @ row) (row @ [0])

if i = n then []

else row :: loop (i+1) (next_row row)

 

=={{header|Octave}}==

for i = 0:h-1

for k = 0:h-i

endfunction

 

 

=={{header|Oforth}}==

No result if n <= 0

 

 

{{out}}

 

=={{header|Oz}}==

fun {NextLine Xs}

{List.zip 0|Xs {Append Xs [0]}

end

in

 

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

=={{header|PARI/GP}}==

my(row=[],prevrow=[]);

for(x=1,N,

print(row);

);

 

=={{header|Pascal}}==

 

procedure Pascal(r : Integer);

begin

Pascal(9)

Output:

<pre>% ./PascalsTriangle

=={{header|Perl}}==

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

my $rows = shift;

my @next = (1);

@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:

{{libheader|ntheory}}

sub pascal {

my $rows = shift;

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:

sub pascal_line { $_[0] ? unpack "A(A6)*", 1000001**$_[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 mine [https://github.com/LorenzoTa/Tartaglia-s-triangle Tartaglia's triangle]

 

#!/usr/bin/perl

use strict;

my @third = tartaglia_row(5);

print "@third\n";

 

which output

1 5 10 10 5 1

</pre>

 

=={{header|Phix}}==

{{out}}

<pre style="font-size: 8px">

 

"Reflected" Pascal's triangle, it uses symmetry property to "mirror" second part. It determines even and odd strings. automatically.

=={{header|PHP}}==

<?php

//Author Ivan Gavryshin @dcc0

?>

$c = 1;

$triangle = Array();

}

echo '<br>';

1

1 1

1 7 21 35 35 21 7 1

1 8 28 56 70 56 28 8 1

 

=={{header|PL/I}}==

declare (t, u)(40) fixed binary;

declare (i, n) fixed binary;

t = u;

end;

 

1

1 1

1 9 36 84 126 126 84 36 9 1

1 10 45 120 210 252 210 120 45 10 1

 

=={{header|Potion}}==

if (n < 1) :

1 print

.

 

 

=={{header|PowerShell}}==

$Infinity = 1

$NewNumbers = $null

$Infinity++

}

 

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

=={{header|Prolog}}==

Difference-lists are used to make quick append.

pascal(1, N, [1], [[1]|X]-X, L),

maplist(my_format, L).

my_writef(X) :-

writef(' %5r', [X]).

 

Output :

1

1 1

1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1

true.

===An alternative===

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

%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

pascal(N, Triangle), member(Row, Triangle), % Iterate and write each row

write(Row), nl, fail.

*Output*:

[1]

[1,1]

[1,2,1]

[1,3,3,1]

 

=={{header|PureBasic}}==

 

For i= 0 To n

Parameter.i = Val(ProgramParameter(0))

pascaltriangle(Parameter);

 

=={{header|Python}}==

===Procedural===

"""Prints out n rows of Pascal's triangle.

It returns False for failure and True for success."""

print row

row=[l+r for l,r in zip(row+k,k+row)]

 

or by creating a scan function:

a = []

result = it

 

for row in pascal(4):

 

===Functional===

 

 

 

 

 

 

 

 

 

 

 

# main :: IO ()

def main():

 

 

# showPascal :: [[Int]] -> String

def showPascal(xs):

ys = list(xs)

 

' '

)(' '.join(map(str, ns)))

w = len(' '.join((map(str, ys[-1]))))

return '\n'.join(map(align(w), ys))

 

 

 

# center :: Int -> Char -> String -> String

def center(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)

 

 

def iterate(f):

def go(x):

v = x

while True:

v = f(v)

 

 

 

if __name__ == '__main__':

{{Out}}

<pre> 1

 

=={{header|q}}==

pascal:{(x-1){0+':x,0}\1}

pascal 5

1 3 3 1

1 4 6 4 1

 

=={{header|Qi}}==

{{trans|Haskell}}

(define iterate

_ _ 0 -> []

(define pascal

N -> (iterate next-row [1] N))

 

=={{header|R}}==

{{trans|Octave}}

for(i in 0:(h-1)) {

s <- ""

print(s)

}

 

Here's an R version:

 

lapply(0:h, function(i) choose(i, 0:i))

 

=={{header|Racket}}==

Iterative version by summing rows up to <math>n</math>.

 

 

(define (pascal n)

 

 

 

=={{header|RapidQ}}==

RapidQ does not require simple variables to be declared before use.

 

 

INPUT "Number of rows: "; nrows

NEXT i

PRINT

 

===Using binary coefficients===

{{trans|BASIC}}

FOR row = 0 TO nrows-1

c = 1

NEXT i

PRINT

 

=={{header|Retro}}==

: pascalTriangle

cr dup

[ dup !j 1 swap 1+ [ !i dup putn space @j @i - * @i 1+ / ] iter cr drop ] iter drop

;

 

=={{header|REXX}}==

generated (without wrapping) in a screen window with a width of 620 characters.

 

&nbsp; &nbsp; where &nbsp; '''n''' &nbsp; is the absolute value of the number entered.

 

:::* &nbsp; Tartaglia's triangle

:::* &nbsp; Yang Hui's triangle

numeric digits 3000 /*be able to handle gihugeic triangles.*/

parse arg nn . /*obtain the optional argument from CL.*/

/* [↓] build rows of Pascals' triangle*/

/* [↑] WIDTH: for nicely looking line.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

1

1 10 45 120 210 252 210 120 45 10 1

</pre>

 

(Output shown at &nbsp; <big>'''⁴/₅'''</big> &nbsp; size.)

 

=={{header|Ring}}==

row = 5

for i = 0 to row - 1

see nl

next

Output:

<pre>

1 4 6 4 1

</pre>

 

=={{header|Ruby}}==

raise ArgumentError, "must be positive." if n < 1

yield ar = [1]

end

{{out}}

<pre>

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

 

 

def pascal(n) n.times.inject([1]) {|x,_| next_row x } end

 

{{out}}

<pre>

 

=={{header|Run BASIC}}==

for i = 0 to r - 1

c = 1

next

print

<pre>Number of rows? ?5

1

=={{header|Rust}}==

{{trans|C}}

fn pascal_triangle(n: u64)

{

}

}

 

=={{header|Scala}}==

===Functional solutions===

====Summing: Recursive row definition====

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:

 

{{Out}}

<pre> 1

1 4 6 4 1</pre>

====Summing: Scala Stream (Recursive & Memoization)====

def pascalTriangle(): Stream[Vector[Int]] =

Vector(1) #:: Stream.iterate(Vector(1, 1))(1 +: _.sliding(2).map(_.sum).toVector :+ 1)

println("Pascal's Triangle")

output.foreach(line => println(s"${" " * ((longest - line.length) / 2)}$line"))

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/8VqiX0P/1 ScalaFiddle (JavaScript)] or by [https://scastie.scala-lang.org/c3dDWMCcT3eoydy6QJcWCw Scastie (JVM)].

 

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(map + (cons 0 row) (append row '(0))))

 

(triangle (list 1) 5)

Output:

 

=={{header|Seed7}}==

 

const proc: main is func

writeln;

end for;

 

=={{header|Sidef}}==

var row = [1]

{ | n|

}

 

 

=={{header|Stata}}==

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).

 

return(comb(J(1,n,0::n-1),J(n,1,0..n-1)))

}

}

return(s)

 

Now print the Pascal triangle.

 

a = pascal1(n)

for (i=1; i<=n; i++) {

1 2 1

1 3 3 1

 

=={{header|Swift}}==

if n==1{

let a=[1]

}

let waste = pascal(n:10)

 

=={{header|Tcl}}==

===Summing from Previous Rows===

if {$n < 1} {error "undefined behaviour for n < 1"}

set row [list 1]

}

 

<pre>1

1 1

===Using binary coefficients===

{{trans|BASIC}}

if {$n < 1} {error "undefined behaviour for n < 1"}

for {set i 0} {$i < $n} {incr i} {

}

 

===Combinations===

{{trans|Java}}

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

 

proc pascal_combinations n {

}

 

 

===Comparing Performance===

puts "calculate $n rows:"

foreach proc {pascal_iterative pascal_coefficients pascal_combinations} {

puts "$proc: [time [list $proc $n] 100]"

{{Out}}

<pre>calculate 100 rows:

=={{header|TI-83 BASIC}}==

===Using Addition of Previous Rows===

:Lbl IN

:ClrHome

:End

:End

===Using nCr Function===

:Lbl IN

:ClrHome

:End

:End

=={{header|Turing}}==

 

for i : 0 .. n

for k : 0 .. i

c := c * (i - k) div (k + 1)

end for

end pascal

 

 

=={{header|uBasic/4tH}}==

@(1) = 1

Print Tab((N+1)*3);"1"

 

Print

Output:

<pre>Number Of Rows: 10

0 OK, 0:380

</pre>

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

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

pascal() {

local -i n=${1:-1}

fi

}

 

=={{header|Ursala}}==

Zero maps to the empty list. Negatives are inexpressible.

This solution uses a library function for binomial coefficients.

#import nat

 

This solution uses direct summation. The algorithm is to

insert zero at the head of a list (initially the unit list <1>), zip it with its reversal,

map the sum over the list of pairs, iterate n times, and return the trace.

#import nat

 

test program:

 

{{Out}}

<pre><

 

=={{header|VBA}}==

Private Sub pascal_triangle(n As Integer)

Dim odd() As String

Public Sub main()

pascal_triangle 13

<pre> 1

1 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</pre>

=={{header|VBScript}}==

Derived from the BASIC version.

Function Pascal_Triangle(n)

Dim values(100)

WScript.StdOut.WriteLine

Next

{{out}}

Invoke from a command line.

For example, if #99 contains value 2, then #@99 accesses contents of numeric register #2.

 

#0=0; #1=1

Ins_Char(' ', COUNT, #100*3-2) Num_Ins(1)

}

Ins_Newline

 

===Using binary coefficients===

{{trans|BASIC}}

for (#2 = 0; #2 < #1; #2++) {

#3 = 1

}

Ins_Newline

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

'Pascal's triangle

Const m = 11

Next n

MsgBox ss, , "Pascal's triangle"

{{out}}

<pre>

1 9 36 84 126 126 84 36 9 1

1 10 45 120 210 252 210 120 45 10 1