พื้นหลัง

สำหรับความท้าทายนี้ 'metasequence' จะถูกกำหนดเป็นลำดับของตัวเลขที่ไม่เพียง แต่ตัวเลขจะเพิ่มขึ้น แต่ยังเพิ่มขึ้นและการเพิ่มขึ้นจะเพิ่มขึ้นตามมูลค่าที่เพิ่มขึ้น ฯลฯ

ตัวอย่างเช่น metasequence ระดับ 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 <-|

ท้าทาย

รับจำนวนเต็มบวกเอาท์พุทยี่สิบรายการแรกของ metasequence ของระดับนั้น

กรณีทดสอบ

อินพุต: 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$$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,#}&

ลองออนไลน์!

metasequence ระดับคือผลรวมขององค์ประกอบแรกของแต่ละแถวของสามเหลี่ยม Pascal$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เป็นฟังก์ชั่นที่ใช้ผลรวมบางส่วนของรายการที่เริ่มต้นจาก (และ 1prepending)

ตัวอย่างเช่น: เท่ากับscanl (+) 1 [20,300,4000][1,21,321,4321]

แต่กลับกลายเป็นชั้นที่เป็นเพียงฟังก์ชั่นนี้นำไปใช้ครั้งในรายการdots]$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 อธิบาย

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$

ทำงานไปข้างหลังเรากำหนดและสำหรับทุกnคำจำกัดความเหล่านี้จะทำให้กรณีพื้นฐานของเราง่ายขึ้น$a(0,n) = 1$$a(-1,n) = 0$$n$

รหัส

เรากำหนดฟังก์ชั่นm(t)ที่ส่งกลับ 20 tองค์ประกอบแรกของลำดับที่ชั้น หากtไม่ใช่ค่าลบเราจะใช้สูตรเรียกซ้ำด้านบน ถ้าtเป็น-1เรากลับรายการที่ว่างเปล่า รายการที่ว่างทำงานเป็นกรณีฐานเนื่องจากผลลัพธ์ของการโทรซ้ำแต่ละครั้งจะถูกแบ่งเป็น ( [:n]) แล้วรวม 0หั่นรายการที่ว่างเปล่าให้รายการที่ว่างเปล่าและข้อสรุปรายการที่ว่างเปล่าให้ นั่นคือผลที่เราต้องการตั้งแต่ชั้นควรทำตัวเหมือนลำดับอย่างต่อเนื่องของทั้งหมด 's$-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))

ลองออนไลน์!

ฟังก์ชั่นการสร้างของmetasequence ระดับคือ:$n$

Perl 6 , 34 32 ไบต์

-2 ไบต์ขอบคุณ Jo King

{(@,{[\+] 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)

สาธิตออนไลน์ แนวคิดเดียวกันแน่นอน แต่น่าเกลียดเล็กน้อยเพราะbetaincต่างจาก R pbetaต้องใช้อาร์กิวเมนต์ที่สองและสามให้มากกว่าศูนย์

ต้องขอขอบคุณGiuseppe ที่ช่วยให้ฉันใช้เวกเตอร์เหล่านี้ได้อย่างประหยัด

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

ใช้ทรัพยากรค่อนข้างมาก - เวอร์ชั่นออนไลน์ไม่สามารถคำนวณ metasequence ที่ 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)

ลองออนไลน์!

มันเป็นเรื่องธรรมดาที่จะเขียนสูตรเรียกซ้ำตามคำอธิบายในคำถาม และคุณต้องสร้างอาร์เรย์จำนวน 20 องค์ประกอบด้วย

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เพื่อหลีกเลี่ยงการเซต ขอบคุณCrulally 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$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)"_

ลองออนไลน์!

หมายเหตุ: ปรากฎว่านี่เป็นคำแปลของคำตอบ APL ของ dzaima ถึงแม้ว่าฉันจะไม่ได้สังเกตเห็นมันก่อนที่จะเขียนสิ่งนี้

คำอธิบาย

<: (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 ไบต์

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

นิยามแบบเรียกซ้ำ: ระดับ 0 คือ1,1,1,1...และแต่ละลำดับชั้นคือ 1 ตามด้วยลำดับที่มีความแตกต่างแรกคือระดับก่อนหน้า น่ารำคาญนี้จะให้ 21 ค่าถ้าฉันไม่ได้ตัดออก 20 แรกอย่างชัดเจน; ดูเหมือนว่าควรมีวิธีที่จะย่อให้สั้นลงโดยหลีกเลี่ยงสิ่งนั้น

เรติน่า 59 ไบต์

.+
19*$(_,

แทนที่อินพุตด้วย 19 1วินาที (เป็นนารี) (ค่าที่ 20 คือ 0 เพราะจะถูกลบโดยการผ่านครั้งแรกผ่านลูปเสมอ)

"$+"{`
)`

วนซ้ำอินพุตจำนวนครั้งเดิม

(.+),_*
_,$1

1นำองค์ประกอบสุดท้ายและคำนำหน้า

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

คำนวณผลรวมสะสม

_+
$.&

แปลงเป็นทศนิยม

ลองออนไลน์!

C # (Visual C # Interactive คอมไพเลอร์) , 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 ไบต์ iterator-> ประเภทเวกเตอร์ที่ประกาศ 20 ไบต์ ฯลฯ ฯลฯ

Ungolfed ที่ 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 Hasler, 30 พฤษภาคม 2010

จาก OEIS A008949 ข้อโต้แย้งที่Reduceเป็นฟังก์ชั่น (ชัด), อาร์เรย์ที่จะแมป, ค่าเริ่มต้น, ค่าที่ไม่แน่นอน (เพื่อพับจากด้านซ้ายมากกว่าด้านขวา), และค่าความจริงเพื่อสะสมผลลัพธ์ระดับกลางในอาร์เรย์

K (oK) , 17 ไบต์

-1 ไบต์ด้วย ngn (เปลี่ยนจาก 0-indexed เป็น 1-indexed)

{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ด้วยpสำหรับการจัดทำดัชนี 1

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