Este es un desafío de policías y ladrones . Para el hilo policías, ve aquí .

Este desafío involucra dos secuencias OEIS elegidas por los policías - S ₁ , S ₂ - y qué tan bien esas secuencias pueden ser golfizadas y ofuscadas.

Los policías están construyendo el código A que produce S ₁ y dan un número X que afirman que es la mejor distancia posible de Levenshtein (en caracteres) para crear B que produce S ₂ .

El desafío de los ladrones

Para descifrar la sumisión de un policía en particular, los ladrones deben idear un programa C en el mismo lenguaje (y versión) que la respuesta que produce S ₂ (n) y si el carácter Y se aleja de A (con Y <= X). Los ladrones no necesariamente necesitan encontrar exactamente el mismo código B que produjo el policía (en secreto). Los envíos de los ladrones deben adherirse al mismo índice 0 o índice 1 especificado por el envío del policía.

Si logra esto, publique una respuesta con la solución, vinculando la respuesta del policía, y deje un comentario sobre la respuesta del policía vinculando la suya.

Cada respuesta de policía solo se puede descifrar una vez y, por supuesto, no puedes descifrar tu propia respuesta. Si la respuesta del policía resulta ser inválida antes o después de ser descifrada, no se cuenta para el puntaje del ladrón.

Ganar y anotar

Los ladrones son anotados por (X - Y)*5 + 5cada una de sus grietas, y el ladrón con el puntaje más alto general gana.

Reglas adicionales

• No debe usar ninguna función integrada para generar hash, cifrado o generación de números aleatorios (incluso si coloca el generador de números aleatorios en un valor fijo).
• Se permiten programas o funciones, pero el código no debe ser un fragmento y no debe asumir un entorno REPL.
• Puede tomar entrada y dar salida en cualquier formato conveniente . Los métodos de entrada / salida deben ser los mismos para ambas secuencias.
• La calculadora definitiva para la distancia de Levenshtein para este desafío es esta en Planet Calc.
• Además de ser un desafío CnR, este es el código de golf, por lo que se aplican todas las reglas habituales de golf.

Pyke, Levenshtein distancia de 1, A036487 , A135628 - puntaje 5

Grieta de una entrada por muddyfish

wX*e

Pruébalo aquí!

El código original X*e, al cuadrado de la entrada, Xmultiplica eso por la entrada *, y reduce a la mitad el resultado e,.

El truco es que 'X'es 56 en la representación de base 96 w, por lo que wXproduce 56, multiplíquelo por la entrada, luego por el piso y reduzca a la mitad y obtendrá 28 veces la entrada según sea necesario.

Brain-Flak , 28 bytes, Distancia de 4, A002817 , A090809

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

Esta respuesta fue descubierta con la ayuda de un brute-forcer, que generó 35,000 programas posibles (muchos de ellos estaban desequilibrados y, por lo tanto, un código inválido de ataque cerebral, pero rodé con el error y encontré la respuesta de todos modos). Esto fue alrededor del programa número 20 mil que se probó, y me llevó alrededor de una hora encontrarlo (aunque no sé exactamente cuánto tiempo estuve fuera cuando terminó).

Todavía no quería publicar esta respuesta, ya que todavía no tengo una comprensión completa de cómo funciona este programa. Sin embargo, la respuesta está a punto de ser segura, así que no quiero que caduque. Espero actualizar esta respuesta más una vez que la entienda completamente, así como publicar el código que usé para encontrar esta respuesta. Pero por ahora, solo publicaré una explicación parcial.

#Push the sum of:
(

    #The (n-1)th triangular number, and the range [1, n] (The range doesn't count towards the sum I believe)
    ({(({})[()])}{})

    #Triangulate every number on the stack
    {{({}[()])}{}}

)

Esto tiene sentido porque OEIS dice:

Para n> 0, los términos de esta secuencia están relacionados con A000124 por a (n) = sum (i * A000124 (i), i = 0..n-1). [Bruno Berselli, 20 de diciembre de 2013]

Y A000124 son los números triangulares + 1. Sin embargo, no sé exactamente qué es el forumla, así que no puedo explicar completamente cómo funciona esto.

Perl 6, 19 bytes, X = 1, A000045 → A000035

{(0,1,*+<*...*)[$_]}

+>en lugar de +<también funcionaría.

Pruébalo en línea!

Cómo funciona

infix ... es bastante útil para secuencias recursivas simples. La (0,1,*+*...*)parte del código original, que es una abreviatura de

(0, 1, -> $x, $y { $x + $y } ... *)

especifica una secuencia que comienza con 0 y 1 , luego agrega elementos calculando la suma de los dos elementos anteriores de la secuencia.

Por el contrario, (0,1,*+<*...*)utiliza el desplazamiento de bits a la izquierda ( +>también funcionaría el desplazamiento de bits a la derecha) para construir la secuencia de paridad. Dado que desplazar 1 unidades cero a la izquierda es 1 , y desplazar 0 una unidad a la izquierda es 0 , obtenemos los patrones alternos deseados de unos y ceros.

Perl 6 , 10 bytes, distancia 1 - puntaje 5

Grieta de una entrada por smls

*[0]o 1***

Se convierte en:

*[0]o 1*+*

¡Pruébelo en línea!

Perl 6 , distancia 2, sonrisas

Original:

+(*%%2)

Grieta:

+(*+0%2)

Pruébalo en línea!

WolframAlpha, Distancia 1, Greg Martin , A002378 , A000537

(sum1to#of n^1)^2&

Cómo funciona

Me di cuenta de que, curiosamente, (n * (n + 1) / 2) ^ 2 es una fórmula para la segunda secuencia. Como sum (1 a n) es equivalente a n * (n + 1) / 2, solo tuve que cambiar el * a a ^.

Brain-Flak , 20 bytes, DJMcMayhem

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

Pruébalo en línea!

Se agregó un ({})al comienzo del ciclo para duplicar el valor en cada iteración.

JavaScript, Distancia 4, LliwTelracs

Original:

f=x=>{return x?2*x-1+f(x-1):0}

Grieta:

f=x=>{return x?2*(-0+f(x-1)):1}

Pruébalo en línea!

JavaScript (ES6), Distancia 1, Advancid

Original:

as=function(){ return 2*2**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Grieta:

as=function(){ return 0*2**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Pruébalo en línea!

o

as=function(){ return 2*1**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Pruébalo en línea!

De alguna manera, pude lograr que se comportara de manera diferente entre TIO y repl.it (absolutamente no tengo idea de por qué 2 * 1 ^ ... sería igual a 0 según el repl.it)

Javascript, 41 bytes, Distancia de 3, A061313, A004526

f=x=>{return x>>1;0?x%2?f(x+1)+1:f(x/2)+1:0}

Pruébalo en línea!

Java, Distancia 4, Peech , A094683 , A000290

Original:

int x{double r=1;for(int i=0;i<42;i++)r=r/2+n/r/2;int k=(int)((int)n*(float)n/Math.pow(n,(Math.sin(n)*Math.sin(n)+Math.cos(n)*Math.cos(n))/2));return n%4%2==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)r:k;}

Grieta:

int x{double r=1;for(int i=0;i<42;i++)r=r/2+n/r/2;int k=(int)((int)n*(float)n/Math.pow(n,(Math.sin(n)*Math.sin(n)+Math.cos(n)*Math.cos(n))/2));return n%4%1==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)n*n:k;}
                                                                                                                                                          ^                                                         ^^^

devuelve n * n

Javascript, Advancid , distancia de 2, A059841 y A000004

Solo dejando el código detrás del enlace TIO porque parece estar rompiendo el sitio.

Gracias a @nderscore, cuyo código usé para descifrar el código inicial

Había un código redundante, como el uso de !! [] + [] + [] en lugar de !! [] + [].

La adición de! + [] - (! + []) (+ 1-1) inicialmente evitó el descifrado.

Pruébalo en línea

Pyke, Levenshtein distancia de 2, A008788, A007526

'SS^

Pruébalo aquí!

Cómo funciona

Esto hace una conversión de base mixta.

'Stoma la entrada ny aplica, presionando [1, ..., n] en la pila. La siguiente Stoma la entrada ny empuja la misma matriz una vez más. 'parece causar que el siguiente comando se aplique a la parte superior anterior en la pila; Estoy un poco confuso con los detalles.

Finalmente, ^aplica la conversión de base mixta, entonces [1, ..., n] [1, ..., n] f calcula
a (n): = [1] n + n + (n) (n-1) .. . + [n!] 1 donde los corchetes indican el valor posicional y el número a la derecha del dígito.

Ahora, a (n) = (1 + (1) (n-1) + (n-1) (n-2) (n-3) + ... + (n-1)!) N = n ( a (n) + 1) , que es la misma fórmula recursiva que define a (n) en [A007526]. Como una suma vacía es cero, a (0) = 0 y el caso base también coincide.