Este desafío tiene dos hilos. Este es el hilo conductor de la policía. El hilo de los ladrones se encuentra aquí .

Su desafío es elegir una secuencia OEIS y escribir dos programas completos en dos idiomas diferentes que produzcan ese enésimo elemento en la secuencia cuando se le da un n a través de STDIN u otras formas de entrada estándar, donde n es cualquier número positivo. Sin embargo, sus dos programas deben ser anagramas, lo que significa que cada uno puede reorganizarse a partir de las letras del otro.

Los programas deben generar el decimal del número seguido de espacios en blanco opcionales para STDOUT. Los programas pueden enviarse a STDERR; sin embargo, debe ignorarse y, si el caso oculto lo hace, debe establecerse claramente que este es el caso.

Si lo desea, también puede generar el código de caracteres. Sin embargo, si lo hace en su solución oculta, debe indicarlo en el cuerpo de su presentación.

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

Los ladrones descifrarán su envío si encuentran un anagrama del envío original que se ejecuta en un idioma diferente al que ya presentó. Para descifrar una respuesta, solo deben encontrar cualquier lenguaje y programa que produzca la secuencia y sea un anagrama del original, no necesariamente la respuesta en la que estaban pensando.

Por lo tanto, se le incentiva para que sea lo más difícil posible encontrar cualquier idioma que realice la tarea utilizando su lista de símbolos.

Puntuación

Este es el código de golf, por lo que el programa sin descifrar más corto es el ganador.

Idiomas

Los idiomas se considerarán diferentes si las dos soluciones propuestas no completan la tarea en ambos idiomas. Esto incluirá diferentes versiones del mismo idioma siempre que ni la solución del policía ni la solución del ladrón produzcan la salida correcta en el idioma del otro.

es decir, si hay dos soluciones 1 y 2 que están en el lenguaje A y B, respectivamente, la solución 2 no debe producir la salida correcta en el idioma A y la solución 1 no debe producir la salida correcta en el lenguaje B.

La seguridad

Una vez que se haya descifrado su envío durante una semana, puede publicar su solución y declarar su publicación segura. Si después de una semana elige no publicar una solución, es posible que su respuesta aún esté descifrada.

Python 2, 118 bytes, A042545 Agrietado

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|

No tenía ganas de implementar una secuencia trivial, así que decidí ir con mi ID de usuario PPCG. Primero escribí esto en el otro idioma, lo que debería darle una pista sobre cuál es ese idioma, aunque apostaría 100 dólares a que se descifrará en un idioma de golf antes de que se descifre en el otro idioma deseado.

Nota: Debido a errores de precisión de coma flotante, esto solo es preciso hasta una entrada de 14. La solución prevista es la misma.

Solución prevista, JavaScript (ES7)

for(i=prompt(),s=1/(801**.5-28),a=[1,0];i--;s=1/(s-n))
  n=s|0,a.unshift(a[1]+a[0]*n);
alert(a[0])  //#+2:[]giiiiinnpt

Funciona casi de la misma manera que la solución de Python, aunque la secuencia se almacena más grande primero que primero más pequeña debido al hecho de que JS no admite indexación negativa.

Brain-Flak, 24 bytes, A000290 , Seguro

Sin embargo, otra solución cuadrada. Esta vez no hay más que paréntesis

({(({}[()])()){}[()]}{})

La solución prevista estaba en Brain-Flueue , una versión de brain-flak que usa colas en lugar de pilas. El programa fue:

({(({})[()]){}}{})[()()]

Los idiomas se consideran distintos porque ninguno de los dos programas se detiene cuando se ejecuta en el otro idioma.

Python 2, 38 bytes, A000290 Agrietado por Emigna

def e(X):return X*X
print e(input())##

Esto probablemente será muy fácil de descifrar. Principalmente estoy publicando esto como un punto de partida.

Solución original en CJam:

ri:XX*e#def ()return X
e#pnt (input())

CJam , 7 bytes, A005843 ¡Agrietado!

ri2*e#^

Esta es una 2*nsecuencia básica .

Explicación:

r          e# read input
 i         e# convert to integer
  2*       e# multiply it by 2
    e#^    e# this is a comment that is ignored by the interpreter

Pruébalo en línea!

Solución original, zanahoria

#^i*2er

La zanahoria es un esolang creado por mí. He dejado de desarrollarlo hace mucho tiempo. La razón por la que elegí esto es porque esperaba que fuera difícil para otros idiomas comentar las partes innecesarias del código.

Explicación:

#^            This pushes the input to the stack (anything before the ^ is the stack)
  i           Convert stack to integer
   *2         Multiply it by 2
     er       These are ignored because they are not Carrot commands
              Implicit output

Pruébalo en línea!

2sable , 15 bytes, A000290 , ¡Agrietado!

Saltar en el mismo tren n ² : p.

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

Pruébalo en línea!

Brain-Flak, 44 bytes, A000290 Agrietado

<({({})({}[()])}{}))()()()turpentine/"*"*4splint>

Pruébalo en línea!

Solución original, Python 2

print(input()**(len(set("{}{}{}[]()<>"))/4))

Excel, 12 bytes, A000012 Agrietado

=IF(1=1,1,1)

Quizás no sea el más difícil, pero sí divertido de descifrar.

Python 2, 25 bytes, A000583 , agrietado

Y=input("");print`Y**4`,X

Este programa sale con un error después de imprimir la salida.

Mi código oculto (¡sustancialmente diferente de la solución descifrada!):

En realidad , 25 bytes

4,n`*`Y")ii(*nppruttY;="X

Pruébalo en línea!

Explicación:

4,n`*`Y")ii(*nppruttY;="X
4,n                        input, repeat 4 times
   `*`Y                    do * until the stack stops changing (fixed-point combinator)
       ")ii(*nppruttY;="X  push this string and immediately pop and discard it

Python, 118 bytes, A042545 , Seguro

i=int(input());s=pow(801.0,0.5);a=[0|0,1]
for Moshprtflmah in range(i):s=1./(s%1);a+=[a[-2]+a[-1]*int(s)];
print(a[i])

Esta vez funciona en 2 y 3. ¡Y no hay comentarios! ¿Qué harás?

Nota: Al igual que con la solución anterior, esto pierde precisión después de los primeros 15 términos debido a errores aritméticos de coma flotante.

Solución prevista, JavaScript (ES6)

giiiiinnnnprt:
i=prompt([n=+2]);s=Math.pow(801,.5);for(a=[1,0];i--;a.unshift(a[1]+a[0]*(s|0)))s=1/(s%1)
alert(a[0])   

Aunque conservé varias versiones antiguas, de alguna manera logré perder esta copia, pero afortunadamente reconstruirla de las otras no fue demasiado difícil. Ahora veo que tuve un extraño prten ambos programas que podría haberse desarrollado. Oh bien.

Python 2, 124 bytes, A144945 , [Seguro]

¡Romper esto te hubiera ganado una recompensa de 500 repeticiones! ¡Demasiado tarde!

Número de formas de colocar 2 reinas en un tablero de ajedrez n X n para que se ataquen entre sí.

Espero que no sea demasiado fácil. Arreglé mi código para que el espacio en blanco sea claramente visible. Esos son espacios y líneas nuevas solamente.

_{Nota: la solución prevista sale a través del código de caracteres}

n=input();print((3+2)*n*n+~0*6*n+1)*n/3;            +6;



























+7+7+7+7+7+7+7+7+7;+++++++++++++++9+9*9*9

Pruébalo en línea

Solución prevista, Headsecks :

r2=ni***p**
(


p((0 ;3+++3;+;/


)





i+++nn
 +)7
n

n+++ 


17+~
 +)7;97++++7


69+9n+ ++7+n 69
 +7+ ++7


**7+++tut

Esto es equivalente al siguiente programa BF:

>>,[->>>+>>>+>>>+++++<<<<<<<<<]>>>->>>>>>-<<<[[>+<-]>[>>[<<<+>>+>-]<[>+<-]<-]<<<<]>>+++>[-<-[<+<<]<[+[->+<]<+<<]>>>>>]<<<.,.

Fuzzy Octo Guacamole, 26 bytes, A070627 [Seguro]

49++*5^pm#]%:"?:.=:#,|"1:@

Casos de prueba:

1 -> 1
3 -> 23
5 -> 1

Solución:

^::::|*?1=#@]","%.#49++5pm

Trabaja en Magistack.

Pyth, 75 bytes, A004526 Agrietado, leche

Más de una prueba lúdica que otra cosa, pero:

/Q/////////////////****22222 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!

Solución de leche (convexa):

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

Solución prevista (///):

/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    

Pruébalo en línea

Toma la entrada en forma de 2 antes del último punto y coma y genera el número correcto de Q.

La secuencia está indexada en 0 (es decir, 0 es 0, 1 es 0, 2 es 1, ...)

Encontró ligeros errores sintácticos en ///, por lo que editó todas las soluciones.

MATL, 7 bytes, A000217 , agrietado

:sp{1}x

La secuencia es n(n+1)/2(números triangulares), a partir de la entrada n=1según lo especificado por el reto: 1, 3, 6, 10, ... (Salida para la entrada 0no se garantiza que sea la misma en los dos programas).

El programa en el otro idioma sale con un error (después de producir la salida correcta en STDOUT).

Pruébalo en línea!

:            % Push [1 2 ... n], where n is implicit input
 s           % Sum of that array. Gives the desired result
   p         % Product of that. Gives the same number
    {1}      % Push a cell array containing number 1
       x     % Delete it

Python 2, 37 bytes, A000290 Agrietado

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

Python 3, 27 bytes, A000012 , Agrietado

No hay entrada esta vez!

if 1:
    if 1:
        print( '1' )

Las sangrías son pestañas, pero no para guardar bytes, son necesarias para los espacios en blanco.

¡No creo que necesite un enlace o explicación de TIO!

(Probablemente no tomará mucho tiempo agrietarse de alguna manera)

Respuesta prevista (espacio en blanco):

-Start-


    if1:if1:print('1')
-End-

(El inicio y el final no forman parte del programa)

Lo siento, olvidé agregar que se imprime en STDERR:

Pruébalo en línea!

Fuzzy Octo Guacamole , 11 bytes, A001844 [¡Seguro!]

hha02^d+**+

Una grieta que tipo de obras es dh*h++^2*0a, en Pyth. Sin embargo, no es el formato de salida correcto.

¡Mi código sigue ahí afuera! (y no está en Pyth)

Casos de prueba:

0 -> 1
1 -> 5

Solución:

^++d0ah*2*h

En jolf.

WinDbg, 39 bytes, A000007 Agrietado por jimmy23013

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

La difícil secuencia de 0**n.

La entrada se realiza pasando un valor en el pseudo-registro $t0.

Mi solución original fue C #:

@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";

JavaScript ES6, 38 bytes, A000290 , Agrietado

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

Este tren cuadrado es bastante ingenioso, pero no va a ninguna parte rápido. (Consígalo? Tren cuadrado ? Como en, ruedas? No? Bien, bien. Críticas .)

Respuesta prevista: Reticular (¡ Pruébelo en línea! ),

in2Jo;=>eval(Array(J).fill(J).j`+`)|-2
in      take input, convert to number
  2J    raise to the second power
    o;  output and terminate; ignores following chars

MATL , 13 bytes, A002275 ¡Agrietado!

i:"@ax'1']
v!

Pruébalo en línea!

Explicación:

i           % Grab input
 :          % Push (range(1,input))
  "         % For each element in this range:
   @        %   Push it
    a       %   Is is truthy?
     x      %   Delete it
      '1'   %   Push '1'
         ]  %   End loop
v           % Join all of these '1's together
 !          % Transpose and display

2sable , 13 bytes, A002378 , ¡Agrietado!

Esperando no haberme perdido algo. Calcula a (n) = n × (n + 1) :

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

Mi version:

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

O la versión desplegada:

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

Tenga >en cuenta que la esquina superior izquierda no se usa (excepto el programa 2sable). Hice esto para confundir a los ladrones (pero eso obviamente no funcionó jaja).

Pruébalo en línea!

2sable, 15 bytes, A087156

D1QiA0*<}.;2->>

Pruébalo en línea

La secuencia de números no negativos, excepto 1.

Befunge 93 , 14 bytes, A121377 , ¡ Agrietado por la leche !

&52* %68*+ .@Q

Dato curioso: la solución prevista para esto es la primera vez que uso ese lenguaje.

Mi solución en Pyth. & @ imprime un error, pero eso va a STDERR que, de acuerdo con el OP, se ignora.

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

Python 2, 35 bytes, A048735 , Seguro

print(lambda u:u&u<<1)(input())>>1

La solución original estaba en mi propio lenguaje de programación Wise .

:<<>&>print(lambda uuu1)(input())1

La mayoría de los personajes son irrelevantes sin operaciones. Los personajes importantes son los primeros seis. :crea dos copias del primer elemento en la pila. <<>el bit se desplaza dos veces hacia la izquierda y una vez hacia la derecha, lo que equivale al desplazamiento de bit una vez hacia la izquierda. &toma el bit a bit y del elemento superior y segundo (el original y la copia desplazada del bit). Por último, >los cambios de bit una vez a la derecha.

05AB1E, 5 bytes, A000012 , Seguro

$;$1?

Secuencia de 1's. Pruébalo en línea

Solución prevista: Arcyou

1;$$?

Pruébalo en línea . No pude encontrar documentación para este idioma, así que no tengo una explicación de cómo funciona exactamente.

Python 2, 70 Bytes, A000217 ¡Agrietado!

Tengo la sensación de que esto no se descifrará en el idioma que utilicé para la otra versión, ya veremos :)

o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v


#|  d00->1@@@++-^,,[

Luego me di cuenta de que había ofuscado incorrectamente el código (no cambia la validez de la respuesta publicada). Aquí está el código con el que comencé en Haystack:

v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|

05AB1E , 9 bytes, A000042 ¡Agrietado!

1×,1*-^$)

Esta es la representación unaria de los números naturales (OEIS). Entonces, si la entrada fue 3, por ejemplo, la salida sería 111.

Explicación:

                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant

Pruébalo en línea!

Solución original, zanahoria

1^*$-1×^)

Explicación

1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter

Los *multiplica por la cadena de (n+1)veces, por lo que a^*3da como resultado aaaay no aaa. Entonces es por eso que resta 1de la entrada.

Solo ahora me doy cuenta de que )ha sido irrelevante en ambos idiomas: D

Pruébalo en línea!

J, 2 bytes, A000290 , Agrietado

*~

Bueno, bien podría comenzar por esos dos byters. Rendimientos n × n , o n ² .

solución prevista, Jolf, 2 bytes

*~

Bien. Sí. Este es mi propio idioma y creo que funciona porque ~busca un carácter extendido, pero no encuentra uno, por lo que simplemente lo ignora. ¯ \ _ (ツ) _ / ¯ ¡ Vaya!

ABCR , 24 bytes, A023443 ¡Agrietado!

70: Quit xi. Classy queue!

Hay un montón de no-ops. Calcula n - 1.

05AB1E, 8 bytes, A000042 , Agrietado

F1}J,(1&

Casos de prueba:

1 -> 1
2 -> 11
3 -> 111

Ouroboros , 6 bytes, A000012 Agrietado

)49.o(

Siempre salidas 1.