파스칼의 삼각형 은 첫 번째 행에서 1로 시작하여 생성됩니다. 다음 행에서 숫자는 바로 위와 왼쪽에있는 두 숫자의 합으로 결정됩니다.

다음은 파스칼 삼각형의 첫 5 행입니다.

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

도전

입력 n이 주어지면 (그러나 선택한 언어에서 가장 편리함) 파스칼 삼각형 의 첫 n 행을 생성하십시오 . n 은 1과 25 사이의 정수 라고 가정 할 수 있습니다 . 각 행과 각 숫자 사이에 공백이 있어야하지만 그 외에는 원하는대로 형식을 지정할 수 있습니다.

이것은 code-golf 이므로 가장 짧은 솔루션이 승리합니다.

예제 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 자

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

   i.5
012 34
   {: i.5
4
   (i.5)! {: i.5
1 4 6 4 1
   (! {:) i.5
1 4 6 4 1
   (! {:) \ i.5
1000 년
1,010
1 2 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 | +-+-+ |||||| |||
|| ||| ||| || || ||! | {: ||||||| |||
|| ||| ||| || || | +-+-+ |||||| |||
|| ||| ||| || | +-+ ------ + ||||| |||
|| ||| ||| | +-+ ---------- + |||| |||
|| ||| || +-+ ----------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || +-+ --------------------- + | |||
|| | + ------------------------- +-+ ||
| +-+ ------------------------------ + |
+ ---------------------------------- +

파이썬, 56 바이트

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

샘플 사용법 :

echo 9 | python filename.py

생산 :

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

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

매스 매 티카 : 36 (41?)

Mathematica에는 Binomial기능이 있지만, 이것으로 인해 재미가 사라집니다. 내가 제안:

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

위의 줄은 다음과 같이 비정형 배열을 렌더링합니다.

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

이것이 Mathematica의 기본 형식이므로 허용 될 것이라고 생각했지만 규칙을 다시 읽으면 그렇지 않을 수도 있습니다. 추가 Grid@하면 총 41 자까지 분명하게 허용되는 출력이 생성됩니다 .

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

C 답변을 보여주는 자기. 더 명확하지 못했습니다! 추가 캐릭터를 찾기위한 보너스 포인트.

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

골프 스크립트 (21 문자)

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

설명이 요청 된 이후 :

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

하스켈, 94 92

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

산출:

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

각 숫자 사이에 공백을 인쇄하지 않는 71 자 버전 :

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

산출:

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

스칼라, 81 78 72 70 자

81 문자 : 첫 번째 시도, 뻔뻔스럽게 파이썬 버전에서 복사 :)

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

스크립트로 실행하거나 REPL에서 직접 실행하십시오.

놀랍도록 읽기 쉽고 관용적 인 것으로 70 자로 자릅니다.

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

또는 완전히 다른 방법으로 72 70 문자 :

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

루비 : 51 49 46 자

(45 자 코드 + 1 자 명령 행 옵션)

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

덕분에 :

• jsvnm값 전환을위한 대안을 제안하는 (2 자)
• GB이전 개선 후 사용하지 않은 변수를 발견하기위한 (4 자)

샘플 실행 :

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]

온라인으로 사용해보십시오!

자바 스크립트 ( 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)

데모 : http://jsfiddle.net/tcRCS/3/

참고 : 숫자는 내장 정수 데이터 유형을 오버플로하고 부동 소수점 숫자가되기 때문에 실제로 n> 30 정도에서는 제대로 작동하지 않습니다.

편집 1 :로 변환 while하여 5자를 제거 했습니다.for 문을과 결합

편집 2 : s=명령문을 내부 로 이동 for하고 2 문자 저장

편집 3 : s=1,j=1이니셜 라이저를 결합하여 s=j=12 문자 저장

R, 39 자

R 은이 작업에 가장 적합한 도구 인 것 같습니다 :-)

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

Q로 (더 짧은 버전의 경우 25 자 / 20 자)

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

더 짧은

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

샘플 사용법 :

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

awk-73 자

상당히 간단한 구현 :

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

샘플 실행 :

% 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

펄, 52 , 49 자

편집 : say대신 사용print

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

펄, 47 54 자

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

명령 행에서 숫자를 가져 오지만 오류 검사는 수행하지 않습니다.

그것은 단지 n = 4까지만 작동한다는 것을 깨달았습니다. 내 HD에 있던 오래된 코드였습니다.

그래도 작동합니다.

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

스크립트에 n을 입력해야합니다. 그렇지 않으면 한 문자 이상이됩니다.

케그 , 40 바이트

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

설명

펄, 77 문자

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

입력 예

5

출력 예

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

C, 132 개 (127) 문자

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

파스칼 : (216) 192 자

(진정한 경쟁자가 아니라 단지 명예로운 존재입니다.)

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.

샘플 실행 :

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 바이트

이 도전 후에 만들어진 언어

1iq:"tTTY+

온라인으로 사용해보십시오!

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 개 문자

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

9의 출력은

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

"하지만 원하는대로 포맷 할 수 있습니다"를 최대한 활용합니다. 각 숫자와 줄 바꿈 사이에 공백이 있습니다

편집 l은 일부 문자를 면도 하기 위해 할당을 재배치했습니다.

스칼라, 131 자

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

명령 행에서 입력을 가져옵니다.

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 자

코드 골프 라운드에서 처음 시도하고 함수형 프로그래밍에서 처음 시도했습니다. 아마 아직 알지 못했던 그것을 줄이는 확실한 방법이있을 것입니다. VS2010s F♯ 컴파일러 (이전 버전과 달리 기본적으로 #light를 실행하는 효과가 있음)를 준수하며 F♯ 인터프리터에서도 작동합니다. stdin을 통한 입력을 허용합니다. 그래도 입 / 출력을위한 더 좋은 방법이 있었으면 좋겠다! 많은 캐릭터!

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

이 질문에 대한 대답이없는 이유는 무엇입니까?

VBA-249 자

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 문자 ( -dn=행 수 를 계산 하는 경우 63 )

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

와 실행

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

얻을

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

매스 매 티카 35 자

파스칼의 삼각형을 자르는 둔하고 게으른 방법은 다음과 같습니다.

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 자

파티에 좀 늦었 을까?

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

그러나 J 항목을이기는 것은 아닙니다.

이것은 인덱스 원점 ( ⎕IO) 이로 설정되어 있다고 가정합니다 0. 불행하게도의 인덱스 출처는 25 18 문자 1가 필요 합니다.

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

⍨내 좌절감을 표현하는 코드 에는 두 가지가 있습니다 .

데모:

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

설명

짧은 버전 :

• ⍳⍵(인덱스 원점 0)은 0에서 ⍵-1포괄적 인 숫자의 배열을 생성 합니다. 여기서 ⍵함수에 대한 올바른 인수입니다.
• ⍳⍵+1 0에서 0까지의 모든 숫자를 생성합니다 ⍵
• {⍵!⍨⍳⍵+1}의 모든 요소 에 대한 ⍵선택 k을 생성 합니다 . (통근) 작업자는 오른손 인수 반대 왼쪽 및 바이스 지도록 주위 함수의 인수 스왑.k⍳⍵+1⍨
• {⍵!⍨⍳⍵+1}¨⍳⍵(각) 연산자 를 ⍳⍵사용하여 각 요소를 전달합니다 ¨. 결과는 첫 번째를 포함하는 1 차원 배열입니다⍵ 파스칼 삼각형 행을 입니다.
• 의 하나의 인수 형식은 ⍪1 차원 벡터 를 취하여 행이 아닌 열로 만듭니다. 삼각형의 각 행은 자체 선에 배치됩니다.

긴 대답 :

• 인덱스 원점을 0으로 복제 1-⍨하기 전에 배치 된 것을 제외하고 는 다른 버전과 거의 동일합니다 ⍳.
• 0,⍳⍵인덱스 오리진이 1 ⍳⍵+1인 인덱스 오리진이 0 인 복제 .

메이플, 46

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

용법:

> 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 바이트

_{^{Taylor Scott 덕분에 22 바이트를 절약했습니다.}}

_{이것은 오래된 질문이지만 VBA에 대한 더 짧은 솔루션을 보았습니다.}

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

이것은 바로 창에서 실행됩니다. 입력이 A1활성 워크 시트의 셀 에 있습니다. 출력은 시작 B2및 사용 중인 활성 워크 시트 에 있지만 입력을 기반으로 많은 셀이 필요합니다. 이 COLUMN()>ROW()검사는 삼각형의 오른쪽 상단을 비워 둡니다. ROW()=2검사는 첫 번째 값 만드는 1삼각형을 시작할 수 있습니다. 나는 출력을 낮추고이 검사를 떨어 뜨릴 수 있었지만 실제 삼각형 앞에 많은 외부 출력을 도입했으며 이것이 도전의 정신에 있다고 생각하지 않았습니다.

원래 행과 열을 기준으로 모든 값을 계산하는 훨씬 복잡한 방법을 게시했습니다. 그러나이 모든 방법은 셀 내 수식을 사용하는 것입니다. 시작하여 오류 B2없이 위의 행을 참조 할 수 #REF!있습니다. 이어서, 셀 블록 위에 복사하기 및 붙여 같은 화학식 N 폭 N 키. 입력 및 출력은 n=25다음과 같습니다.

05AB1E , 14 바이트

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

온라인으로 사용해보십시오!

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