En este desafío, el objetivo es recrear la Enciclopedia en línea de secuencias enteras una secuencia a la vez. Similar a la evolución de Hello World , cada respuesta depende de una respuesta previa.

Con el tiempo, este desafío creará un "árbol genealógico" de las secuencias OEIS. Es simple agregar a este árbol.

1. Encuentre una respuesta previa, que puede estar a cualquier profundidad N del árbol.
2. Determine los primeros N números generados por la secuencia de esa respuesta.
3. Encuentre una secuencia en OEIS que comience con esos mismos números y que no se haya usado antes.
4. Escribe un programa para generar esta nueva secuencia que acabas de encontrar.
5. Envíe su respuesta como profundidad N + 1

Dado que el nivel de su respuesta influye en la puntuación, siempre debe agregar su respuesta en el árbol en el nivel más profundo posible. Si no puede ajustar su respuesta en ningún lugar del árbol, puede comenzar una nueva rama del árbol y poner su respuesta como profundidad 1.

Requisitos de respuesta

Hay algunas formas de generar una secuencia.

La primera opción es escribir un programa o función que ingrese un número (desde STDIN o como argumento) y devuelva el enésimo número en la secuencia elegida. Puede suponer que la secuencia se definirá para N y que N y S_N tienen un "tamaño razonable" (por lo que no provocará desbordamientos). También puede usar cualquier indexación razonable, como 0 indexación, 1 indexación o la indexación que aparece en "desplazamiento" en la página OEIS de la secuencia, eso no importa. El término producido por el primer índice debe coincidir con el primer término de la entrada OEIS.

La segunda opción es escribir un programa o función que ingrese un número y devuelva los primeros N términos de la secuencia. Los primeros términos de la salida deben ser los primeros términos de la entrada OEIS (no puede omitir los primeros términos). Los términos consecutivos deben estar delimitados por cadenas arbitrarias de caracteres que no sean dígitos, por lo que 0,1 1.2/3,5;8,11funciona pero 011235811no cuenta.

La tercera opción es crear un programa que genere un flujo continuo de números. De manera similar a la segunda opción, debe haber delimitadores entre términos consecutivos.

Su respuesta debe contener un encabezado como este para ayudar al análisis de Stack Snippet:

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

Su respuesta debe contener el código para generar la secuencia, junto con los primeros términos que cualquier descendiente deberá contener. Estos pocos términos deben ir precedidos de la palabra exactaterms: para que el controlador pueda usarlos como parte del diagrama de árbol. También se recomienda escribir una descripción de la secuencia que eligió.

Si su publicación es una respuesta de profundidad 1 y, por lo tanto, no tiene antepasado, simplemente debe omitir la from A[number]en su encabezado.

Aquí hay una respuesta de ejemplo:

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

Para que este desafío sea más justo, existen restricciones sobre las respuestas a las que puede encadenar las suyas. Estas reglas son principalmente para evitar que una sola persona cree una rama completa del árbol por sí misma o sea propietaria de muchos nodos "raíz".

• No puedes encadenarte a ti mismo.
• No puede encadenar directamente dos de sus respuestas al mismo antepasado.
• No puede hacer más de una respuesta de "Nivel 1".

Además, si el antepasado tenía una profundidad N, tu publicación debe tener una profundidad N + 1, incluso si está de acuerdo con más de la cantidad requerida de términos.

Puntuación

Su puntaje como usuario es la suma de los puntajes de todas sus respuestas. La puntuación de una sola respuesta está determinada por la siguiente fórmula:

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

Este sistema de puntuación debería alentar a los usuarios a enviar una gran cantidad de respuestas más profundas. Se prefieren respuestas más cortas que respuestas más largas, pero la profundidad tiene una influencia mucho mayor.

A continuación se muestra un fragmento de pila que genera una tabla de clasificación, así como un diagrama de árbol de todas las respuestas. Me gustaría agradecer a Martin Büttner y d3noob como las fuentes de gran parte de este código. Debe hacer clic en "Pantalla completa" para ver los 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éntesis, 150 bytes, profundidad 4, A000292 de A000290

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

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 4, 10

Esta es la secuencia de números tetraédricos, la generalización 3D de números triangulares. La fórmula para esto es

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

Parenthetic es un lenguaje tipo Lisp que utiliza paréntesis para definir todo. Lo anterior es una función ()()()que toma ny emite T(n). Llamar como:

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

Anotado

(
  define
  (() ()())

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

  (
    lambda
    (() ())

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

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

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

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

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

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


Test call:

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

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

Pancake Stack, 118 bytes, profundidad 1, A000012

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

La siguiente respuesta debe coincidir con los siguientes términos:

1

Esto imprime el divisor más pequeño de n. Probado con el intérprete de Python en la página wiki de esolang . El intérprete espera que un mensaje ~en la línea indique el final del programa, después de lo cual viene la entrada STDIN (que se ignorará de todos modos).

Instrucciones 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

Respuesta 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 se imprime en un bucle infinito. Instrucciones adicionales:

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

Hay otras instrucciones, pero aun así Pancake Stack es muy engorroso de usar normalmente, gracias a la falta de salida numérica y acceso a solo los dos elementos superiores de la pila.

Desafortunadamente, la primera línea de este programa parece necesaria para evitar un error relacionado con las etiquetas en el intérprete de Python.

Python, 31 bytes, profundidad 4, A010060 desde A000045

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

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 1, 0

Este es uno de mis favoritos, y es la secuencia Thue-Morse . Hay al menos dos definiciones de esto:

• La paridad de unos en la expansión binaria de n(utilizada anteriormente), y
• La secuencia obtenida comenzando con 0, luego agregando repetidamente el complemento bit a bit de la secuencia hasta el momento (es decir 0 -> 01 -> 0110 -> 01101001 -> ...)

Una de las muchas cosas interesantes de esta secuencia es si agarramos una tortuga y hacemos:

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

obtenemos esto:

¿Parecer familiar?

MarioLANG, 265 bytes, profundidad 3, A016957 de A006370

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

La siguiente respuesta debe coincidir con los siguientes términos:

4, 10, 16

La secuencia es simplemente la progresión aritmética 6n + 4.

MarioLANG es un lenguaje de programación esotérico basado en, bueno, Super Mario. Los cálculos se realizan de forma similar a Brainfuck : hay una cinta de celdas que puede aumentar / disminuir.

Los comandos similares a BF relevantes aquí son:

+      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

Entonces, ¿dónde está el Mario? Bueno, Mario es tu puntero de instrucciones, y comienza a la izquierda (donde ;está). Mario sigue ejecutando instrucciones mientras está en el suelo =, y cuando cae, el programa termina.

Las instrucciones relevantes para esto son:

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

En general, el programa hace esto:

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

Probado con el intérprete de Ruby. Tenga en cuenta que el lenguaje tiene un comportamiento indefinido, como lo que sucede con las instrucciones que Mario encuentra cuando cae, por lo que traté de evitarlo.

Brainfuck, 2 bytes, profundidad 2, A000030 de A001477

,.

A000030 es la secuencia de los dígitos iniciales de los enteros no negativos, por lo que simplemente lee el primer carácter de dígito y lo vuelve a escribir. La siguiente secuencia debe comenzar con los términos:

0, 1

Piet, 16 bytes, profundidad 3, A000035 desde A000030

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 0

Este es Piet, por lo que los "bytes" son realmente codeles. Aquí está en un tamaño de codel más grande:

El programa simplemente lee ny emite el nmódulo 2.

Maravilloso, 7 bytes, profundidad 3, A011760 de A000027

¡Ha pasado un tiempo desde que este sitio ha visto una respuesta maravillosa !

}0
<D++

La siguiente respuesta debe comenzar con los términos:

1, 2, 3

Puede probar el código en el intérprete de Stack Snippet de es1024 . En put se proporciona a través del argumento de la línea de comandos, y debe elegir "Mostrar salida como números decimales". De lo contrario, el resultado se generará como un valor de byte, que técnicamente también está bien .

La secuencia es la secuencia de "botones de elevador en EE. UU.", Es decir, todos los enteros positivos excepto 13. Tenga en cuenta que Marbelous está limitado a números de 8 bits, pero que yo sepa, no hay edificios con cerca de 256 pisos. :)

Marbelous es un lenguaje 2D en el que los datos fluyen a través del código en forma de canicas (valores de bytes) que caen por la cuadrícula. }0se reemplaza con el primer argumento de línea de comandos. <Des un conmutador que actúa como una celda vacía para canicas de menos de 13 ( Destá en la base 36), de modo que las entradas 1 a 12 pasan sin verse afectadas. Si la canica es igual o mayor que 13, la canica se desvía hacia la derecha y pasa a través de la ++cual incrementa el valor en 1. En cualquier caso, la canica se cae del tablero, lo que imprime su valor.

Carril , 56 bytes, profundidad 4, A033547 desde A002378

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

La siguiente respuesta debe coincidir con los siguientes términos:

0, 2, 6, 14

El programa lee ndesde STDIN y produce resultados n*(n^2+5)/3, lo que suponía una conjetura sobre los números mágicos para el modelo de caparazón nuclear de la década de 1940.

Rail es un lenguaje 2D que tiene como tema las vías del tren. El código anterior se juega con @reflectores que invierten la dirección del tren para reducir el número de líneas nuevas. Aquí no tiene golf:

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

Observe cómo Rail comienza en la esquina superior izquierda y comienza a moverse verticalmente hacia abajo y a la derecha.

Los comandos de manipulación de pila utilizados son:

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

El tren se bifurca en los cruces >v<^, girando a la derecha si la parte superior de la pila es verdadera, de lo contrario a la izquierda si es falsa.

Estrellado, 22 bytes, profundidad 4, A008619 de A000142

      + + +*,  +   **.

La siguiente respuesta debe coincidir con los siguientes términos:

1, 1, 2, 2

La secuencia consiste en los enteros positivos repetidos dos veces. El programa lee un número de STDIN y calcula 1 + floor(n/2).

Starry es un lenguaje esotérico implementado en Ruby que era parte de un libro sobre ... hacer lenguajes esotéricos en Ruby. Cada instrucción está determinada por el número de espacios antes de uno de +*.,`'. Todos los demás caracteres se ignoran, por lo que lo anterior es equivalente a

      +
 + +*,
  +   *
*.

que se ve mucho más estrellado! (tenga en cuenta los espacios finales)

Los comandos relevantes son:

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

Respuesta anterior, 53 bytes

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

Esto genera la secuencia ad infinitum en su lugar. Algunos comandos adicionales son:

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

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

Esta es una función sin nombre que simplemente calcula la definición de la secuencia. La siguiente secuencia debe comenzar con los términos:

0, 1, 4, 18, 80, 350

CJam, 34 bytes, profundidad 14, A157271 de A238263

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

La siguiente respuesta debe comenzar con los términos:

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

pero no queda nada que no se haya hecho ya.

Sea D(n)el conjunto de los primeros n3 números lisos: es decir, enteros cuyos factores primos son un subconjunto de {2, 3}. Sea S(n)el subconjunto más grande del D(n)cual no contiene ningún subconjunto del formulario {x, 2x}o {y, 3y}. Entonces A157271 es del tamaño de S(n).

Golfscript, 3 bytes, profundidad 3, A000290 de A000030

~2?

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 4

Esta secuencia es simplemente los números cuadrados, por lo que el programa toma un número y genera su cuadrado.

Preludio , 16 bytes, profundidad 1, A000211

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

Pensé en comenzar un árbol con un número inicial menos obvio. Se trata de una sucesión de Fibonacci generalizada con la definición a(0) = 4, a(1) = 3, a(n) = a(n-1) + a(n-2) - 2. En consecuencia, esta es principalmente una adaptación simple de mi solución Prelude Fibonacci . Lo anterior es un programa que imprime un flujo infinito de los números. Asume el intérprete de Python que genera números en lugar de caracteres individuales.

La siguiente respuesta debe comenzar con los términos:

4

Clip, 0 bytes, profundidad 2, A000027 de A000012

Dado un número n, imprime el nthnúmero en la secuencia1, 2, 3, 4...

La siguiente respuesta debe comenzar con los términos:

1, 2

J, 4 bytes, profundidad 4, A001563 de A000290

(*!)

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 4, 18

Esta secuencia es el número multiplicado por su factorial. En J (fg)xestá f(x,g(x))aquí x*factorial(x).

Mathematica, 48 bytes, profundidad 5, A104631 de A001563

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

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 4, 18, 80

Salvo los nombres largos de las funciones, Mathematica es absolutamente genial en este desafío. Éste es simplemente el coeficiente de x^(2n+1)expansión de

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

Elemento , 13 bytes, profundidad 3, A000045 de A000030

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

A000045 representa los números de Fibonacci. Cada término de la secuencia es la suma de los dos términos anteriores. Es notable porque la proporción entre términos consecutivos se aproxima a la proporción áurea, también conocida como phi. Curiosamente, la entrada OEIS comienza con en 0, 1lugar de la común 1, 1. La siguiente respuesta debe coincidir con los términos:

0, 1, 1

Preludio , 1 byte, profundidad 2, A000004 desde A001477

!

La siguiente respuesta debe coincidir con los siguientes términos:

0, 0

Este programa toma ncomo entrada, lo ignora por completo y genera la constante cero. Requiere NUMERIC_OUTPUT = Trueen el intérprete de Python.

Lo bueno de Prelude es que tiene un suministro infinito de ceros en la parte inferior de la pila, por lo que todo lo que se necesitaba era un solo comando de salida.

Perl, 10 bytes, profundidad 1, A001477

Para comenzar, aquí hay una secuencia simple.

print$_=<>

Esto representa los números no negativos 0, 1, 2, 3, etc. imprimiendo el número de entrada. La siguiente secuencia debe comenzar con los términos:

0

GolfScript, 9 bytes, profundidad 4, A051682 de A002275

~.9*7-*2/

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 11, 30

Esto simplemente usa la fórmula para los números hendecagonales que se encuentran en la página OEIS.

Deadfish, 4 bytes, profundidad 2, A005563 de A001477

isdo

Esta secuencia se define como (n+1)^2-1, que es exactamente lo que hace este programa. Dado que Deadfish no tiene entrada, se supone que el acumulador está en el número de entrada deseado. La siguiente respuesta debe comenzar con los términos:

0, 3

APL, 13 bytes, profundidad 4, A000108 de A000142

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

Números catalanes! La indexación comienza en cero para estos. La siguiente respuesta debe comenzar con los términos:

1, 1, 2, 5

GolfScript, 31 bytes, profundidad 11, A029030 de A242681

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

La siguiente respuesta debe coincidir con los siguientes términos:

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

pero no podrá: esta es una hoja del árbol. Esta secuencia es el número de formas de dar cambio con monedas de valor 1, 2, 10 y 11.

Retina , 1 byte, profundidad 3, A055642 de A001333

.

La siguiente respuesta debe comenzar con los términos:

1, 1, 1

Creo que esta es la primera vez que utilizo Retina en algo más que el modo Reemplazar. Si solo se proporciona un solo archivo sin ninguna opción, Retina asume el modo Match, que por defecto cuenta el número de coincidencias de la expresión regular dada en la entrada. Esta expresión regular es .y coincide con cualquier personaje. Por lo tanto, este programa devuelve el número de dígitos de la entrada que es A055642.

Clip , 24 bytes, profundidad 4, A049666 de A002275

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

La siguiente respuesta debe coincidir con los siguientes términos:

0, 1, 11, 122

La secuencia es justa Fibonacci(5n)/5. Vea la página de ejemplos para una explicación.

Clip, 37 bytes, profundidad 5, A227327 de A000292

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

Posibles formas de elegir dos puntos en una cuadrícula triangular del lado n, excluyendo rotaciones y reflejos. El ejemplo dado es: para n = 3, hay 4 formas:

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

La siguiente secuencia debe comenzar con los siguientes términos:

0, 1, 4, 10, 22

APL, 24 bytes, profundidad 6, A025581 de A182712

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

La secuencia A025581 es la secuencia de ... No estoy muy seguro de ser honesto. Me asusta.

La indexación comienza en 0 y la función simplemente calcula la secuencia por definición.

La siguiente secuencia debe comenzar con los términos:

0, 1, 0, 2, 1, 0

> <>, 25 bytes, profundidad 2, A001333 desde A002522

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

Estos son los numeradores de la fracción continua de convergentes a sqrt (2). El código necesita que el usuario rellene previamente la pila con el índice del convergente que debe devolverse. La indexación comienza en 1. La siguiente respuesta debe comenzar con los términos:

1, 1

J, 44 bytes, profundidad 10, A242681 de A026233

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

La siguiente respuesta debe comenzar con los términos:

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

Algo más cercano a la vida cotidiana: "la cantidad de formas en que nse puede obtener una puntuación utilizando dos dardos en un tablero de dardos estándar". Solo importa el par de puntuación desordenado. El desplazamiento inicial es dos como en la página OEIS. Uso:

f 2 => 1
f 72 => 12

R, 20 bytes, profundidad 11, A194964 de A242681

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

La siguiente respuesta debe coincidir con los siguientes términos:

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

La secuencia A194964 da para cada n el resultado de 1+[n/sqrt(5)]donde [significa "piso". La función R toma la entrada como stdin.