배경

이 도전에서 '메타 시퀀스'는 숫자 자체뿐만 아니라 증가 할뿐만 아니라 증가하는 값의 순서로 증가하는 숫자의 시퀀스로 정의됩니다.

예를 들어, 계층 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 ]

알다시피, 각 계층 시퀀스의 첫 번째 항목 은 2 의 첫 번째 t + 1 거듭 제곱입니다.$t+1$$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 Language (Mathematica) , 34 바이트

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

온라인으로 사용해보십시오!

계층 메타 시퀀스는 파스칼 삼각형의 각 행의 첫 번째 요소의 합입니다 .$n$$n+1$

하스켈 , 34 바이트

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

인덱스가 0 인 입력을 사용합니다 ( f 45 단계를 반환합니다).

하스켈 , 36 바이트

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

온라인으로 사용해보십시오! 1 인덱싱 된 입력을 사용합니다 ( f 55 단계를 반환합니다)

설명

scanl (+) 1(부터 시작하여) 목록의 부분 합계를 취하는 함수입니다 1.

예를 들어 : scanl (+) 1 [20,300,4000]equals [1,21,321,4321]입니다.

티어 은 리스트 에이 함수를 번 적용한 것 입니다.$n$$(n-1)$$[1,2,3,\dots]$

(또는 동등하게 : 을 모든 것의 목록에 번)$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 설명 된 접근 방식을 기반으로합니다.

파이썬 2 , 69 58 55 바이트

ovs 와 Jo King 덕분에 바이트를 절약했습니다 . 또한 파이썬 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

Pari / GP , 39 바이트

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

온라인으로 사용해보십시오!

Pari / GP , 40 바이트

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

온라인으로 사용해보십시오!

계층 메타 시퀀스 의 생성 기능 은 다음과 같습니다.$n$

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

온라인 데모 . 이것은 사용하는 정규화 불완전 베타 함수 이항의 누적 분포 함수를 제공하고, 따라서 단지 파스칼의 삼각형의 행의 부분합을 수득 스케일링의 비트를 필요.

옥타브 ( 66 46 바이트)

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

온라인 데모 . betaincR과 달리 pbeta두 번째와 세 번째 인수가 0보다 커야 하므로 정확히 같은 개념이지만 약간 더 추악 합니다.

크게 절약하면서 벡터화에 도움을 준 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 Language (Mathematica) , 42 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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 에게 감사드립니다 !

자바 스크립트 (ES6),  68  67 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 63 바이트

NB :이 버전은 작동합니다 .$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*

누적 합계를 계산하십시오.

_+
$.&

십진수로 변환합니다.

온라인으로 사용해보십시오!

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에서 ungolfed

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 Hasler, 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입니다.

펄 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