Pascals Dreieck wird erzeugt, indem mit einer 1 in der ersten Zeile begonnen wird. In den folgenden Zeilen wird die Zahl durch die Summe der beiden Zahlen links und rechts direkt darüber bestimmt.

Zur Veranschaulichung sind hier die ersten 5 Zeilen von Pascals Dreieck:

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

Die Herausforderung

Bei einer Eingabe von n (vorausgesetzt, dies ist in der von Ihnen gewählten Sprache am bequemsten) generieren Sie die ersten n Zeilen des Pascalschen Dreiecks. Sie können annehmen, dass n eine ganze Zahl ist, die zwischen 1 und 25 liegt. Zwischen jeder Zeile muss ein Zeilenumbruch und zwischen jeder Zahl ein Leerzeichen stehen. Ansonsten können Sie die Zahl beliebig formatieren.

Das ist Code-Golf , also gewinnt die kürzeste Lösung.

Beispiel 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 Zeichen

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

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

Beispielnutzung:

echo 9 | python filename.py

Produziert:

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

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

Mathematica: 36 (41?)

Mathematica hat die BinomialFunktion, aber das macht den Spaß daraus. Ich schlage vor:

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

Die obige Zeile zeigt ein zerlumptes Array wie:

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

Da dies ein Grundformat in Mathematica ist, dachte ich, dass es akzeptabel wäre, aber wenn ich die Regeln noch einmal lese, denke ich, dass es möglicherweise nicht so ist. Durch Grid@das Hinzufügen wird eine eindeutig akzeptable Ausgabe mit insgesamt 41 Zeichen erstellt:

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

Eine selbstdemonstrierende C-Antwort. Könnte nicht klarer sein! Bonuspunkte für das Finden des zusätzlichen Charakters.

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

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

Da eine Erklärung angefordert wurde:

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

Ausgabe:

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

Eine 71-stellige Version ohne Leerzeichen zwischen den einzelnen Ziffern:

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

Ausgabe:

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

Scala, 81 78 72 70 Zeichen

81 Zeichen: erster Versuch, schamlos aus der Python-Version kopiert :)

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

Führen Sie es als Skript oder direkt in der REPL aus.

Schneiden Sie auf 70 Zeichen mit etwas überraschend Lesbarem und Idiomatischem:

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

Oder 72 bis 70 Zeichen mit einer ganz anderen Methode:

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

Ruby: 51 49 46 Zeichen

(45 Zeichen Code + 1 Zeichen Befehlszeilenoption)

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

Dank an:

• jsvnm für den Vorschlag einer Alternative für die Wertumschaltung (2 Zeichen)
• GB zum Erkennen einer Variablen, die nach einer vorherigen Verbesserung nicht verwendet wurde (4 Zeichen)

Probelauf:

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]

Probieren Sie es 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/

ANMERKUNG : Funktioniert in der Praxis für etwa n> 30 nicht gut, da Zahlen den integrierten Integer-Datentyp überlaufen und zu Gleitkommazahlen werden.

Edit 1 : 5 entfernt Zeichen durch die Umwandlung whilezu forund die Kombination von Aussagen

2 bearbeiten : s=Anweisung nach innen verschieben forund 2 Zeichen speichern

Edit 3 : Kombiniere den s=1,j=1Initialisierer s=j=1und speichere 2 Zeichen

R, 39 Zeichen

R scheint das richtige Werkzeug für diese Aufgabe zu sein :-)

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

in Q (25 Zeichen / 20 mit kürzerer Version)

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

Kürzer

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

Beispielnutzung:

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

awk - 73 Zeichen

ziemlich einfache Implementierung:

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

Probelauf:

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

Bearbeiten: mit saystattprint

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

Perl, 47 54 Zeichen

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

Es nimmt eine Nummer von der Kommandozeile, führt aber keine Fehlerprüfungen durch.

Nur realisiert, dass es nur bis zu n = 4 funktioniert. Es war ein alter Code, den ich auf meiner Festplatte hatte.

Dies funktioniert jedoch:

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

n muss allerdings in das Skript eingegeben werden, sonst wäre es ein Zeichen mehr.

Fass , 40 Bytes

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

Erklärt

Perl, 77 Zeichen

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

Beispiel Eingabe

5

Beispielausgabe

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

C, 132 127 Zeichen

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 Zeichen

(Kein echter Konkurrent, nur eine Ehrenpräsenz.)

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.

Probelauf:

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

Sprache, die nach dieser Herausforderung erstellt wurde

1iq:"tTTY+

Probieren Sie es 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 Zeichen

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

Ausgabe für 9 ist

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

den vollen Nutzen von "Sie können es formatieren, wie Sie möchten"; Zwischen jeder Zahl und einem Zeilenumbruch befindet sich ein Leerzeichen

edit hat die Aufgabe umpositioniert, leinige Zeichen zu rasieren

Scala, 131 Zeichen

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

Übernimmt die Eingabe von der Befehlszeile.

Ausgabe für 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 Zeichen

Mein erster Versuch, eine Runde Code Golf zu spielen, und mein erster Versuch, eine funktionierende Programmierung durchzuführen. Es gibt wahrscheinlich einen offensichtlichen Weg, es zu verkürzen, den ich noch nicht ganz herausgefunden habe. Es entspricht dem F♯-Compiler von VS2010 (der im Gegensatz zu früheren Versionen standardmäßig #light ausführt) und funktioniert auch im F♯-Interpreter. Akzeptiert Eingaben über stdin. Ich wünschte, es gäbe einen besseren Weg für die Eingabe / Ausgabe! Viele Charaktere!

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

Warum gibt es keine akzeptierte Antwort auf diese Frage?

VBA - 249 Zeichen

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 Zeichen (63, wenn Sie zählen -dn=, um die Anzahl der Zeilen zu erhalten)

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

renn mit

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

bekommen

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

Hier ist die langweilige und faule Art, Pascals Dreieck zu zerschneiden:

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 Zeichen

Vielleicht ein bisschen zu spät zur Party?

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

Der J-Eintrag wird jedoch nicht übertroffen.

Dies setzt voraus, dass der Indexursprung ( ⎕IO) auf gesetzt ist 0. Leider 1benötigen wir bei einer Indexherkunft von 25 bis 18 Zeichen:

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

⍨Der Code enthält zwei s, um meine Frustration auszudrücken.

Demo:

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

Erklärungen

Kurzfassung:

• ⍳⍵(mit einem Indexursprung von 0) erzeugt ein Array der Zahlen von 0 bis ⍵-1einschließlich, wobei ⍵das richtige Argument für die Funktion ist.
• ⍳⍵+1 generiert alle Zahlen von 0 bis ⍵
• {⍵!⍨⍳⍵+1}generiert für jedes Element in ⍵select . Der (Pendel-) Operator tauscht die Argumente gegen eine Funktion aus, sodass das rechte Argument zum linken Argument wird und umgekehrt.kk⍳⍵+1⍨
• {⍵!⍨⍳⍵+1}¨⍳⍵Übergibt jedes Element ⍳⍵mit dem ¨Operator (each). Das Ergebnis ist ein eindimensionales Array, das das erste enthält⍵ Zeilen des Pascalschen Dreiecks enthält.
• Die Ein-Argument-Form von ⍪nimmt einen eindimensionalen Vektor an und macht ihn eher zu einer Spalte als zu einer Zeile. Jede Reihe des Dreiecks wird in eine eigene Linie gesetzt.

Lange Antwort:

• Praktisch das Gleiche wie die andere Version, mit der Ausnahme, dass 1-⍨vor einem steht, ⍳um einen Indexursprung von 0 zu replizieren.
• 0,⍳⍵mit einem Indexursprung von 1 wird ⍳⍵+1mit einem Indexursprung von 0 repliziert .

Ahorn, 46

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

Verwendung:

> 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

_{^{22 Bytes gespart dank Taylor Scott.}}

_{Dies ist eine alte Frage, aber ich sah eine kürzere Lösung für VBA.}

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

Dies soll im unmittelbaren Fenster ausgeführt werden. Die Eingabe erfolgt in der Zelle A1des aktiven Arbeitsblatts. Die Ausgabe erfolgt im aktiven Arbeitsblatt ab B2und unter Verwendung der Anzahl der Zellen, die für die Eingabe erforderlich sind. Das COLUMN()>ROW()Häkchen lässt das Dreieck oben rechts leer. Das ROW()=2Häkchen gibt den ersten Wert 1an, der das Dreieck auslöst. Ich hätte die Ausgabe nach unten verschieben und diesen Scheck fallen lassen können, aber er führt vor dem eigentlichen Dreieck eine Menge irrelevanter Ausgaben ein, und ich hatte nicht das Gefühl, dass dies im Geiste der Herausforderung lag.

Ich habe ursprünglich eine viel kompliziertere Methode gepostet, die jeden Wert basierend auf seiner Zeile und Spalte berechnet. Bei dieser Methode werden jedoch nur zelleninterne Formeln verwendet. Ich beginne bei, B2damit ich die Zeile darüber ohne #REF!Fehler referenzieren kann. Dann kopiert und fügt es die gleiche Formel über einen Block von n breiten und n hohen Zellen ein . Die Ein- und Ausgabe für n=25sieht folgendermaßen aus:

05AB1E , 14 Bytes

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

Probieren Sie es online!

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