Il triangolo di Pascal viene generato iniziando con un 1 nella prima riga. Nelle righe successive, il numero è determinato dalla somma dei due numeri direttamente sopra di esso a sinistra e a destra.

Per dimostrare, ecco le prime 5 file del triangolo di Pascal:

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

La sfida

Dato un input n (fornito tuttavia è più conveniente nella lingua scelta), genera le prime n righe del triangolo di Pascal. Puoi supporre che n sia un numero intero compreso tra 1 e 25. Ci deve essere un'interruzione di riga tra ogni riga e uno spazio tra ciascun numero, ma a parte questo, puoi formattarlo come preferisci.

Questo è code-golf , quindi vince la soluzione più breve.

Esempio 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 caratteri

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

Esempio di utilizzo:

echo 9 | python filename.py

produce:

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

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

Mathematica: 36 (41?)

Mathematica ha la Binomialfunzione, ma questo ci toglie il divertimento. Propongo:

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

La riga sopra renderà un array irregolare come:

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

Poiché questo è un formato di base in Mathematica, ho pensato che sarebbe stato accettabile, ma mentre rileggo le regole, penso che potrebbe non esserlo. L'aggiunta Grid@produrrà un risultato inequivocabilmente accettabile, per un totale di 41 caratteri:

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

Una risposta C auto-dimostrativa. Non potrebbe essere più chiaro! Punti bonus per trovare il personaggio extra.

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

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

Poiché è stata richiesta una spiegazione:

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

Produzione:

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

Una versione di 71 caratteri che non stampa uno spazio tra ogni numero:

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

Produzione:

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

Scala, 81 78 72 70 caratteri

81 caratteri: primo tentativo, copiato senza vergogna dalla versione di Python :)

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

Eseguirlo come uno script o direttamente nel REPL.

Taglia a 70 caratteri con qualcosa di sorprendentemente leggibile e idiomatico:

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

O 72 70 caratteri con un metodo totalmente diverso:

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

Rubino: 51 49 46 caratteri

(Codice 45 caratteri + opzione riga comandi 1 carattere)

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

Grazie a:

• jsvnm per aver suggerito un'alternativa per la commutazione di valore (2 caratteri)
• GB per individuare una variabile non utilizzata dopo un precedente miglioramento (4 caratteri)

Esecuzione di esempio:

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]

Provalo 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/

NOTA : in pratica non funziona per circa n> 30 poiché i numeri traboccano di tipo di dati integer incorporato e diventano numeri in virgola mobile.

Edit 1 : rimosso 5 caratteri convertendo whileper fore combinando le dichiarazioni

Modifica 2 : sposta l' s=istruzione all'internofor e salva 2 caratteri

Modifica 3 : combina l' s=1,j=1inizializzatore in s=j=1e salva 2 caratteri

R, 39 caratteri

R sembra essere lo strumento giusto per questo compito :-)

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

in Q (25 caratteri / 20 con versione più corta)

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

Più breve

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

Esempio di utilizzo:

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

awk - 73 caratteri

implementazione abbastanza semplice:

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

esempio di esecuzione:

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

Modifica: usando sayinvece diprint

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

Perl, 47 54 caratteri

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

Prende un numero dalla riga di comando, ma non esegue alcun controllo degli errori.

Ho appena realizzato che funziona solo fino a n = 4. Era un vecchio codice che avevo sul mio hd.

Questo funziona però:

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

n deve essere inserito nello script, altrimenti sarebbe un carattere in più.

Fusto , 40 byte

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

spiegato

Perl, 77 caratteri

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

Esempio di input

5

Esempio di output

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

C, 132 127 caratteri

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 caratteri

(Non un vero concorrente, solo una presenza onorifica.)

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.

Esecuzione di esempio:

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

Lingua creata dopo questa sfida

1iq:"tTTY+

Provalo 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 caratteri

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

l'uscita per 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]

sfruttando appieno "puoi formattarlo come preferisci"; c'è uno spazio tra ogni numero e un'interruzione di riga

modifica riposizionato il compito ldi radere alcuni caratteri

Scala, 131 caratteri

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

Prende l'input dalla riga di comando.

Uscita per 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 caratteri

Il mio primo tentativo di una partita a code golf e il primo tentativo di programmazione funzionale. C'è probabilmente un modo ovvio per accorciarlo che non ho ancora capito. È conforme al compilatore F♯ di VS2010 (che ha l'effetto di eseguire #light di default a differenza delle versioni precedenti) e funziona anche nell'interprete F♯. Accetta input tramite stdin. Vorrei che ci fosse un modo migliore per l'input / output! Molti personaggi!

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

Perché non esiste una risposta accettata a questa domanda?

VBA - 249 caratteri

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 caratteri (63 se conti -dn=per ottenere il numero di righe)

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

Corri con

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

ottenere

[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