Trójkąt Pascala jest generowany, zaczynając od 1 w pierwszym rzędzie. W kolejnych wierszach liczba jest określona przez sumę dwóch liczb bezpośrednio nad nią po lewej i prawej stronie.

Aby to zademonstrować, oto 5 pierwszych rzędów trójkąta Pascala:

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

Wyzwanie

Biorąc pod uwagę wartość n (pod warunkiem, że jest to najwygodniejsze w wybranym języku), wygeneruj pierwsze n wierszy trójkąta Pascala. Możesz założyć, że n jest liczbą całkowitą zawierającą się między 1 a 25. Musi istnieć przerwa między wierszami i spacja między każdą liczbą, ale poza tym możesz sformatować ją w dowolny sposób.

To jest golf golfowy , więc wygrywa najkrótsze rozwiązanie.

Przykład I / O

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

J , 12 znaków

":@(!{:)\@i.

   i.5
0 1 2 3 4
   {: i.5
4
   (i.5)! {: i.5
1 4 6 4 1
   (! {:) i.5
1 4 6 4 1
   (! {:) \ i.5
10000
1 1 0 0 0
1 2 1 0 0
1 3 3 1 0
1 4 6 4 1
   „: @ (! {:) \ i.5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
   („: @ (! {:) \ @ i.) ''
+ ---------------------------------- +
| + - + ------------------------------ + |
|| @ | + ------------------------- + - + ||
|| || + - + --------------------- + | i. |||
|| ||| \ | + ------------------- + || |||
|| ||| || + - + --------------- + ||| |||
|| ||| ||| @ | + - + ---------- + |||| |||
|| ||| ||| || ": | + - + ------ + ||||| |||
|| ||| ||| || || 2 | + - + - + |||||| |||
|| ||| ||| || || ||! | {: ||||||| |||
|| ||| ||| || || | + - + - + |||||| |||
|| ||| ||| || | + - + ------ + ||||| |||
|| ||| ||| | + - + ---------- + |||| |||
|| ||| || + - + --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || + - + --------------------- + | |||
|| | + ------------------------- + - + ||
| + - + ------------------------------ + |
+ ---------------------------------- +

Python, 56 bajtów

a=[1];exec"print a;a=map(sum,zip([0]+a,a+[0]));"*input()

Przykładowe użycie:

echo 9 | python filename.py

Produkuje:

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

Python, 94 91 88 70 63 znaków

x=[1]
for i in input()*x:
 print x
 x=map(sum,zip([0]+x,x+[0]))

Mathematica: 36 (41?)

Mathematica ma tę Binomialfunkcję, ale zabiera to zabawę. Proponuję:

NestList[{0,##}+{##,0}&@@#&,{1},n-1]

Linia powyżej wyświetli nierówną tablicę, taką jak:

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

Ponieważ jest to podstawowy format w Mathematica, pomyślałem, że będzie akceptowalny, ale kiedy ponownie czytam zasady, myślę, że może nie być. Dodanie Grid@wygeneruje jednoznacznie akceptowalny wynik, w sumie 41 znaków:

Grid@NestList[{0,##}+{##,0}&@@#&,{1},n-1]

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

C 522

Samo demonstrująca odpowiedź C. Nie może być jaśniejsze! Punkty bonusowe za znalezienie dodatkowej postaci.

#define returns return 0
#define fr for
#define twentyonechexpressis0 0
                                                                                i
                                                                               , x
                                                                              [ 52 ]
                                                                            [ 52] ,j, y
                                                                       ; main (c){fr (;i< c
                                                                    ; i++){ x[i][i]=x[ i][0]= 1
                                                         ; }for(i =2;i<c;i++){for (j=1;j<i;j++){x [i][j] =
                                    1 +x[i][j ]+x[i-1][j-1]+x[i-1] [j]+1-1+1-1+1-1+1-1+1-1+111-11- twentyonechexpressis0 -100-1; }
} ;for(i=0 ;i<c;i++){for(j=0;j<=i;j++){ printf("%3d%c",x[i][j],(1+1+1+1)*(1+1+1+1+1+1+1+1)) ;}putchar(1+1+(1<<1+1)+1+1+1+1+1+111111-111111-1);} /*thiscomment_takes28chars*/ returns; }

Golfscript (21 znaków)

~]({0\{.@+\}/;1].p}*;

Ponieważ zażądano wyjaśnienia:

# Stack contains 'n'
~](
# Stack: [] n
{
    # prev_row is [\binom{i,0} ... \binom{i,i}]
    # We loop to generate almost all of the next row as
    #     [(\binom{i,-1} + \binom{i,0}) ... (\binom{i,i-1} + \binom{i,i})]
    # \binom{i,-1} is, of course, 0
    # Stack: prev_row
    0\
    # Stack: 0 prev_row
    {
        # Stack: ... \binom{i,j-1} \binom{i,j}
        .@+\
        # Stack: ... (\binom{i,j-1} + \binom{i,j}) \binom{i,j}
    }/
    # Stack: \binom{i+1,0} ... \binom{i+1,i} \binom{i,i}
    # unless it's the first time round, when we still have 0
    # so we need to pop and then push a 1 for \binom{i+1,i+1}
    ;1]
    # next_row
    .p
}*
# final_row
;

Haskell, 94 92

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_(putStrLn.unwords.map show).(`take`f)

Wydajność:

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

Wersja 71 znaków, która nie drukuje spacji między każdą liczbą:

f=[1]:[zipWith(+)(0:x)x++[1]|x<-f]
main=readLn>>=mapM_ print.(`take`f)

Wydajność:

[1]
[1,1]
[1,2,1]
[1,3,3,1]

Scala, 81 78 72 70 znaków

81 znaków: pierwsza próba, bezwstydnie skopiowana z wersji Python :)

var x=Seq(1)
for(i<-1 to args(0).toInt){println(x)
x=(0+:x,x:+0).zipped.map(_+_)}

Uruchom jako skrypt lub bezpośrednio w REPL.

Obetnij do 70 znaków za pomocą czegoś zaskakująco czytelnego i idiomatycznego:

Seq.iterate(Seq(1),readInt)(a=>(0+:a,a:+0).zipped.map(_+_))map println

Lub 72 70 znaków z zupełnie inną metodą:

0 to(readInt-1)map(i=>println(0 to i map(1 to i combinations(_)size)))

Ruby: 51 49 46 znaków

(Kod 45 znaków + opcja wiersza poleceń 1 znak)

p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}

Dzięki:

• jsvnm za zasugerowanie alternatywy dla przełączania wartości (2 znaki)
• GB na wykrycie zmiennej nieużywanej po poprzednim ulepszeniu (4 znaki)

Przykładowy przebieg:

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 1
[1]

bash-4.4$ ruby -ne 'p=[];$_.to_i.times{n=0;p p.map!{|i|n+n=i}<<1}' <<< 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]

Wypróbuj online!

JavaScript ( 90 85 83 81)

for(n=prompt(o=i='');i++<n;o+='\n')for(s=j=1;j<=i;s=s*(i-j)/j++)o+=s+' ';alert(o)

Demo: http://jsfiddle.net/tcRCS/3/

UWAGA : Nie działa dobrze w praktyce dla około n> 30, ponieważ liczby przepełniają wbudowany typ danych liczb całkowitych i stają się liczbami zmiennoprzecinkowymi.

Edycja 1 : 5 znaków usunięto przez konwersję whiledo fori łączenie sprawozdań

Edycja 2 : przenieśs= instrukcję do środka fori zapisz 2 znaki

Edycja 3 : połącz s=1,j=1inicjator s=j=1i zapisz 2 znaki

R, 39 znaków

R wydaje się być właściwym narzędziem do tego zadania :-)

x=1;for(i in 1:n)x=c(print(x),0)+c(0,x)

w Q (25 znaków / 20 w krótszej wersji)

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

Krótszy

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

Przykładowe użycie:

q)t 4
1
1 1
1 2 1
1 3 3 1

awk - 73 znaki

dość prosta implementacja:

{for(i=0;i<$1;++i)for(j=i;j>=0;)printf"%d%c",Y[j]+=i?Y[j-1]:1,j--?32:10}

przykładowy przebieg:

% awk -f pascal.awk <<<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

Perl, 52 , 49 znaków

Edycja: za pomocą sayzamiastprint

map{@_=(1,map$_[$_-1]+$_[$_],1..@_);say"@_"}1..<>

Perl, 47 54 znaków

$p=1;map{print"@{[split//,$p]}\n";$p*=11}1..<>

Pobiera liczbę z wiersza poleceń, ale nie wykonuje żadnych kontroli błędów.

Właśnie zdałem sobie sprawę, że działa tylko do n = 4. To był stary kod, który miałem na swoim dysku HD.

Działa to jednak:

map{@a=(1,map$a[$_-1]+=$a[$_],1..@a);print"@a\n"}a..n

n musi jednak zostać wprowadzone do skryptu, inaczej byłby to jeden znak więcej.

Beczka , 40 bajtów

1®n1¿1.
,(|(©n|:©n$@MCƒℤ. ,⑨)©n⑨®n_01.
,

Wyjaśnił

Perl, 77 znaków

$o[0]=1;for(1..<>){$"=" ";for(1..$_){$n[$_]=$o[$_]+$o[$_-1]}@o=@n;print"@o
"}

Przykładowe dane wejściowe

5

Przykładowe dane wyjściowe

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

C, 132 127 znaków

c[25][25],n,i,j;main(){for(scanf("%d",&n);i<n;i++)for(j=0;j<=i;j++)printf("%d%c",c[i][j]=j?c[i-1][j-1]+c[i-1][j]:1,i-j?32:10);}

Pascal: 216 192 znaków

(Nie prawdziwy konkurent, tylko honorowa obecność.)

var p:array[0..1,0..25]of LongInt;i,j,n,u:Word;begin
Read(n);u:=0;for i:=1to n do begin
p[1,1]:=1;for j:=1to i do begin
p[u,j]:=p[1-u,j-1]+p[1-u,j];Write(p[u,j],' ')end;u:=1-u;Writeln
end
end.

Przykładowy przebieg:

bash-4.2$ fpc pascal.pas 
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?

bash-4.2$ ./pascal <<< 1
1 

bash-4.2$ ./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 

MATL, 10 bytes

Language created after this challenge

1iq:"tTTY+

Try it online!

1       % Push a 1. This will be the first row
iq:     % Take input n. Generate range [1,2,...,n-1]
"       % For each (that is, repeat n-1 times)
  t     %   Duplicate latest row
  TT    %   Push [1 1]
  Y+    %   Convolve latest row with [1 1] to produce next row
        % Implicitly end for each
        % Implicitly display stack contents

D 134 128 chars

import std.stdio;void main(){int n,m;int[]l,k=[0,1];readf("%d",&n);foreach(i;0..n){writeln(l=k~0);k=[];foreach(e;l)k~=m+(m=e);}}

output for 9 is

>9
[0, 1, 0]
[0, 1, 1, 0]
[0, 1, 2, 1, 0]
[0, 1, 3, 3, 1, 0]
[0, 1, 4, 6, 4, 1, 0]
[0, 1, 5, 10, 10, 5, 1, 0]
[0, 1, 6, 15, 20, 15, 6, 1, 0]
[0, 1, 7, 21, 35, 35, 21, 7, 1, 0]
[0, 1, 8, 28, 56, 70, 56, 28, 8, 1, 0]

taking full advantage of "you may format it however you like"; there is a space between each number and a linebreak

edit repositioned the assignment to l to shave of some chars

Scala, 131 characters

object P extends App{var x=List(1)
while(x.size<=args(0).toInt){println(x.mkString(" "))
x=(0+:x:+0).sliding(2).map(_.sum).toList}}

Takes the input from the command line.

Output for n=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

F♯ - 203 characters

My first attempt at a round of code golf, and first attempt at functional programming. There is probably some obvious way to shorten it I haven't quite figured out yet. It complies in VS2010s F♯ compiler (which has the effect of running #light by default unlike earlier versions), and also works in the F♯ interpreter. Accepts input via stdin. Wish there was a better way for the input/output though! Lots of characters!

open System
let rec C r m =if r=0||m<=0||m>=r then 1 else C(r-1)m+C(r-1)(m-1)
for j = 0 to Convert.ToInt32(Console.ReadLine ()) do (
 [0..j]|>List.map(C j)|>List.iter(fun k->printf "%i " k)
 printf "\n")

Why is there no accepted answer to this question?

VBA - 249 chars

Sub t(n)
ReDim a(1 To n,1 To n*2)
a(1,n)=1:y=vbCr:z=" ":d=z & 1 & z & y:For b=2 To n:For c=1 To n*2:x=a(b-1,c)
If c>1 Then a(b,c)=a(b-1,c-1)+x
If c<n*2 Then a(b,c)=a(b-1,c+1)+x
d=IIf(a(b,c)<>0,d & z & a(b,c) & z,d):Next:d=d & y:Next:MsgBox d
End Sub

postscript - 59 chars (63 if you count -dn= to get the number of rows in)

[1]n{dup ==[0 3 2 roll{dup 3 2 roll add exch}forall]}repeat

run with

gs -q -dn=10 -dBATCH pascal.ps 

to get

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

Mathematica 35 chars

Here is the dull and lazy way of slicing Pascal's triangle:

Table[n~Binomial~k,{n,0,5},{k,0,n}]

(* out *)
{{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 6, 4, 1}, {1, 5, 10, 10,5, 1}}

APL, 19 15 characters

A bit late to the party, perhaps?

{⍪{⍵!⍨⍳⍵+1}¨⍳⍵}

It doesn't beat the J entry, though.

This assumes that the index origin (⎕IO) is set to 0. Unfortunately, with an index origin of 1, we need 25 18 characters:

{⍪{⍵!⍨0,⍳⍵}¨1-⍨⍳⍵}

There are two ⍨s in the code to express my frustration.

Demo:

      {⍪{⍵!⍨⍳⍵+1}¨⍳⍵}5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

Explanations

Short version:

• ⍳⍵ (with an index origin of 0) produces an array of the numbers from 0 to ⍵-1 inclusive, where ⍵ is the right argument to the function.
• ⍳⍵+1 generates all numbers from 0 to ⍵
• {⍵!⍨⍳⍵+1} generates ⍵ choose k for every element k in ⍳⍵+1. The ⍨ (commute) operator swaps the arguments to a function around, such that the right hand argument becomes the left, and vice versa.
• {⍵!⍨⍳⍵+1}¨⍳⍵ passes each element in ⍳⍵ using the ¨ (each) operator. The result is a one dimensional array containing the first ⍵ rows of the Pascal's Triangle.
• The one argument form of ⍪ takes a one dimensional vector, and makes it a column rather than a row. Each row of the triangle is put on its own line.

Long answer:

• Virtually the same as the other version, except that 1-⍨ is placed before an ⍳ to replicate an index origin of 0.
• 0,⍳⍵ with an index origin of 1 replicates ⍳⍵+1 with an index origin of 0.

Maple, 46

seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1)

Usage:

> f:=n->seq(print(seq(binomial(i,k),k=0..i)),i=0..n-1);
> f(3)
    1
   1 1
  1 2 1

VBA, 162 142 102 80 bytes

_{^{Saved 22 bytes thanks to Taylor Scott.}}

_{This is an old question now but I saw a shorter solution for VBA.}

[B2].Resize([A1],[A1])="=IF(COLUMN()>ROW(),"""",IF(ROW()=2,1,IFERROR(A1+B1,1)))"

This is meant to be run in the immediate window. Input is in cell A1 of the active worksheet. Output is in the active worksheet starting at B2 and using however many cells are required based on the input. The COLUMN()>ROW() check keeps the top right of the triangle blank. The ROW()=2 check makes the first value 1 to initiate the triangle. I could have shifted the output down and dropped this check, but it introduces a lot of extraneous output before the actual triangle and I didn't feel that it was in the spirit of the challenge.

I originally posted a much more complicated method that calculated every value based on its row and column. All this method does, though, is to use in-cell formulas. I start at B2 so I can reference the row above it without #REF! errors. Then, it copies and pastes the same formula over a block of cells n wide and n tall. The input and output for n=25 looks like this:

05AB1E, 14 bytes

FN©>F®Ne})ˆ}¯»

Try it online!

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1