背景

对于此挑战，“元序列”将被定义为一系列数字，其中不仅数字本身会增加，而且增量也会增加，并且增量将增加值，依此类推。

例如，第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$ $t+1$

规则

适用标准漏洞
这是代码高尔夫球，因此最短答案以字节为单位

— 格扎·克雷塞尼（Geza Kerecsenyi）
source

2

我假设您是指20个字词，而不是数字？

— Quintec

4

顺便说一句，第三层元序列

— 无知的体现

6

您可能需要澄清解决方案是否必须适用于输入20或更大的值。

— FryAmTheEggman

4

我们是否可以选择0索引（因此，输入的输出层为1，输入的输出层为02 1，等等）？

— 林恩

1

@ MilkyWay90，您的意思不是很清楚：219（从5级开始）仅在Pascal三角形中以和。

(\binom{219}{1})

$\binom{219}{1}$

(\binom{219}{218})

$\binom{219}{218}$

— 彼得·泰勒

8

果冻，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的见解，即

{meta-sequence}_{n} (i) = \sum_{k = 0}^{n} (\binom{i}{k}) .

$\text{meta-sequence}_n(i) = \sum_{k=0}^n \binom ik.$

— 林恩
source

那简直是残酷的。太棒了

— 唐明亮

22

Wolfram语言（Mathematica），34个字节

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

在线尝试！

该层元序列是所述第一总和帕斯卡三角形的每个行的元素。 $n$ $n+1$

— Alephalpha
source

1

几乎有内置功能，但不幸的是它更长。

— 彼得·泰勒

1

我不知道足够的WL在其中做任何有用的事情，但是在我看来，

T (n, k) = {\begin{cases} 1 & if k = 0 \\ 2 T (n, k - 1) - (\binom{k - 1}{n}) & otherwise \end{cases}

$T(n,k) = \begin{cases}1 & \textrm{if }k=0 \\ 2T(n,k-1) - \binom{k-1}{n} & \textrm{otherwise}\end{cases}$

— 彼得·泰勒

17

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是一个函数，它从（开始）开始并接受列表的部分和1。

例如：scanl (+) 1 [20,300,4000]equals [1,21,321,4321]。

事实证明，层 $n$ 只是这个函数应用于 $(n-1)$ 次到列表 $[1,2,3,\dots]$ 。

（或等效地： $n$ 次所有列表。）

我们使用init或[1..20-n]来考虑每个应用程序将列表加长 $1$ 。

— 林恩
source

1

[1..20-n]不会为

n > 20

$n > 20$

— 彼得·泰勒

take 20.(iterate(scanl(+)1)[1..]!!)只需花费一个字节即可解决

— H.PWiz

1

使用其他答案：，您的无意义答案可以恢复为34个字节(iterate(init.scanl(+)1)[1..20]!!)。

— xnor

7

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

在线尝试！

— 小麦巫师
source

3

您知道这比Rust短是很有趣的

— 唐明亮

7

R，36个字节

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

在线尝试！

感谢@Giuseppe的建议outer。

这基于@alephalpha描述的方法

— 尼克·肯尼迪
source

您也许可以Map代替外部使用？

— JDL

@JDL我看不到它如何工作。我需要所有可能的组合，而不仅仅是组合对。

— 尼克·肯尼迪

5

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

在线尝试！

数学

让 $a(t,n)$ 是 $n^{th}$ 在层中的序列的术语（0索引） $t$ 。稍作分析便得出以下重复公式：

a (t, n) = 1 + \sum_{i = 0}^{n - 1} a (t - 1, i)

$a(t,n) = 1+\sum_{i=0}^{n-1}a(t-1,i)$

向后工作，我们为所有定义 $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)

— DLosc
source

61字节作为递归lambda函数（效率明显低得多）。

— ovs

@ovs谢谢！我也通过使用不同的基本情况找到了更多的字节。

— DLosc

:(好的方法太长了

— 仅限ASCII

1

(t>=0)*range(20)保存一个字节，尽管可能有一个更短的表达式。

— xnor

1

if~t在@xnor上节省了两个多

— Jo King

4

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

— 宰马
source

-1字节使用dzaima / APL：1∘,→1,

— ADAM

@Adámoh duh .. right

— dzaima

17时的完整节目：(≢↑(+\1∘,)⍣⎕)20⍴1

— 阿达姆

通过使用REPL（添加-s标志）获得14个字节。

— ，Outgolfer的埃里克（Erik）

如果使用该标志，语言将变为-sbtw（除非-s是repl标志？）

— 仅ASCII的

3

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$

\sum_{一世 = 0}^{ñ} \frac{X^{一世}}{（ 1个 - X ）^{一世 + 1个}} = \frac{1个 - {（ \frac{X}{1个 - X} ）}^{1个 + ñ}}{1个 - 2 X}

$\sum_{i=0}^n\frac{x^i}{(1-x)^{i+1}}=\frac{1-\left(\frac{x}{1-x}\right)^{1+n}}{1-2x}$

— Alephalpha
source

3

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

— 恩韦恩霍夫
source

29个字节（$^a不是$_必需的）

— Jo King

1

@JoKing Nice，但这假定$_在调用函数时未定义。我更喜欢不依赖于全局变量状态的解决方案。

— nwellnhof

3

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)

— ovs
source

3

R（63 47字节）

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

在线演示。这使用了正则化的不完全beta函数，该函数提供了二项式的累积分布函数，因此只需要一点缩放即可给出Pascal三角形行的部分和。

八度（66 46字节）

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

在线演示。完全相同的概念，但略显丑陋，因为betainc与R不同pbeta，它要求第二个和第三个自变量大于零。

非常感谢 Giuseppe帮助我将这些向量矢量化，并节省了大量资金。

— 彼得·泰勒
source

2

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

相当耗费资源-在线版本无法计算第13个元序列。

在线尝试

— CG一手
source

2

Wolfram语言（Mathematica），42个字节

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

在线尝试！

— 报废
source

2

JavaScript（Node.js），58字节

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

在线尝试！

如果问题根据以下描述写下递归公式是很简单的

G （ Ť ， 一世 ） = {\begin{cases} G （ Ť ， 一世 - 1个 ） + G （ Ť - 1个 ， 一世 - 1个 ） & 如果 一世 \cdot Ť > 0 \\ 1个 & 如果 一世 \cdot Ť = 0 \end{cases}

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

[g (t, 0) \dots g (t, 19)]

$[g(t,0)\dots g(t,19)]$

— tsh
source

2

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)

— 凯文·克鲁伊森
source

1

很好用.¥！

— Emigna

2

R，59 49字节

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

在线尝试！

递归地Reduce使用+，init=1并accumulation=TRUE避免子集化。感谢刑事粗俗建议递归方法！

— 朱塞佩
source

蒂奥这仅仅是39个字节（使用二项式方法）

— 尼克肯尼迪

@NickKennedy这是一个独立的方法，所以我建议你自己发布它，它的golfier使用outer比sapply为36个字节

— 朱塞佩

1

将这种方法转换为递归函数可以得到53个字节（我认为在递归中我们需要包含赋值吗？如果不包含，则为

— CrimelyVulgar

1

@CriminallyVulgar，我们可以获取49个字节:-)

— 朱塞佩

@Giuseppe哈哈我知道它可以打高尔夫球，只是看不见！我花cumsum了一段时间尝试使它工作，但是那Reduce太光滑了。很高兴能够将索引也降低1，但在评论中却没有看到。

— 刑事

1

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\le20$

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

在线尝试！

— Arnauld
source

1

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

— 约拿
source

1

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，后跟一个序列，其第一个差异是前一层。令人讨厌的是，如果我没有明确地分割掉前20个值，它将给我21个值。似乎应该有一种避免这种情况的方法来缩短这种情况。

— 历史学家
source

tio.run/#ruby pls

— 仅限ASCII

也49

— 仅限ASCII

46

— 仅限ASCII

1

视网膜，59字节

.+
19*$(_,

用19 1s 替换输入（一元）。（第20个值为0，因为它总是在循环的第一遍被删除。）

"$+"{`
)`

将循环重复原始输入次数。

(.+),_*
_,$1

删除最后一个元素，并在前缀上1。

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

计算累计和。

_+
$.&

转换为十进制。

在线尝试！

— 尼尔
source

1

C＃（Visual C＃交互式编译器），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的公式。

— 无知的体现
source

1

锈，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上取消投放

— 唐明亮
source

1

有一种更好的方法可以以相同的成本计算二项式系数，但可以删除min：

fn t(m:i64)->Vec<i64>{let b=|n,k|(1..=k).fold(1,|a,j|a*(n-j+1)/j);(0..20).map(|i|(0..=m).fold(0,|a,x|a+b(i,x))).collect()}

（122字节）

— Peter Taylor

1

实际上，二项式可以内联：fn t(m:i64)->Vec<i64>{(0..20).map(|i|(0..=m).fold(0,|a,x|a+(1..=x).fold(1,|a,j|a*(i-j+1)/j))).collect()}（104字节）。最好将这两个折叠结合起来，但是我不确定元组的简洁程度。

— 彼得·泰勒

1

足够简洁：fn t(m:i64)->Vec<i64>{(0..20).map(|i|(0..=m).fold((0,1),|a,b|(a.0+a.1,a.1*(b-i)/!b)).0).collect()}（98个字节）

— Peter Taylor

真是太神奇了……我什至都无法理解它是如何工作的，但是它却非常了不起。

— 不要明亮的

\frac{ñ ！}{ķ ！ （ ñ - ķ ） ！} = \frac{ñ ！}{（ ķ - 1个 ） ！ （ ñ - （ ķ - 1个 ） ） ！} \times \frac{ñ - ķ + 1个}{ķ}

$\frac{n!}{k!(n-k)!} = \frac{n!}{(k-1)!(n-(k-1))!} \times \frac{n-k+1}{k}$

1

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是函数（很明显），要映射到的数组，起始值，错误值（从左侧而不是右侧折叠）和真实值以在数组中累积中间结果。

— 彼得·泰勒
source

1

K（oK），17个字节

-1字节归功于ngn（从0索引切换到1索引）

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

在线尝试！

1索引

K（oK），18个字节

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

在线尝试！

0索引

— 加伦·伊万诺夫（Galen Ivanov）
source

1

将其1+!2020#1

— 设为

@ngn谢谢，和往常一样，我错过了一些事情:)

— Galen Ivanov

0

果冻，10字节

20RṖ1;ÄƲ⁸¡

在线尝试！

0索引。

— 暴民埃里克
source

0

Perl 5，48个字节

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

蒂奥

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

0

Japt，15个字节

0索引；替换h用p1索引。

ÈîXi1 å+}gNh20õ

试试吧

— 毛茸茸
source

0

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

— 彼得·泰勒
source

让我变元

背景

挑战

测试用例

规则

果冻，8 7字节

Wolfram语言（Mathematica），34个字节

Haskell，34个字节

Haskell，36个字节

说明

Brain-Flak，84 82字节

带注释

R，36个字节

Python 2中，69个 58 55字节

数学

代码

dzaima / APL REPL，14个字节

Pari / GP，39个字节

Pari / GP，40字节

Perl 6的，34 32个字节

说明

Python 3.8（预发布），62字节

说明

R（63 47字节）

八度（66 46字节）

Ruby，74个字节

Wolfram语言（Mathematica），42个字节

JavaScript（Node.js），58字节

05AB1E，11 9 字节

R，59 49字节

JavaScript（ES6）， 68 67字节

JavaScript（ES6），63个字节

J，24个字节

说明

Ruby，49个字节

视网膜，59字节

C＃（Visual C＃交互式编译器），120字节

锈，135字节

R（60 59字节）

K（oK），17个字节

K（oK），18个字节

果冻，10字节

Perl 5，48个字节

Japt，15个字节

CJam（20字节）

解剖