Pascal üçgeni ilk satırda 1 ile başlayarak üretilir. Sonraki satırlarda, sayı doğrudan üstündeki iki sayının sola ve sağa toplanmasıyla belirlenir.

Göstermek için, işte Pascal'ın üçgeninin ilk 5 sırası:

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

Meydan okuma

Bir girdi n verildiğinde (ancak, seçtiğiniz dilde en uygun olanı), Pascal üçgeninin ilk n satırını oluşturun . N'nin 1 ile 25 arasında bir tam sayı olduğunu varsayabilirsiniz. Her satır ile her sayı arasında bir boşluk olmalıdır, bunun dışında istediğiniz şekilde biçimlendirmeniz gerekir.

Bu kod golf , bu yüzden en kısa çözüm kazanır.

Örnek G / Ç

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

":@(!{:)\@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 |||
|| ||| \ | + ------------------- + || |||
|| ||| || + - + --------------- + ||| |||
|| ||| ||| @ | + - + ---------- + |||| |||
|| ||| ||| || ": | + - + ------ + ||||| |||
|| ||| ||| || || 2 | + - + - + |||||| |||
|| ||| ||| || || || | {:! ||||||| |||
|| ||| ||| || || | + - + - + |||||| |||
|| ||| ||| || | + - + ------ + ||||| |||
|| ||| ||| | + - + ---------- + |||| |||
|| ||| || + - + --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || + - + --------------------- + | |||
|| | + ------------------------- + - + ||
| + - + ------------------------------ + |
+ ---------------------------------- +

Python, 56 Bayt

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

Örnek kullanım:

echo 9 | python filename.py

üretir:

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

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

Mathematica: 36 (41?)

Mathematica'nın bir Binomialişlevi var, ama bu eğlenceyi ortadan kaldırıyor. Öneriyorum:

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

Yukarıdaki satır aşağıdaki gibi düzensiz bir dizi oluşturacaktır:

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

Bu, Mathematica'da temel bir format olduğu için kabul edilebilir olacağını düşündüm, ancak kuralları tekrar okuduğumda, olmayabileceğini düşünüyorum. Ekleme Grid@, toplamda 41 olmak üzere kesin olarak kabul edilebilir bir çıktı üretecektir. karakter :

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

Kendini gösteren bir C cevap. Daha net olamazdı! Ekstra karakteri bulmak için bonus puan.

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

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

Bir açıklama istendiğinden:

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

Çıktı:

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

Her numara arasında boşluk bırakmayan 71 karakterlik bir sürüm:

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

Çıktı:

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

Scala, 81 78 72 70 karakter

81 karakter: ilk deneme, utanmadan Python versiyonundan kopyalandı :)

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

Bir komut dosyası olarak veya doğrudan REPL'de çalıştırın.

Şaşırtıcı derecede okunabilir ve deyimsel bir şeyle 70 karaktere kesin:

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

Veya tamamen farklı bir yöntemle 72 70 karakter:

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

Yakut: 51 49 46 karakter

(45 karakter kodu + 1 karakter komut satırı seçeneği)

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

Sayesinde:

• Değer değiştirme için bir alternatif önermek için jsvnm (2 karakter)
• Önceki iyileştirmeden sonra kullanılmayan bir değişkeni bulmak için GB (4 karakter)

Örnek çalışma:

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]

Çevrimiçi deneyin!

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)

Gösteri: http://jsfiddle.net/tcRCS/3/

NOT : N> 30 için pratikte iyi çalışmaz, çünkü sayılar yerleşik tam sayı veri türünden taşar ve kayan noktalı sayılar haline gelir.

Düzenleme 1 : dönüştürerek 5 karakter çıkarıldı whileiçin fortablolar ve birleştirme

Düzenleme 2 : s=deyimi içeri fortaşı ve 2 karakter kaydet

Düzenleme 3 : s=1,j=1başlatıcıyı birleştirin s=j=1ve 2 karakter kaydedin

R, 39 karakter

R bu görev için doğru araç gibi görünüyor :-)

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

S (25 karakter / 20 kısa versiyonlu)

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

Daha kısa

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

Örnek kullanım:

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

awk - 73 karakter

oldukça basit uygulama:

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

örnek çalışma:

% 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 karakter

Düzenleme: sayyerineprint

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

Perl, 47 54 karakter

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

Komut satırından bir sayı alır, ancak hata kontrolleri yapmaz.

Sadece n = 4'e kadar çalıştığını fark ettim. Benim hd üzerinde sahip olduğum eski bir koddu.

Bu olsa çalışır:

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

n komut dosyasına girdi olmak zorunda, yoksa bir karakterden daha fazla olurdu.

Fıçı , 40 bayt

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

Açıklaması

Perl, 77 Karakter

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

Örnek giriş

5

Örnek çıktı

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

C, 132 127 karakter

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 karakter

(Gerçek bir rakip değil, sadece onurlu bir varlık.)

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.

Örnek çalışma:

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 bayt

Bu mücadeleden sonra oluşturulan dil

1iq:"tTTY+

Çevrimiçi deneyin!

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 karakter

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 için çıktı

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

tam olarak yararlanarak "dilediğiniz şekilde biçimlendirebilirsiniz"; Her sayı ve bir satır sonu arasında boşluk var

değiştir lbazı karakterlerin traş edilmesine yapılan atama

Scala, 131 karakter

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

Girişi komut satırından alır.

N = 10 için çıktı:

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 karakter

İlk olarak bir golf turunda ilk denemem ve ilk olarak fonksiyonel programlamaya başladım. Muhtemelen, henüz tam olarak çözemediğim kısaltmanın açık bir yolu var. VS2010'un F♯ derleyicisine (önceki sürümlerden farklı olarak varsayılan olarak #light'ı çalıştırma etkisi olan) uygundur ve ayrıca F♯ yorumlayıcısında da çalışır. Stdin ile girişi kabul eder. Keşke girdi / çıktı için daha iyi bir yol olsaydı! Bir sürü karakter!

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

Neden bu soruya kabul edilmiş bir cevap yok?

VBA - 249 karakter

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 karakter ( -dn=satır sayısını bulmak için sayılırsanız 63 )

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

koşmak

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

almak

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

İşte Pascal üçgenini kesmenin donuk ve tembel yolu:

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 karakter

Belki partiye biraz geç kaldın?

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

Yine de J girişini geçmiyor.

Bu, indeks orijininin ( ⎕IO) ayarlandığını varsayar 0. Ne yazık ki, bir dizin kökenli, 25 18 karaktere 1ihtiyacımız var :

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

⍨Hayal kırıklığımı ifade etmek için kodda iki tane var .

Demo:

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

açıklamalar

Kısa versiyon:

• ⍳⍵(0 dizin kökeni ile), 0'dan ⍵-1kapsayıcıya kadar sayılardan oluşan bir dizi üretir , burada ⍵işlev için doğru argümandır.
• ⍳⍵+1 0'dan tüm sayıları oluşturur ⍵
• {⍵!⍨⍳⍵+1}üretir ⍵seçim kher eleman için kde ⍳⍵+1. ⍨(Gidip gelme), operatörün sağ argüman tersi sol ve yardımcısı olur, öyle ki, yaklaşık bir fonksiyona bağımsız değişkenler değiştirir.
• {⍵!⍨⍳⍵+1}¨⍳⍵(her) operatörünü ⍳⍵kullanarak her bir öğeyi ¨iletir. Sonuç, ilkini içeren tek boyutlu bir dizidir.⍵ Pascal Üçgeni'nin satırlarını .
• Bir argüman formu ⍪tek boyutlu bir vektör alır ve onu bir satırdan ziyade bir sütun haline getirir. Üçgenin her satırı kendi satırına konur.

Uzun cevap:

• Neredeyse diğer sürümle aynı, bunun dışında 1-⍨⍳ , 0 dizininin bir kopyasını çoğaltmak için
• 0,⍳⍵1 ⍳⍵+1dizin kökeni olan 0 dizin kökeni ile yinelenir.

Akçaağaç, 46

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

Kullanımı:

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

_{^{Taylor Scott sayesinde 22 byte kurtarıldı.}}

_{Bu şimdi eski bir soru ama VBA için daha kısa bir çözüm gördüm.}

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

Bu hemen pencerede çalıştırılmak içindir. Giriş, A1aktif çalışma sayfasının hücresinde . Çıktı, aktif çalışma sayfasında başlar B2ve kullanılır ancak girdi bazında birçok hücre gerekir. COLUMN()>ROW()Çek üçgen boş üst saklı tutar. ROW()=2Çek ilk değeri yapar 1üçgen başlatmak için. Çıkışı düşürebilir ve bu çekimi düşürebilirdim, ancak gerçek üçgenden önce çok fazla dışsal çıktı ortaya çıkardı ve bunun zorunluluk ruhu içinde olduğunu hissetmedim.

Başlangıçta satır ve sütununa göre her değeri hesaplayan çok daha karmaşık bir yöntem yayınladım. Tüm bu yöntem olsa da, hücre içi formülleri kullanmaktır. Baştan başladım, B2böylece yukarıdaki satıra #REF!hatasız başvurabilirim . Daha sonra, hücreler, bir blok üzerine bu kopyalar ve aynı formül n genişliğinde ve n, uzun. Giriş ve çıkış n=25şöyle görünür:

05AB1E , 14 bayt

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

Çevrimiçi deneyin!

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