Quasi tutti qui conoscono il triangolo di Pascal. È formato da file successive, dove ogni elemento è la somma dei suoi due vicini in alto a sinistra e in alto a destra. Ecco le prime 5righe (prese in prestito dal triangolo di Generate Pascal ):

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

Prenderemo il Triangolo di Pascal ed eseguiremo alcune somme (hah-ha). Per un dato input n, genera la somma colonnare delle prime nrighe del Triangolo di Pascal. Ad esempio, per l'input 5, l'output sarebbe formato da

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

Quindi l'output sarebbe [1, 1, 5, 4, 9, 4, 5, 1, 1].

Nota che non devi necessariamente generare il Triangolo di Pascal per calcolare la somma - dipende dalla tua implementazione se è più breve farlo o no.

Ingresso

Un singolo numero intero positivo ncon n >= 1 qualsiasi formato conveniente .

Produzione

L'array / elenco risultante della somma per colonna delle prime nrighe del triangolo di Pascal, come indicato sopra. Ancora una volta, in qualsiasi formato adatto.

Regole

• Le nuove linee iniziali o finali o gli spazi bianchi sono tutti opzionali, purché i personaggi stessi si allineino correttamente.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

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

tZv=Gq:"t5BZ+]vs

Provalo online!

Spiegazione

Ciò applica ripetutamente la convoluzione per generare le righe. Ad esempio, per l'input n=5iniziamo con la prima riga

0 0 0 0 1 0 0 0 0

Coinvolgere con [1 0 1]dà

0 0 0 1 0 1 0 0 0

Ripetendo l'operazione si ottiene

0 0 1 0 2 0 1 0 0

poi

0 1 0 3 0 3 0 1 0

ecc. Concatenare queste matrici verticalmente e calcolare la somma di ogni colonna dà il risultato.

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 byte

Grazie a Luis Mendo per aver salvato 1 byte.

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

Provalo online!

Spiegazione

(       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 byte

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>

L'indicizzazione mi costa un byte. Spiegazione: g(j-1,i-1)+g(j-1,i+1)calcola ricorsivamente il triangolo di Pascal fino a raggiungere la prima riga, che è il caso base. Per ottenere somme di colonna, uso il fatto che mapeffettivamente passa un terzo parametro, quindi in questo caso esiste un passaggio ricorsivo aggiuntivo.

JavaScript (ES6), 90 87 86 84 82 byte

Risparmiato 3 byte grazie 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

Casi test

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 byte

Grazie a Martin Ender per aver trovato un risparmio di due byte!

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

Funzione pura che accetta un input intero positivo e restituisce un elenco di numeri interi. Produce letteralmente tutte le voci pertinenti del triangolo di Pascal e le somma in modo appropriato.

Presentazione precedente (che è un po 'più facile da leggere):

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

Ottava , 84 67 45 byte

22 byte salvati grazie a Neil !

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

Provalo online!

Spiegazione

La pascalfunzione fornisce una matrice che contiene i valori nel triangolo 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

Per estrarre i valori desiderati, capovolgiamo verticalmente ( flip), manteniamo la parte triangolare inferiore ( tril) e capovolgiamo di nuovo. Questo 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 quindi estrae le diagonali come colonne

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

e sumcalcola la somma di ogni colonna, che fornisce il risultato.

05AB1E , 34 32 28 25 24 byte

-4 grazie a Emigna.

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

Provalo online!

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.

Fondamentalmente tutto ciò che fa è generare questo:

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

Trasponilo:

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

Quindi somma ogni riga:

0
1
1
5
4
9
4
5
1
1
0

Se uno 0 iniziale e finale non sono accettabili, non ®>-Åviene ®-Årisolto per una penalità di +1 byte.

Risultato per 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 byte

numeri di colonne da 1 input a input -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);

Provalo online!

Gelatina , 12 byte

Ḷµc€j€0Ṛṙ"NS

Provalo online!

Come funziona

Ḷµ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 byte

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 byte

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]

Provalo online! o provalo online!

^Pern=3
iniziare con un elenco con nzeri racchiudono uno - [[0, 0, 0, 1, 0, 0, 0]]
Genera la piramide completa

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

Ruota di 90º e somma ogni riga, scartando la prima e l'ultima (solo zeri)

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

6 14 byte salvati grazie 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 caratteri

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

Questo utilizza il fatto che il Triangolo Pascal può essere definito con coefficienti binomiali. Ho provato a rimuovere il abs(x)e range(-n+1,n)facendolo range(n)e poi usando lambda l:l[-1:0:-1]+lma era più lungo.

Anche questa è la prima volta che gioco a golf, quindi spero che perdonerai qualsiasi passo falso.

Il binomio non è mio ed è stato preso da qui .