Pascal's triangle: Difference between revisions

{{trans|Python}}

V row = [1]

V k = [0]

row = zip(row [+] k, k [+] row).map((l, r) -> l + r)

{{out}}

=={{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|Action!}}==

BYTE count=[10],row,item

CHAR ARRAY s(5)

PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Pascal's_triangle.png Screenshot from Atari 8-bit computer]

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>

Pascal' s triangle of order ⍵

=== Dyalog APL ===

{⍕0~¨⍨(-⌽A)⌽↑,/0,¨⍉A∘.!A←0,⍳⍵}

example

{⍕0~¨⍨(-⌽A)⌽↑,/0,¨⍉A∘.!A←0,⍳⍵}5

<pre>

GNU APL doesn't allow multiple statements within lambdas so the solution is phrased differently:

{{⍉⍵∘.!⍵} 0,⍳⍵}

example

{{⍉⍵∘.!⍵} 0,⍳⍵} 3

<pre>

=={{header|AppleScript}}==

Drawing n rows from a generator:

-- pascal :: Generator [[Int]]

return lst

end tell

{{Out}}

<pre> 1

=={{header|Arturo}}==

{{trans|Nim}}

triangle: new [[1]]

loop pascalTriangle 10 'row [

print pad.center join.with: " " map to [:string] row 'x -> pad.center x 5 60

{{out}}

=={{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

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

=={{header|BCPL}}==

let pascal(n) be

$)

{{out}}

<pre> 1

=={{header|Befunge}}==

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

{{Out}}

<pre>Number of rows: 10

Displays n rows.

⟨ 1 1 ⟩

⟨ 1 2 1 ⟩

⟨ 1 3 3 1 ⟩

⟨ 1 4 6 4 1 ⟩

=={{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 sharp|C#}}==

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

namespace RosettaCode {

}

}

===Arbitrarily large numbers (BigInteger), arbitrary row selection===

using System.Linq;

using System.Numerics;

}

}

Example:

{

IEnumerable<BigInteger[]> triangle = PascalsTriangle.GetTriangle(20);

string output = PascalsTriangle.FormatTriangleString(triangle)

Console.WriteLine(output);

{{out}}

=={{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.

(genrow n '(1)))

'(1)

(cons (+ (first l) (second l))

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

(loop :for q :in a

:and p = 0 :then q

(loop :for a = (list 1) :then (pascal-next-row a)

:repeat n

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.

(defun next-pascal-triangle-row (list)

`(1

(format nil "~~{~~~D:@<~~{~~A ~~}~~>~~%~~}" max-row-length)

triangle)))

For example:

1

1 1

1 2 1

1 3 3 1

1

1 1

1 6 15 20 15 6 1

1 7 21 35 35 21 7 1

=={{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}}

=={{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}}

=={{header|Emacs Lisp}}==

===Using mapcar and append, returing a list of rows===

(defun next-row (row)

(if (= rows 0)

'()

{{Out}}

</pre>

===Translation from Pascal===

(dotimes (i r)

(let ((c 1))

(setq c (/ (* c (- i k))

(+ k 1))))

{{Out}}

From the REPL:

===Returning a string===

Same as the translation from Pascal, but now returning a string.

(let ((out ""))

(dotimes (i r)

(+ k 1))))

(setq out (concat out "\n"))))

{{Out}}

Now, since this one returns a string, it is possible to insert the result in the current buffer:

=={{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}}

{{Works with|Office 365 betas 2021}}

=LAMBDA(n,

BINCOEFF(n - 1)(

QUOTIENT(FACT(n), FACT(k) * FACT(n - k))

)

{{Out}}

Or defining the whole triangle as a single grid, by binding the name TRIANGLE to an additional lambda:

=LAMBDA(n,

LET(

)

)

{{Out}}

=={{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|FOCAL}}==

1.2 F N=1,10; D 2

1.3 Q

3.1 S OLD(X)=NEW(X)

{{output}}

<pre>

=={{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}}

=={{header|Frink}}==

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] :=

{

pascal[10]

{{out}}

=== 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}}

=={{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:

binCoef n k = fac n `div` (fac k * fac (n - k))

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

=={{header|ivy}}==

op pascal N = transp (0 , iota N) o.! -1 , iota N

pascal 5

1 4 6 4 1 0

1 5 10 10 5 1

=={{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===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre> 1

====Recursive====

const aux = n => {

if(n <= 1) return [1]

}

pascal(8)

{{Out}}

<pre>

</pre>

====Recursive - memoized====

const aux = (() => {

const layers = [[1], [1]]