Dans ce défi, l’objectif est de recréer l’ Encyclopédie en ligne de séquences entières, une séquence à la fois. Semblable à l' évolution de Hello World , chaque réponse dépend d'une réponse précédente.

Avec le temps, ce défi créera un "arbre généalogique" des séquences OEIS. Il est simple d'ajouter à cet arbre.

1. Trouver une réponse précédente, qui peut être à n'importe quelle profondeur N de l'arbre.
2. Déterminez les N premiers nombres générés par la séquence de cette réponse.
3. Trouvez une séquence dans OEIS qui commence par ces mêmes numéros et qui n'a pas encore été utilisée.
4. Ecrivez un programme pour générer cette nouvelle séquence que vous venez de trouver.
5. Soumettez votre réponse en profondeur N + 1

Étant donné que le niveau de votre réponse influence le pointage, vous devez toujours ajouter votre réponse sur l’arbre au niveau le plus profond possible. Si vous ne pouvez adapter votre réponse à aucun endroit de l’arbre, vous pouvez créer une nouvelle branche de l’arbre et indiquer votre réponse en profondeur 1.

Réponse requise

Il existe plusieurs façons de générer une séquence.

La première option consiste à écrire un programme ou une fonction qui entre un nombre (à partir de STDIN ou sous forme d'argument) et renvoie le Nième nombre dans la séquence choisie. Vous pouvez supposer que la séquence sera définie pour N et que N et S_N auront une "taille raisonnable" (pour éviter les débordements). Vous pouvez également utiliser une indexation raisonnable, telle qu'une indexation 0, une indexation ou l'indexation répertoriée sous "offset" sur la page OEIS de la séquence, cela n'a pas d'importance. Le terme produit par le premier index doit correspondre au premier terme de l'entrée OEIS.

La deuxième option consiste à écrire un programme ou une fonction qui entre un nombre et renvoie les N premiers termes de la séquence. Les premiers termes de la sortie doivent être les premiers termes de l'entrée OEIS (vous ne pouvez pas laisser les premiers termes). Les termes consécutifs doivent être délimités par des chaînes arbitraires de caractères non numériques, donc 0,1 1.2/3,5;8,11fonctionne mais 011235811ne compte pas.

La troisième option consiste à créer un programme qui génère un flux continu de nombres. De même que pour la deuxième option, il doit y avoir des délimiteurs entre les termes consécutifs.

Votre réponse devrait contenir un en-tête comme celui-ci pour faciliter l'analyse syntaxique de Stack Snippet:

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

Votre réponse doit contenir le code pour générer la séquence, ainsi que les premiers termes que tout descendant devra contenir. Ces quelques termes doivent être précédés du mot exactterms: pour que le contrôleur puisse les utiliser dans l’arborescence. Il est également recommandé de rédiger une description de la séquence choisie.

Si votre message répond à la profondeur 1 et n'a donc aucun ancêtre, vous devez simplement omettre la from A[number]dans votre en-tête.

Voici un exemple de réponse:

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

Chaînage requis

Afin de rendre ce défi plus équitable, il existe des restrictions sur les réponses auxquelles vous pouvez chaîner les vôtres. Ces règles visent principalement à empêcher une seule personne de créer seule une branche de l’arbre ou de posséder un grand nombre de nœuds «racine».

• Vous ne pouvez pas vous enchaîner.
• Vous ne pouvez pas relier directement deux de vos réponses au même ancêtre.
• Vous ne pouvez pas donner plus d’une réponse de "Niveau 1".

De plus, si l'ancêtre était de profondeur N, votre message doit avoir une profondeur N + 1, même si plus que le nombre de termes requis concordent.

Notation

Votre score en tant qu'utilisateur est la somme des scores de toutes vos réponses. Le score d'une réponse unique est déterminé par la formule suivante:

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

Ce système de notation devrait encourager les utilisateurs à soumettre un grand nombre de réponses plus approfondies. Les réponses plus courtes sont préférées aux réponses plus longues, mais la profondeur a une influence beaucoup plus grande.

Ci-dessous se trouve un extrait de pile qui génère un classement ainsi qu’un diagramme en arbre de toutes les réponses. Je voudrais remercier Martin Büttner et d3noob en tant que sources de ce code. Vous devez cliquer sur "Plein écran" pour voir les résultats complets.

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>

Parenthétique, 150 octets, profondeur 4, A000292 à partir de A000290

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

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 4, 10

C’est la séquence des nombres tétraédriques, la généralisation 3D des nombres triangulaires. La formule pour cela est

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

Parenthetic est un langage de type Lisp qui utilise des parenthèses pour tout définir. Ce qui précède est une fonction ()()()qui prend net sort T(n). Appelez comme:

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

Annoté

(
  define
  (() ()())

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

  (
    lambda
    (() ())

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

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

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

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

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

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


Test call:

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

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

Pile de crêpes, 118 octets, profondeur 1, A000012

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

La réponse suivante devrait correspondre aux termes suivants:

1

Ceci imprime le plus petit diviseur de n. Testé avec l'interpréteur Python sur la page wiki d'esolang . L'interprète s'attend à ce que ~la fin du programme soit indiquée sur la ligne suivante, après quoi vient l'entrée STDIN (qui sera ignorée de toute façon).

Instructions pertinentes:

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

Réponse précédente

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

Celui-ci imprime dans une boucle infinie. Instructions additionnelles:

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

Il existe d’autres instructions, mais Pancake Stack est néanmoins très fastidieux à utiliser normalement, en raison du manque de sortie numérique et de l’accès uniquement aux deux éléments supérieurs de la pile.

Malheureusement, la première ligne de ce programme semble nécessaire pour éviter un bogue concernant les étiquettes dans l'interpréteur Python.

Python, 31 octets, profondeur 4, A010060 à partir de A000045

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

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 1, 0

Celui-ci est l'un de mes préférés, et c'est la séquence Thue-Morse . Il existe au moins deux définitions:

• La parité de uns dans le développement binaire de n(utilisé ci-dessus), et
• La séquence obtenue en commençant par 0, puis en ajoutant de manière répétée le complément au bit de la séquence jusqu'à présent (c'est-à-dire 0 -> 01 -> 0110 -> 01101001 -> ...)

Une des nombreuses choses intéressantes à propos de cette séquence est si nous prenons une tortue et faisons:

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

nous obtenons ceci:

Semble familier?

MarioLANG, 265 octets, profondeur 3, A016957 à partir de A006370

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

La réponse suivante devrait correspondre aux termes suivants:

4, 10, 16

La séquence est simplement la progression arithmétique 6n + 4.

MarioLANG est un langage de programmation ésotérique basé sur Super Mario. Les calculs sont faits de la même manière que Brainfuck - il y a une bande de cellules que vous pouvez incrémenter / décrémenter.

Les commandes pertinentes de type BF sont les suivantes:

+      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

Alors, où est le Mario? Eh bien, Mario est votre pointeur d’instruction et il commence à gauche (où se ;trouve). Mario continue à exécuter les instructions tant qu'il est sur le terrain =et quand il tombe, le programme se termine.

Les instructions pertinentes pour cela sont:

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

Dans l’ensemble, le programme fait ceci:

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

Testé avec l'interprète Ruby. Notez que le langage a beaucoup de comportements indéfinis, tels que ce qui arrive aux instructions que Mario rencontre lorsqu'il tombe, alors j'ai essayé d'éviter tout cela.

Brainfuck, 2 bytes, profondeur 2, A000030 à partir de A001477

,.

A000030 est la séquence des premiers chiffres des nombres entiers non négatifs. Il s’agit donc de lire le premier caractère et de le réécrire. La prochaine séquence devrait commencer par les termes:

0, 1

Piet, 16 octets, profondeur 3, A000035 à partir de A000030

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 0

C'est Piet, donc les "octets" sont vraiment des codes. Le voici à une taille de code plus grande:

Le programme lit simplement net produit le nmodulo 2.

Marbelous, 7 bytes, profondeur 3, A011760 à partir de A000027

Cela fait un moment que ce site a reçu une réponse Marbelous !

}0
<D++

La prochaine réponse devrait commencer par les termes:

1, 2, 3

Vous pouvez essayer le code dans l' interpréteur Stack Snippet de es1024 . In put est donné via un argument de ligne de commande et vous devez choisir "Afficher la sortie sous forme de nombres décimaux". Sinon, le résultat sera affiché sous forme d'octet, ce qui est techniquement parfait .

La séquence est la séquence des "boutons d'ascenseur aux États-Unis", c'est-à-dire tous les entiers positifs sauf 13. Notez que Marbelous est limité à des nombres à 8 bits, mais pour autant que je sache, il n'y a pas de bâtiment de quelque 256 étages. :)

Marbelous est un langage 2D dans lequel les données circulent dans le code sous forme de billes (valeurs d'octets) tombant dans la grille. }0est remplacé par le premier argument de ligne de commande. <Dest un commutateur qui agit comme une cellule vide pour les billes de moins de 13 (le Dest dans la base 36), de sorte que les entrées 1 à 12 passent sans affectation. Si la bille est égale ou supérieure à 13, la bille est déviée vers la droite et passe à travers ++laquelle augmente la valeur de 1. Dans les deux cas, la bille tombe alors du tableau, qui affiche sa valeur.

Rail , 56 octets, profondeur 4, A033547 à partir de A002378

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

La réponse suivante devrait correspondre aux termes suivants:

0, 2, 6, 14

Le programme lit dans nSTDIN et les résultats n*(n^2+5)/3, ce qui était une estimation des chiffres magiques pour le modèle de l' enveloppe nucléaire des années 1940.

Le rail est un langage 2D dont le thème est autour des voies ferrées. Le code ci-dessus utilise des @réflecteurs qui inversent la direction du train afin de réduire le nombre de nouvelles lignes. Ici c'est non-golfé:

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

Notez que Rail commence en haut à gauche et commence à se déplacer verticalement en bas à droite.

Les commandes de manipulation de pile utilisées sont:

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

Le train se branche aux carrefours >v<^, tournant à droite si le haut de la pile est vrai, sinon à gauche s'il est faux.

Étoilé, 22 octets, profondeur 4, A008619 à partir de A000142

      + + +*,  +   **.

La réponse suivante devrait correspondre aux termes suivants:

1, 1, 2, 2

La séquence est constituée des entiers positifs répétés deux fois. Le programme lit un nombre à partir de STDIN et calcule 1 + floor(n/2).

Starry est un langage ésotérique implémenté en Ruby qui faisait partie d'un livre sur ... la fabrication de langages ésotériques en Ruby. Chaque instruction est déterminée par le nombre d'espaces avant l'une des +*.,`'. Tous les autres caractères sont ignorés, ce qui précède équivaut à

      +
 + +*,
  +   *
*.

qui a l'air beaucoup plus étoilé! (notez les espaces de fin)

Les commandes pertinentes sont:

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

Réponse précédente, 53 octets

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

Cela génère la séquence ad infinitum à la place. Quelques commandes supplémentaires sont:

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 octets, profondeur 6, A037965 à partir de A104631

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

C'est une fonction sans nom qui calcule simplement la définition de la séquence. La prochaine séquence devrait commencer par les termes:

0, 1, 4, 18, 80, 350

CJam, 34 octets, profondeur 14, A157271 à partir de A238263

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

La prochaine réponse devrait commencer par les termes:

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

mais il n'en reste plus qui ne soient déjà terminés.

Soit D(n)l’ensemble des n3 premiers nombres lisses: c’est-à-dire des entiers dont les facteurs premiers sont un sous-ensemble de {2, 3}. Soit S(n)le plus grand sous-ensemble de D(n)ce qui ne contient pas lui-même un sous-ensemble de la forme {x, 2x}ou {y, 3y}. Alors A157271 est la taille de S(n).

Golfscript, 3 octets, profondeur 3, A000290 à partir de A000030

~2?

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 4

Cette séquence est simplement les nombres carrés, ainsi le programme prend un nombre et affiche son carré.

Prélude , 16 octets, profondeur 1, A000211

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

Je pensais que je commencerais un arbre avec un numéro initial moins évident. Ceci est une séquence de Fibonacci généralisée avec définition a(0) = 4, a(1) = 3, a(n) = a(n-1) + a(n-2) - 2. Par conséquent, il s’agit principalement d’une simple adaptation de ma solution Prelude Fibonacci . Ce qui précède est un programme qui imprime un flux infini de nombres. Il suppose que l'interpréteur Python génère des nombres au lieu de caractères individuels.

La prochaine réponse devrait commencer par les termes:

4

Clip, 0 octet, profondeur 2, A000027 à partir de A000012

Étant donné un numéro n, imprime le nthnuméro dans la séquence1, 2, 3, 4...

La prochaine réponse devrait commencer par les termes:

1, 2

J, 4 octets, profondeur 4, A001563 à partir de A000290

(*!)

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 4, 18

Cette séquence est le nombre multiplié par sa factorielle. En J (fg)xest f(x,g(x))ici x*factorial(x).

Mathematica, 48 octets, profondeur 5, A104631 à partir de A001563

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

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 4, 18, 80

À l'exception des noms de fonction longs, Mathematica bascule à ce défi. Celui-ci est simplement le coefficient de x^(2n+1)dans l'expansion de

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

Elément , 13 octets, profondeur 3, A000045 à partir de A000030

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

A000045 représente les nombres de Fibonacci. Chaque terme de la séquence est la somme des deux termes précédents. C'est remarquable car le rapport entre les termes consécutifs se rapproche du nombre d'or, également appelé phi. De manière assez intéressante, l'entrée OEIS commence par la 0, 1place du commun 1, 1. La prochaine réponse devrait correspondre aux termes:

0, 1, 1

Prelude , 1 byte, profondeur 2, A000004 à partir de A001477

!

La réponse suivante devrait correspondre aux termes suivants:

0, 0

Ce programme prend en nentrée, l’ignore complètement et renvoie la constante zéro. Cela nécessite NUMERIC_OUTPUT = Truedans l'interpréteur Python.

La bonne chose à propos de Prelude est qu’il contient un nombre infini de zéros au bas de la pile; il ne lui fallait donc qu’une seule commande de sortie.

Perl, 10 octets, profondeur 1, A001477

Pour lancer les choses, voici une séquence simple.

print$_=<>

Ceci représente les nombres non négatifs 0, 1, 2, 3, etc. en imprimant le nombre saisi. La prochaine séquence devrait commencer par les termes:

0

GolfScript, 9 octets, profondeur 4, A051682 à partir de A002275

~.9*7-*2/

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 11, 30

Ceci utilise simplement la formule pour les nombres hendécagonaux figurant sur la page OEIS.

Deadfish, 4 bytes, profondeur 2, A005563 à partir de A001477

isdo

Cette séquence est définie comme (n+1)^2-1ce qui est exactement ce que fait ce programme. Comme Deadfish n’a pas d’entrée, cela suppose que l’accumulateur se trouve au numéro d’entrée souhaité. La prochaine réponse devrait commencer par les termes:

0, 3

APL, 13 octets, profondeur 4, A000108 à partir de A000142

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

Chiffres catalans! L'indexation commence à zéro pour ces derniers. La prochaine réponse devrait commencer par les termes:

1, 1, 2, 5

GolfScript, 31 octets, profondeur 11, A029030 à partir de A242681

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

La réponse suivante devrait correspondre aux termes suivants:

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

mais il ne pourra pas: c'est une feuille de l'arbre. Cette séquence est le nombre de façons de rendre la monnaie avec des pièces de valeur 1, 2, 10 et 11.

Rétine , 1 octet, profondeur 3, A055642 à partir de A001333

.

La prochaine réponse devrait commencer par les termes:

1, 1, 1

Je pense que c'est la première fois que j'utilise Retina dans autre chose que le mode Remplacer. Si un seul fichier est donné sans aucune option, Retina assume le mode Correspondance, qui compte par défaut le nombre de correspondances de la regex donnée dans l'entrée. Cette expression régulière est .et correspond à n'importe quel caractère. Par conséquent, ce programme renvoie le nombre de chiffres de l'entrée qui est A055642.

Clip , 24 octets, profondeur 4, A049666 à partir de A002275

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

La réponse suivante devrait correspondre aux termes suivants:

0, 1, 11, 122

La séquence est juste Fibonacci(5n)/5. Voir la page des exemples pour une explication.

Clip, 37 octets, profondeur 5, A227327 à partir de A000292

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

Méthodes possibles pour choisir deux points sur une grille triangulaire du côté n, en excluant les rotations et les réflexions. L'exemple donné est le suivant: pour n = 3, il y a 4 façons:

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

La séquence suivante doit commencer par les termes suivants:

0, 1, 4, 10, 22

APL, 24 octets, profondeur 6, A025581 à partir de A182712

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

La séquence A025581 est la séquence de ... Je ne suis pas tout à fait sûr d'être honnête. Ça me fait peur.

L'indexation commence à 0 et la fonction calcule simplement la séquence par définition.

La prochaine séquence devrait commencer par les termes:

0, 1, 0, 2, 1, 0

> <>, 25 octets, profondeur 2, A001333 à partir de A002522

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

Ce sont les numérateurs de la fraction continue convergents en sqrt (2). Le code nécessite que l'utilisateur préremplisse la pile avec l'index du convergent à renvoyer. L'indexation commence à 1. La réponse suivante devrait commencer par les termes suivants:

1, 1

J, 44 octets, profondeur 10, A242681 à partir de A026233

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

La prochaine réponse devrait commencer par les termes:

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

Quelque chose de plus proche de la vie quotidienne: "le nombre de façons dont non peut obtenir un score en utilisant deux fléchettes sur un jeu de fléchettes standard". Seul le score non ordonné est important. Le décalage de départ est deux comme dans la page OEIS. Usage:

f 2 => 1
f 72 => 12

R, 20 octets, profondeur 11, A194964 à partir de A242681

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

La réponse suivante devrait correspondre aux termes suivants:

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

La séquence A194964 donne pour chaque n le résultat de 1+[n/sqrt(5)]où [signifie "sol". La fonction R prend l’entrée en tant que stdin.