Lý lịch

Đối với thử thách này, một 'siêu dữ liệu' sẽ được định nghĩa là một chuỗi các số trong đó không chỉ bản thân các số sẽ tăng mà còn cả số gia tăng và số gia sẽ tăng theo giá trị tăng, v.v.

Chẳng hạn, siêu dữ liệu cấp 3 sẽ bắt đầu như sau:

1 2 4 8 15 26 42 64 93 130 176

bởi vì:

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

Thử thách

Cho một số nguyên dương, xuất ra hai mươi mục đầu tiên của siêu dữ liệu của tầng đó.

Các trường hợp thử nghiệm

Đầu vào: 3Đầu ra:[ 1, 2, 4, 8, 15, 26, 42, 64, 93, 130, 176, 232, 299, 378, 470, 576, 697, 834, 988, 1160 ]

Đầu vào: 1Đầu ra:[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]

Đầu vào: 5Đầu ra:[ 1, 2, 4, 8, 16, 32, 63, 120, 219, 382, 638, 1024, 1586, 2380, 3473, 4944, 6885, 9402, 12616, 16664 ]

Đầu vào: 13Đầu ra:[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16383, 32752, 65399, 130238, 258096, 507624 ]

Như bạn có thể nhận ra, các mục $t+1$ đầu tiên của mỗi chuỗi bậc là sức mạnh đầu tiên của 2 ...$t$$t+1$

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng

Thạch , 8 7 byte

20ḶcþŻS

Hãy thử trực tuyến!

   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, …]

Đây sử dụng @ cái nhìn sâu sắc alephalpha rằng

Ngôn ngữ Wolfram (Mathicala) , 34 byte

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

Hãy thử trực tuyến!

Siêu dữ liệu tier $n$ là tổng của các phần tử $n+1$ đầu tiên của mỗi hàng của tam giác Pascal.

Haskell , 34 byte

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

Sử dụng đầu vào 0 chỉ mục ( f 4trả về tầng 5.)

Haskell , 36 byte

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

Hãy thử trực tuyến! Sử dụng đầu vào 1 chỉ mục ( f 5trả về tầng 5.)

Giải trình

scanl (+) 1là một hàm lấy tổng một phần của danh sách, bắt đầu từ (và trả trước) 1.

Ví dụ: scanl (+) 1 [20,300,4000]bằng [1,21,321,4321].

Hóa ra tier $n$ chỉ là chức năng này được áp dụng $(n-1)$ lần cho danh sách $[1,2,3,\dots]$ .

(Hoặc tương đương: $n$ lần vào danh sách tất cả những người.)

Chúng tôi sử dụng inithoặc [1..20-n]để tính đến danh sách dài hơn $1$ mỗi ứng dụng.

Brain-Flak , 84 82 byte

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

Hãy thử trực tuyến!

Chú thích

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

Hãy thử trực tuyến!

R , 36 byte

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

Hãy thử trực tuyến!

Cảm ơn @Giuseppe đã gợi ý outer.

Điều này dựa trên cách tiếp cận @alephalpha được mô tả

Python 2 , 69 58 55 byte

Lưu byte nhờ vào ovs và Jo King ; Ngoài ra, nó cũng hoạt động trong Python 3.

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

Hãy thử trực tuyến!

Toán

Đặt $a(t,n)$ là số hạng $n^{th}$ (0-index) của chuỗi ở tầng $t$ . Một phân tích nhỏ dẫn đến công thức tái phát sau đây:

Làm việc ngược, chúng tôi xác định $a(0,n) = 1$ và $a(-1,n) = 0$ cho tất cả $n$ . Những định nghĩa sẽ đơn giản hóa trường hợp cơ sở của chúng tôi.

Mật mã

Chúng tôi xác định một hàm m(t)trả về 20 phần tử đầu tiên của chuỗi tại tier t. Nếu tkhông âm, chúng tôi sử dụng công thức đệ quy ở trên; nếu tcó -1, chúng tôi trả về một danh sách trống. Danh sách trống hoạt động như một trường hợp cơ sở vì kết quả của mỗi cuộc gọi đệ quy được cắt ( [:n]) và sau đó được tóm tắt. Cắt một danh sách trống cung cấp một danh sách trống và tổng hợp một danh sách trống cung cấp 0. Đó chính là kết quả chúng tôi muốn, vì tầng $-1$ nên cư xử như một chuỗi liên tục của tất cả các $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)

REPL / APL , 14 byte

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

Hãy thử trực tuyến!

(+\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 byte

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

Hãy thử trực tuyến!

Pari / GP , 40 byte

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

Hãy thử trực tuyến!

Hàm tạo của siêu dữ liệu tier $n$ là:

Perl 6 , 34 32 byte

-2 byte nhờ Jo King

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

Hãy thử trực tuyến!

Giải trình

{                              }  # 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 (tiền phát hành) , 62 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Bản demo trực tuyến . Điều này sử dụng chức năng beta không đầy đủ thường xuyên , cung cấp hàm phân phối tích lũy của nhị thức, và do đó chỉ cần một chút tỷ lệ để đưa ra một phần các hàng của tam giác Pascal.

Octave ( 66 46 byte)

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

Bản demo trực tuyến . Chính xác là cùng một khái niệm, nhưng hơi xấu bởi vì betainc, không giống như Rpbeta , yêu cầu các đối số thứ hai và thứ ba phải lớn hơn 0.

Rất cám ơn Giuseppe đã giúp tôi vẽ ra những thứ này, với khoản tiết kiệm đáng kể.

Ruby, 74 byte

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}

Phiên bản bị đánh cắp:

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

Khá tốn tài nguyên - phiên bản trực tuyến không thể tính được siêu dữ liệu thứ 13.

Dùng thử trực tuyến

Ngôn ngữ Wolfram (Mathicala) , 42 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 58 byte

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

Hãy thử trực tuyến!

05AB1E , 11 9 byte

20LIF.¥>¨

Chỉ số 0

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Đệ quy Reducevới +, init=1và accumulation=TRUEđể tránh phải tập hợp con. Cảm ơn tội phạm hình sự gợi ý cách tiếp cận đệ quy!

JavaScript (ES6),  68  67 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 63 byte

$n\le20$

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

Hãy thử trực tuyến!

J , 24 byte

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

Hãy thử trực tuyến!

LƯU Ý: Hóa ra đây là bản dịch câu trả lời APL của dzaima, mặc dù tôi thực sự không nhận thấy nó trước khi viết nó.

giải trình

<: (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 byte

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

Định nghĩa đệ quy: Cấp 0 là 1,1,1,1...và mỗi tầng tiếp theo là 1 theo sau là một chuỗi có sự khác biệt đầu tiên là tầng trước. Khó chịu điều này sẽ mang lại cho tôi 21 giá trị nếu tôi không cắt ra rõ ràng 20 giá trị đầu tiên; có vẻ như nên có một cách để rút ngắn điều này bằng cách tránh điều đó.

Võng mạc , 59 byte

.+
19*$(_,

Thay thế đầu vào bằng 19 1s (đơn nguyên). (Giá trị thứ 20 là 0 vì nó luôn bị xóa bởi lần đầu tiên đi qua vòng lặp.)

"$+"{`
)`

Lặp lại vòng lặp số lần nhập ban đầu của thời gian.

(.+),_*
_,$1

Loại bỏ phần tử cuối cùng và tiền tố a 1.

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

Tính tổng tích lũy.

_+
$.&

Chuyển đổi thành số thập phân.

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 120 byte

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;}

Hãy thử trực tuyến!

Dựa trên công thức của alephalpha.

Rust , 135 byte

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()}

đã sử dụng ý tưởng của @alephalpha, giống như một số người khác. không có giai thừa dựng sẵn để chiếm ít nhất 36 byte, (cộng với xử lý các phủ định). không có nội dung chọn, 16 byte khác. iterator-> loại vectơ khai báo, 20 byte .. vv

Ungolfed tại play.rust-lang.org

R ( 60 59 byte)

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

Bản demo trực tuyến

Thực hiện đơn giản việc quan sát

T (n, k) = 2 T (n-1, k) - nhị thức (n-1, k). - MF Hasler, ngày 30 tháng 5 năm 2010

từ OEIS A008949 . Các đối số Reducelà hàm (rõ ràng), mảng cần ánh xạ, giá trị bắt đầu, giá trị giả (để gấp từ bên trái thay vì bên phải) và giá trị trung thực để tích lũy kết quả trung gian trong một mảng.

K (oK) , 17 byte

-1 byte nhờ ngn (chuyển từ 0-index sang 1-index)

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

Hãy thử trực tuyến!

1 chỉ mục

K (oK) , 18 byte

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

Hãy thử trực tuyến!

Chỉ số 0

Thạch , 10 byte

20RṖ1;ÄƲ⁸¡

Hãy thử trực tuyến!

Chỉ số 0.

Perl 5, 48 byte

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

TIO

Japt , 15 byte

Chỉ số 0; thay thế hvới p1-lập chỉ mục.

ÈîXi1 å+}gNh20õ

Thử nó

CJam (20 byte)

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

Bản demo trực tuyến . Đây là một chương trình lấy đầu vào từ stdin và in ra thiết bị xuất chuẩn; với cùng số điểm, một khối ẩn danh (hàm) có thể được lấy là

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

Mổ xẻ

Điều này áp dụng định nghĩa theo nghĩa đen:

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