[Question]
  [
# Background
For this challenge, a 'metasequence' will be defined as a sequence of numbers where not only the numbers themselves will increase, but also the increment, and the increment will increase by an increasing value, etc.
For instance, the tier 3 metasequence would start as:
`1 2 4 8 15 26 42 64 93 130 176`
because:
```
    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 <-|
```
# Challenge
Given a positive integer, output the first twenty terms of the metasequence of that tier.
## Test cases
Input: `3` Output: `[ 1, 2, 4, 8, 15, 26, 42, 64, 93, 130, 176, 232, 299, 378, 470, 576, 697, 834, 988, 1160 ]`
Input: `1` Output: `[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]`
Input: `5` Output: `[ 1, 2, 4, 8, 16, 32, 63, 120, 219, 382, 638, 1024, 1586, 2380, 3473, 4944, 6885, 9402, 12616, 16664 ]`
Input: `13` Output: `[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16383, 32752, 65399, 130238, 258096, 507624 ]`
As you may realise, the first \$t+1\$ items of each sequence of tier \$t\$ are the first \$t+1\$ powers of 2...
# Rules
* Standard loopholes apply
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins
  
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 34 bytes
```
0~Range~19~Binomial~i~Sum~{i,0,#}&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zg@9@gLigxLz21ztCyzikzLz83MzGnLrMuuDS3rjpTx0BHuVbtf0BRZl5JtLKCrp1CWrRybKyCmoK@g0K1sY6CoY6CKZA0rv0PAA "Wolfram Language (Mathematica) – Try It Online")
The tier \$n\$ metasequence is the sum of the first \$n+1\$ elements of each row of the Pascal triangle.
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
(iterate(init.scanl(+)1)[1..20]!!)
```
Uses 0-indexed inputs (`f 4` returns tier 5.)
# [Haskell](https://www.haskell.org/), 36 bytes
```
f 1=[1..20]
f n=init$scanl(+)1$f$n-1
```
[Try it online!](https://tio.run/##BcExCoAwDADA3Vdk6NAiFiM49iXiEIrRYgzF9v3Gu4vafYiYMWDaMMZl3gcGTUVLdy2Tih8DOnY6oT1UFBLUt2gHz7AG@zILnc2mXOsP "Haskell – Try It Online") Uses 1-indexed inputs (`f 5` returns tier 5.)
# Explanation
`scanl (+) 1` is a function that takes partial sums of a list, starting from (and prepending) `1`.
> 
> For example: `scanl (+) 1 [20,300,4000]` equals `[1,21,321,4321]`.
> 
> 
> 
It turns out that tier \$n\$ is just this function applied \$ (n-1) \$ times to the list \$[1,2,3,\dots]\$.
(Or equivalently: \$n\$ times to a list of all ones.)
We use either `init` or `[1..20-n]` to account for the list getting longer by \$1\$ every application.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ 7 bytes
```
20ḶcþŻS
```
[Try it online!](https://tio.run/##y0rNyan8/9/I4OGObcmH9x3dHfz//39TAA "Jelly – Try It Online")
```
   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, …]
```
This uses @alephalpha’s insight that $$\text{meta-sequence}\_n(i) = \sum\_{k=0}^n \binom ik.$$
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~84~~ 82 bytes
```
<>((()()()()()){}){({}[((()))])}{}<>{({}[(())]<<>{({}<>({}))<>}<>{}{({}<>)<>}>)}<>
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v/fxk5DQ0MTBjWrazWrNapro0GCmpqxmrXVtTZ2UBEg3wbCAWoCKtS0sQNJ1kJEQDw7TSDj////JgA "Brain-Flak (BrainHack) – Try It Online")
## Annotated
```
<>               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
```
[Try it online!](https://tio.run/##dZFBT4QwEIXv/Io50gtxjUfCxejNrHFNPBgPBQbbAC1py66k6W/HtoAJa7ZN5jKd9755LRXlgtGqnee8gP05XbipGBgJhiHIpgFt/MskTVOyXWIdgddRMzjcJTa17jN0Cfkizjp4oS2CufDKV0YN9FRMcNDJLasyyNurHnww3iFkWZYs@l493@bG0ihaGZACoVGyj6hcDKMBKmoYItktv/9Wz1IBnlFN8OMlo9i6s3V54Qshq9Yb9vKM/lmwoXUN3ISkKFRymHxYS2a@KHg/nhJ37fTkxzopB89m981V@QDYYY8iyraIQ3C4X0LOC4@xTT0GwwhtGBffMcS/T4sAywoFcfscAoL2uKjjEoFGz/P88As "Brain-Flak (BrainHack) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 36 bytes
```
rowSums(outer(0:19,0:scan(),choose))
```
[Try it online!](https://tio.run/##K/r/vyi/PLg0t1gjv7QktUjDwMrQUsfAqjg5MU9DUyc5Iz@/OFVT87/xfwA "R – Try It Online")
Thanks to @Giuseppe for suggesting `outer`.
This is based on the [approach @alephalpha described](https://codegolf.stackexchange.com/a/180863/42248)
[Answer]
# [dzaima/APL](https://github.com/dzaima/APL) REPL, 14 bytes
```
(+\1,19↑)⍣⎕⍳20
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfwPBBraMYY6hpaP2iZqPupd/Khv6qPezUYGXIZG//ILSjLz84r/6xYDAA "APL (dzaima/APL) – Try It Online")
```
(+\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
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~69~~ ~~58~~ 55 bytes
*Saved bytes thanks to [ovs](https://codegolf.stackexchange.com/users/64121/ovs) and [Jo King](https://tio.run/##K6gsycjPM/r/P9c2JzE3KSVRIc8q2lC7uDRXI1cjT9dQM9oqM1YzLb9IIVMhM0@hKDEvPVWjLk8hMS9FwchAM/Y/SKoEIWWoY6ppxaVQUJSZVwI0oURT8z8A); also, it works in Python 3 now as well.*
```
m=lambda t:[1+sum(m(t-1)[:n])for n in range(~t and 20)]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9c2JzE3KSVRocQq2lC7uDRXI1ejRNdQM9oqL1YzLb9IIU8hM0@hKDEvPVWjrkQhMS9FwchAM/Y/SKoEIWWoY6ppxaVQUJSZVwIyQVPzPwA "Python 2 – Try It Online")
### The math
Let \$a(t,n)\$ be the \$n^{th}\$ term (0-indexed) of the sequence at tier \$t\$. A little analysis leads to the following recurrence formula:
$$
a(t,n) = 1+\sum\_{i=0}^{n-1}a(t-1,i)
$$
Working backwards, we define \$a(0,n) = 1\$ and \$a(-1,n) = 0\$ for all \$n\$. These definitions will simplify our base case.
### The code
We define a function `m(t)` that returns the first 20 elements of the sequence at tier `t`. If `t` is nonnegative, we use the recursive formula above; if `t` is `-1`, we return an empty list. The empty list works as a base case because the result of each recursive call is sliced (`[:n]`) and then summed. Slicing an empty list gives an empty list, and summing an empty list gives `0`. That's exactly the result we want, since tier \$-1\$ should behave like a constant sequence of all \$0\$'s.
```
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)
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~34~~ 32 bytes
*-2 bytes thanks to Jo King*
```
{(@,{[\+] 1,|.[^19]}...*)[$_+1]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WsNBpzo6RjtWwVCnRi86ztAytlZPT09LM1olXtswtvZ/cWKlQpqGSrymQlp@EVCRsY6pjqGx9X8A "Perl 6 – Try It Online")
### Explanation
```
{                              }  # 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
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 62 bytes
```
f=lambda n:[t:=1]+[t:=t+n for n in(n and f(n-1)[:-1]or[0]*19)]
```
[Try it online!](https://tio.run/##FcqxCsMgFAXQvV9xR00M9NWlFfIl4mAJUiG9irjk600yneXUo/8K7bu2MdK6x/93i6Dz3a0S5ps@E6k0EJmKiNyQFBfR3i0SSvPPMMlHh3GnfCWIeRlrxLoHUFtmV0llrccJ "Python 3.8 (pre-release) – Try It Online")
---
## Explanation
```
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)
```
[Answer]
## R (63 47 bytes)
```
function(n,k=0:19)2^k*pbeta(.5,pmax(k-n,0),n+1)
```
[Online demo](https://tio.run/##K/pfbKP7P600L7kkMz9PI08n29bAytBS0yguW6sgKbUkUUPPVKcgN7FCI1s3T8dAUydP21Dzf7GGqeZ/AA). This uses the [regularised incomplete beta function](https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function), which gives the cumulative distribution function of a binomial, and hence just needs a bit of scaling to give partial sums of rows of Pascal's triangle.
## Octave (66 46 bytes)
```
@(n,k=0:19)2.^k.*betainc(.5,max(k-n,1E-9),n+1)
```
[Online demo](https://tio.run/##y08uSSxL/V@sYKugp6f330EjTyfb1sDK0FLTSC8uW08rKbUkMTMvWUPPVCc3sUIjWzdPx9BV11JTJ0/bUPN/sYap5n8A). Exactly the same concept, but slightly uglier because `betainc`, unlike R's `pbeta`, requires the second and third arguments to be greater than zero.
Many thanks to [Giuseppe](/users/67312/giuseppe) for helping me to vectorise these, with significant savings.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 36 bytes
```
n->vector(20,i,i<n+2)*matpascal(19)~
```
[Try it online!](https://tio.run/##K0gsytRNL/ifpmD7P0/Xriw1uSS/SMPIQCdTJ9MmT9tIUys3saQgsTg5MUfD0FKz7n9iQUFOpUaegq6dQkFRZl4JkKkE4igppGnkaWrqKEQb6ygY6iiYAknjWM3/AA "Pari/GP – Try It Online")
A port of my Mathematica answer.
---
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 39 bytes
```
n->Vec(sum(i=1,n+1,(1/x-1)^-i)+O(x^21))
```
[Try it online!](https://tio.run/##K0gsytRNL/ifpmD7P0/XLiw1WaO4NFcj09ZQJ0/bUEfDUL9C11AzTjdTU9tfoyLOyFBT839iQUFOpUaegq6dQkFRZl4JkKkE4igppGnkaWrqKEQb6ygY6iiYAknjWM3/AA "Pari/GP – Try It Online")
---
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 42 bytes
```
Nest[FoldList[Plus,1,#]&,Range[21-#],#-1]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zg@98vtbgk2i0/J8UnE8gIyCkt1jHUUY5V0wlKzEtPjTYy1FWO1VHWNYxV@x9QlJlXEq2soGunkBatHBuroKag76BQbayjYKijYAokjWv/AwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 59 bytes
```
.+
19*$(_,
```
Replace the input with 19 `1`s (in unary). (The 20th value is 0 because it always gets deleted by the first pass through the loop.)
```
"$+"{`
)`
```
Repeat the loop the original input number of times.
```
(.+),_*
_,$1
```
Remove the last element and prefix a `1`.
```
_+(?<=((_)|,)+)
$#2*
```
Calculate the cumulative sum.
```
_+
$.&
```
Convert to decimal.
[Try it online!](https://tio.run/##K0otycxLNPz/X0@by9BSS0UjXodLSUVbqTpBQ09bUydeiyteR8WQSzMhXlvD3sZWQyNes0ZHU1uTS0XZCCinzaWip/b/vzEA "Retina – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 58 bytes
```
t=>Array(20).fill(t).map(g=(t,i)=>i--*t?g(t,i)+g(t-1,i):1)
```
[Try it online!](https://tio.run/##TY1BCoMwFESvkoXg/6YJmmXbWHqGXsCgxkbSRGIoFvHsVu2mq5nHPJhevdVYBzNE5nzTrlquUZb3ENQHRI5cG2shIn@pAToJ8WRQloaxLN66g@gWrNjKucBV@0DAEUnyC3HkSsSelCKpvRu9bbn1HVQakhnSlDrkg2oeUYUIAhckyazB/b5gOp52bfrTdhZZZpDb1nXxSQtE3nvjtgGXCi/rFw "JavaScript (Node.js) – Try It Online")
It is trivial to write down following recursive formula based on the description in question
$$ g(t,i)=\begin{cases}
g(t,i-1)+g(t-1,i-1) & \text{if} \quad i\cdot t>0 \\
1 & \text{if} \quad i\cdot t=0 \\
\end{cases} $$
And you just need to generate an Array of 20 elements with \$[g(t,0)\dots g(t,19)]\$
[Answer]
# [Rust](https://www.rust-lang.org/), 135 bytes
```
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()}
```
used @alephalpha 's idea, like several others. there is no builtin factorial so that takes up at least 36 bytes, (plus dealing with negatives). no builtin choose, another 16 bytes. iterator->declared vector type, 20 bytes.. etc etc. 
[Ungolfed at play.rust-lang.org](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=21078808eeb3a0d8adb8edd8f99110e6)
[Answer]
# [R](https://www.r-project.org/), ~~59~~ 49 bytes
```
f=function(n)`if`(n,Reduce(`+`,f(n-1),1,,T),1:20)
```
[Try it online!](https://tio.run/##K/r/P802rTQvuSQzP08jTzMhMy1BI08nKDWlNDlVI0E7QSdNI0/XUFPHUEcnBEhaGRlo/k/TMNDkStMw0vwPAA "R – Try It Online")
Recursively `Reduce` with `+`, `init=1` and `accumulation=TRUE` to avoid having to subset. Thanks to [Criminally Vulgar](https://codegolf.stackexchange.com/users/72784/criminallyvulgar) for suggesting the recursive approach!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~11~~ ~~9~~ 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
19ÝIÝδcO
```
1-indexed
-1 byte by porting [*@alephalpha*'s Mathematica answer](https://codegolf.stackexchange.com/a/180863/52210), so make sure to upvote him!!
[Try it online](https://tio.run/##yy9OTMpM/f/f0PLwXM/Dc89tSfb//98EAA) or [verify all test cases](https://tio.run/##yy9OTMpM/W9k4Opnr6TwqG2SgpL9f0PLw3P9Ds89tyXZ/7/OfwA).
**Explanation:**
```
19Ý       # Push a list in the range [0, 19]
   IÝ     # Push a list in the range [0, input-integer]
     δ    # Apply on the two lists double-vectorized (as a table):
      c   #  The binomial coefficient
       O  # And then sum each inner list
          # (after which the resulting list is output implicitly)
```
---
**Old ~~11~~ 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) answer:**
```
20LIF.¥>¨
```
0-indexed
[Try it online](https://tio.run/##yy9OTMpM/f/fyMDH003v0FK7Qyv@/zcBAA) or [verify all test cases](https://tio.run/##yy9OTMpM/W9k4OZnr6TwqG2SgpI9kOfj56Z3aKndoRX/a/UObdX5DwA).
**Explanation:**
```
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, the result-list is output implicitly)
```
[Answer]
# Ruby, 74 bytes
`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}`
Ungolfed version:
```
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
```
Quite resource-intensive--the online version can't calculate the 13th metasequence.
[Try it online](https://rextester.com/NGR10964)
[Answer]
# JavaScript (ES6), ~~68~~ 67 bytes
```
f=(n,a=[...f+f])=>n--?f(n,[s=1,...a.map(x=>s-=~--x)]):a.slice(0,20)
```
[Try it online!](https://tio.run/##Dc7LCsIwEIXhvU8xC6EZTIamInghdeUTuCwFh9rUSk1KE6Qg@uo1i58D3@o8@c2hmfoxKufv7bJYI5xkUxGR3dgaTemUOtuEVTBaJmZ68ShmUwZlfkrNWOORKQx904pcFjkup0pL2ErYSdBp9D51kFDkKV2T9dOFm4dwYMoVQONd8ENLg@/ELRmsP46iv8apd53QOdLI92vkKYoCv0e4wQbSH6Sn753IZIa4wuUP "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 63 bytes
NB: this version works for \$n\le20\$.
```
f=(n,a=[...Array(20-n)])=>n--?f(n,[s=1,...a.map(x=>s+=x||1)]):a
```
[Try it online!](https://tio.run/##DY1BCsIwEADvvmIPQhNMFmPxUknFgy/wWASX1taWuilJkIr69prrzMAM9KJQ@36Kml1zX5bWClZkK0Q8eU9vsdtqlldpS9b62CZZBWtU0oRPmsRsy7Cx8/drUlTQcqiMglzBXoHJr9g6f6b6IRhsuQKoHQc33nF0nbglBusPY3SX6HvuhNlKnKi5RPJR7OSvgBtsID0lDq5nkalMypVc/g "JavaScript (Node.js) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 24 bytes
```
<:(1+/\@,])^:[(1+i.20)"_
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/baw0DLX1Yxx0YjXjrKKB7Ew9IwNNpfj/mlypyRn5CmkKhjCGMVzE@D8A "J – Try It Online")
NOTE: Turns out this is a translation of dzaima's APL answer, though I actually didn't notice it before writing this.
## explanation
```
<: (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
```
[Answer]
# Ruby, 49 bytes
```
f=->n{n<1?[1]*20:[o=1]+f[n-1][0,19].map{|x|o+=x}}
```
Recursive definition: Tier 0 is `1,1,1,1...` and each subsequent tier is 1 followed by a sequence whose first differences are the previous tier. Annoyingly this would give me 21 values if I didn't explicitly slice out the first 20; seems like there should be a way to shorten this by avoiding that.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 120 bytes
```
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;}
```
[Try it online!](https://tio.run/##JY1BDsIgEEWv4pKREqHLDkPjDbwCISKTCE0Ku8azI9XdT97L@6GqULnfQ@OtWC7NtWdt1Au5I267eG/ldWFSZkqkp0wapWQ7a3zsQxZszWqWBHC6mYaD2VJBSJKiYLiJKDJcx1RZSgD89eI/64Gcd2b1g3tlYDH46Xj@i1kD9i8 "C# (Visual C# Interactive Compiler) – Try It Online")
Based off of alephalpha's formula.
[Answer]
# Perl 5, 48 bytes
```
$x=1,@A=(1,map$x+=$_,@A[0..18])for 0..$_;$_="@A"
```
[TIO](https://tio.run/##K0gtyjH9n1vp4Gj9X6XC1lDHwdFWw1AnN7FApULbViUeyI820NMztIjVTMsvUgAyVeKtVeJtlRwclf7/N@Yy5DLlMjT@l19QkpmfV/xftyAHAA)
[Answer]
## R (60 59 bytes)
```
function(n)Reduce(function(p,q)2*p-choose(q-1,n),1:19,1,,1)
```
[Online demo](https://tio.run/##K/pfbKP7P600L7kkMz9PI08zKDWlNDlVAy5SoFOoaaRVoJuckZ9fnKpRqGuok6epY2hlaKljqKNjqPm/WMNU8z8A)
Straightforward implementation of the observation
> 
> T(n,k) = 2 T(n-1,k) - binomial(n-1,k). - M. F. Hasler, May 30 2010
> 
> 
> 
from OEIS [A008949](//oeis.org/A008949). The arguments to `Reduce` are the function (obviously), the array over which to map, the starting value, a falsy value (to fold from the left rather than the right), and a truthy value to accumulate the intermediate results in an array.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 17 bytes
-1 byte thanks to ngn (switching from 0-indexed to 1-indexed)
```
{x(+\1,19#)/20#1}
```
[Try it online!](https://tio.run/##y9bNz/7/P82qukJDO8ZQx9BSWVPfyEDZsPZ/mrqhtqLpfwA "K (oK) – Try It Online")
1-indexed
# [K (oK)](https://github.com/JohnEarnest/ok), 18 bytes
```
{x(+\1,19#)/1+!20}
```
[Try it online!](https://tio.run/##y9bNz/7/P82qukJDO8ZQx9BSWVPfUFvRyKD2f5q6oul/AA "K (oK) – Try It Online")
0-indexed
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
20RṖ1;ÄƲ⁸¡
```
[Try it online!](https://tio.run/##AR0A4v9qZWxsef//MjBS4bmWMTvDhMay4oG4wqH///8xOQ "Jelly – Try It Online")
0-indexed.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 15 bytes
0-indexed; replace `h` with `p` for 1-indexed.
```
ÈîXi1 å+}gNh20õ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=yO5YaTEg5St9Z05oMjD1&input=Mg==)
[Answer]
## CJam (20 bytes)
```
1aK*{1\{1$+}/;]}q~*p
```
[Online demo](http://cjam.aditsu.net/#code=1aK*%7B1%5C%7B1%24%2B%7D%2F%3B%5D%7Dq~*p&input=5). This is a program which takes input from stdin and prints to stdout; for the same score an anonymous block (function) can be obtained as
```
{1aK*{1\{1$+}/;]}@*}
```
### Dissection
This applies the definition literally:
```
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
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `R`, 7 bytes
```
20⁰(ÞR›
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJSIiwiIiwiMjDigbAow55S4oC6IiwiIiwiNCJd)
0-indexed.
## How?
```
20⁰(ÞR›
20      # Push number 20
  ⁰(    # Loop input times
    ÞR  # Take the cumulative sum of list (20, R flag makes this a [1, 20] range), remove last item, and prepend 0. Short for ¦Ṫ0p
      › # Increment (implicit vectorization)
```
# [Vyxal](https://github.com/Vyxal/Vyxal) `RM`, 7 bytes
```
19ƛ⁰ʀƈ∑
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJSTSIsIiIsIjE5xpvigbDKgMaI4oiRIiwiIiwiNCJd)
1-indexed.
## How?
```
19ƛ⁰ʀƈ∑
19      # Push the number 19
  ƛ     # Map, R and M flags make this be a [0, 19] range
   ⁰ʀ   # Inclusive zero range of input
     ƈ  # Binomial coefficient, implicit vectorization
      ∑ # Sum these binomimal coefficients
```
]