La tarea aquí es escribir un programa que toma un número natural, $n$ , y produce el $n$ º término de una secuencia de OEIS. Esa secuencia debe tener un identificador en forma de A6 dígitos seguidos. Ahora, cuando toma su código fuente y revierte el orden de sus bytes para producir un nuevo programa, ese programa también debe implementar una secuencia OEIS. La nueva secuencia debe identificarse con un Aseguido de los mismos 6 dígitos que la última vez pero en orden inverso (incluidos los ceros a la izquierda).

Ahora, para evitar que las cosas sean triviales, ni el número de identificación OEIS ni su programa pueden ser palíndromos. Es decir, las secuencias y los programas deberían ser diferentes. No puede elegir una secuencia para la que su inversión no exista o esté vacía.

Para cada una de sus secuencias, puede optar por usar 0 o 1 indexación. No tienen que usar la misma indexación. Dado que algunas secuencias OEIS tienen un dominio limitado, solo necesita generar los números correctos para el dominio de la secuencia. Su comportamiento requerido no está definido fuera del dominio (puede generar 0, bloquear, pedir una pizza, etc.).

Este es el código de golf, por lo que las respuestas se puntuarán en bytes con menos bytes mejor.

05AB1E , 9 4 bytes ( A000040 y A040000 )

Ø=>≠

Pruébalo en línea!

! enilno ti yrT

Explicación:

Ø          # nth prime
 =         # output
  >≠       # ignored

: noitanalpxE

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

Perl 6 , 55 bytes (A055642 y A246550)

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

Pruébalo en línea!

$n$

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

Pruébalo en línea!

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

La mayor parte de este desafío fue simplemente encontrar una buena secuencia con un reverso no demasiado complicado.

Actualización: Usando la respuesta de torcado , esto puede ser de 19 bytes (A010851 y A158010)

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

Pruébalo en línea!

\ / \ /> , 15 14 bytes ( A010851 y A158010 )

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

efectivamente cn, salida 12

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

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

¡Gracias a un amigo por encontrar secuencias increíblemente simples!

Haskell, 47 bytes ( A000010 y A010000 )

Ambas secuencias son relativamente simples.

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

Pruébalo en línea!

p n = la función totient de Euler de n (A000010) (1 indexado)

Invertido:

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

Pruébalo en línea!

p n = 1 si n = 0, de lo contrario n ^ 2 + 2

Sería interesante ver una respuesta que no use comentarios ...

Python 2 , 59 bytes (A030000 y A000030)

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

Pruébalo en línea!

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

Pruébalo en línea!

$n$

Versión más corta, que toma cadenas como entrada (para ambas secuencias), y ambas siguen indexadas en 0:

Python 2 , 56 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!