Фон

Для цього виклику «метанаслідок» буде визначений як послідовність чисел, де збільшуватимуться не тільки самі числа, але й приріст, а приріст збільшуватиметься із збільшенням значення тощо.

Наприклад, мета-наслідок 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 <-|

Виклик

Враховуючи додатне ціле число, виведіть перші двадцять елементів мета-наслідку цього рівня.

Тестові справи

Вхід: 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+1$ пункти кожної послідовності ярусу $t$ є першими $t+1$ потужностями по 2 ...

Правила

• Застосовуються стандартні лазівки
• Це код-гольф , тому найкоротша відповідь у байтах виграє

Желе , 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, що

Мова Вольфрама (Mathematica) , 34 байти

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

Спробуйте в Інтернеті!

Метаслідок ярусу $n$ - це сума перших $n+1$ елементів кожного ряду трикутника Паскаля.

Хаскелл , 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]$ .

(Або еквівалентно: $n$ разів до списку всіх.)

Ми використовуємо initабо [1..20-n]для обліку списку, який збільшується на $1$ додаток.

Мозг-Флак , 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

Пітон 2 , 69 58 55 байт

Збережено байтів завдяки овам та Джо Кінгу ; також він працює і в Python 3.

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

Спробуйте в Інтернеті!

Математика

Нехай $a(t,n)$ - $n^{th}$ член (0-індексований) послідовності на рівні $t$ . Невеликий аналіз призводить до наступної формули рецидиву:

Працюючи назад, ми визначаємо $a(0,n) = 1$ і $a(-1,n) = 0$ для всіх $n$ . Ці визначення спростять наш базовий випадок.

Кодекс

Визначимо функцію, m(t)яка повертає перші 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 bytes

-2 bytes thanks to Jo King

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

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

Python 3.8 (pre-release), 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!

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)

R (63 47 bytes)

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

Online demo. This uses the regularised 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. 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 for helping me to vectorise these, with significant savings.

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

Wolfram Language (Mathematica), 42 bytes

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

Try it online!

JavaScript (Node.js), 58 bytes

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

Try it online!

It is trivial to write down following recursive formula based on the description in question

05AB1E, 11 9 bytes

20LIF.¥>¨

0-indexed

Try it online or verify all test cases.

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, output the result-list implicitly)

R, 59 49 bytes

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

Try it online!

Recursively Reduce with +, init=1 and accumulation=TRUE to avoid having to subset. Thanks to Criminally Vulgar for suggesting the recursive approach!

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!

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!

J, 24 bytes

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

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

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.

Retina, 59 bytes

.+
19*$(_,

Replace the input with 19 1s (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!

C# (Visual C# Interactive Compiler), 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!

Based off of alephalpha's formula.

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

R (60 59 bytes)

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

Online demo

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

K (oK), 17 bytes

-1 byte thanks to ngn (switching from 0-indexed to 1-indexed)

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

Try it online!

1-indexed

K (oK), 18 bytes

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

Try it online!

0-indexed

Jelly, 10 bytes

20RṖ1;ÄƲ⁸¡

Try it online!

0-indexed.

Perl 5, 48 bytes

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

TIO

Japt, 15 bytes

0-indexed; replace h with p for 1-indexed.

ÈîXi1 å+}gNh20õ

Try it

CJam (20 bytes)

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

Online demo. 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