Neste desafio, o objetivo é recriar a Enciclopédia On-line de Sequências Inteiras, uma sequência de cada vez. Semelhante à evolução do Hello World , cada resposta depende de uma resposta anterior.

Com o tempo, esse desafio criará uma "árvore genealógica" das sequências OEIS. É simples adicionar a esta árvore.

1. Encontre uma resposta anterior, que pode estar em qualquer profundidade N da árvore.
2. Determine os primeiros N números gerados pela sequência dessa resposta.
3. Encontre uma sequência no OEIS que comece com os mesmos números e que não tenha sido usada antes.
4. Escreva um programa para gerar essa nova sequência que você acabou de encontrar.
5. Envie sua resposta como profundidade N + 1

Como o nível da sua resposta influencia a pontuação, você deve sempre adicioná-la à árvore no nível mais profundo possível. Se você não conseguir encaixar sua resposta em nenhum lugar da árvore, inicie um novo ramo da árvore e coloque-a em profundidade 1.

Requisitos de resposta

Existem algumas maneiras de gerar uma sequência.

A primeira opção é escrever um programa ou função que insira um número (de STDIN ou como argumento) e retorne o enésimo número na sequência escolhida. Você pode supor que a sequência será definida para N e que N e S_N são "de tamanho razoável" (para não causar estouros). Você também pode usar qualquer indexação razoável, como 0, 1 ou a indexação listada em "deslocamento" na página OEIS da sequência, que não importa. O termo produzido pelo primeiro índice deve corresponder ao primeiro termo da entrada OEIS.

A segunda opção é escrever um programa ou função que insira um número e retorne os primeiros N termos da sequência. Os primeiros termos da saída devem ser os primeiros da entrada OEIS (você não pode deixar de lado os primeiros termos). Termos consecutivos devem ser delimitados por seqüências arbitrárias de caracteres que não sejam dígitos, para que 0,1 1.2/3,5;8,11funcione, mas 011235811não conte.

A terceira opção é criar um programa que produz um fluxo contínuo de números. Da mesma forma que a segunda opção, deve haver delimitadores entre termos consecutivos.

Sua resposta deve conter um cabeçalho como este para ajudar na análise do Snippet de pilha:

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

Sua resposta deve conter o código para gerar a sequência, juntamente com os primeiros termos que qualquer descendente precisará conter. Esses poucos termos devem ser precedidos pela palavra exataterms: para que o controlador possa usá-los como parte do diagrama em árvore. Também é recomendável escrever uma descrição da sequência que você escolheu.

Se a sua postagem for uma resposta profunda 1 e, portanto, não tiver um ancestral, você deve simplesmente omitir a from A[number]no cabeçalho.

Aqui está um exemplo de resposta:

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

Requisitos de encadeamento

Para tornar esse desafio mais justo, existem restrições nas quais você pode encadear as suas respostas. Essas regras são principalmente para impedir que uma única pessoa crie um ramo inteiro da árvore sozinha ou possua muitos nós "raiz".

• Você não pode se acorrentar.
• Você não pode encadear diretamente duas de suas respostas para o mesmo ancestral.
• Você não pode fazer mais de uma resposta "Nível 1".

Além disso, se o ancestral tiver profundidade N, sua postagem deverá ter profundidade N + 1, mesmo que mais do que o número necessário de termos esteja de acordo.

Pontuação

Sua pontuação como usuário é a soma das pontuações de todas as suas respostas. A pontuação de uma única resposta é determinada pela seguinte fórmula:

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

Esse sistema de pontuação deve incentivar os usuários a enviar um grande número de respostas mais profundas. As respostas mais curtas são preferidas às respostas mais longas, mas a profundidade tem uma influência muito maior.

Abaixo está um trecho de pilha que gera uma tabela de classificação e um diagrama em árvore de todas as respostas. Gostaria de agradecer a Martin Büttner e d3noob como fontes de grande parte desse código. Você deve clicar em "Tela cheia" para ver os resultados completos.

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>

Parênteses, 150 bytes, profundidade 4, A000292 de A000290

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

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 4, 10

Esta é a sequência de números tetraédricos, a generalização 3D de números triangulares. A fórmula para isso é

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

Parenthetic é uma linguagem parecida com Lisp que usa parênteses para definir tudo. A descrição acima é uma função ()()()que recebe ne envia T(n). Ligue como:

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

Anotado

(
  define
  (() ()())

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

  (
    lambda
    (() ())

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

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

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

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

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

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


Test call:

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

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

Pilha de panquecas, 118 bytes, profundidade 1, A000012

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

A próxima resposta deve corresponder aos seguintes termos:

1

Isso imprime o menor divisor de n. Testado com o intérprete Python no página wiki esolang . O intérprete espera que um ~na linha depois indique o final do programa, após o que vem a entrada STDIN (que será ignorada de qualquer maneira).

Instruções relevantes:

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

Resposta anterior

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

Este imprime em um loop infinito. Instruções adicionais:

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

Existem outras instruções, mas mesmo assim o Pancake Stack é muito complicado de usar normalmente, graças à falta de saída numérica e ao acesso apenas aos dois principais elementos da pilha.

Infelizmente, a primeira linha deste programa parece necessária para evitar um erro relacionado a rótulos no interpretador Python.

Python, 31 bytes, profundidade 4, A010060 de A000045

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

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 1, 0

Este é o meu favorito, e é a sequência Thue-Morse . Existem pelo menos duas definições:

• A paridade de uns na expansão binária de n (usada acima) e
• A sequência obtida iniciando com 0 e, em seguida, anexando repetidamente o complemento bit a bit da sequência até o momento (ie 0 -> 01 -> 0110 -> 01101001 -> ...)

Uma das muitas coisas legais sobre essa sequência é se pegarmos uma tartaruga e fizermos:

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

nós entendemos isso:

Parece familiar?

MarioLANG, 265 bytes, profundidade 3, A016957 de A006370

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

A próxima resposta deve corresponder aos seguintes termos:

4, 10, 16

A sequência é apenas a progressão aritmética 6n + 4.

MarioLANG é uma linguagem de programação esotérica baseada em Super Mario. Os cálculos são feitos em um Brainfuck maneira semelhante a - há uma fita de células que você pode aumentar / diminuir.

Os comandos relevantes do tipo BF aqui são:

+      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

Então, onde está o Mario? Bem, Mario é o seu ponteiro de instruções e ele começa à esquerda (onde ;está). Mario continua executando instruções enquanto estiver no chão= estiver e, quando ele cai, o programa termina.

As instruções relevantes para isso são:

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

Em suma, o programa faz o seguinte:

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

Testado com o intérprete Ruby. Observe que a linguagem tem um comportamento indefinido, como o que acontece com as instruções que Mario encontra quando cai, então tentei evitar nada disso.

Brainfuck, 2 bytes, profundidade 2, A000030 de A001477

,.

A000030 é a sequência dos dígitos iniciais dos números inteiros não negativos; portanto, ele simplesmente lê o primeiro caractere do dígito e o grava de volta. A próxima sequência deve começar com os termos:

0, 1

Piet, 16 bytes, profundidade 3, A000035 de A000030

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 0

Este é Piet, então os "bytes" são realmente codels. Aqui está em um tamanho de codel maior:

O programa simplesmente lê ne gera o nmódulo 2.

Marbelous, 7 bytes, profundidade 3, A011760 de A000027

Já faz um tempo desde que este site recebeu uma resposta maravilhosa !

}0
<D++

A próxima resposta deve começar com os termos:

1, 2, 3

Você pode tentar o código no interpretador de snippet de pilha do es1024 . O put é fornecido através do argumento da linha de comando e você deve escolher "Exibir saída como números decimais". Caso contrário, o resultado será gerado como um valor de byte, o que também é tecnicamente correto .

A sequência é a sequência dos "botões do elevador nos EUA", ou seja, todos os números inteiros positivos, exceto 13. Observe que o Marbelous é limitado a números de 8 bits, mas até onde eu sei, não há edifícios com 256 andares. :)

Marbelous é uma linguagem 2D em que os dados fluem através do código na forma de bolas de gude (valores de bytes) caindo na grade. }0é substituído pelo primeiro argumento da linha de comando. <Dé um comutador que atua como uma célula vazia para bolinha menor que 13 ( Destá na base 36), para que as entradas 1 a 12 passem sem serem afetadas. Se o mármore for igual ou superior a 13, o mármore será desviado para a direita e passará pelo ++que incrementa o valor em 1. Nos dois casos, o mármore cai do tabuleiro, o que imprime seu valor.

Trilho , 56 bytes, profundidade 4, A033547 de A002378

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

A próxima resposta deve corresponder aos seguintes termos:

0, 2, 6, 14

O programa lê o nSTDIN e as saídas n*(n^2+5)/3, o que foi um palpite sobre os números mágicos para o modelo de reservatório nuclear da década de 1940.

Rail é uma linguagem 2D que tem como tema trilhos de trem. O código acima é jogado com @refletores que invertem a direção do trem, para reduzir o número de novas linhas. Aqui está não destruído:

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

Observe como o trilho começa no canto superior esquerdo e se move verticalmente para baixo e para a direita.

Os comandos de manipulação de pilha usados ​​são:

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

O trem se ramifica nas junções >v<^, girando para a direita se o topo da pilha for verdadeiro, caso contrário, para a esquerda se for falso.

Estrelado, 22 bytes, profundidade 4, A008619 de A000142

      + + +*,  +   **.

A próxima resposta deve corresponder aos seguintes termos:

1, 1, 2, 2

A sequência consiste nos números inteiros positivos repetidos duas vezes. O programa lê um número de STDIN e calcula 1 + floor(n/2).

Estrelado é uma linguagem esotérica implementada em Ruby, que fazia parte de um livro sobre ... criar línguas esotéricas em Ruby. Cada instrução é determinada pelo número de espaços antes de um dos +*.,`'. Todos os outros caracteres são ignorados, portanto, o acima é equivalente a

      +
 + +*,
  +   *
*.

que parece muito mais estrelado! (observe os espaços à direita)

Os comandos relevantes são:

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

Resposta anterior, 53 bytes

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

Isso gera a sequência ad infinitum. Alguns comandos adicionais são:

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 bytes, profundidade 6, A037965 de A104631

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

Esta é uma função sem nome que simplesmente calcula a definição da sequência. A próxima sequência deve começar com os termos:

0, 1, 4, 18, 80, 350

CJam, 34 bytes, profundidade 14, A157271 de A238263

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

A próxima resposta deve começar com os termos:

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

mas não sobrou nada que ainda não tenha sido feito.

Seja D(n)o conjunto dos primeiros ntrês números suaves: ou seja, números inteiros cujos fatores primos são um subconjunto de {2, 3}. Let S(n)Ser o maior subconjunto do D(n)qual ele próprio não contém nenhum subconjunto do formulário {x, 2x}ou {y, 3y}. Então A157271 é o tamanho de S(n).

Golfscript, 3 bytes, profundidade 3, A000290 de A000030

~2?

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 4

Essa sequência é simplesmente o número do quadrado, então o programa pega um número e gera seu quadrado.

Prelúdio , 16 bytes, profundidade 1, A000211

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

Pensei em começar uma árvore com um número inicial menos óbvio. Esta é uma sequência de Fibonacci generalizada com a definição a(0) = 4, a(1) = 3, a(n) = a(n-1) + a(n-2) - 2. Consequentemente, essa é principalmente uma adaptação simples da minha solução Prelude Fibonacci . O acima é um programa que imprime um fluxo infinito dos números. Ele assume o interpretador Python que gera números em vez de caracteres individuais.

A próxima resposta deve começar com os termos:

4

Clipe, 0 bytes, profundidade 2, A000027 de A000012

Dado um número n, imprime o nthnúmero na sequência1, 2, 3, 4...

A próxima resposta deve começar com os termos:

1, 2

J, 4 bytes, profundidade 4, A001563 de A000290

(*!)

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 4, 18

Essa sequência é o número multiplicado por seu fatorial. Em J (fg)xestá f(x,g(x))aqui x*factorial(x).

Mathematica, 48 bytes, profundidade 5, A104631 de A001563

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

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 4, 18, 80

Salvo os nomes de funções longas, o Mathematica é absolutamente favorável a esse desafio. Este é simplesmente o coeficiente de x^(2n+1)expansão de

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

Elemento , 13 bytes, profundidade 3, A000045 de A000030

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

A000045 representa os números de Fibonacci. Cada termo na sequência é a soma dos dois termos anteriores. É notável porque a razão entre termos consecutivos se aproxima da proporção áurea, também conhecida como phi. Um pouco interessante, a entrada OEIS começa com em 0, 1vez de comum 1, 1. A próxima resposta deve corresponder aos termos:

0, 1, 1

Prelúdio , 1 byte, profundidade 2, A000004 de A001477

!

A próxima resposta deve corresponder aos seguintes termos:

0, 0

Este programa recebe ncomo entrada, ignora-o completamente e gera a constante zero. Requer NUMERIC_OUTPUT = Trueno interpretador Python.

O bom do Prelude é que ele tem um suprimento infinito de zeros na parte inferior da pilha; portanto, tudo o que era necessário era um único comando de saída.

Perl, 10 bytes, profundidade 1, A001477

Para começar, aqui está uma sequência simples.

print$_=<>

Isso representa os números não negativos 0, 1, 2, 3 etc., imprimindo o número de entrada. A próxima sequência deve começar com os termos:

0

GolfScript, 9 bytes, profundidade 4, A051682 de A002275

~.9*7-*2/

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 11, 30

Isso simplesmente usa a fórmula para números hendecagonais encontrados na página OEIS.

Peixe morto, 4 bytes, profundidade 2, A005563 de A001477

isdo

Essa sequência é definida como (n+1)^2-1, que é exatamente o que este programa faz. Como o Deadfish não tem entrada, ele assume que o acumulador está no número de entrada desejado. A próxima resposta deve começar com os termos:

0, 3

APL, 13 bytes, profundidade 4, A000108 de A000142

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

Números catalães! A indexação começa em zero para estes. A próxima resposta deve começar com os termos:

1, 1, 2, 5

GolfScript, 31 bytes, profundidade 11, A029030 de A242681

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

A próxima resposta deve corresponder aos seguintes termos:

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

mas não será capaz de: esta é uma folha da árvore. Essa sequência é o número de maneiras de alterar com moedas de valor 1, 2, 10 e 11.

Retina , 1 byte, profundidade 3, A055642 de A001333

.

A próxima resposta deve começar com os termos:

1, 1, 1

Acho que esta é a primeira vez que usei o Retina em outra coisa que não o modo Substituir. Se apenas um arquivo for fornecido sem nenhuma opção, o Retina assumirá o modo de Correspondência, que por padrão conta o número de correspondências da regex especificada na entrada. Essa regex é .e corresponde a qualquer caractere. Portanto, este programa retorna o número de dígitos da entrada que é A055642.

Clipe , 24 bytes, profundidade 4, A049666 de A002275

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

A próxima resposta deve corresponder aos seguintes termos:

0, 1, 11, 122

A sequência é justa Fibonacci(5n)/5. Veja a página de exemplos para uma explicação.

Clipe, 37 bytes, profundidade 5, A227327 de A000292

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

Formas possíveis de escolher dois pontos em uma grade triangular do lado n, excluindo rotações e reflexões. O exemplo dado é: para n = 3, existem 4 maneiras:

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

A próxima sequência deve começar com os seguintes termos:

0, 1, 4, 10, 22

APL, 24 bytes, profundidade 6, A025581 de A182712

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

A sequência A025581 é a sequência de ... Não tenho muita certeza de ser honesto. Isso me assusta.

A indexação começa em 0 e a função apenas calcula a sequência por definição.

A próxima sequência deve começar com os termos:

0, 1, 0, 2, 1, 0

> <>, 25 bytes, profundidade 2, A001333 de A002522

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

Estes são os numeradores da fração contínua convergentes para sqrt (2). O código precisa que o usuário preencha previamente a pilha com o índice do convergente que deve ser retornado. A indexação começa em 1. A próxima resposta deve começar com os termos:

1, 1

J, 44 bytes, profundidade 10, A242681 de A026233

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

A próxima resposta deve começar com os termos:

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

Algo mais próximo da vida cotidiana: "o número de maneiras pelas quais uma pontuação npode ser obtida usando dois dardos em um alvo padrão". Apenas o par de pontuação não ordenado é importante. O deslocamento inicial é dois, como na página OEIS. Uso:

f 2 => 1
f 72 => 12

R, 20 bytes, profundidade 11, A194964 de A242681

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

A próxima resposta deve corresponder aos seguintes termos:

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

A sequência A194964 fornece para cada n o resultado de 1+[n/sqrt(5)]onde [significa "piso". A função R aceita a entrada como stdin.