Tam giác của Pascal được tạo bằng cách bắt đầu bằng 1 trên hàng đầu tiên. Trên các hàng tiếp theo, số được xác định bằng tổng của hai số trực tiếp bên trên nó bên trái và bên phải.

Để chứng minh, đây là 5 hàng tam giác đầu tiên của Pascal:

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

Các thách thức

Đưa ra một đầu vào n (được cung cấp tuy nhiên thuận tiện nhất trong ngôn ngữ bạn đã chọn), tạo n hàng đầu tiên của tam giác Pascal. Bạn có thể giả sử rằng n là một số nguyên nằm trong khoảng từ 1 đến 25. Phải có một ngắt dòng giữa mỗi hàng và khoảng trắng giữa mỗi số, nhưng ngoài ra, bạn có thể định dạng nó theo cách bạn muốn.

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất sẽ thắng.

Ví dụ 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 ký tự

":@(!{:)\@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
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
   ": @ (! {:) \ I.5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
   (": @ (! {:) \ @ i.)` ''
+ ---------------------------------- +
| + - + ------------------------------ + |
|| @ | + ------------------------- + - + | |
| | | | + - + --------------------- + | i. |||
| | ||| \ | + ------------------- + || | |
| | | | | | + - + --------------- + ||| | |
| | | | ||| @ | + - + ---------- + | | | |
| | | | | | || ": | + - + ------ + | |
| | | | | | | | | | 2 | + - + - + | | | |
| | | | | | | | | | | |! | {: | | | |
| | | | | | | | | | | + - + - + | | | |
| | | | | | | | | + - + ------ + | | | |
| | | | | | | + - + ---------- + | | | |
| | | | | | + - + --------------- + ||| | |
| | | | | + ------------------- + || | |
| | | | + - + --------------------- + | | |
| | | + ------------------------- + - + | |
| + - + ------------------------------ + |
+ ---------------------------------- +

Python, 56 byte

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

Sử dụng mẫu:

echo 9 | python filename.py

Sản xuấ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]

Con trăn, 94 91 88 70 63 ký tự

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

Toán học: 36 (41?)

Mathematica có Binomialchức năng, nhưng điều đó mang lại niềm vui từ điều này. Tôi đề nghị:

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

Dòng trên sẽ hiển thị một mảng rách rưới, chẳng hạn như:

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

Vì đây là định dạng cơ bản trong Mathematica tôi nghĩ rằng nó sẽ được chấp nhận, nhưng khi tôi đọc lại các quy tắc, tôi nghĩ nó có thể không được. Việc thêm Grid@sẽ tạo ra đầu ra chấp nhận một cách rõ ràng, với tổng số 41 ký tự:

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

Một câu tự thể hiện C. Không thể rõ ràng hơn! Điểm thưởng cho việc tìm kiếm các nhân vật phụ.

#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 ký tự)

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

Vì một lời giải thích đã được yêu cầu:

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

Đầu ra:

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

Phiên bản 71 ký tự không in khoảng trắng giữa mỗi số:

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

Đầu ra:

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

Scala, 81 78 72 70 ký tự

81 ký tự: lần thử đầu tiên, được sao chép một cách đáng xấu hổ từ phiên bản Python :)

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

Chạy nó dưới dạng tập lệnh hoặc trực tiếp trong REPL.

Cắt tới 70 ký tự với một cái gì đó đáng ngạc nhiên có thể đọc và thành ngữ:

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

Hoặc 72 70 ký tự với một phương thức hoàn toàn khác:

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

Hồng ngọc: 51 49 46 ký tự

(Mã 45 ký tự + 1 ký tự tùy chọn dòng lệnh)

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

Nhờ vào:

• jsvnm để đề xuất một thay thế cho việc chuyển đổi giá trị (2 ký tự)
• GB để phát hiện ra một biến không được sử dụng sau lần cải tiến trước đó (4 ký tự)

Chạy mẫu:

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]

Hãy thử trực tuyến!

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)

Bản trình diễn: http://jsfiddle.net/tcRCS/3/

LƯU Ý : Không hoạt động tốt trong thực tế trong khoảng n> 30 vì các số tràn kiểu dữ liệu số nguyên tích hợp và trở thành số dấu phẩy động.

Chỉnh sửa 1 : xóa 5 ký tự bằng cách chuyển đổi whilethành forvà kết hợp các câu lệnh

Chỉnh sửa 2 : di chuyển s=câu lệnh bên trong forvà lưu 2 ký tự

Chỉnh sửa 3 : kết hợp trình s=1,j=1khởi tạo vào s=j=1và lưu 2 ký tự

R, 39 ký tự

R dường như là công cụ rất phù hợp cho nhiệm vụ này :-)

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

trong Q (25 ký tự / 20 với phiên bản ngắn hơn)

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

Ngắn hơn

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

Sử dụng mẫu:

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

awk - 73 ký tự

thực hiện khá đơn giản:

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

chạy mẫu:

% 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 ký tự

Chỉnh sửa: sử dụng saythay vìprint

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

Perl, 47 54 ký tự

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

Nó lấy một số từ dòng lệnh, nhưng không thực hiện bất kỳ kiểm tra lỗi nào.

Chỉ cần nhận ra nó chỉ hoạt động tối đa n = 4. Đó là một số mã cũ tôi có trên hd của tôi.

Điều này hoạt động mặc dù:

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

n phải được nhập vào tập lệnh, hoặc nó sẽ là một ký tự nữa.

Keg , 40 byte

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

Giải thích

Perl, 77 Chars

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

Ví dụ đầu vào

5

Ví dụ đầu ra

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

C, 132 127 ký tự

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 ký tự

(Không phải là một đối thủ cạnh tranh thực sự, chỉ là một sự hiện diện danh dự.)

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.

Chạy mẫu:

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 byte

Ngôn ngữ được tạo ra sau thử thách này

1iq:"tTTY+

Hãy thử trực tuyến!

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 ký tự

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

đầu ra cho 9 là

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

tận dụng tối đa "bạn có thể định dạng nó theo cách bạn muốn"; có một khoảng cách giữa mỗi số và ngắt dòng

chỉnh sửa định vị lại nhiệm vụ lđể cạo một số ký tự

Scala, 131 ký tự

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

Lấy đầu vào từ dòng lệnh.

Đầu ra cho 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 ký tự

Nỗ lực đầu tiên của tôi tại một vòng golf mã, và lần đầu tiên cố gắng lập trình chức năng. Có lẽ có một số cách rõ ràng để rút ngắn nó mà tôi chưa tìm ra. Nó tuân thủ trình biên dịch F♯ của VS2010 (có tác dụng chạy #light theo mặc định không giống như các phiên bản trước đó) và cũng hoạt động trong trình thông dịch F. Chấp nhận đầu vào thông qua stdin. Muốn có một cách tốt hơn cho đầu vào / đầu ra mặc dù! Rất nhiều nhân vật!

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

Tại sao không có câu trả lời được chấp nhận cho câu hỏi này?

VBA - 249 ký tự

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

postcript - 59 ký tự (63 nếu bạn đếm -dn=để có được số lượng hàng trong)

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

chạy với

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

để có được

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

Toán học 35 ký tự

Đây là cách ngu ngốc và lười biếng để cắt tam giác của Pascal:

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 ký tự

Một chút muộn để dự tiệc, có lẽ?

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

Nó không đánh bại mục J, mặc dù.

Điều này giả định rằng nguồn gốc chỉ mục ( ⎕IO) được đặt thành 0. Thật không may, với nguồn gốc chỉ mục là 1, chúng ta cần 25 18 ký tự:

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

Có hai ⍨s trong mã để thể hiện sự thất vọng của tôi.

Bản giới thiệu:

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

Giải thích

Phiên bản ngắn:

• ⍳⍵ (với nguồn gốc chỉ số là 0) tạo ra một mảng các số từ 0 đến ⍵-1 bao gồm, trong đó⍵ là đối số đúng cho hàm.
• ⍳⍵+1 tạo ra tất cả các số từ 0 đến ⍵
• {⍵!⍨⍳⍵+1}tạo ⍵chọn kcho mọi phần tử ktrong⍳⍵+1 . Các ⍨(đi làm) điều hành giao dịch hoán đổi các đối số cho hàm xung quanh, như vậy mà tranh cãi tay phải trở thành trái, và ngược lại.
• {⍵!⍨⍳⍵+1}¨⍳⍵vượt qua từng yếu tố trong ⍳⍵việc sử dụng¨ toán tử (mỗi). Kết quả là một mảng một chiều chứa các ⍵hàng đầu tiên của Tam giác Pascal.
• Một dạng đối số của ⍪ lấy một vectơ một chiều và biến nó thành một cột chứ không phải là một hàng. Mỗi hàng của tam giác được đặt trên một dòng riêng của nó.

Câu trả lời dài:

• Hầu như giống với các phiên bản khác, ngoại trừ điều đó 1-⍨ được đặt trước một⍳ bản sao chỉ mục gốc bằng 0.
• 0,⍳⍵với chỉ số gốc là 1 lần lặp ⍳⍵+1với chỉ số gốc là 0.

Cây phong, 46

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

Sử dụng:

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

_{^{Lưu được 22 byte nhờ Taylor Scott.}}

_{Đây là một câu hỏi cũ nhưng tôi đã thấy một giải pháp ngắn hơn cho VBA.}

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

Điều này có nghĩa là được chạy trong cửa sổ ngay lập tức. Đầu vào là trong ô A1của bảng tính hoạt động. Đầu ra nằm trong bảng tính hoạt động bắt đầu tại B2và sử dụng tuy nhiên nhiều ô được yêu cầu dựa trên đầu vào. CácCOLUMN()>ROW() kiểm tra giữ phía trên bên phải của trống hình tam giác. Các ROW()=2kiểm tra làm cho giá trị đầu tiên1 để bắt đầu hình tam giác. Tôi có thể đã chuyển đầu ra xuống và bỏ kiểm tra này, nhưng nó đưa ra rất nhiều đầu ra không liên quan trước tam giác thực tế và tôi không cảm thấy rằng đó là tinh thần của thử thách.

Ban đầu tôi đã đăng một phương thức phức tạp hơn nhiều, tính toán mọi giá trị dựa trên hàng và cột của nó. Mặc dù vậy, tất cả phương pháp này là sử dụng các công thức trong ô. Tôi bắt đầu tại B2để tôi có thể tham chiếu hàng phía trên nó mà không có #REF!lỗi. Sau đó, nó sao chép và dán cùng một công thức trên một khối các ô n rộng và n cao. Đầu vào và đầu ra n=25trông như thế này:

05AB1E , 14 byte

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

Hãy thử trực tuyến!

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