Este es un desafío de policías y ladrones. Este es el hilo del ladrón. El hilo del policía está aquí .

Los policías elegirán cualquier secuencia del OEIS y escribirán un programa p que imprima el primer entero de esa secuencia. También encontrarán algunas cadenas s . Si inserta s en algún lugar de p , este programa debe imprimir el segundo entero de la secuencia. Si inserta s + s en la misma ubicación en p , este programa debe imprimir el tercer entero de la secuencia. s + s + s en la misma ubicación imprimirá el cuarto, y así sucesivamente. Aquí hay un ejemplo:

Python 3, secuencia A000027

print(1)

La cadena oculta es de dos bytes .

La cadena es +1, porque el programa print(1+1)imprimirá el segundo entero en A000027, el programa print(1+1+1)imprimirá el tercer entero, etc.

Los policías deben revelar la secuencia, el programa original p y la longitud de la cadena oculta s . Los ladrones descifran una presentación al encontrar cualquier cadena de esa longitud y la ubicación para insertarla para crear la secuencia. La cadena no necesita coincidir con la solución prevista para ser una grieta válida, ni tampoco la ubicación en la que se inserta.

Si descifras una de las respuestas de la policía, publica tu solución (con la cadena oculta y la ubicación revelada) y un enlace a la respuesta. Luego comente la respuesta de la policía con un enlace a su crack aquí.

Reglas

• Su solución debe funcionar para cualquier número en la secuencia, o al menos hasta un límite razonable donde falle debido a restricciones de memoria, desbordamiento de enteros / pila, etc.

• El ladrón ganador es el usuario que descifra la mayor cantidad de envíos, siendo el desempate el que alcanzó ese número de grietas primero.

• El policía que gana es el policía con la cadena más corta s que no está agrietada. Tiebreaker es el más corto p . Si no hay envíos sin descifrar, el policía que tenía una solución descifrada para ganar más tiempo.

• Para ser declarado seguro, su solución debe permanecer sin descifrar durante 1 semana y luego debe revelar la cadena oculta (y la ubicación para insertarla).

• s no puede estar anidado, debe concatenarse de extremo a extremo. Por ejemplo, si s fuera 10, cada iteración iría en 10, 1010, 101010, 10101010...lugar de10, 1100, 111000, 11110000...

• Todas las soluciones criptográficas (por ejemplo, verificar el hash de la subcadena) están prohibidas.

• Si s contiene caracteres no ASCII, también debe especificar la codificación que se está utilizando.

Python 2 , secuencia A138147 por xnor

Original:

print 10

Agrietado:

print "1%s0"%10
      ^^^^^^^

Pruébalo en línea!

Brain-Flak , A000984 por Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Esto es solo 30 bytes, no estoy seguro de lo que Nitrodon tenía en mente.

Pruébalo en línea!

Explicación

Intenté muchas cosas, pero esto es lo que funcionó. Los términos de A000984 son los elementos centrales del triángulo de Pascal.

Ahora descubrí que puedo obtenerlos sumando las diagonales por encima de ellos:

Por ejemplo:

$1+3+6+10 = 20$

Y dado que la acción final en el programa de Nitrodon es resumir todo, me pareció un buen candidato (más bien, intenté un montón de cosas pero este terminó funcionando).

Entonces, queremos un programa que tome una suma parcial y produzca la siguiente. Afortunadamente, hay una manera bastante ordenada de pasar de uno de estos al siguiente. Cada fila es el deltas de la siguiente fila. Ese es el $n$ º plazo en una fila es la diferencia entre el $n$ º y $n-1$ º términos en la siguiente fila.

El único problema es que no tenemos suficiente de la última fila para calcular la fila que queremos. Dado que cada fila es una más larga que la última si tenemos una fila, no podemos obtener el último miembro de la siguiente fila con este método. Sin embargo, aquí tenemos otro truco, ¡el último miembro de cada fila es igual a todos los miembros anteriores de esa fila!

$1+3+6=10$

Y si estás familiarizado con Brain-Flak, eso debería destacarte como algo que será realmente fácil de hacer.

Ahora para el código:

Para comenzar, hacemos el siguiente cálculo de fila donde cada miembro nuevo es la suma de dos miembros antiguos adyacentes. Eso se puede hacer con:

{({}<>({}))<>}<>

Lo que básicamente mueve un elemento y agrega (sin eliminar) lo que ya estaba encima. Sin embargo, esto revierte todo, así que para la próxima vez que tengamos una fila necesitamos volver a colocarla.

{({}<>({}))<>}<>{({}<>)<>}<>

Ahora necesitamos calcular el último miembro de la fila. Como dije antes, esto es súper fácil. Como teníamos un bucle sobre todos los elementos de la fila, podemos tomar esa suma y empujarla. Lo empujamos antes del segundo bucle para que termine en la parte inferior.

({({}<>({}))<>}<>){({}<>)<>}<>

Y eso es.

Brain-Flak, A000290 , por Sriotchilism O'Zaic

Original:

((()))({}<>)

Agrietado:

((()))({}([])[]<>)
         ^^^^^^

Pruébalo en línea!

Alternativamente:

((())([])[])({}<>)
     ^^^^^^

Pruébalo en línea!

MAT , secuencia A005206 por Luis Mendo

Original:

voOdoO

Pruébalo en línea!

Agrietado:

voOdoOdNq17L/k
      ^^^^^^^^

No soy un experto en MATL, pero por lo que entiendo, el original voOdoOcrea dos matrices vacías y una matriz [0]en la pila. Esto [0]es lo que se imprime sin corchetes como primer elemento de la secuencia. La grieta / solución hace lo siguiente:

• dquita elementos de la pila y (suponiendo que sea un número o una matriz de tamaño 1) lo convierte en una matriz vacía. Estas matrices vacías no se imprimen, pero contribuyen al tamaño de la pila
• Nqcuenta el tamaño de la pila y resta uno. Este es el n+1término al evaluar la función (ya que comienza en 2 y aumenta en uno cada iteración debido a la dadición de cosas invisibles a la pila)
• 17L esta es la constante Phi = (1+sqrt(5))/2
• /kesto realiza floor((n+1)/Phi)cuál es una de las fórmulas que computa los elementos de la secuencia. Esta fórmula aparece en OEIS, a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2excepto que usamos la identidad(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

Pruébalo en línea!

100 botellas de cerveza, agregue -1para obtener el siguiente número 99, etc.

Barrilete , secuencia A000045 , por A__

Original:

0.

Agrietado:

01":&+.
 ^^^^^

Tenga en cuenta que el desafío fue encontrar una subcadena de longitud <= 6, pero la cadena encontrada tiene una longitud 5.

Definición de los comandos para aquellos que son demasiado vagos para buscar la especificación Keg: 0y 1empujar el número respectivo a la pila; "mueve la parte superior de la pila a la parte inferior de la pila (rodar); &coloca la parte superior de la pila en el registro si está vacía; de lo contrario, vacía el registro en la pila; +agrega los dos valores superiores de la pila.

La inicial 1"solo inserta un 1 en la parte inferior de la pila. Esta creciente lista de 1 solo juega un papel en la primera iteración, donde nos permite asumir que la pila comienza como 1 0algo más que simplemente 0. De hecho, el programa 10:&+., donde :&+se repite la parte, tiene exactamente el mismo comportamiento que la solución anterior, excepto que no tiene una lista creciente de 1 en la parte inferior.

Como &se usa solo una vez en la parte que se repite y tiene un comportamiento alternativo, el comportamiento de 1":&+depende de la paridad de la iteración.

Ahora, este programa realmente no imprime la secuencia de Fibonacci que comienza con 0, 1 desde el principio; en realidad imprime la secuencia de Fibonacci 1, 0 desde el segundo lugar, es decir, desde el 0. (Esto da como resultado la misma secuencia). Sabiendo esto, el programa se analiza fácilmente:

• En la primera, tercera, ... iteración, el estado comienza como [a, b]y termina como a+b (&=b).
• En la segunda, cuarta, ... iteración, el estado comienza como [b] (&=a)y termina como [b, b+a].

De hecho, esto calcula la secuencia según sea necesario.

Java 8+, secuencia A010686 por Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Cerebro-Flak, A000578 por Sriotchilism O'Zaic

Original:

((())<>)

Pruébalo en línea!

Agrietado:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Pruébalo en línea!

Pyret , secuencia A083420 , por MLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Puede ejecutarlo aquí, pero no he descubierto cómo vincular el código. Tendrás que copiar y pegar.

La función proporcionada ignora su segundo argumento. Duplica el primero y agrega uno, lo que generará la 2^n - 1secuencia necesaria que se necesita aquí; todo lo que necesito hacer es decirle cuántas veces realizar esa operación, al cambiar la longitud de la lista plegada. Afortunadamente, Pyret no se queja de esa coma final.

Python 3 , secuencia A268575 por NieDzejkob

Original:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Agrietado (100 bytes):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Pruébalo en línea!

Por lo que puedo deducir, el código original está configurando definiciones para hacer que la cadena oculta sea lo más abreviada posible y luego define el patrón inicial del Juego de la Vida. La cadena oculta es equivalente a escribir una iteración del Juego de la vida de Conway en 102 bytes.

Para los propósitos de este crack, Ses una función que suma los elementos dentro de sus argumentos (que son iterables) y Faplica una función que devuelve un iterable a cada elemento de una lista y junta todos los resultados.

• ;A=-1,1,0;finaliza la declaración anterior y abrevia la tupla (-1,1,0) con A, que se usa como la product(A,A)que da a todos los vecinos en relación con una celda determinada, así como la celda misma.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);crea una nueva lista que Xcontiene todos los vecinos de las celdas Wy las celdas en Wsí mismos al agregar las posiciones relativas de los vecinos a cada celda y juntarlas en una lista.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}revisa esta lista Xy determina si cada celda Xpertenece al conjunto de celdas en la siguiente iteración. Esto fue tomado casi literalmente de este juego de golf de la vida .

Haskell, A014675 por Khuldraeseth na'Barya

Código original

main=print$uncurry(!!)([2],0)

Con subcadena

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Pruébalo en línea!

Calculadora de escritorio, A006125 , por A__

Original:

1n

Agrietado:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Pruébalo en línea!

Implementación directa.

cQuents , secuencia A003617 de Stephen

=10#2:pZ
  ^

Pruébalo en línea!

Comience con el número más bajo de n + 1 dígito, uno seguido de n ceros. Los #2especifica que sólo el segundo término de la secuencia, que es la definición de secuencia aplica una vez a la semilla, se imprimirá; esta definición de secuencia simplemente encuentra y devuelve el siguiente primo.

Python 3 - agtoever

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Pruébalo en línea!

MAT , secuencia A000796 por Luis Mendo

Original:

'pi'td1_&:_1)Y$J)

Pruébalo en línea!

Agrietado:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

El autor original creó furtivamente el conjunto [-7:-1]y luego extrajo y negó el primer elemento para obtenerlo 7. Luego usó eso para obtener el séptimo dígito redondeado de pi (que es 3) y lo presentó como el primer dígito de pi. Agregarlo |SQhace que la matriz original sea positiva, la ordena y agrega uno a todo. Esto significa que, después de todo, en lugar de obtener el índice 7, obtiene el índice -2después de una aplicación, -3después de dos aplicaciones, etc. El -es importante porque le dice a la Y$función que no redondee los dígitos.

Adelante (gforth) , A000042 , por NieDzejkob

.( 1)1 .
^^^^^

Pruébalo en línea!

El trivial 1 byter simplemente extiende el literal. El problema es que se desborda 64 bits tan pronto como el décimo noveno dígito. La solución fácil es imprimir el único dígito repetidamente, ¿verdad? Sí, pero no es tan fácil. Si bien pegar 1 .en el extremo imprimirá los dígitos adicionales que requerimos, estarán separados por espacios. Eso no va a funcionar.

Ahora, según Wikipedia, " .((dot-paren) es una palabra inmediata que analiza una cadena delimitada por paréntesis y la muestra". Afortunadamente, esa visualización no tiene otros caracteres extraños, por lo que usar .(para imprimir un solo 1 debería ser suficiente. Y lo hace No se necesita espacio después del paréntesis cerrado, por lo que estos cinco caracteres (hay un espacio después del paréntesis abierto) se pueden repetir al contenido de nuestros corazones. Para demostrarlo, he incluido en TIO un ejemplo que habría desbordado varias veces un int de 64 bits. Funciona de maravilla.

Unefunge-98 (PyFunge) , secuencia A000108 , por NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Pruébalo en línea!

Repetido seis veces

¡Dos bytes de sobra de los diecinueve permitidos! Lo que parece ser un espacio en realidad es un carácter de inicio de encabezado 0x01.

Explicación:

Este desafío se trata de generar a(n)desde a(n-1)y quizás n. OEIS proporciona la fórmula explícita a(n) = (2n)!/(n!(n+1)!), que se convierte fácilmente en a(n) = a(n-1) * (4n-6) / n. Ahora para implementar esto en Funge.

Debo insertar código entre el 1y el .. Esa es la mitad del rompecabezas ya hecho. Todo lo que queda es ¿qué código insertar? Funge carece notablemente de herramientas de manipulación de la pila, por lo que la parte inferior de la pila está prohibida; Necesito rastrear ambos ny a(n)sin aumentar la pila. ¿Y qué mejor hacer eso que con el espacio Funge?

Ese personaje 0x01 es mi contador n. Sigo a(n)en la pila, ya que debe estar en la pila después de que mi bit termine de ejecutarse.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3 , A008574 por tsh

print(1*2+2)
       ^^^^

Pruébalo en línea!

V, A000290 , por DJMcMayhem

é*Ä2é*Ø.
  ^^^^

produce los cuadrados de 1.

Pruébalo en línea!

La base é*inserta *y Ø.cuenta el número de caracteres que no son de nueva línea en todo el búfer. La inserción Äduplica la línea superior en su propia línea, en la que se 2é*inserta **. Las concatenaciones de las inserciones producen números impares sucesivos con el más grande en la parte superior. El final Ø.en efecto suma los primeros n números impares, por lo tanto, produce el enésimo cuadrado.

AsciiDots , secuencia A019523 por Alion

\ +++ /
// \ / \

¡Una vez!

¡Dos veces!

¡Diez veces!

Mientras trataba de averiguar cómo funciona el código / lenguaje, aprendí que las dos primeras líneas del código existente hacen todo el trabajo de generar la secuencia de Fibonacci infinitamente. El código termina cuando cualquier punto toca el &, por lo que simplemente necesitaba agregar más demoras en las líneas restantes para permitir que salga el número apropiado de entradas.

Después de algunas pruebas, errores y observaciones, descubrí que el intervalo de retraso correcto es de 16 unidades de tiempo por número. Encajar suficientes caracteres en una sola fila parecía inviable, por lo que necesitaría poner el retraso en 2 filas, dejando 10 caracteres para el retraso real. Para que el patrón coincida consigo mismo, ambas filas deben tener 5 caracteres, y dado que los tres caracteres del medio de una fila se pueden atravesar dos veces, esto da 16 unidades de tiempo como se desee.

El requisito de hacer coincidir esto con el &de la octava columna parecía hacer esto imposible, hasta que me di cuenta de que podía comenzar con una nueva línea en el interior de la tercera fila. Esto hace que la penúltima fila tenga la longitud correcta y elimina el extremo ahora redundante de la tercera línea.

Brachylog , secuencia A114018 por cadena no relacionada

Programa original:

≜ṗ↔ṗb&w

Cadena para insertar:

≜ṗ↔ṗẹbb&w
    ^^

Pruébalo en línea!

Explicación

Aquí está primero la explicación del programa original (sabiendo que la secuencia utilizada es "mínimo primo de n dígitos cuya inversión de dígitos también es primo")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Como puede ver, el programa es bastante sencillo, excepto por una cosa: hay una b - beheadllamada de predicado completamente inútil , que elimina el primer elemento del reverso de nuestro número, con el que no hacemos nada.

Esta es una pista definitiva sobre cómo podemos encontrar la cadena. La idea es que, dado que queremos aumentar la longitud del número en 1 dígito cada vez que agreguemos la cadena, necesitamos una cadena que "evalúe" la longitud de ese número de alguna manera, usando esa inútil b.

La solución es usar ẹb: primero, ẹ - elementstransformará el número en una lista de dígitos; luego, b - beheadeliminará su primer elemento. El truco es que bfallará si la lista de dígitos está vacía. Por lo tanto, cada vez que agreguemos a b, aumentaremos la longitud del número requerido en 1 (porque fallará hasta que el valor asignado de ?sea ​​lo suficientemente alto como para contener suficientes dígitos para que el último bse aplique en una lista de un dígito).

Reaplicar ẹcada vez no tiene ningún efecto porque ya es una lista de dígitos. Solo lo necesitamos una vez al principio porque si decapitamos un número como en 9001lugar de la lista de sus dígitos, obtendremos el 001 = 1que pierde información sobre el número de dígitos.

VDM-SL , A000312 , por datos caducados

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Dado que las expresiones de VDM-SL letpueden volver a enlazar variables que ya están vinculadas en un ámbito envolvente, x**xpueden evaluarse arbitrariamente profundamente anidadas en ámbitos en los que xhay uno más que en el ámbito anterior, mientras que el original xes aún menor que la cardinalidad dem(1) .

Haskell, A083318 por xnor

f=length     [2]
        $show

Pruébalo en línea!

Haskell , A000045 (Fibonacci) , por la transformación de Fourier de Rin

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Pruébalo en línea!

23 bytes exactamente.

Este fue divertido y un poco complicado. Los 0 y 1 invertidos me arrojaron un poco antes de darme cuenta de que no era un problema. La falta de $en el original me hizo probar cosas incompletas como $...$id(un byte demasiado tiempo) antes de que me diera cuenta de que podía envolverlo todo entre paréntesis. Con todo, un pequeño rompecabezas agradable.

H.PWiz señala que la coincidencia de patrones me podría haber salvado al menos cinco bytes: $(\[x,y]->[y,x+y]). Ese maldito desafío sin sentido me tiene pensando sin sentido en todas partes.