La plupart des gens ici connaissent le triangle de Pascal. Il est formé de rangées successives, où chaque élément est la somme de ses deux voisins supérieur gauche et supérieur droit. Voici les premières 5lignes (empruntées au triangle Générer Pascal ):

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

Nous allons prendre le triangle de Pascal et y effectuer quelques sommes (hah-ha). Pour une entrée donnée n, sortez la somme en colonnes des premières nlignes du triangle de Pascal. Par exemple, pour l'entrée 5, la sortie serait formée par

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

Ainsi, la sortie serait [1, 1, 5, 4, 9, 4, 5, 1, 1].

Notez que vous n'avez pas nécessairement besoin de générer le triangle de Pascal pour calculer la somme - cela dépend de votre implémentation, si elle est plus courte ou non.

Contribution

Un entier positif unique navec n >= 1 dans un format pratique .

Sortie

Le tableau / liste résultant de la somme des ncolonnes des premières lignes du triangle de Pascal, comme indiqué ci-dessus. Encore une fois, dans n'importe quel format approprié.

Règles

• Les sauts de ligne ou les espaces de début ou de fin sont tous facultatifs, tant que les caractères eux-mêmes s'alignent correctement.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

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

tZv=Gq:"t5BZ+]vs

Essayez-le en ligne!

Explication

Cela applique à plusieurs reprises la convolution pour générer les lignes. Par exemple, pour l'entrée, n=5nous commençons par la première ligne

0 0 0 0 1 0 0 0 0

Convolving avec [1 0 1]donne

0 0 0 1 0 1 0 0 0

La répétition de l'opération donne

0 0 1 0 2 0 1 0 0

puis

0 1 0 3 0 3 0 1 0

etc. Concaténer ces tableaux verticalement et calculer la somme de chaque colonne donne le résultat.

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 octets

Merci à Luis Mendo d'avoir sauvé 1 octet.

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

Essayez-le en ligne!

Explication

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

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'indexation 1 m'a coûté un octet. Explication: g(j-1,i-1)+g(j-1,i+1)calcule récursivement le triangle de Pascal jusqu'à ce qu'il atteigne la première ligne, qui est le cas de base. Pour obtenir les sommes des colonnes, j'utilise le fait qui mappasse en fait un troisième paramètre, il y a donc une étape récursive supplémentaire lorsque c'est le cas.

JavaScript (ES6), 90 87 86 84 82 octets

Sauvegardé 3 octets grâce à 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

Cas de 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 octets

Merci à Martin Ender d'avoir trouvé une économie de deux octets!

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

Fonction pure prenant une entrée entière positive et renvoyant une liste d'entiers. Produit littéralement toutes les entrées pertinentes du triangle de Pascal et les additionne de manière appropriée.

Soumission précédente (qui est un peu plus facile à lire):

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

Octave , 84 67 45 octets

22 octets économisés grâce à Neil !

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

Essayez-le en ligne!

Explication

La pascalfonction donne une matrice qui contient les valeurs dans le triangle 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

Pour extraire les valeurs souhaitées, nous inversons verticalement ( flip), gardons la partie triangulaire inférieure ( tril), et inversons à nouveau. Cela donne

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 extrait ensuite les diagonales sous forme de colonnes

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

et sumcalcule la somme de chaque colonne, ce qui donne le résultat.

05AB1E , 34 32 28 25 24 octets

-4 merci à Emigna.

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

Essayez-le en ligne!

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.

Fondamentalement, il ne fait que générer ceci:

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

Transposez-le:

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

Additionne ensuite chaque ligne:

0
1
1
5
4
9
4
5
1
1
0

Si un 0 de ®>-Ådébut et de fin n'est pas acceptable, il n'est pas corrigé ®-Åpour une pénalité de +1 octet.

Résultat pour 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 octets

numéros de colonnes de 1 entrée à entrée -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);

Essayez-le en ligne!

Gelée , 12 octets

Ḷµc€j€0Ṛṙ"NS

Essayez-le en ligne!

Comment ça marche

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

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 octets

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]

Essayez-le en ligne! ou Essayez-le en ligne!

^{Pour lesn=3}
départs avec une liste de nzéros entourant un - [[0, 0, 0, 1, 0, 0, 0]]
Générez la pyramide complète

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

Faites une rotation de 90 ° et additionnez chaque ligne, en éliminant la première et la dernière (uniquement des zéros)

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

6 14 octets économisés grâce à @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 caractères

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

Cela utilise le fait que le triangle de Pascal peut être défini avec des coefficients binomiaux. J'ai essayé de retirer le abs(x)et le range(-n+1,n)en le faisant range(n)puis en l'utilisant lambda l:l[-1:0:-1]+lmais c'était plus long.

C'est aussi ma première fois au golf, donc j'espère que vous pardonnerez tout faux pas.

Le binôme n'est pas le mien et a été pris d' ici .