Este es el hilo conductor de los ladrones de este desafío.

Los policías elegirán una secuencia OEIS y escribirán dos programas completos en dos idiomas diferentes que producen ese enésimo elemento en la secuencia cuando se les da un n a través de STDIN. Los dos programas deben ser anagramas entre sí, lo que significa que cada uno puede reorganizarse a partir de las letras del otro.

Presentarán el número OEIS, el código fuente y el nombre de un idioma en el que se encuentra.

Debes encontrar un anagrama de la presentación del policía original que se ejecute en un idioma que no sea el utilizado por el policía. Para descifrar una respuesta solo debes encontrar cualquier lenguaje y programa que produzca la secuencia y sea un anagrama del original, no necesariamente la respuesta en la que estaba pensando el policía.

Puede mostrar por código de caracteres o incluir STDERR en su solución, pero solo si el policía ha indicado que su solución oculta lo hace. La salida decimal a STDOUT siempre es un crack válido.

Por lo tanto, los policías están incentivados para que sea lo más difícil posible encontrar cualquier lenguaje que realice la tarea utilizando su lista de símbolos.

Tanteo

La persona con más grietas será la ganadora de esta sección. Solo la primera grieta para cada solución contará para la puntuación.

Junta de líderes

Muchas gracias a todos los que tuvieron lugar en este desafío.

Aquí está la tabla de líderes tal como está

Place  User             Score
-----------------------------
1      Adnan            3
1      Kritixi Lithos   3
1      Emigna           3
1      milk             3
5      Steven H.        2
5      Wheat Wizard     2
5      jimmy23013       2
8      ETH Productions  1
8      Dennis           1
8      alleks           1
8      Martin Ender     1
8      Oliver           1
8      Conor O'Brien    1

05AB1E , 38 bytes, Loovjo , A000290

nXtdief e():return X*X
pr e(input())##

Pruébalo en línea!

Muy probablemente no sea la solución prevista, pero funciona.

Explicación

n      # square input
 X     # push 1
  t    # push sqrt(1)
   d   # push is_number(1.0)
    i  # if true do the rest of the code (1.0 is not a number so it will never execute)

Jolf, 15 bytes, Adnan , A000290

*&"?!#$|<=@\^{}

Pruébalo aquí! Definitivamente no es la solución prevista, pero bueno, funciona.

Explicación

*&"?!#$|<=@\^{}
*                multiply
 &               the two inputs to this func, x, y: x && y
                 returns y if x and y, or the falsey argument.
  "?!#$|<=@\^{}  this string is always truthy, so the second arg is used.
                 two implicit inputs are taken, both equal to the first arg
                 so, this corresponds to *xx, which is x^2.

05AB1E , 49 bytes, Wheat Wizard , A000290

En realidad, el mismo enfoque que el crack de Emigna: p.

n4i<({({)({[()]){))()()()turpetne/"*"*splint>}}}}

Explicación:

n          # Square the input
 4i        # If 4 == 1, do the following...
   <({...

Pruébalo en línea!

05AB1E , 35 bytes, Oliver , A000290

Los policías deberían dejar de publicar n^2desafíos en Python ...

n0iprt(input()**(1+1))
"'1°3¢','m'"

Pruébalo en línea!

Explicación

n    # square input
 0i  # if 0 == 1 do the rest of the code

2sable , 7 bytes, Kritixi Lithos , A005843

Código:

r^#ei2*

Explicación:

r         # Reverse the stack, which is a no-op
 ^        # XOR the input with itself, always leading to 0
  #       # If 1, break (which stops the program)
   e      # Compute input nPr input, which always leads to 1
    i     # If equal to one, do the following..
     2*   #   Multiply the input by 2.

Pruébalo en línea!

Hexagonía , 13 bytes, Adnan , A002378

?"&\>=})\*!@<

Pruébalo en línea!

Desplegado:

  ? " &
 \ > = }
) \ * ! @
 < . . .
  . . .

No es 100% si este es el original, porque la parte superior izquierda \no está en uso.

El <\>son sólo espejos, por lo que el programa es en realidad todo lineal:

?"&)}=*!@

?          Read input.
 "         Move back and left.
  &        Copy input.
   )       Increment copy.
    }=     Move forward and right and turn around (to face the n and n+1 edges).
      *    Multiply.
       !   Print.
        @  Terminate.

V , 13 bytes, DJMcMayhem , A002275

v!:x]''"
@ai1

Pruébalo en línea!

Esta podría ser la primera solución en el idioma que pretendía el autor.

Explicación

v!:x]''"   Does nothing
@ai1       inserts 1 a times

2sable, Conor O'Brien , A000290

~*

Pruébalo en línea!

No sé cómo funciona, en realidad solo hay un programa que cumple con los requisitos y simplemente me vi obligado a encontrar el idioma en el que funcionaba.

Después de revisar los documentos, puedo llegar a una explicación:

~         Push Input OR Input (always pushes the input)
 *        Multiply that by Input 

Pyth , 26 bytes, Steven H. , A023443

Código:

tQ.qly 7:esau0euii s uxC !

Pruebe en línea .

Bastante simple:

 Q                            Reads input
t                             Substracts 1 from it
  .q                          Quits program (implicit print)
    ly 7:esau0euii s uxC !    None of this ever plays a part...
                                I just thought it'd be fun to scramble it.

Python 3, 118 bytes, ETHproductions, A042545

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
(print(a[-2]),) #.0fhlmop|

Pruébalo en Ideone .

Presentación de la policía

i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|

Qué es diferente

El envío de policía no funciona en Python 3 por dos razones.

• La función de entrada de Python 2 evalúa automáticamente una línea de entrada, mientras que la contraparte de Python 3 solo devuelve la línea como una cadena. Simplemente podemos llamar a int para arreglar esto.

• print era una declaración en Python 2, pero es una función en Python 3. En particular, eso significa que tenemos que rodear su argumento con paréntesis.

Eso significa que necesitamos int()y (), pero esos personajes no son parte del comentario. Eso significa que debemos hacer algunos cambios.

En lugar de la fracción s , hacemos un seguimiento de 1 / s .

La inicialización de s - s=1/(801**.5-28)- se convierte en s=801**.5-28guardar los caracteres 1/().

El factor de a [-1] en la actualización de a - int(s)- se convierte int(1/s), costando los caracteres 1/.

La actualización de s - s=1/(s-int(s))- se hace s=1/s-1//s, costando los caracteres 1//, pero guardando los caracteres (int()).

Los caracteres guardados ()(int())cubren los que necesitábamos para portar el código a Python 3, pero obtenerlos nos costó 1//. Podemos tomar //del comentario, pero tendremos que guardar en 1otro lugar.

Una forma (¿la única?) De guardar lo necesario 1es reemplazar 1la inicialización de a con 0==0. Esto cuesta esos cuatro caracteres, pero podemos tomar00 del comentario.

Hasta ahora, tenemos el siguiente código.

i=int(input());s=801**.5-28;a=[0,0==0]
for p in range(i):a+=[a[-2]+a[-1]*int(1/s)];s=1/s-1//s
print(a[i]) #,,,.()0fhlmo|

Para recuperar uno de los =que ahora "deber", podemos reescribir la inicialización de s y una con una sola misión: s,a=801**.5-28,[0,0==0]Además, esto ahorra ;y cuesta ,, que se puede agregar a y se retira del comentario.

El segundo =se puede guardar no almacenando la entrada en una variable, es decir, escribiendo en su range(int(input()))lugar, guardando los caracteres i=. Utilizamos i después del bucle así, pero el i ^º elemento de una es sólo el segundo desde la derecha, por lo que podemos reemplazar icon -2. Por la misma razón, a[-2]en el cuerpo del bucle se puede reemplazar con i.

Ahora tenemos una permutación en el código de trabajo de Python 3:

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
print(a[-2]) #,.()0fhlmop|

¡Sin embargo, este código también funciona en Python 2! Una forma de arreglar esto es reemplazar print(a[-2])con (print(a[-2]),); Tenemos los personajes que necesitamos en el comentario. Como se mencionó anteriormente, print es una función en Python 3, por lo que construye la tupla ( None ,) . Sin embargo, la declaración de impresión de Python 2 es un SyntaxError dentro de un literal de tupla.

CJam, 39 bytes, leche , A000007

l~0{"e.bockj(>=@$t0)@$t0+(<7)??0t:"};1?

Pruébalo aquí

Pyth, 7 bytes, Luis Mendo , A000217

x:{ps}1

Según lo solicitado, el programa sale con error después de paclarar la respuesta correcta.

Pruébelo en línea aquí !

05AB1E , 12 bytes, tuskiomi , A000012

1,(FI1=1=1,)

Pruébalo en línea!

Explicación

1,            # print 1
  (           # negate input
   F          # that many times do (i.e. no times)
    I1=1=1,)  # the rest of the code

05AB1E , 38 bytes, Conor O'Brien , A000290

n2iJ=>eval(Array(J).fill(J).jo`+`)|-2;

Pruébalo en línea!

Explicación

Esto se basa en la grieta de Emigna aquí .

n   #Squares the number
 2i #Runs the rest of the code if 2==1

05AB1E, 27 bytes, boboquack , A000012

1 1pif:
    if :
        rint( '1' )

Pruébalo en línea

Cómo funciona:

1                     # push 1
  1                   # push 1
   p                  # pop (1), push is_prime(1)
    i                 # pop (is_prime(1), false), if is false so don't execute rest

CJam, 70 bytes, Shebang , A000217

ri),:+








e#|  d00->1@@@++-^,[o=input(v=0i=1whil o v=i i+=1pnt v

Pruébalo aquí

Convexo, 75 bytes, boboquack , A004526

2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Pruébalo en línea

Cómo funciona:

2  e# push 2
 / e# pop first 2, divide, push result
   e# push a bunch of garbage but discard it all with semi-colons (;)
  Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Dip , 9 bytes, Kritixi Lithos

Definitivamente no es la respuesta prevista.

1^,-$)×1*

Explicación:

1$^,-)×   # Basically does nothing
       1* # Repeat "1" n times

Pip , 6 bytes, DLosc , A000012

.()49o

Pensé que primero probaría el esolang del OP ;-)

Pruébalo en línea.

05AB1E , 25 bytes, Mego , A000583

Código:

nnYi=put("");prit`Y**4`,X

Explicación:

n       # Square the input
 n      # Square the squared input
  Y     # Constant that pushes 2
   i    # If equal to 1, do the following:
    =put...

Pruébalo en línea!

Dip , 8 bytes, Oliver , A000042

(1J&F},1

Explicación

              #Implicit Input
(             #Start range loop
 1            #Push 1 to the stack
  J           #Join all the elements in the stack
   &          #End program
    F},1      #These are ignored

Lo curioso es que este era el lenguaje previsto. Dip es un esolang creado por Oliver.

Casos de prueba y Dip en ejecución desde la línea de comandos

$python3 dip.py
Dip v1.0.0 by Oliver Ni.
>>> (1J&F},1
> 4
1111
>>> (1J&F},1
> 7
1111111

2sable, 14 bytes, Dopapp , A121377

Q@5 2*%6 8*+.&

Pruébalo en línea.

Cómo funciona (más o menos):

Q@
  5              # Push 5
    2            # Push 2
     *           # Pop (2), pop (5), push 5*2=10
      %          # Pop (10), pop (input), push input%10
       6         # Push 6
         8       # Push 8
          *      # Pop (8), pop (6), push 8*6=48
           +     # Pop (48), pop (input), push input+48
            .&

05AB1E , 4 bytes, Oliver , A000012

p¥_1

Pruébalo en línea!

Esta es una secuencia de 1s.

              # Implicit input
p¥_           # Does nothing
   1          # Pushes 1 to the stack
              # Implicit output

Esto genera 1sin importar la entrada.

Dip , 5 bytes, Oliver , A000012

`¸WW/

La secuencia solo imprime 1sin importar cuál sea la entrada. La respuesta de Oliver imprime a 1.0. Este programa también imprime a 1.0. Al parecer, esta es la solución prevista.

Explicación

`¸                  # push character `¸`
  W                 # pushes 1000000
   W                # pushes 1000000 also
    /               # divides the last two items in stack resulting in 1.0
                    # implicit output (1.0)

Solución alternativa (cortesía de @milk)

Convexo , 5 bytes

WW¸`/

Pruébalo en línea!

Explicación

                  // implicit input
W                 // pushes -1
 W                // pushes -1 also
  ¸               // calculates the LCM of the two numbers (which evaluates to 1)
   `              // finds its string representation
    /             // slices the string (so that it would evaluate to "1")
                  // implicit output