Pascal's triangle: Difference between revisions

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

 

begin

Print(General_Triangle(7));

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

Output:

1

 

GuiClose:

 

=={{header|AWK}}==

 

=={{header|BASIC}}==

 

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

 

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

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

 

(genrow n '(1)))

 

(if (> 2 (length l))

'(1)

 

=={{header|D}}==

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

 

=={{header|Fortran}}==

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

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

 

=={{header|Groovy}}==

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

 

=={{header|J}}==

=== solution ===

 

 

=== explanation ===

 

So, for example, the number of ways to choose a poker hand (5 cards from the deck of 52):

 

So <tt>!</tt> is the mathematical choose function. What of <tt>/~@i.</tt>? Well, you can think of <tt>/~</tt> as "table of" and <tt>@i.</tt> "the first N non-negative integers (i.e. 0 .. N-1)".

 

So, for example, here's the multiplication table you had to memorize in first grade:

0 0 0 0 0 0 0 0 0 0

0 1 2 3 4 5 6 7 8 9

0 7 14 21 28 35 42 49 56 63

0 8 16 24 32 40 48 56 64 72

 

and here's the addition table for 0 to 4

0 1 2 3

1 2 3 4

2 3 4 5

 

Similarly, <tt>!/~@i.</tt> is the number-of-combinations table, or the "choose" table:

1 1 1 1 1

0 1 2 3 4

0 0 1 3 6

0 0 0 1 4

 

Of course, to format it nicely, you need to do a little more work:

1

1 1

1 2 1

1 3 3 1

 

(I won't bother explaining the formatting.)

print, r

 

 

=={{header|Java}}==

 

=={{header|Logo}}==

if :n = 1 [output [1]]

localmake "a pascal :n-1

end

 

 

=={{header|Metafont}}==

 

(pascal.nial)

Using it

 

=={{header|OCaml}}==

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

return if n < 1

p

 

=={{header|Seed7}}==

writeln;

end for;

 

=={{header|Tcl}}==

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:

<lang Ursala>#cast %nLL

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