Il compito è quello di scrivere un programma che richiede un numero naturale, $n$ , e produce il $n$ esimo termine di una sequenza OEIS. Tale sequenza dovrebbe avere un identificatore sotto forma di Aseguito da 6 cifre. Ora quando prendi il tuo codice sorgente e inverti l'ordine dei suoi byte per produrre un nuovo programma, quel programma dovrebbe anche implementare una sequenza OEIS. La nuova sequenza dovrebbe essere identificata da una Aseguita dalle stesse 6 cifre dell'ultima volta ma in ordine inverso (compresi gli zeri iniziali).

Ora, per evitare che le cose siano banali, né il numero identificativo OEIS né il tuo programma possono essere palindromi. Cioè le sequenze e i programmi dovrebbero essere diversi. Non è possibile scegliere una sequenza per la quale non esiste il contrario o è vuoto.

Per ciascuna delle tue sequenze puoi scegliere di utilizzare l'indicizzazione 0 o 1. Non devono utilizzare la stessa indicizzazione. Poiché alcune sequenze OEIS hanno un dominio limitato, è necessario solo generare i numeri corretti per il dominio della sequenza. Il comportamento richiesto non è definito al di fuori del dominio (è possibile eseguire l'output 0, l'arresto anomalo, ordinare una pizza, ecc.).

Si tratta di code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

05AB1E , 9 4 byte ( A000040 e A040000 )

Ø=>≠

Provalo online!

! enilno ti yrT

Spiegazione:

Ø          # nth prime
 =         # output
  >≠       # ignored

: noitanalpxE

≠          # boolean negation (0 if n == 1, 1 otherwise)
 >         # increment
  =        # output
   Ø       # ignored

Perl 6 , 55 byte (A055642 e A246550)

+*.comb#}]1-_$[)4+_$^**X]_$^[)*..2,emirp-si&(perg(tros{

Provalo online!

$n$

{sort(grep(&is-prime,2..*)[^$_]X**^$_+4)[$_-1]}#bmoc.*+

Provalo online!

$x^e$$x$$e \ge 4$

Gran parte di questa sfida consisteva nel trovare una buona sequenza con un rovescio non troppo complicato.

Aggiornamento: usando la risposta di torcado , questo può essere di 19 byte (A010851 e A158010)

{256*$_**2-$_}#{21}

Provalo online!

\ / \ /> , 15 14 byte ( A010851 e A158010 )

cn;n*-1*"Ā":j

efficacemente cn, uscita 12

j:"Ā"*1-*n;nc

effettivamente j:"Ā"*1-*n, n (256n-1)

grazie a un amico per aver trovato sequenze incredibilmente semplici!

Haskell, 47 byte ( A000010 e A010000 )

Entrambe le sequenze sono relativamente semplici.

p n=sum[1|x<-[1..n],gcd x n<2]--2+n*n=n p;1=0 p

Provalo online!

p n = la funzione totulante di Eulero di n (A000010) (1 indicizzato)

invertito:

p 0=1;p n=n*n+2--]2<n x dcg,]n..1[-<x|1[mus=n p

Provalo online!

p n = 1 se n = 0, altrimenti n ^ 2 + 2

Sarebbe interessante vedere una risposta che non usa i commenti ...

Python 2 , 59 byte (A030000 e A000030)

f=lambda n,k=0:k if`n`in`2**k`else f(n,k+1)#]0[`n`:n adbmal

Provalo online!

f$k$$2^k$$n$

lambda n:`n`[0]#)1+k,n(f esle`k**2`ni`n`fi k:0=k,n adbmal=f

Provalo online!

$n$

Versione più breve, che accetta le stringhe come input (per entrambe le sequenze) ed entrambe ancora con indice 0:

Python 2 , 56 byte

f=lambda n,k=0:`k`*(n in`2**k`)or f(n,k+1)#]0[n:n adbmal

Provalo online!

lambda n:n[0]#)1+k,n(f ro)`k**2`ni n(*`k`:0=k,n adbmal=f

Provalo online!