Buradaki herkes Pascal'ın Üçgeni'ne aşinadır. Her elemanın iki sol üst ve sağ üst komşusunun toplamı olduğu art arda sıralardan oluşur. İşte ilk 5satırlar ( Generate Pascal'ın üçgeninden alınmış ):

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

Pascal Üçgeni'ni alıp üzerinde bazı toplamlar yapacağız (hah-ha). Belirli bir giriş için n, nPascal Üçgeni'nin ilk satırlarının sütunlu toplamını gösterir . Örneğin, girdi 5için çıktı aşağıdaki gibi

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

Yani çıktı olacaktı [1, 1, 5, 4, 9, 4, 5, 1, 1].

Toplamı hesaplamak için Pascal Üçgeni oluşturmanız gerekmediğini unutmayın - bunu yapmak daha kısa ya da yapmamak sizin uygulamanıza bağlıdır.

Giriş

Tek bir pozitif tam sayı nile n >= 1 uygun olan herhangi bir biçimde .

Çıktı

Sonuçta n, yukarıda belirtildiği gibi, Pascal üçgeni ilk satırlarının sütun şeklinde toplamının dizisi / listesi . Yine, uygun bir formatta.

kurallar

• Lider ya da izleyen yeni satırlar ya da boşluklar, karakterlerin kendileri doğru bir şekilde hizalandığı sürece isteğe bağlıdır.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Mümkünse, lütfen başkalarının kodunuzu deneyebilmesi için çevrimiçi bir test ortamına bir bağlantı ekleyin!
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

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

tZv=Gq:"t5BZ+]vs

Çevrimiçi deneyin!

açıklama

Bu, satırları oluşturmak için tekrar tekrar evrişim uygular. Örneğin, giriş n=5için ilk satırdan başlıyoruz

0 0 0 0 1 0 0 0 0

İle evriştirerek [1 0 1]verir

0 0 0 1 0 1 0 0 0

İşlemi tekrarlamak verir

0 0 1 0 2 0 1 0 0

sonra

0 1 0 3 0 3 0 1 0

Bu dizileri dikey olarak birleştirmek ve her bir sütunun toplamını hesaplamak sonucu verir.

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 bayt

Luis Mendo'ya 1 byte kaydettiği için teşekkür ederiz.

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

Çevrimiçi deneyin!

açıklama

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

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-indeksleme bana bir byte'a mal oldu. Açıklama: g(j-1,i-1)+g(j-1,i+1)Pascal üçgenini temel durum olan ilk satıra ulaşana kadar tekrarlı bir şekilde hesaplar. Sütun toplamları elde etmek için, aslında mapüçüncü bir parametreyi geçen bir gerçeği kullanıyorum, bu durumda bu durum söz konusu olduğunda fazladan özyinelemeli bir adım var.

JavaScript (ES6), 90 87 86 84 82 bayt

ETHproductions sayesinde 3 bayt kurtardı

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

Test durumları

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 bayt

İki baytlık tasarruf bulmak için Martin Ender'e teşekkürler!

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

Pozitif bir tamsayı girişi almak ve bir tamsayı listesi döndürmek için saf işlev. Kelimenin tam anlamıyla Pascal üçgeni ile ilgili tüm girdileri üretir ve bunları uygun şekilde toplar.

Önceki gönderim (okunması biraz daha kolay):

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

Octave , 84 67 45 bayt

Neil sayesinde 22 bayt kurtarıldı !

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

Çevrimiçi deneyin!

açıklama

pascalİşlev Pascal üçgeni değerleri içeren bir matris verir:

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

İstediğiniz değerleri çıkarmak için dikey olarak döndürüyoruz ( flip), alt üçgen kısmı ( tril) tutuyoruz ve tekrar çeviriyoruz. Bu verir

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 daha sonra köşegenleri sütunlar halinde ayıklar

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

ve sumsonucu veren her bir sütunun toplamını hesaplar.

05AB1E , 34 32 28 25 24 bayt

-4, Emigna'ya teşekkürler.

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

Çevrimiçi deneyin!

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.

Temel olarak yaptığı tek şey bu üretmek:

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

Transpoze et:

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

Sonra her satırı toplar:

0
1
1
5
4
9
4
5
1
1
0

®>-ÅÖndeki ve sondaki 0 ​​kabul edilemezse, ®-Å+1 baytlık bir ceza için düzeltmeler yapılmaz .

Sonuç 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 bayt

1 girişinden giriş -1'e kadar olan sayıları sütunlar

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

Çevrimiçi deneyin!

Jöle , 12 bayt

Ḷµc€j€0Ṛṙ"NS

Çevrimiçi deneyin!

Nasıl çalışır

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

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 bayt

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]

Çevrimiçi deneyin! veya Çevrimiçi deneyin!

^İçinn=3
bir liste ile başlar nsıfırların bir tane çevreleyen - [[0, 0, 0, 1, 0, 0, 0]]
tam piramit üret

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

90º döndürün ve her bir sırayı toplayın, ilk ve sonuncuyu atın (yalnızca sıfır)

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

@Nimi sayesinde 6 14 bayt kaydedildi

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 karakter

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

Bu, Pascal Üçgeni'nin binom katsayılarıyla tanımlanabilmesi gerçeğini kullanır. Ben çıkarmadan çalıştı abs(x)ve range(-n+1,n)bunu yaparak range(n)ve daha sonra kullanarak lambda l:l[-1:0:-1]+lancak daha uzun oldu.

Ayrıca bu benim ilk kez golf oynamak bu yüzden umarım herhangi bir taklitçiyi affedersiniz.

Binom benim değil ve buradan alındı .