在此挑战中，目标是一次重新创建一个整数序列在线百科全书。与《 Hello World的进化》相似，每个答案都取决于先前的答案。

随着时间的推移，这一挑战将创造出OEIS序列的“家族树”。添加到此树很简单。

1. 查找先前的答案，该答案可以在树的任何深度N处。
2. 确定该答案序列生成的前N个数字。
3. 在OEIS中找到一个序列，该序列以相同的数字开头并且之前从未使用过。
4. 编写一个程序以生成刚刚发现的这个新序列。
5. 将答案提交为深度N + 1

由于答案的级别会影响评分，因此您应该始终将答案添加到树上尽可能深的级别。如果您无法在树上的任何位置放置答案，则可以开始树的新分支并将答案设为深度1。

答案要求

有几种输出序列的方法。

第一种选择是编写一个程序或函数，该程序或函数输入一个数字（从STDIN或作为参数）并按您选择的顺序返回第N个数字。您可以假定将为N定义序列，并且N和S_N的大小“合理”（因此不会引起溢出）。您也可以使用任何合理的索引，例如0索引，1索引或序列的OEIS页面上“偏移量”下列出的索引，都没有关系。第一个索引产生的术语必须与OEIS条目的第一个术语匹配。

第二种选择是编写一个程序或函数，该程序或函数输入一个数字并返回序列的前N个项。输出的第一项必须是OEIS条目的第一项（您不能忽略前几项）。连续术语必须由任意的非数字字符字符串分隔，因此0,1 1.2/3,5;8,11可以，但011235811不计算在内。

第三个选项是创建一个输出连续数字流的程序。与第二个选项类似，连续项之间必须有定界符。

您的答案应包含这样的标头，以帮助Stack Snippet解析：

 # [language], [number] bytes, depth [number], A[new sequence] from A[old sequence] 

您的答案应包含生成序列的代码以及任何后代必须包含的前几个术语。这几个术语之前terms:应加上确切的词，以便控制器可以将它们用作树形图的一部分。还建议您对选择的顺序进行描述。

如果您的帖子是深度1答案，因此没有祖先，则只需from A[number]在标题中省略即可。

这是一个示例答案：

# Perl, 26 bytes, depth 3, A026305 from A084912

    various code here
    and here

The next answer should match the following terms:

    1, 4, 20

This sequence is .... and does ....

链接要求

为了使此挑战更加公平，您可以将答案链接到其上有一些限制。这些规则主要是为了防止一个人自己创建树的整个分支或拥有很多“根”节点。

• 你不能束缚自己。
• 您不能将两个答案直接链接到同一祖先。
• 您不能做出多个“一级”答案。

同样，如果祖先的深度为N，则即使您同意的术语数量超出要求，您的帖子也必须具有深度N + 1。

计分

您作为用户的分数是所有答案分数的总和。单个答案的分数由以下公式确定：

Answer Score = Sqrt(Depth) * 1024 / (Length + 256)

该评分系统应鼓励用户提交大量更深入的答案。较短的答案比较长的答案更可取，但是深度的影响更大。

下面是一个堆栈摘要，可生成一个排行榜以及所有答案的树形图。 我要感谢马丁布特内尔和d3noob的来源很多这样的代码。您应该单击“全屏”以查看完整结果。

function answersUrl(t){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+t+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(t){answers.push.apply(answers,t.items),t.has_more?getAnswers():process()}})}function shouldHaveHeading(t){var e=!1,r=t.body_markdown.split("\n");try{e|=/^#/.test(t.body_markdown),e|=["-","="].indexOf(r[1][0])>-1,e&=LANGUAGE_REG.test(t.body_markdown)}catch(a){}return e}function shouldHaveScore(t){var e=!1;try{e|=SIZE_REG.test(t.body_markdown.split("\n")[0])}catch(r){}return e}function getAuthorName(t){return t.owner.display_name}function decodeEntities(t){return $("<textarea>").html(t).text()}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.reverse();var t={},e=[],r=1,a=null,n=1,s=[];answers.forEach(function(t){var r=t.body_markdown.split("\n")[0],a=getAuthorName(t),n=r.match(SEQUENCE_REG)[0];n=n.trim();var o="from A000000";PARENT_REG.test(r)&&(o=r.match(PARENT_REG)[0]),o=o.substring(5).trim(),"A000000"==o&&(o="OEIS");var i="";SEQDATA_REG.test(t.body_markdown)&&(i=t.body_markdown.match(SEQDATA_REG)[1]);for(var u=!0,c=0;c<e.length;++c)u=u&&!(e[c]===n);for(var l=!0,c=0;c<e.length;++c)l=!(!l||e[c]===n||e[c]===n+a||e[c]===o+a);e.push(n),e.push(n+a),e.push(o+a),u&&data.push({name:n,parent:o,term:i+" : ",author:decodeEntities(a),URL:t.share_link}),l&&s.push(t)}),answers.sort(function(t,e){var r=t.body_markdown.split("\n")[0].match(SEQUENCE_REG),a=e.body_markdown.split("\n")[0].match(SEQUENCE_REG);return a>r?-1:r>a?1:void 0}),answers.forEach(function(e){var o=e.body_markdown.split("\n")[0],i=(o.match(NUMBER_REG)[0],(o.match(SIZE_REG)||[0])[0]),u=parseInt((o.match(DEPTH_REG)||[0])[0]).toString(),c=o.match(SEQUENCE_REG)[0],l="from A000000";PARENT_REG.test(o)&&(l=o.match(PARENT_REG)[0]),l=l.substring(5);var d=o.match(LANGUAGE_REG)[1];d.indexOf("]")>0&&(d=d.substring(1,d.indexOf("]")));for(var p=getAuthorName(e),E=!1,h=0;h<s.length;++h)E=E||s[h]===e;if(E){var f=jQuery("#answer-template").html();i!=a&&(n=r),a=i,++r;var m=1024*Math.pow(parseInt(u),.5)/(parseInt(i)+256);f=f.replace("{{SEQUENCE}}",c).replace("{{SEQUENCE}}",c).replace("{{NAME}}",p).replace("{{LANGUAGE}}",d).replace("{{SIZE}}",i).replace("{{DEPTH}}",u).replace("{{LINK}}",e.share_link),f=jQuery(f),jQuery("#answers").append(f),t[p]=t[p]||{lang:d,user:p,size:"0",numanswers:"0",link:e.share_link},t[p].size=(parseFloat(t[p].size)+m).toString(),t[p].numanswers=(parseInt(t[p].numanswers)+1).toString()}});var o=[];for(var i in t)t.hasOwnProperty(i)&&o.push(t[i]);o.sort(function(t,e){return parseFloat(t.size)>parseFloat(e.size)?-1:parseFloat(t.size)<parseFloat(e.size)?1:0});for(var u=0;u<o.length;++u){var c=jQuery("#language-template").html(),i=o[u];c=c.replace("{{RANK}}",u+1+".").replace("{{NAME}}",i.user).replace("{{NUMANSWERS}}",i.numanswers).replace("{{SIZE}}",i.size),c=jQuery(c),jQuery("#languages").append(c)}createTree()}function createTree(){function t(){var t=i.nodes(root).reverse(),e=i.links(t);t.forEach(function(t){t.y=180*t.depth});var r=c.selectAll("g.node").data(t,function(t){return t.id||(t.id=++o)}),a=r.enter().append("g").attr("class","node").attr("transform",function(t){return"translate("+t.y+","+t.x+")"});a.append("a").attr("xlink:href",function(t){return t.URL}).append("circle").attr("r",10).style("fill","#fff"),a.append("text").attr("x",function(){return 0}).attr("y",function(){return 20}).attr("dy",".35em").attr("text-anchor",function(){return"middle"}).text(function(t){return t.term+t.name}).style("fill-opacity",1),a.append("text").attr("x",function(){return 0}).attr("y",function(){return 35}).attr("dy",".35em").attr("text-anchor",function(){return"middle"}).text(function(t){return t.author}).style("fill-opacity",1);var n=c.selectAll("path.link").data(e,function(t){return t.target.id});n.enter().insert("path","g").attr("class","link").attr("d",u)}var e=data.reduce(function(t,e){return t[e.name]=e,t},{}),r=[];data.forEach(function(t){var a=e[t.parent];a?(a.children||(a.children=[])).push(t):r.push(t)});var a={top:20,right:120,bottom:20,left:120},n=3203-a.right-a.left,s=4003-a.top-a.bottom,o=0,i=d3.layout.tree().size([s,n]),u=d3.svg.diagonal().projection(function(t){return[t.y,t.x]}),c=d3.select("body").append("svg").attr("width",n+a.right+a.left).attr("height",s+a.top+a.bottom).append("g").attr("transform","translate("+a.left+","+a.top+")");root=r[0],t(root)}var QUESTION_ID=49223,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",data=[{name:"OEIS",parent:"null",term:"",author:"",URL:"https://oeis.org/"}],answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*,)/,DEPTH_REG=/\d+, A/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/,SEQUENCE_REG=/A\d+/,PARENT_REG=/from\s*A\d+/,SEQDATA_REG=/terms:\s*(?:(?:-)?\d+,\s*)*((?:-)?\d+)/;

body{text-align: left !important}#answer-list{padding: 10px; width: 550px; float: left;}#language-list{padding: 10px; width: 290px; float: left;}table thead{font-weight: bold;}table td{padding: 5px;}.node circle{fill: #fff; stroke: steelblue; stroke-width: 3px;}.node text{font: 12px sans-serif;}.link{fill: none; stroke: #ccc; stroke-width: 2px;}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script src="http://d3js.org/d3.v3.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Sequence List</h2> <table class="answer-list"> <thead> <tr> <td>Sequence</td><td>Author</td><td>Language</td><td>Size</td><td>Depth</td></tr></thead> <tbody id="answers"></tbody> </table></div><div id="language-list"> <h2>Leaderboard</h2> <table class="language-list"> <thead> <tr> <td>Rank</td><td>User</td><td>Answers</td><td>Score</td></tr></thead> <tbody id="languages"></tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr> <td><a href="https://oeis.org/{{SEQUENCE}}">{{SEQUENCE}}</a></td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td>{{DEPTH}}</td><td><a href="{{LINK}}">Link</a> </td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr> <td>{{RANK}}</td><td>{{NAME}}</td><td>{{NUMANSWERS}}</td><td>{{SIZE}}</td></tr></tbody></table>

括号，150字节，深度4，A000292从A000290

((()()())(()()()())((()())((()(()())))((()(())())((()()(()))(()(()()))((()(()))(()(()()))((())()))((()(()))(()(()()))((())()())))((())()()()()()()))))

下一个答案应符合以下条件：

0, 1, 4, 10

这是四面体数的序列，即三角数的3D概括。公式是

T(n) = n*(n+1)*(n+2)/6

括号是一种类似于Lisp的语言，它使用括号来定义所有内容。上面是一个()()()接受n和输出的功能T(n)。致电方式：

((()()()())((())()()()()()()()))

带注释

(
  define
  (() ()())

  f [][][]
  (() ()()())

  (
    lambda
    (() ())

    (
      n [[][]]
      (() (()()))
    )

    (
      div
      (() (())())

      (
        *
        (() ()(()))

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

          2
          ((()) ()())
        )
      )

      6
      ((()) ()()()()()())
    )
  )
)


Test call:

(
  f
  (() ()()())

  6
  ((()) ()()()()()())
)

煎饼堆，118字节，深度1，A000012

Put this kindercarnavalsoptochtvoorbereidingswerkzaamheden pancake on top!
Show me a pancake!
Eat all of the pancakes!

下一个答案应符合以下条件：

1

这会输出的最小除数n。在esolang Wiki页面上使用Python解释器进行了测试。解释器希望~后面的一行表示程序结束，之后是STDIN输入（无论如何将被忽略）。

相关说明：

Put this <blah> pancake on top!                # Push length of <blah> 
Show me a pancake!                             # Output top of stack as char
Eat all of the pancakes!                       # Terminate the program

上一个答案

Put this  pancake on top!
[]
Put this kindercarnavalsoptochtvoorbereidingswerkzaamheden pancake on top!
Show me a pancake!
Put this delectable pancake on top!
Show me a pancake!
If the pancake is tasty, go over to "".

这是无限循环打印的。附加说明：

[<blah>]                                       # Define the label <blah>
If the pancake is tasty, go over to "<blah>".  # If top of stack nonzero, go to label

还有其他说明，但是即使如此，由于缺少数字输出并且只能访问堆栈的前两个元素，因此Pancake Stack 正常使用起来非常麻烦。

不幸的是，该程序的第一行似乎对于防止与Python解释器中的标签有关的错误很有必要。

Python，31个字节，深度4，来自A000045的A010060

lambda n:sum(map(ord,bin(n)))%2

下一个答案应符合以下条件：

0, 1, 1, 0

这是我的最爱，这是Thue-Morse序列。至少有两个定义：

• n（在上面使用）的二进制扩展中的奇偶校验和
• 序列从0开始，然后重复添加到目前为止的序列的按位补码（即0 -> 01 -> 0110 -> 01101001 -> ...）

关于此序列的许多很酷的事情之一是，如果我们抓住一只乌龟并这样做：

import turtle

turtle.speed(0)
n = 12

# Calculate first 2^n of Thue-Morse
tm = map(lambda n:sum(map(ord,bin(n)))%2, range(2**n)) 

# Move to top left
turtle.penup()
turtle.setx(-300)
turtle.sety(300)
turtle.pendown()

# For each num, go forward a unit if 0, or turn left 120 degrees if 1
for m in tm:
    if m == 0:
        turtle.forward(1)

    elif m == 1:
        turtle.left(120)

turtle.hideturtle()
turtle.mainloop()

我们得到这个：

看起来熟悉？

MarioLANG，265字节，深度3，来自A006370的A016957

                           <
         =================="
               (((+)< ))+(<
              ======" ===="
               >-))+!  >-(!
               "====#  "==#
          >-(>[!))   >[!(  !
          "====#=======#===#
;)++++++>[!))++++:
==========#=======

下一个答案应符合以下条件：

4, 10, 16

序列仅仅是算术级数6n + 4。

MarioLANG是一种深奥的编程语言，它基于Super Mario。以类似于Brainfuck的方式进行计算-有一条可以增加/减少的单元格。

相关的类似BF的命令如下：

+      Increment current memory cell
-      Decrement current memory cell
(      Move memory pointer left
)      Move memory pointer right
;      Numeric input
:      Numeric output
[      Skip next instruction is current cell is zero

那马里奥呢？好吧，马里奥（Mario）是您的指令指针，他从左边开始（在哪里;）。只要Mario在地面上=，他就会一直执行指令，当他跌倒时程序会终止。

有关的说明是：

=      Ground for Mario to stand on
<      Make Mario move leftward
>      Make Mario move rightward
!      Make Mario stop moving
#      Elevator start
"      Elevator end

总而言之，该程序执行以下操作：

Put input (n) in cell 0
Increment cell 1 to 6
While cell 1 is not zero...
    Decrement cell 1
    Move n from cell 0 to cells 2, 3
    Move n from cell 2 to cell 0
Increment cell 3 by 4
Output as num

经过Ruby解释器测试。请注意，该语言具有许多不确定的行为，例如Mario跌倒时遇到的指令发生了什么，因此我尝试避免任何此类行为。

Brainfuck，2字节，深度2，来自A001477的A000030

,.

A000030是非负整数的起始数字的序列，因此这仅读取了第一个数字字符并将其写回。下一个序列应以以下术语开头：

0, 1

Piet，16字节，深度3，从A000030开始的A000035

下一个答案应符合以下条件：

0, 1, 0

这是Piet，因此“字节”实际上是编码。这是更大的编解码器大小：

该程序只需读入n并以n模2 输出。

Marbelous，7个字节，深度3，来自A000027的A011760

自从该站点看到Marbelous答案以来已经有一段时间了！

}0
<D++

下一个答案应以以下术语开头：

1, 2, 3

您可以在es1024的Stack Snippet解释器中尝试代码。输入通过命令行参数给出，您应该选择“将输出显示为十进制数字”。否则，结果将作为字节值输出，从技术上讲也可以。

该顺序是“美国的电梯按钮”的顺序，即除13外的所有正整数。请注意，Marbelous限于8位数字，但据我所知，没有建筑物在256层附近。:)

Marbelous是一种2D语言，其中数据以落在网格上的大理石（字节值）的形式流过代码。}0被第一个命令行参数替换。<D是一个开关，用作小于13的大理石（D位于底座36中）的空单元，因此输入1到12不会受到影响。如果大理石等于或大于13，则大理石向右偏斜并穿过，大理石将使++值增加1。在任何一种情况下，大理石都将从板上掉下来，并打印其值。

导轨，56字节，深度4，来自A002378的A033547

$'main'
 0/aima19-@
@------e<
  /()(!!)-@
@-()m5a()m3do#

下一个答案应符合以下条件：

0, 2, 6, 14

该程序n从STDIN 读取并输出n*(n^2+5)/3，这是对1940年代核壳模型的魔幻数字的猜测。

Rail是一种2D语言，以火车轨道为主题。上面的代码使用@反射器打高尔夫球，该反射器使火车的方向反向，以减少换行符的数量。这里是无高尔夫球的：

$ 'main'
 \
  0
   \ /--aima19--\
    |           |
    \--e-------<
                \
                 \-(!n!)-(n)-(n)-m-5-a-(n)-m-3-d-o-#

请注意Rail是如何从左上角开始并开始垂直向下右移的。

使用的堆栈操作命令为：

0-9       Push 0-9 respectively
e         Push t (true) if EOF, else f (false)
i         Input char
o         Output
a         Add
m         Multiply
(!n!)     Store top of stack as variable n
(n)       Push variable n to stack
#         Halt program

火车在路口处分支，>v<^如果堆栈的顶部为true，则向右转，否则为false。

星空，22字节，深度4，A008142起的A008619

      + + +*,  +   **.

下一个答案应符合以下条件：

1, 1, 2, 2

该序列由重复两次的正整数组成。程序从STDIN读取一个数字并进行计算1 + floor(n/2)。

Starry是用Ruby实现的一种深奥语言，它是关于...用Ruby制作深奥语言的书的一部分。每条指令由之一前的空格数确定+*.,`'。所有其他字符都将被忽略，因此上述等效于

      +
 + +*,
  +   *
*.

看起来更繁星点点！（注意尾随空格）

相关命令为：

Spaces     Final      Instruction
------     -----      -----------
n >= 5     +          Push n-5 to stack
1          +          Duplicate top of stack
0 mod 5    *          Add
0 mod 2    ,          Input num
2          +          Swap top 2
3 mod 5    *          Divide
0 mod 2    .          Output num

上一个答案，53个字节

      +` +.               + + .  + +.  + .      +* +'

而是生成无限序列。一些其他命令是：

Spaces     Final      Instruction
------     -----      -----------
1 mod 2    .          Output as ASCII char
n          `          Mark a label n
n          '          Pop and if nonzero, jump back to label n

Mathematica，20字节，深度6，来自A104631的A037965

Binomial[2#-2,#-1]#&

这是一个未命名的函数，仅计算序列的定义。下一个序列应以以下术语开头：

0, 1, 4, 18, 80, 350

CJam，34字节，深度14，来自A238263的A157271

qi_,_m*{~2@#3@#*}$<::+1f&_:+\1-,e>

下一个答案应以以下术语开头：

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7

但是没有剩下的事情还没有完成。

令其D(n)为前n3个平滑数字的集合：即，其主要因子是的子集的整数{2, 3}。我们S(n)是最大的子集，D(n)它本身不包含窗体的任何子集{x, 2x}或{y, 3y}。那么A157271的大小为S(n)。

Golfscript，3字节，深度3，从A000030开始的A000290

~2?

下一个答案应符合以下条件：

0, 1, 4

该序列只是平方数，因此程序将获取一个数字并输出其平方。

前奏，16字节，深度1，A000211

3(v!  v)
4 ^+2-^

我以为我会以不太明显的初始编号开始一棵树。这是定义一个广义斐波纳契数列a(0) = 4，a(1) = 3，a(n) = a(n-1) + a(n-2) - 2。因此，这主要是我的Prelude Fibonacci解决方案的简单改编。上面是一个打印数字无限流的程序。假定Python解释器输出数字而不是单个字符。

下一个答案应以以下术语开头：

4

剪辑，0字节，深度2，来自A000012的A000027

给定数字n，nth按顺序打印数字1, 2, 3, 4...

下一个答案应以以下术语开头：

1, 2

J，4字节，深度4，来自A000290的A001563

(*!)

下一个答案应符合以下条件：

0, 1, 4, 18

该序列是数字乘以阶乘。在J (fg)x在f(x,g(x))这里x*factorial(x)。

Mathematica，48字节，深度5，来自A001563的A104631

SeriesCoefficient[((x^5-1)/(x-1))^#,{x,0,2#+1}]&

下一个答案应符合以下条件：

0, 1, 4, 18, 80

除非使用长函数名，否则Mathematica绝对会迎接这一挑战。这只是x^(2n+1)扩展中的系数

(1 + x + x^2 + x^3 + x^4)^n

元素，13字节，深度3，A000030从A000030

1_'0[3:~2@+]`

A000045代表斐波那契数。序列中的每一项都是前两项的总和。值得注意的是，连续项之间的比率接近黄金比率，也称为phi。有趣的是，OEIS条目以0, 1而不是common 开头1, 1。下一个答案应符合以下条件：

0, 1, 1

序曲，1字节，深度2，A001477从A001477

!

下一个答案应符合以下条件：

0, 0

该程序将n输入作为输入，完全忽略它，然后输出零常数。它NUMERIC_OUTPUT = True在Python解释器中需要。

Prelude的优点在于，它在堆栈的底部具有无限的零供给，因此所需的只是一个输出命令。

Perl，10个字节，深度为1，A001477

要开始，这是一个简单的序列。

print$_=<>

通过打印输入数字来表示非负数字0、1、2、3等。下一个序列应以以下术语开头：

0

GolfScript，9字节，深度4，来自A002275的A051682

~.9*7-*2/

下一个答案应符合以下条件：

0, 1, 11, 30

这仅使用OEIS页面上的十进制数字公式。

死鱼（Deadfish），4字节，深度2，来自A001477的A005563

isdo

此序列定义为(n+1)^2-1，这正是该程序的作用。由于Deadfish没有输入，因此它假定累加器处于所需的输入编号。下一个答案应以以下术语开头：

0, 3

APL，13字节，深度4，来自A000142，A000108

{(⍵!2×⍵)÷⍵+1}

加泰罗尼亚语的数字！这些索引从零开始。下一个答案应以以下术语开头：

1, 1, 2, 5

GolfScript，31字节，深度11，来自A242681的A029030

~][11.(2]{:C;{{.C-.)0>}do;}%}/,

下一个答案应符合以下条件：

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 7

但却无法：这是树上的叶子。此序列是使用值分别为1、2、10和11的硬币进行找零的方式数目。

视网膜，1字节，深度3，来自A001333的A055642

.

下一个答案应以以下术语开头：

1, 1, 1

我认为这是我第一次在Replace模式之外的其他地方使用Retina。如果仅给出一个没有任何选项的文件，则Retina会采用“匹配”模式，默认情况下会计算输入中给定正则表达式的匹配数。此正则表达式是.并且匹配任何字符。因此，该程序返回输入的位数A055642。

剪辑，24字节，深度4，来自A002275的A049666

/F*5nx5[Fx?<x3O]+F(xF((x

下一个答案应符合以下条件：

0, 1, 11, 122

顺序是Fibonacci(5n)/5。请参阅示例页面以获取解释。

剪辑，37字节，深度5，来自A000292的A227327

[t/m++#t4*2#t3*8#t2?%t2+*2t9]*8t]48]n

在n边的三角形网格上选择两个点的可能方法，不包括旋转和反射。给出的示例是：对于n = 3，有4种方法：

  X        X        X        .
 X .      . .      . .      X X
. . .    X . .    . X .    . . .

下一个序列必须以下列术语开头：

0, 1, 4, 10, 22

APL，24字节，深度6，来自A182712的A025581

{¯1-⍵-2!1+⌊.5+.5*⍨2×1+⍵}

序列A025581是...的序列...我不太确定是诚实的。吓到我了。

索引从0开始，该函数只是根据定义计算序列。

下一个序列应以以下术语开头：

0, 1, 0, 2, 1, 0

> <>，​​25字节，深度2，来自A002522的A001333

301-v >rn;
*2@:<r^!?:-1r+

这些是连续分数收敛到sqrt（2）的分子。该代码需要用户使用应返回的收敛索引来预填充堆栈。索引从1开始。下一个答案应从以下术语开始：

1, 1

J，44字节，深度10，来自A026233的A242681

f=.(,(<:*+)"0/~~.50,25,(,+:,3*])1+i.20)+/@:=]

下一个答案应以以下术语开头：

1, 1, 2, 2, 3, 3, 4, 4, 5, 5

更接近日常生活的事物：“在n标准飞镖板上使用两支飞镖可获得分数的方式的数量”。仅无序得分对很重要。起始偏移量为2，如OEIS页面中所示。用法：

f 2 => 1
f 72 => 12

R，20字节，深度11，来自A242681的A194964

1+floor(scan()/5^.5)

下一个答案应符合以下条件：

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5

序列A194964为每个n提供1+[n/sqrt(5)]where [表示“ floor” 的结果。R函数将输入作为标准输入。