La mayoría de los que están aquí están familiarizados con el Triángulo de Pascal. Está formado por filas sucesivas, donde cada elemento es la suma de sus dos vecinos superior izquierdo y superior derecho. Aquí están las primeras 5filas (tomadas del triángulo Generate Pascal ):

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

Vamos a tomar el Triángulo de Pascal y le haremos algunas sumas (hah-ha). Para una entrada dada n, genera la suma de columnas de las primeras nfilas del Triángulo de Pascal. Por ejemplo, para la entrada 5, la salida estaría formada por

            1
          1   1
        1   2   1
      1   3   3   1
[+] 1   4   6   4   1
----------------------
    1 1 5 4 9 4 5 1 1

Entonces la salida sería [1, 1, 5, 4, 9, 4, 5, 1, 1].

Tenga en cuenta que no necesariamente necesita generar el Triángulo de Pascal para calcular la suma, eso depende de su implementación si es más corto hacerlo o no.

Entrada

Un solo entero positivo ncon n >= 1 cualquier formato conveniente .

Salida

La matriz / lista resultante de la suma en columnas de las primeras nfilas del triángulo de Pascal, como se describe anteriormente. De nuevo, en cualquier formato adecuado.

Reglas

• Las nuevas líneas o espacios en blanco iniciales o finales son opcionales, siempre que los caracteres se alineen correctamente.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

[input]
[output]

1
[1]

2
[1, 1, 1]

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

5
[1, 1, 5, 4, 9, 4, 5, 1, 1]

11
[1, 1, 11, 10, 54, 44, 155, 111, 286, 175, 351, 175, 286, 111, 155, 44, 54, 10, 11, 1, 1]

MATL , 16 bytes

tZv=Gq:"t5BZ+]vs

Pruébalo en línea!

Explicación

Esto aplica repetidamente convolución para generar las filas. Por ejemplo, para la entrada n=5comenzamos con la primera fila

0 0 0 0 1 0 0 0 0

Convolucionar con [1 0 1]da

0 0 0 1 0 1 0 0 0

Repetir la operación da

0 0 1 0 2 0 1 0 0

luego

0 1 0 3 0 3 0 1 0

etc. Concatenar estas matrices verticalmente y calcular la suma de cada columna da el resultado.

t       % Input n implictly. Duplicate
Zv      % Symmetric range. Gives [1 2 3 4 5 4 3 2 1] for input 5
=       % Equal to (element-wise). Gives [0 0 0 0 1 0 0 0 0]. This is the first row
Gq:     % Push [1 2 ... n-1]
"       % For each. This executes the following code n-1 times
  t     %   Duplicate
  5B    %   Push 5 in binary, that is, [1 0 1]
  Z+    %   Convolution keeping size
]       % End
v       % Concatenate all results vertically 
s       % Sum. Display implicitly.

CJam , 32 25 24 bytes

Gracias a Luis Mendo por guardar 1 byte.

{(_0a*1+\{_(2$+.+}*]:.+}

Pruébalo en línea!

Explicación

(       e# Decrement input N.
_0a*1+  e# Create a list of N-1 zeros and a 1. This is the top row with
        e# the required indentation.
\{      e# Run this block N-1 times.
  _     e#   Duplicate the last row.
  (     e#   Pull off a leading zero, shifting the row left.
  2$+   e#   Copy the full row and prepend that zero, shifting the row right.
  .+    e#   Element-wise addition, which results in the next row.
}*
]       e# Wrap all rows in a list.
:.+     e# Add up the columns by reducing element-wise addition over the rows.

JavaScript (ES6), 83 bytes

f=
n=>[...Array(n+--n)].map(g=(j=n,i,a)=>j--?g(j,i-1)+g(j,i+1)+(a?g(j,i,a):0):i-n?0:1)

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

La indexación 1 me costó un byte. Explicación: g(j-1,i-1)+g(j-1,i+1)calcula recursivamente el triángulo de Pascal hasta que alcanza la primera fila, que es el caso base. Para obtener sumas de columna, utilizo el hecho de que maprealmente pasa un tercer parámetro, por lo que hay un paso recursivo adicional cuando este es el caso.

JavaScript (ES6), 90 87 86 84 82 bytes

Guardado 3 bytes gracias a ETHproductions

f=(n,a=[1],b=a)=>n--?f(n,[...(F=x=>a.map((n,i)=>n+~~x[i-d]))(a,d=2),0,d=1],F(b)):b

Casos de prueba

f=(n,a=[1],b=a)=>n--?f(n,[...(F=x=>a.map((n,i)=>n+~~x[i-d]))(a,d=2),0,d=1],F(b)):b

console.log(JSON.stringify(f(1)))
console.log(JSON.stringify(f(2)))
console.log(JSON.stringify(f(3)))
console.log(JSON.stringify(f(5)))
console.log(JSON.stringify(f(11)))

Mathematica, 59 57 bytes

¡Gracias a Martin Ender por encontrar un ahorro de dos bytes!

Binomial[i,(j+i)/2]~Sum~{i,Abs@j,b,2}~Table~{j,-b,b=#-1}&

Función pura que toma una entrada entera positiva y devuelve una lista de enteros. Literalmente produce todas las entradas relevantes del triángulo de Pascal y las suma apropiadamente.

Envío previo (que es un poco más fácil de leer):

Table[Sum[Binomial[i,(j+i)/2],{i,Abs@j,b,2}],{j,-b,b=#-1}]&

Octava , 84 67 45 bytes

¡22 bytes guardados gracias a Neil !

@(n)sum(spdiags(flip(tril(flip(pascal(n))))))

Pruébalo en línea!

Explicación

La pascalfunción proporciona una matriz que contiene los valores en el triángulo de Pascal:

>> pascal(5)
ans =
     1     1     1     1     1
     1     2     3     4     5
     1     3     6    10    15
     1     4    10    20    35
     1     5    15    35    70

Para extraer los valores deseados, volteamos verticalmente ( flip), mantenemos la parte triangular inferior ( tril) y volvemos a voltear. Esto da

ans =
   1   1   1   1   1
   1   2   3   4   0
   1   3   6   0   0
   1   4   0   0   0
   1   0   0   0   0

spdiags luego extrae las diagonales como columnas

ans =
   1   1   1   1   1   0   0   0   0
   0   0   4   3   2   1   0   0   0
   0   0   0   0   6   3   1   0   0
   0   0   0   0   0   0   4   1   0
   0   0   0   0   0   0   0   0   1

y sumcalcula la suma de cada columna, que da el resultado.

05AB1E , 34 32 28 25 24 bytes

-4 gracias a Emigna.

FN©ƒ®Ne0})¹®-Å0.ø˜¨ˆ}¯øO

Pruébalo en línea!

FN©ƒ®Ne0})               # Generate, iteratively, the current pascal row, interspersed with 0's.
          ¹®-Å0          # Calculate the number of zeros to middle pad it.
               .ø˜¨ˆ}¯øO # Surround with the zeros, transpose and sum.

Básicamente, todo lo que hace es generar esto:

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

Transponerlo:

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

Luego suma cada fila:

0
1
1
5
4
9
4
5
1
1
0

Si un 0 ®>-Åinicial y final no es aceptable, una cantidad de ®-Åarreglos lo arregla con una penalización de +1 byte.

Resultado para 50:

[0, 1, 1, 50, 49, 1224, 1175, 19551, 18376, 229125, 210749, 2100384, 1889635, 15679951, 13790316, 97994765, 84204449, 523088334, 438883885, 2421229251, 1982345366, 9833394285, 7851048919, 35371393434, 27520344515, 113548602181, 86028257666, 327340174085, 241311916419, 851817398634, 610505482215, 2009517658701, 1399012176486, 4313184213360, 2914172036874, 8448367214664, 5534195177790, 15139356846901, 9605161669111, 24871748205410, 15266586536299, 37524050574849, 22257464038550, 52060859526501, 29803395487951, 66492351226050, 36688955738099, 78239857877649, 41550902139550, 84859704298201, 43308802158651, 84859704298201, 41550902139550, 78239857877649, 36688955738099, 66492351226050, 29803395487951, 52060859526501, 22257464038550, 37524050574849, 15266586536299, 24871748205410, 9605161669111, 15139356846901, 5534195177790, 8448367214664, 2914172036874, 4313184213360, 1399012176486, 2009517658701, 610505482215, 851817398634, 241311916419, 327340174085, 86028257666, 113548602181, 27520344515, 35371393434, 7851048919, 9833394285, 1982345366, 2421229251, 438883885, 523088334, 84204449, 97994765, 13790316, 15679951, 1889635, 2100384, 210749, 229125, 18376, 19551, 1175, 1224, 49, 50, 1, 1, 0]

PHP , 119 bytes

números de columnas de 1 entrada a entrada -1

for(;$r<$argn;$l=$t[+$r++])for($c=-$r;$c<=$r;$c+=2)$s[$c]+=$t[+$r][$c]=$r|$c?$l[$c+1]+$l[$c-1]:1;ksort($s);print_r($s);

Pruébalo en línea!

Jalea , 12 bytes

Ḷµc€j€0Ṛṙ"NS

Pruébalo en línea!

Cómo funciona

Ḷµc€j€0Ṛṙ"NS  Main link. Argument: k

Ḷ             Unlength; yield A := [0, ..., k-1].
 µ            New chain. Argument: A
  c€          Combinations each; compute nCr for each n and r in A, grouping by n.
    j€0       Join each resulting array [nC0, ..., nC(k-1)], separating by zeroes,
              yielding, [nC0, 0, ..., 0, nC(k-1)].
              Note that nCr = 0 whenever r > n.
       Ṛ      Reverse the resulting 2D array.
          N   Negate A, yielding [0, ..., -(k-1)].
        ṙ"    Zipwith rotate; for each array in the result to the left and the
              corresponding integer non-positive integer to the right, rotate
              the array that many units to the left.
           S  Take the columnwise sum.

Python 3, 201 184 bytes

def f(n):x,z,m=[1],[0],n-1;l=[z*m+x+z*m];exec("x=[*map(sum,zip(z+x,x+z))];l.append(z*(n-len(x))+[b for a in zip(x,z*len(x))for b in a][:-1]+z*(n-len(x)));"*m);return[*map(sum,zip(*l))]

Python 2 , 140 137 bytes

n=input()
x=[]
a=[0]*n+[1]+n*[0]
z=n%2
exec'x+=[a];a=[(i%2^z)*sum(a[i-1:i+2])for i in range(2*n+1)];z^=1;'*n
print map(sum,zip(*x))[1:-1]

Pruébalo en línea! o Pruébelo en línea!

^Paran=3
comienza con una lista con nceros alrededor de uno: [[0, 0, 0, 1, 0, 0, 0]]
genere la pirámide completa

[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 0, 1, 0, 0],
 [0, 1, 0, 2, 0, 1, 0]]

Gire 90º y sume cada fila, descartando la primera y la última (solo ceros)

[[0, 0, 0],
 [0, 0, 1],
 [0, 1, 0],
 [1, 0, 2],
 [0, 1, 0],
 [0, 0, 1],
 [0, 0, 0]]

Haskell, 118 112 104 bytes

6 14 bytes guardados gracias a @nimi

z=zipWith(+)
p n|n<2=[1]|m<-p(n-1)=z(0:0:m)(m++[0,0])            -- Generate the nth triangle row.
f n=foldl1 z[d++p x++d|x<-[1..n],d<-[0<$[1..n-x]]]  -- Pad each row with 0s and then sum all the rows.

Python 3, 124 caracteres

f=lambda n:[sum(map(lambda n,k:k<1or (2*k+n)*f(2*k+n-1,k-1)/k,[abs(x)]*n,range(n))[:(n+1-abs(x))/2]) for x in range(-n+1,n)]

Esto utiliza el hecho de que el Triángulo de Pascal se puede definir con coeficientes binomiales. Intenté eliminar el abs(x)y el range(-n+1,n)haciéndolo range(n)y luego usarlo, lambda l:l[-1:0:-1]+lpero fue más largo.

Además, esta es mi primera vez jugando al golf, así que espero que perdones cualquier imitación.

El binomio no es mío y fue tomado de aquí .