El triángulo de Pascal se genera comenzando con un 1 en la primera fila. En las filas subsiguientes, el número está determinado por la suma de los dos números directamente arriba a la izquierda y a la derecha.

Para demostrar, aquí están las primeras 5 filas del triángulo de Pascal:

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

El reto

Dada una entrada n (siempre que sea más conveniente en el idioma elegido), genera las primeras n filas del triángulo de Pascal. Puede suponer que n es un número entero comprendido entre 1 y 25. Debe haber un salto de línea entre cada fila y un espacio entre cada número, pero aparte de eso, puede formatearlo como desee.

Este es el código de golf , por lo que gana la solución más corta.

Ejemplo de E / S

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

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

   i.5
0 1 2 3 4
   {: i.5
4 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()

Uso de la muestra:

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 caracteres

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

Mathematica: 36 (41?)

Mathematica tiene la Binomialfunción, pero eso le quita la diversión. Yo propongo:

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

La línea anterior representará una matriz irregular, como:

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

Dado que este es un formato básico en Mathematica, pensé que sería aceptable, pero al volver a leer las reglas, creo que no lo es. Agregar Grid@producirá un resultado inequívocamente aceptable, para un total de 41 caracteres:

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 respuesta C auto demostrativa. ¡No podría ser más claro! Puntos de bonificación por encontrar el personaje 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 caracteres)

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

Como se solicitó una explicación:

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

Salida:

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

Una versión de 71 caracteres que no imprime un espacio entre cada número:

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

Salida:

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

Scala, 81 78 72 70 caracteres

81 caracteres: primer intento, copiado descaradamente de la versión de Python :)

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

Ejecútelo como un script o directamente en REPL.

Corte a 70 caracteres con algo sorprendentemente legible e idiomático:

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

O 72 70 caracteres con un método totalmente diferente:

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

Rubí: 51 49 46 caracteres

(Código de 45 caracteres + opción de línea de comando de 1 carácter)

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

Gracias a:

• jsvnm por sugerir una alternativa para el cambio de valor (2 caracteres)
• GB para detectar una variable no utilizada después de una mejora previa (4 caracteres)

Ejecución de muestra:

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]

Pruébalo en línea!

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)

Demostración: http://jsfiddle.net/tcRCS/3/

NOTA : No funciona bien en la práctica durante aproximadamente n> 30 porque los números desbordan el tipo de datos entero incorporado y se convierten en números de punto flotante.

Editar 1 : eliminó 5 caracteres mediante la conversión whilea fory la combinación de estados

Edición 2 : mover la s=declaración dentro fory guardar 2 caracteres

Edición 3 : combina el s=1,j=1inicializador s=j=1y guarda 2 caracteres

R, 39 caracteres

R parece ser la herramienta correcta para esta tarea :-)

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

en Q (25 caracteres / 20 con versión más corta)

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

Corto

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

Uso de la muestra:

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

awk - 73 caracteres

implementación bastante sencilla:

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

ejecución de muestra:

% 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 caracteres.

Editar: usando en saylugar deprint

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

Perl, 47 54 caracteres

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

Toma un número de la línea de comando, pero no realiza ninguna comprobación de errores.

Acabo de darme cuenta de que solo funciona hasta n = 4. Era un código antiguo que tenía en mi disco duro.

Sin embargo, esto funciona:

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

Sin embargo, se debe ingresar n en el script, o sería un carácter más.

Barril , 40 bytes

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

Explicado

Perl, 77 caracteres

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

Entrada de ejemplo

5

Salida de ejemplo

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

C, 132 127 caracteres

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 caracteres

(No es un verdadero competidor, solo una presencia honorífica).

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.

Ejecución de muestra:

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

Lenguaje creado después de este desafío

1iq:"tTTY+

Pruébalo en línea!

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 caracteres

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

la salida para 9 es

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

aprovechando al máximo "puede formatearlo como quiera"; hay un espacio entre cada número y un salto de línea

editar reposicionó la tarea lde afeitar algunos caracteres

Scala, 131 caracteres

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

Toma la entrada de la línea de comando.

Salida para 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 caracteres

Mi primer intento en una ronda de golf de código, y mi primer intento de programación funcional. Probablemente haya alguna forma obvia de acortarlo que aún no he descubierto. Cumple con el compilador F♯ de VS2010s (que tiene el efecto de ejecutar #light por defecto a diferencia de las versiones anteriores), y también funciona en el intérprete F♯. Acepta entrada a través de stdin. ¡Ojalá hubiera una mejor manera para la entrada / salida! ¡Muchos personajes!

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

¿Por qué no hay una respuesta aceptada a esta pregunta?

VBA - 249 caracteres

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

Postdata: 59 caracteres (63 si cuenta -dn=para obtener el número de filas)

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

corre con

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

Llegar

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

Aquí está la manera aburrida y perezosa de cortar el triángulo de 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 caracteres

¿Un poco tarde para la fiesta, tal vez?

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

Sin embargo, no supera la entrada J.

Esto supone que el origen del índice ( ⎕IO) está establecido en 0. Desafortunadamente, con un origen de índice de 1, necesitamos 25 18 caracteres:

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

Hay dos ⍨s en el código para expresar mi frustración.

Manifestación:

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

Explicaciones

Version corta:

• ⍳⍵(con un origen de índice de 0) produce una matriz de números desde 0 hasta ⍵-1inclusivo, donde ⍵es el argumento correcto para la función.
• ⍳⍵+1 genera todos los números del 0 al ⍵
• {⍵!⍨⍳⍵+1}genera ⍵elegir kpara cada elemento ken ⍳⍵+1. El ⍨operador (conmutar) intercambia los argumentos por una función, de modo que el argumento de la mano derecha se convierte en el izquierdo y viceversa.
• {⍵!⍨⍳⍵+1}¨⍳⍵pasa cada elemento ⍳⍵usando el ¨(cada) operador. El resultado es una matriz unidimensional que contiene las primeras ⍵filas del Triángulo de Pascal.
• La forma de un argumento ⍪toma un vector unidimensional y lo convierte en una columna en lugar de una fila. Cada fila del triángulo se coloca en su propia línea.

Respuesta larga:

• Prácticamente igual que la otra versión, excepto que 1-⍨se coloca antes de una ⍳para replicar un origen de índice de 0.
• 0,⍳⍵ con un origen de índice de 1 réplicas ⍳⍵+1 con un índice de origen de 0.

Arce, 46

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

Uso:

> 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

_{^{Guardado 22 bytes gracias a Taylor Scott.}}

_{Esta es una vieja pregunta ahora, pero vi una solución más corta para VBA.}

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

Esto debe ejecutarse en la ventana inmediata. La entrada está en la celda A1de la hoja de trabajo activa. La salida está en la hoja de trabajo activa comenzando en B2y usando, sin embargo, se requieren muchas celdas en función de la entrada. El COLUMN()>ROW()cheque mantiene la parte superior derecha del triángulo en blanco. La ROW()=2verificación hace el primer valor 1para iniciar el triángulo. Podría haber desplazado la salida hacia abajo y soltar esta verificación, pero introduce una gran cantidad de resultados extraños antes del triángulo real y no sentí que fuera el espíritu del desafío.

Originalmente publiqué un método mucho más complicado que calculaba cada valor en función de su fila y columna. Sin embargo, todo este método lo hace es usar fórmulas en la celda. Comienzo en B2para poder hacer referencia a la fila por encima sin #REF!errores. Entonces, se copia y pastas de la misma fórmula a través de un bloque de celdas n de ancho y n altos. La entrada y salida de se n=25ve así:

05AB1E , 14 bytes

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

Pruébalo en línea!

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