Fast jeder hier ist mit Pascals Dreieck vertraut. Es besteht aus aufeinanderfolgenden Zeilen, wobei jedes Element die Summe der beiden Nachbarn oben links und oben rechts ist. Hier sind die ersten 5Zeilen (aus dem Generate Pascal-Dreieck entlehnt ):

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

Wir werden Pascals Dreieck nehmen und ein paar Summen drauf machen (hah-ha). Geben Sie für eine bestimmte Eingabe ndie Spaltensumme der ersten nZeilen des Pascalschen Dreiecks aus. Zum Beispiel für die Eingabe5 die Ausgabe durch gebildet

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

So wäre die Ausgabe [1, 1, 5, 4, 9, 4, 5, 1, 1] .

Beachten Sie, dass Sie nicht unbedingt das Pascalsche Dreieck generieren müssen, um die Summe zu berechnen. Dies hängt von Ihrer Implementierung ab, ob dies kürzer ist oder nicht.

Eingang

Eine einzelne positive ganze Zahl nmit n >= 1 in jedem geeigneten Format .

Ausgabe

Das resultierende Array / die Liste der spaltenweisen Summierung des ersten n Zeilen des Pascalschen Dreiecks, wie oben beschrieben. Auch hier in jedem geeigneten Format.

Regeln

• Führende oder nachfolgende Zeilenumbrüche oder Leerzeichen sind optional, sofern die Zeichen selbst korrekt ausgerichtet sind.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

[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

Probieren Sie es online!

Erläuterung

Dies wendet wiederholt eine Faltung an, um die Zeilen zu erzeugen. Bei der Eingabe beginnen n=5wir zum Beispiel mit der ersten Zeile

0 0 0 0 1 0 0 0 0

Sich mit [1 0 1]dem Geben befassen

0 0 0 1 0 1 0 0 0

Das Wiederholen der Operation ergibt

0 0 1 0 2 0 1 0 0

dann

0 1 0 3 0 3 0 1 0

usw. Wenn Sie diese Arrays vertikal verketten und die Summe jeder Spalte berechnen, erhalten Sie das Ergebnis.

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

Vielen Dank an Luis Mendo für das Speichern von 1 Byte.

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

Probieren Sie es online!

Erläuterung

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

1-Indizierung hat mich ein Byte gekostet. Erläuterung: g(j-1,i-1)+g(j-1,i+1)Berechnet rekursiv das Pascalsche Dreieck, bis es die erste Zeile erreicht, die der Basisfall ist. Um Spaltensummen zu erhalten, benutze ich die Tatsache, dass maptatsächlich ein dritter Parameter übergeben wird, sodass es in diesem Fall einen zusätzlichen rekursiven Schritt gibt.

JavaScript (ES6), 90 87 86 84 82 Byte

3 Bytes gespart dank 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

Testfälle

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

Vielen Dank an Martin Ender für die Zwei-Byte-Einsparung!

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

Reine Funktion, die eine positive Ganzzahleingabe verwendet und eine Liste von Ganzzahlen zurückgibt. Produziert buchstäblich alle relevanten Einträge von Pascals Dreieck und summiert sie entsprechend.

Vorheriger Beitrag (der etwas leichter zu lesen ist):

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

Oktave , 84 67 45 Bytes

22 Bytes gespart dank Neil !

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

Probieren Sie es online!

Erläuterung

Die pascalFunktion liefert eine Matrix, die die Werte im Pascal-Dreieck enthält:

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

Um die gewünschten Werte zu extrahieren, drehen wir vertikal ( flip), behalten den unteren dreieckigen Teil ( tril) bei und drehen erneut. Das gibt

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 extrahiert dann die Diagonalen als Spalten

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

und sumberechnet die Summe jeder Spalte, die das Ergebnis ergibt.

05AB1E , 34 32 28 25 24 Bytes

-4 danke an Emigna.

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

Probieren Sie es 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.

Im Grunde ist alles, was es tut, dies zu erzeugen:

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

Transponiere es:

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

Dann summiert jede Zeile:

0
1
1
5
4
9
4
5
1
1
0

Wenn eine führende und eine ®>-Ånachfolgende 0 nicht akzeptabel sind, wird ®-Åsie nicht für eine +1-Byte-Strafe korrigiert .

Ergebnis für 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

Spaltennummern von 1-Eingabe bis Eingabe -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);

Probieren Sie es online!

Gelee , 12 Bytes

Ḷµc€j€0Ṛṙ"NS

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online! oder Online ausprobieren!

^Fürn=3
Beginnt mit einer Liste mit nNullen umgibt eine Eins - [[0, 0, 0, 1, 0, 0, 0]]
Generieren Sie die vollständige Pyramide

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

Drehe um 90º und summiere jede Reihe, wobei du die erste und die letzte (nur Nullen) verwerfst.

[[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 gespart dank @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 Zeichen

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

Dies nutzt die Tatsache, dass das Pascal-Dreieck mit Binomialkoeffizienten definiert werden kann. Ich habe versucht, das abs(x)und das zu entfernen, indem ich range(-n+1,n)es gemacht range(n)und dann verwendet habelambda l:l[-1:0:-1]+l aber es war länger.

Auch dies ist mein erstes Mal Golf, also hoffe ich, dass Sie alle Fauxpas verzeihen.

Das Binom ist nicht meins und wurde von hier genommen .