Generar el triángulo de Pascal

35

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
Peter Olson
fuente
Nota: En cierto sentido, esta es una versión simplificada de Distribuir las bolas
Peter Taylor
@ Peter Olson: ¿Cuál es su opinión sobre la interpretación de Ratchet Freak de "puede formatearlo como quiera"? Si siguiera su interpretación podría afeitarme 18 caracteres.
Steven Rumbalski
@StevenRumbalski Está bien. Hay una nueva línea entre cada fila y hay un espacio entre cada número, por lo que cumple con los criterios.
Peter Olson
@ Peter Olson: Gracias por la aclaración. ¿Qué pasa con la suposición de Tomás T de que n ya está definido?
Steven Rumbalski
44
@Gaffi Probablemente no, aceptar una respuesta me hace sentir que estoy terminando el concurso y desalienta las respuestas nuevas y posiblemente mejores.
Peter Olson

Respuestas:

30

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 | + - + - + |||||| |||
|| ||| ||| || || ||! | {: ||||||| |||
|| ||| ||| || || | + - + - + |||||| |||
|| ||| ||| || | + - + ------ + ||||| |||
|| ||| ||| | + - + ---------- + |||| |||
|| ||| || + - + --------------- + ||| |||
|| ||| | + ------------------- + || |||
|| || + - + --------------------- + | |||
|| | + ------------------------- + - + ||
| + - + ------------------------------ + |
+ ---------------------------------- +
efímero
fuente
1
J supera a GolfScript? Interesante. Me gustaría ver una explicación para este código, si tiene tiempo.
Mr.Wizard
44
Ya está dividido, pero aquí hay una línea por línea si desea inglés adicional. La línea 1 i.5devuelve los primeros cinco naturales. La línea 2 agrega {:"Cola" (regreso último). La línea 3 los combina con !"Fuera de" (número de combinaciones). La línea 4 (!{:)i.5es igual. factorizando el gancho. Entonces, (!:)es una operación que transforma los primeros n naturales en la enésima línea del triángulo de Pascal. La línea 5 lo aplica a todos los prefijos (barra invertida) de 0..4, pero J llena los puntos no utilizados con 0, por lo que la operación se combina ( @) con la operación de formateo de cadenas ":. Muy genial J, votado.
JB
@JB no lo es! significa factorial aquí? También podemos deshacernos de @ a la derecha.
defhlt
@ArtemIce Monadic !significa factorial; !combinaciones de cuentas diádicas . La final @en ":@(!{:)\@i.sólo está ahí para hacer de este un verbo independiente.
Ephemient
18

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]
primo
fuente
1
+1 Manera inteligente de usar para execevitar un forbucle.
Steven Rumbalski el
15

Python, 94 91 88 70 63 caracteres

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

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
Señor mago
fuente
14

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; }
Walpen
fuente
44
No puedo evitar sentir que esto pierde el sentido del código golf. (Tampoco puedo evitar señalar que el carácter adicional está en la posición \ binom {5} {4}).
Peter Taylor
2
Fue divertido de escribir. En general, eso es por lo que vengo a codegolf.
walpen
1
Inteligente :) Tener un voto a favor. ¡Quizás no sea un candidato ganador sino creativo!
Accatyyc
11

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
;
Peter Taylor
fuente
Es posible que desee probar golf.shinh.org/p.rb?pascal+triangle
Nabb el
¿Podría por favor proporcionar algún pseudocódigo o explicación? Entiendo lo que está sucediendo, pero no entiendo completamente la parte de intercambio.
Rob
Gracias por la explicación detallada y la excelente respuesta (+1), pero ahora estoy aún más confundido. La lógica (proceso) no está bien.
Rob
@ MikeDtrick, hubo un pequeño error en la explicación. También hay un punto sutil que necesitaba una explicación, pero que me había perdido porque hacía mucho tiempo que no escribía el código.
Peter Taylor
Está bien, está empezando a tener sentido. Mi última pregunta es ¿funciona el proceso de impresión y ejecución de arriba hacia abajo o de abajo hacia arriba (1, 1 1, 1 2 1: de arriba hacia abajo, 1 2 1, 1 1, 1: de abajo hacia arriba)?
Rob
7

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]
hammar
fuente
Puedes guardar un personaje usando en mapMlugar de mapM_.
dfeuer
7

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)))
Luigi Plinge
fuente
¡+ 1 para una copia desvergonzada!
Steven Rumbalski
La última versión debe usarse con cuidado para valores enormes de readInt, como 50.;)
usuario desconocido
@userunknown presumiblemente por eso la pregunta especifica un límite superior de 25 ...
Luigi Plinge
No fue una crítica, solo una advertencia para los curiosos.
usuario desconocido
6

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!

hombre trabajando
fuente
1
puedes guardar 2 caracteres conp.map!{|i|(v=n)+n=i}
jsvnm
¡Genial, @jsvnm! Hombre, cuánto tiempo combiné para acortar esa parte. Gracias.
manatwork
1
Quizás un poco tarde, pero: ¿por qué usar la variable v?
GB
Buena captura, @GB! Eso quedó atrás de la primera revisión , donde ... donde ... doh. Donde también era un poco inútil. Supongo que proviene de un intento anterior cuando se usa .map. Gracias.
manatwork
5

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

mellamokb
fuente
¡Agradable! Puede guardar un personaje más cambiando "s = s * ..." a "s * = ..."
Derek Kurth
@DerekKurth: Pensé que cuando hacía optimizaciones por primera vez, pero eso estropearía la lógica porque tiene que ser así s*(i-j)/j, no s*((i-j)/j).
mellamokb
Hmm, lo intenté como s * = ... en el jsfiddle y parecía funcionar. Tal vez hice algo mal, sin embargo.
Derek Kurth
1
@DerekKurth: Técnicamente es lo mismo, pero la idea es que si multiplicas por (i-j)antes de dividir entre j, entonces no hay necesidad de aritmética de coma flotante porque los resultados siempre deben ser enteros. Si lo hace ((i-j)/j)primero, esto dará como resultado valores decimales que pueden ser una fuente de error, y al menos requerirá un código adicional para redondear / truncar. No comienza a ver esto hasta que se acerca n>11, y verá valores decimales en la salida, es decir,1 11 55 165 330 461.99999999999994 461.99999999999994...
mellamokb
Ah, eso tiene sentido!
Derek Kurth
5

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)
Tomás
fuente
3
Le falta uno de los requisitos: "Dada una entrada n (siempre que sea más conveniente en el idioma elegido)"
Steven Rumbalski
@ Steven, "Dada una entrada n" ... entonces, ¿puedo suponer que nse da Corrija el código. ¿Esto está bien ahora?
Tomás
Me piden que Peter Olson aclare.
Steven Rumbalski
@StevenRumbalski No creo que sea válido a menos que se requiera información. No sé R, así que tal vez el compilador hace que las variables indefinidas soliciten una entrada, por lo que podría estar bien, pero si es como la mayoría de los otros idiomas en ese sentido, no creo que lo sea.
Peter Olson
1
Básicamente, ndebe suministrarse desde una fuente externa en tiempo de ejecución y el aparato para capturarlo está incluido en su programa. Normalmente, eso significa por argumento de línea de comando, o stdin, o archivo. Por archivo casi nunca se usa porque es invariablemente más largo que las otras dos opciones.
Steven Rumbalski
5

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
sinedcm
fuente
O, alternativamente, 20 personajest:{(x-1){0+':x,0}\1}
skeevey
Agradable, más corto que la solución GolfScript ahora.
sinedcm
4

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
Dan Andreatta
fuente
4

Perl, 52 , 49 caracteres.

Editar: usando en saylugar deprint

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

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.

flesk
fuente
4

Barril , 40 bytes

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

Explicado

Bolígrafo Resaltado

Jono 2906
fuente
3

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
PhiNotPi
fuente
3

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);}
saeedn
fuente
3

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 
hombre trabajando
fuente
3

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
Luis Mendo
fuente
no competitivo, pero un desastre santa, ninguna de las anteriores comunicaciones (J), incluso logrado reducirlo hasta la cantidad Matl hizo !!!
Abr001am
Estoy bastante seguro de que Jelly o 05AB1E serían más cortos :-)
Luis Mendo
2

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

monstruo de trinquete
fuente
2

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
Gareth
fuente
¿Qué pasa con todos esos 0s :-)?
mellamokb
@mellamokb Un poco de reorganización los hizo desaparecer y acortó el código. :-)
Gareth
2

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")
lochok
fuente
2

¿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
Gaffi
fuente
2

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]
Geoff Reedy
fuente
2

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}}
DavidC
fuente
2

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.
Volatilidad
fuente
2

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
DSkoog
fuente
2

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í:

Salida

Tostadas de ingeniero
fuente
Muy buena respuesta, pero puedes jugar golf bastante. Convertir Function p(r)a Sub p(r)ya que no tiene un valor de salida de función, eliminar el espacio debug.? c(n,k);y convertir la if-then-elseinstrucción multilínea en una sola línea ( If k Then c=c(n-1,k-1)*n/k Else c=1) reduce el recuento de bytes a 130mi recuento
Taylor Scott
@TaylorScott ¡Gracias! Soy bastante nuevo en el golf y solo un poco menos nuevo en la programación en general. Conté 142 debido a los saltos de línea. Por lo que pude encontrar , se supone que esos cuentan.
Ingeniero Toast
Ah, tienes razón, olvidé contar mis líneas nuevas y, como resultado, al menos otro truco de golf For n=0 To...se puede condensar para For n=0To...llevar mi versión del código a Sub p(r):For n=0To r-1:For k=0To n:Debug.?c(n,k);:Next:Debug.?:Next:End Sub Function c(n,k):If k Then c=1 Else c=c(n-1,k-1)*n/k[char (10)] End Functioncon un recuento de bytes de139
Taylor Scott
Un segundo vistazo a esto sugiere que si se descomponen en una función de ventana inmediato con una función de ayuda, lo puede conseguir hasta 112 Bytes (ventana Inmediato Función: For n=0To[A1-1]:For k=0To n:?c(n,k);:Next:?:NextAyudante Función: Function c(n,k) If k Then c=c(n-1,k-1)*n/k Else c=1 End Function)
Taylor de Scott
1
@TaylorScott ¿Qué hay de dejarlos caer por completo? Con un cambio en la fórmula, funciona bien. Creo que la salida a partir de en B2lugar de A1es aceptable.
Engineer Toast