Evoluzione di OEIS


56

In questa sfida, l'obiettivo è ricreare l' enciclopedia online delle sequenze intere una sequenza alla volta. Simile all'evoluzione di Hello World , ogni risposta dipende da una risposta precedente.

Nel tempo, questa sfida creerà un "albero genealogico" delle sequenze OEIS. È semplice aggiungere a questo albero.

  1. Trova una risposta precedente, che può trovarsi a qualsiasi profondità N dell'albero.
  2. Determina i primi N numeri generati dalla sequenza di quella risposta.
  3. Trova una sequenza in OEIS che inizia con quegli stessi numeri e che non è mai stato usato prima.
  4. Scrivi un programma per generare questa nuova sequenza che hai appena trovato.
  5. Invia la tua risposta come profondità N + 1

Poiché il livello della tua risposta influenza il punteggio, devi sempre aggiungere la tua risposta sull'albero al livello più profondo possibile. Se non riesci ad adattare la tua risposta in nessun punto dell'albero, puoi iniziare un nuovo ramo dell'albero e inserire la risposta come profondità 1.

Requisiti di risposta

Esistono alcuni modi per generare una sequenza.

La prima opzione è scrivere un programma o una funzione che inserisca un numero (da STDIN o come argomento) e restituisca l'ennesimo numero nella sequenza scelta. Si può presumere che la sequenza sarà definita per N e che N e S_N siano "dimensionati ragionevolmente" (quindi non causerà overflow). Puoi anche utilizzare qualsiasi indicizzazione ragionevole, come 0 indicizzazione, 1 indicizzazione o l'indicizzazione elencata sotto "offset" nella pagina OEIS della sequenza, che non ha importanza. Il termine prodotto dal primo indice deve corrispondere al primo termine della voce OEIS.

La seconda opzione è scrivere un programma o una funzione che inserisca un numero e restituisca i primi N termini della sequenza. I primi termini dell'output devono essere i primi termini della voce OEIS (non è possibile tralasciare i primi termini). I termini consecutivi devono essere delimitati da stringhe arbitrarie di caratteri non numerici, quindi 0,1 1.2/3,5;8,11funziona ma 011235811non conta.

La terza opzione è quella di creare un programma che genera un flusso continuo di numeri. Analogamente alla seconda opzione, devono esserci delimitatori tra termini consecutivi.

La tua risposta dovrebbe contenere un'intestazione come questa per aiutare l'analisi dello snippet di stack:

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

La tua risposta dovrebbe contenere il codice per generare la sequenza, insieme ai primi termini che dovranno contenere tutti i discendenti. Questi pochi termini dovrebbero essere preceduti dalla parola esatta interms: modo che il controller possa usarli come parte del diagramma ad albero. Si consiglia inoltre di scrivere una descrizione della sequenza scelta.

Se il tuo post è una risposta di profondità 1 e quindi non ha antenati, dovresti semplicemente ometterlo from A[number]nella tua intestazione.

Ecco una risposta di esempio:

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

Requisiti per il concatenamento

Al fine di rendere questa sfida più giusta, ci sono delle restrizioni su quali risposte puoi incatenare alle tue. Queste regole servono principalmente a impedire a una sola persona di creare un intero ramo dell'albero da solo o di possedere molti nodi "root".

  • Non puoi incatenare a te stesso.
  • Non puoi incatenare direttamente due delle tue risposte allo stesso antenato.
  • Non è possibile effettuare più di una risposta "Livello 1".

Inoltre, se l'antenato aveva una profondità N, il tuo post deve avere una profondità N + 1, anche se è d'accordo un numero di termini superiore a quello richiesto.

punteggio

Il tuo punteggio come utente è la somma dei punteggi di tutte le tue risposte. Il punteggio di una singola risposta è determinato dalla seguente formula:

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

Questo sistema di punteggio dovrebbe incoraggiare gli utenti a inviare un gran numero di risposte più profonde. Le risposte più brevi sono preferite rispetto alle risposte più lunghe, ma la profondità ha un'influenza molto maggiore.

Di seguito è riportato uno snippet di stack che genera una classifica e un diagramma ad albero di tutte le risposte. Vorrei ringraziare Martin Büttner e d3noob come fonti per gran parte di questo codice. Dovresti fare clic su "Schermo intero" per vedere i risultati completi.

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>


5
Sai, penso che questa sia la domanda codegolf.sx più interessante che abbia mai visto. Non è solo bello, ma in realtà utile come archivio.
Todd Lehman,

3
Dato che l'OEIS è online, prende N termini di una sequenza come termine di ricerca e contiene il codice matematico o maple per molte delle sequenze, sarebbe possibile scrivere una meta-voce che cercasse la voce di punteggio migliore per cui esiste il codice in OEIS che è un discendente di qualsiasi voce data qui e l'ha pubblicata.
circa

2
Posso consigliare un modo per contrassegnare sul grafico lo snippet che genera un nodo come terminale, ovvero che non sono disponibili sequenze inutilizzate di maggiore profondità sull'OEIS?
Claudiu,

1
Penso che l'unico modo per portare avanti questa sfida sarebbe quello di fornire qualcosa in cui fornisci il tuo nome utente ed elenca i problemi OEIS che potresti fare, in ordine dal più profondo al più basso. Altrimenti, ci vuole troppo tempo per trovare la sequenza successiva da pubblicare.
Claudiu,

1
L'SVG è leggermente troppo stretto.
Calcolatrice

Risposte:


21

Tra parentesi, 150 byte, profondità 4, A000292 da A000290

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 4, 10

Questa è la sequenza dei numeri tetraedrici, la generalizzazione 3D dei numeri triangolari. La formula per questo è

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

La parentesi è un linguaggio simile al Lisp che usa le parentesi per definire tutto. Quanto sopra è una funzione ()()()che accetta ne genera T(n). Chiama come:

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

commentata

(
  define
  (() ()())

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

  (
    lambda
    (() ())

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

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

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

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

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

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


Test call:

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

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

19
Cosa nel mondo è questa lingua? È come una versione più cattiva di Lisp.
Alex A.

10
@AlexA. Non è un Lisp! È un vero e proprio impedimento vocale!
CJ Dennis,

18

Stack di pancake, 118 byte, profondità 1, A000012

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

1

Questo stampa il divisore più piccolo di n. Testato con l'interprete Python sulla pagina wiki di esolang . L'interprete si aspetta che a ~sulla riga dopo indichi la fine del programma, dopodiché arriva l'input STDIN (che verrà comunque ignorato).

Istruzioni pertinenti:

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

Risposta precedente

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

Questo stampa in un ciclo infinito. Istruzioni addizionali:

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

Ci sono altre istruzioni, ma anche così Pancake Stack è molto ingombrante da usare normalmente, grazie alla mancanza di output numerico e all'accesso solo ai primi due elementi dello stack.

Sfortunatamente, la prima riga di questo programma sembra necessaria per prevenire un bug relativo alle etichette nell'interprete Python.


17

Python, 31 byte, profondità 4, A010060 da A000045

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 1, 0

Questo è uno dei miei preferiti, ed è la sequenza di martedì e marzo . Ne esistono almeno due definizioni:

  • La parità di quelli nell'espansione binaria di n(usato sopra) e
  • La sequenza ottenuta iniziando con 0, quindi aggiungendo ripetutamente il complemento bit a bit della sequenza finora (cioè 0 -> 01 -> 0110 -> 01101001 -> ...)

Una delle tante cose interessanti di questa sequenza è se prendiamo una tartaruga e facciamo:

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

otteniamo questo:

inserisci qui la descrizione dell'immagine

Ti sembra familiare?


15

MarioLANG, 265 byte, profondità 3, A016957 da A006370

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

4, 10, 16

La sequenza è semplicemente la progressione aritmetica 6n + 4.

MarioLANG è un linguaggio di programmazione esoterico basato su Super Mario. I calcoli vengono eseguiti in modo simile a Brainfuck : è presente un nastro di celle che è possibile incrementare / decrementare.

I comandi simili a BF qui sono:

+      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

Allora dov'è il Mario? Bene Mario è il tuo puntatore alle istruzioni, e inizia a sinistra (dove si ;trova). Mario continua a eseguire le istruzioni finché rimane a terra =e quando cade il programma termina.

Le istruzioni pertinenti per questo sono:

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

Tutto sommato, il programma fa questo:

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

Testato con l'interprete Ruby. Nota che la lingua ha molti comportamenti indefiniti, come quello che succede alle istruzioni che Mario incontra mentre cade, quindi ho cercato di evitarlo.


12

Brainfuck, 2 byte, profondità 2, A000030 da A001477

,.

A000030 è la sequenza delle cifre iniziali degli interi non negativi, quindi questo legge semplicemente il carattere della prima cifra e lo riscrive. La sequenza successiva dovrebbe iniziare con i termini:

0, 1

12
Questo potrebbe essere il programma Brainfuck utile più breve che abbia mai visto.
Alex A.

9

Piet, 16 byte, profondità 3, A000035 da A000030

inserisci qui la descrizione dell'immagine

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 0

Questo è Piet, quindi i "byte" sono davvero dei codici. Eccolo ad una dimensione del codice maggiore:

inserisci qui la descrizione dell'immagine

Il programma legge semplicemente ned emette il nmodulo 2.


9

Marbelous, 7 byte, profondità 3, A011760 da A000027

È passato un po 'di tempo da quando questo sito ha visto una risposta Marbelous !

}0
<D++

La prossima risposta dovrebbe iniziare con i termini:

1, 2, 3

Puoi provare il codice nell'interprete Snippet Stack di es1024 . In put viene fornito tramite argomento della riga di comando e si dovrebbe scegliere "Visualizza output come numeri decimali". Altrimenti, il risultato verrà emesso come valore in byte, che tecnicamente va anche bene .

La sequenza è la sequenza di "pulsanti dell'ascensore negli Stati Uniti", vale a dire tutti i numeri interi positivi tranne 13. Si noti che Marbelous è limitato a numeri a 8 bit, ma per quanto ne so non ci sono edifici con un livello vicino a 256 piani. :)

Marbelous è un linguaggio 2D in cui i dati scorrono attraverso il codice sotto forma di biglie (valori di byte) che cadono lungo la griglia. }0viene sostituito con il primo argomento della riga di comando. <Dè un interruttore che funge da cella vuota per biglie inferiori a 13 ( Dè nella base 36), in modo che gli ingressi da 1 a 12 passino senza essere influenzati. Se il marmo è uguale o maggiore di 13, il marmo viene deviato a destra e passa attraverso il ++quale aumenta il valore di 1. In entrambi i casi il marmo cade quindi dal bordo, che stampa il suo valore.


8

Rail , 56 byte, profondità 4, A033547 da A002378

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 2, 6, 14

Il programma si basa su nSTDIN e le uscite n*(n^2+5)/3, che era un'ipotesi dei numeri magici per il modello di shell nucleare degli anni '40.

Rail è un linguaggio 2D incentrato sui binari del treno. Il codice sopra è golfato usando i @riflettori che invertono la direzione del treno, al fine di ridurre il numero di nuove linee. Qui è ungolfed:

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

Nota come Rail inizia in alto a sinistra e inizia a muoversi verticalmente in basso a destra.

I comandi di manipolazione dello stack utilizzati sono:

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

Il treno si dirama agli incroci >v<^, girando a destra se la parte superiore della pila è vera, altrimenti a sinistra se falsa.


8

Stellato, 22 byte, profondità 4, A008619 da A000142

      + + +*,  +   **.

La prossima risposta dovrebbe corrispondere ai seguenti termini:

1, 1, 2, 2

La sequenza è composta da numeri interi positivi ripetuti due volte. Il programma legge un numero da STDIN e calcola 1 + floor(n/2).

Starry è un linguaggio esoterico implementato in Ruby che faceva parte di un libro sul ... fare lingue esoteriche in Ruby. Ogni istruzione è determinata dal numero di spazi prima di uno di +*.,`'. Tutti gli altri personaggi vengono ignorati, quindi quanto sopra equivale a

      +
 + +*,
  +   *
*.

che sembra molto più stellato! (notare gli spazi finali)

I comandi rilevanti sono:

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

Risposta precedente, 53 byte

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

Questo genera invece la sequenza all'infinito. Alcuni comandi aggiuntivi sono:

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

7

Mathematica, 20 byte, profondità 6, A037965 da A104631

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

Questa è una funzione senza nome che calcola semplicemente la definizione della sequenza. La sequenza successiva dovrebbe iniziare con i termini:

0, 1, 4, 18, 80, 350

Nodo foglia (nessun'altra sequenza)
Calcolatrice

7

CJam, 34 byte, profondità 14, A157271 da A238263

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

La prossima risposta dovrebbe iniziare con i termini:

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

ma non ne è rimasto nessuno che non sia già stato fatto.

Lascia che D(n)sia l'insieme dei primi n3 numeri morbidi: ovvero numeri interi i cui fattori primi sono un sottoinsieme di {2, 3}. Sia S(n)il sottoinsieme più grande del D(n)quale non contiene esso stesso alcun sottoinsieme del modulo {x, 2x}o {y, 3y}. Quindi A157271 è la dimensione di S(n).


1
Ah bene, stavo guardando questo, ma non ero abbastanza chiaro cosa significasse la loro spiegazione. Il tuo è molto più chiaro.
Claudiu,

6

Golfscript, 3 byte, profondità 3, A000290 da A000030

~2?

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 4

Questa sequenza è semplicemente i numeri quadrati, quindi il programma prende un numero e produce il suo quadrato.


6

Preludio , 16 byte, profondità 1, A000211

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

Ho pensato di iniziare un albero con un numero iniziale meno ovvio. Questa è una sequenza Fibonacci generalizzata con definizione a(0) = 4, a(1) = 3, a(n) = a(n-1) + a(n-2) - 2. Di conseguenza, questo è principalmente un semplice adattamento della mia soluzione Prelude Fibonacci . Quanto sopra è un programma che stampa un flusso infinito di numeri. Presuppone l'interprete Python che genera numeri anziché singoli caratteri.

La prossima risposta dovrebbe iniziare con i termini:

4

6

Clip, 0 byte, profondità 2, A000027 da A000012

Dato un numero n, stampa il nthnumero nella sequenza1, 2, 3, 4...

La prossima risposta dovrebbe iniziare con i termini:

1, 2

5

J, 4 byte, profondità 4, A001563 da A000290

(*!)

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 4, 18

Questa sequenza è il numero moltiplicato per il suo fattoriale. In J (fg)xè f(x,g(x))qui x*factorial(x).


Potresti tralasciare le parentesi per 2 byte:*!
Aprıʇǝɥʇuʎs

@ ɐɔıʇǝɥʇuʎs Non ho intenzione di discutere con nessuno che dice che non posso lasciarli fuori per ~ 1/128 parte del punteggio. :)
randomra,

5

Mathematica, 48 byte, profondità 5, A104631 da A001563

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 4, 18, 80

Escludendo i nomi lunghi delle funzioni, Mathematica è assolutamente entusiasta di questa sfida. Questo è semplicemente il coefficiente di x^(2n+1)nell'espansione di

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

5

Elemento , 13 byte, profondità 3, A000045 da A000030

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

A000045 rappresenta i numeri di Fibonacci. Ogni termine nella sequenza è la somma dei due termini precedenti. È notevole perché il rapporto tra termini consecutivi si avvicina al rapporto aureo, noto anche come phi. Abbastanza interessante, la voce OEIS inizia con 0, 1invece del comune 1, 1. La prossima risposta dovrebbe corrispondere ai termini:

0, 1, 1

5

Preludio , 1 byte, profondità 2, A000004 da A001477

!

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 0

Questo programma accetta ncome input, lo ignora completamente e genera la costante zero. Richiede NUMERIC_OUTPUT = Truenell'interprete Python.

La cosa bella di Prelude è che ha una scorta infinita di zeri nella parte inferiore dello stack, quindi tutto ciò che serviva era un singolo comando di output.


4

Perl, 10 byte, profondità 1, A001477

Per dare il via alle cose, ecco una semplice sequenza.

print$_=<>

Ciò rappresenta i numeri non negativi 0, 1, 2, 3, ecc. Stampando il numero di input. La sequenza successiva dovrebbe iniziare con i termini:

0

4

GolfScript, 9 byte, profondità 4, A051682 da A002275

~.9*7-*2/

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 11, 30

Questo utilizza semplicemente la formula per i numeri endecagonali presenti nella pagina OEIS.


4

Pesce morto, 4 byte, profondità 2, A005563 da A001477

isdo

Questa sequenza è definita come (n+1)^2-1, che è esattamente ciò che fa questo programma. Poiché Deadfish non ha input, presuppone che l'accumulatore si trovi sul numero di input desiderato. La prossima risposta dovrebbe iniziare con i termini:

0, 3

4

APL, 13 byte, profondità 4, A000108 da A000142

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

Numeri catalani! L'indicizzazione inizia da zero per questi. La prossima risposta dovrebbe iniziare con i termini:

1, 1, 2, 5

4

GolfScript, 31 byte, profondità 11, A029030 da A242681

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

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

ma non sarà in grado di: questa è una foglia dell'albero. Questa sequenza è il numero di modi per dare il resto con monete del valore 1, 2, 10 e 11.


3
A258000: 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 7, 42 - Qualche strana sequenza che hanno chiesto a codegolf.stackexchange.com
schnaader

4

Retina , 1 byte, profondità 3, A055642 da A001333

.

La prossima risposta dovrebbe iniziare con i termini:

1, 1, 1

Penso che questa sia la prima volta che ho usato Retina in qualcosa di diverso dalla modalità Sostituisci. Se viene fornito un solo file senza alcuna opzione, Retina assume la modalità Match, che per impostazione predefinita conta il numero di corrispondenze della regex specificata nell'input. Questa regex è .e corrisponde a qualsiasi personaggio. Pertanto, questo programma restituisce il numero di cifre dell'ingresso che è A055642.


3

Clip , 24 byte, profondità 4, A049666 da A002275

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

0, 1, 11, 122

La sequenza è giusta Fibonacci(5n)/5. Vedi la pagina degli esempi per una spiegazione.


3

Clip, 37 byte, profondità 5, A227327 da A000292

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

Modi possibili per scegliere due punti su una griglia triangolare del lato n, esclusi rotazioni e riflessioni. L'esempio fornito è: per n = 3, ci sono 4 modi:

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

La sequenza successiva deve iniziare con i seguenti termini:

0, 1, 4, 10, 22

3

APL, 24 byte, profondità 6, A025581 da A182712

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

La sequenza A025581 è la sequenza di ... Non sono del tutto sicuro di essere onesto. Mi spaventa.

L'indicizzazione inizia da 0 e la funzione calcola solo la sequenza per definizione.

La sequenza successiva dovrebbe iniziare con i termini:

0, 1, 0, 2, 1, 0

Numero intero decrescente da m a 0 seguito da numeri interi decrescenti m + 1 a 0, ecc. Ciò potrebbe essere d'aiuto.
Calcolatrice

3

> <>, 25 byte, profondità 2, A001333 da A002522

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

Questi sono i numeratori della frazione continua convergenti a sqrt (2). Il codice richiede all'utente di prepopolare lo stack con l'indice del convergente che deve essere restituito. L'indicizzazione inizia da 1. La risposta successiva dovrebbe iniziare con i termini:

1, 1

3

J, 44 byte, profondità 10, A242681 da A026233

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

La prossima risposta dovrebbe iniziare con i termini:

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

Qualcosa di più vicino alla vita di tutti i giorni: "il numero di modi in cui è npossibile ottenere un punteggio usando due freccette su un bersaglio standard". Solo la coppia di punteggio non ordinata conta. L'offset iniziale è due come nella pagina OEIS. Uso:

f 2 => 1
f 72 => 12

3

R, 20 byte, profondità 11, A194964 da A242681

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

La prossima risposta dovrebbe corrispondere ai seguenti termini:

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

La sequenza A194964 fornisce per ogni n il risultato di 1+[n/sqrt(5)]dove [significa "piano". La funzione R accetta input come stdin.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.