バックグラウンド

この課題の場合、「メタシーケンス」は、数字自体だけでなく増分も増加する数字のシーケンスとして定義され、増分は値の増加などによって増加します。

たとえば、ティア3メタシーケンスは次のように始まります。

1 2 4 8 15 26 42 64 93 130 176

なぜなら：

    1 2 3  4  5  6  7  8   9       >-|
      ↓+↑ = 7                        | Increases by the amount above each time
  1 2 4 7  11 16 22 29 37  46  >-| <-|
                                 | Increases by the amount above each time
1 2 4 8 15 26 42 64 93 130 176 <-|

チャレンジ

正の整数を指定すると、その層のメタシーケンスの最初の20項目を出力します。

テストケース

入力：3出力：[ 1, 2, 4, 8, 15, 26, 42, 64, 93, 130, 176, 232, 299, 378, 470, 576, 697, 834, 988, 1160 ]

入力：1出力：[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]

入力：5出力：[ 1, 2, 4, 8, 16, 32, 63, 120, 219, 382, 638, 1024, 1586, 2380, 3473, 4944, 6885, 9402, 12616, 16664 ]

入力：13出力：[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16383, 32752, 65399, 130238, 258096, 507624 ]

気づくかもしれませんが、ティアtの各シーケンスの最初の$t+1$アイテムは、最初のt + 1の2のべき乗です...$t$$t+1$

ルール

• 標準的な抜け穴が適用されます
• これはcode-golfなので、バイト単位の最短回答が勝ちます

ゼリー、8 7バイト

20ḶcþŻS

オンラインでお試しください！

   cþ       Table of binom(x,y) where:
20Ḷ           x = [0..19]
     Ż        y = [0..n]    e.g.  n=3 → [[1, 1, 1, 1, 1, 1,  …]
                                         [0, 1, 2, 3, 4, 5,  …]
                                         [0, 0, 1, 3, 6, 10, …]
                                         [0, 0, 0, 1, 4, 10, …]]

      S     Columnwise sum.           →  [1, 2, 4, 8, 15, 26, …]

これは、という@alephalphaの洞察を使用してい

Wolfram言語（Mathematica）、34バイト

0~Range~19~Binomial~i~Sum~{i,0,#}&

オンラインでお試しください！

ティアメタシーケンスは、パスカルの三角形の各行の最初の要素の合計です。$n$$n+1$

Haskell、34バイト

(iterate(init.scanl(+)1)[1..20]!!)

0インデックスの入力を使用します（f 4ティア5を返します）

Haskell、36バイト

f 1=[1..20]
f n=init$scanl(+)1$f$n-1

オンラインでお試しください！1インデックス付きの入力を使用します（f 5ティア5を返します）

説明

scanl (+) 1は、リストの部分的な合計を取得する（および先頭に追加する）関数です1。

例：scanl (+) 1 [20,300,4000]等しい[1,21,321,4321]。

層は、この関数がリスト回適用されるだけであることがます。$n$$(n-1)$$[1,2,3,\dots]$

（または同等：すべて1のリストに回。）$n$

initまたはを使用して、アプリケーションごとにずつ[1..20-n]リストが長くなることを説明します。$1$

Brain-Flak、84 82バイト

<>((()()()()()){}){({}[((()))])}{}<>{({}[(())]<<>{({}<>({}))<>}<>{}{({}<>)<>}>)}<>

オンラインでお試しください！

注釈付き

<>               Switch to the off stack
((()()()()()){}) Push 10
{({}[((()))])}{} Make twice that many 1s
<>               Switch back
{                While ...
({}[(())]<       Subtract one from the input and push 1
<>               Switch
{                For every x on the stack
({}<>({}))<>     Remove x and add it to a copy of the other TOS
}                End loop
<>{}             Remove 1 element to keep it 20
{({}<>)<>}       Copy everything back to the other stack
>)}<>            End scopes and loops

オンラインでお試しください！

R、36バイト

rowSums(outer(0:19,0:scan(),choose))

オンラインでお試しください！

提案してくれた@Giuseppeに感謝しouterます。

これは、@ alephalphaが説明したアプローチに基づいています。

Pythonの2、69の 58 55バイト

ovsとJo Kingのおかげでバイトを節約できました。また、Python 3でも機能するようになりました。

m=lambda t:[1+sum(m(t-1)[:n])for n in range(~t and 20)]

オンラインでお試しください！

数学

ましょうである層の配列の用語（0-インデックス付き）。少し分析すると、次の繰り返し式が導き出されます。$a(t,n)$$n^{th}$$t$

後方に向かって、すべてのおよびを定義します。これらの定義は、ベースケースを単純化します。$a(0,n) = 1$$a(-1,n) = 0$$n$

コード

m(t)tierでシーケンスの最初の20要素を返す関数を定義しますt。tが負でない場合、上記の再帰式を使用します。場合tで-1、我々は空のリストを返します。空のリストは、各再帰呼び出しの結果がスライス（[:n]）されてから合計されるため、基本ケースとして機能します。空のリストをスライスすると空のリストが得られ、空のリストを合計するとが得られ0ます。ティアは、すべての定数シーケンスのように動作する必要があるため、これがまさに望みの結果です。$-1$$0$

m=lambda t:                     # Define a function m(t):
 [          ]                   # List comprehension
     for n in range(         )  # for each n from 0 up to but not including...
                    ~n and 20   # 0 if n is -1, else 20:
  1+sum(          )             # a(t,n) = 1 + sum of
              [:n]              # the first n elements of
        m(t-1)                  # the previous tier (calculated recursively)

dzaima / APL REPL、14バイト

(+\1,19↑)⍣⎕⍳20

オンラインでお試しください！

(+\1,19↑)⍣⎕⍳20
(       )⍣⎕     repeat the function below input times:
 +\               cumulative sum of
   1,             1 prepended to
     19↑          the first 19 items of the previous iteration
           ⍳20  starting with the first 20 integers

パリ/ GP、39バイト

n->Vec(sum(i=1,n+1,(1/x-1)^-i)+O(x^21))

オンラインでお試しください！

パリ/ GP、40バイト

n->Vec((1-(1/x-1)^-n++)/(1-2*x)+O(x^20))

オンラインでお試しください！

ティアメタシーケンスの生成関数は次のとおりです。$n$

Perl 6の、34の 32バイト

-Jo Kingのおかげで2バイト

{(@,{[\+] 1,|.[^19]}...*)[$_+1]}

オンラインでお試しください！

説明

{                              }  # Anonymous block
   ,                ...*  # Construct infinite sequence of sequences
  @  # Start with empty array
    {              }  # Compute next element as
     [\+]     # cumulative sum of
          1,  # one followed by
            |.[^19]  # first 19 elements of previous sequence
 (                      )[$_+1]  # Take (n+1)th element

Python 3.8（プレリリース）、62バイト

f=lambda n:[t:=1]+[t:=t+n for n in(n and f(n-1)[:-1]or[0]*19)]

オンラインでお試しください！

説明

f=lambda n:     # funtion takes a single argument
     [t:=1]     # This evaluates to [1] and assigns 1 to t
                # assignment expressions are a new feature of Python 3.8
       +        # concatenated to
     [  ....  ] # list comprehension

# The list comprehesion works together with the
# assignment expression as a scan function:
[t := t+n for n in it]
# This calculates all partial sums of it 
# (plus the initial value of t, which is 1 here)

# The list comprehension iterates
# over the first 19 entries of f(n-1)
# or over a list of zeros for n=0
 for n in (n and f(n-1)[:-1] or [0]*19)

R（63 47バイト）

function(n,k=0:19)2^k*pbeta(.5,pmax(k-n,0),n+1)

オンラインデモ。これは、2項分布の累積分布関数を与える正則化された不完全なベータ関数を使用します。したがって、Pascalの三角形の行の部分和を得るために少しスケーリングが必要です。

オクターブ（66 46バイト）

@(n,k=0:19)2.^k.*betainc(.5,max(k-n,1E-9),n+1)

オンラインデモ。まったく同じ概念ですがbetainc、Rのpbeta場合とは異なり、2番目と3番目の引数をゼロより大きくする必要があるため、ややugいです。

これらをベクトル化するのを助けてくれたGiuseppeに感謝します。

ルビー、74バイト

a=->b{c=[1];d=0;b==1?c=(1..20).to_a: 19.times{c<<c[d]+(a[b-1])[d];d+=1};c}

ゴルフされていないバージョン：

def seq num
    ary = [1]
    index = 0
    if num == 1
        ary = (1..20).to_a
    else
        19.times{ary << ary[index]+seq(num-1)[index]; index+=1}
    end
    return ary
end

かなりリソースを消費します。オンラインバージョンでは、13番目のメタシーケンスを計算できません。

オンラインで試す

Wolfram言語（Mathematica）、42バイト

Nest[FoldList[Plus,1,#]&,Range[21-#],#-1]&

オンラインでお試しください！

JavaScript（Node.js）、58バイト

t=>Array(20).fill(t).map(g=(t,i)=>i--*t?g(t,i)+g(t-1,i):1)

オンラインでお試しください！

問題の説明 そして、

05AB1E、11 9 バイト

20LIF.¥>¨

0インデックス付き

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

20L        # Create a list in the range [1,20]
   IF      # Loop the input amount of times:
     .¥    #  Get the cumulative sum of the current list with 0 prepended automatically
       >   #  Increase each value in this list by 1
        ¨  #  Remove the trailing 21th item from the list
           # (after the loop, output the result-list implicitly)

R、59 49バイト

f=function(n)`if`(n,Reduce(`+`,f(n-1),1,,T),1:20)

オンラインでお試しください！

再帰的Reduceで+、init=1かつaccumulation=TRUEサブセットすることを避けるために。再帰的なアプローチを提案してくれたCriminally Vulgarに感謝します！

JavaScript（ES6）、 68  67バイト

f=(n,a=[...f+f])=>n--?f(n,[s=1,...a.map(x=>s-=~--x)]):a.slice(0,20)

オンラインでお試しください！

JavaScript（ES6）、63バイト

注意：このバージョンはます。$n\le20$

f=(n,a=[...Array(20-n)])=>n--?f(n,[s=1,...a.map(x=>s+=x||1)]):a

オンラインでお試しください！

J、24バイト

<:(1+/\@,])^:[(1+i.20)"_

オンラインでお試しください！

注：これはdzaimaのAPL回答の翻訳であることが判明しましたが、実際にはこれを書く前に気づいていませんでした。

説明

<: (1 +/\@, ])^:[ (1+i.20)"_
<:                           NB. input minus 1 (left input)
                  (1+i.20)"_ NB. 1..20 (right input)
   (         )^:[            NB. apply verb in parens 
                             NB. "left input" times
   (1     , ])               NB. prepend 1 to right input
   (  +/\@   )               NB. and take scan sum

ルビー、49バイト

f=->n{n<1?[1]*20:[o=1]+f[n-1][0,19].map{|x|o+=x}}

再帰的定義：ティア0が1,1,1,1...あり、後続の各ティアは1で、その後に最初の違いが前のティアであるシーケンスが続きます。面倒なことに、最初の20個を明示的にスライスしなかった場合、21個の値が得られます。それを回避することでこれを短縮する方法があるはずです。

網膜、59バイト

.+
19*$(_,

入力を19 1秒（単項）に置き換えます。（20番目の値は、ループの最初のパスで常に削除されるため、0です。）

"$+"{`
)`

元の入力回数だけループを繰り返します。

(.+),_*
_,$1

最後の要素を削除し、プレフィックスaを付け1ます。

_+(?<=((_)|,)+)
$#2*

累積合計を計算します。

_+
$.&

10進数に変換します。

オンラインでお試しください！

C＃（Visual C＃Interactive Compiler）、120バイト

n=>{for(long i=-1,h=0,m=0;++i<20;Print(i<1?1:h))for(m=h=0;m<=n;)h+=f(i)/(f(m)*f(i-m++));long f(long a)=>a>1?a*f(a-1):1;}

オンラインでお試しください！

alephalphaの式に基づいています。

さび、135バイト

fn t(m:u64)->Vec<u64>{let f=|y|(1..=y).fold(1,|a,n|a*n);(0..20).map(|i| (0..=u64::min(i,m)).fold(0,|a,x|a+f(i)/f(x)/f(i-x))).collect()}

他のいくつかのように、@ alephalphaのアイデアを使用しました。組み込みの階乗がないため、少なくとも36バイトを使用します（さらにネガを処理します）。組み込みの選択なし、さらに16バイト。イテレータ->宣言されたベクトル型、20バイトなど。

play.rust-lang.orgでゴルフをしていない

R（60 59バイト）

function(n)Reduce(function(p,q)2*p-choose(q-1,n),1:19,1,,1)

オンラインデモ

観察の簡単な実装

T（n、k）= 2 T（n-1、k）-二項（n-1、k）。-MFハスラー、2010年5月30日

OEIS A008949から。への引数Reduceは、関数（明らかに）、マッピングする配列、開始値、偽の値（右ではなく左から折り畳む）、および中間結果を配列に蓄積するための真理値です。

K（oK）、17バイト

ngnによる-1バイト（0インデックスから1インデックスへの切り替え）

{x(+\1,19#)/20#1}

オンラインでお試しください！

1インデックス付き

K（oK）、18バイト

{x(+\1,19#)/1+!20}

オンラインでお試しください！

0インデックス付き

ゼリー、10バイト

20RṖ1;ÄƲ⁸¡

オンラインでお試しください！

0インデックス。

Perl 5、48バイト

$x=1,@A=(1,map$x+=$_,@A[0..18])for 0..$_;$_="@A"

TIO

Japt、15バイト

0インデックス付き。置き換えるhとp1-インデックス化のために。

ÈîXi1 å+}gNh20õ

それを試してみてください

CJam（20バイト）

1aK*{1\{1$+}/;]}q~*p

オンラインデモ。これは、stdinから入力を取り、stdoutに出力するプログラムです。同じスコアに対して、匿名ブロック（関数）は次のように取得できます。

{1aK*{1\{1$+}/;]}@*}

解剖

これは定義をそのまま適用します：

1aK*      e# Start with an array of 20 1s
{         e# Loop:
  1\      e#   Push a 1 before the current list
  {1$+}/  e#   Form partial sums (including that bonus 1)
  ;]      e#   Ditch the last and gather in an array (of length 20)
}
q~*       e# Take input and repeat the loop that many times
p         e# Pretty print