Lockers vs. Crackers: la secuencia de cinco elementos

31

El reto

Un simple desafío "espía versus espía".

Escriba un programa con las siguientes especificaciones:

  1. El programa puede estar escrito en cualquier idioma pero no debe exceder los 512 caracteres (como se representa en un bloque de código en este sitio).
  2. El programa debe aceptar 5 enteros de 32 bits con signo como entradas. Puede tomar la forma de una función que acepta 5 argumentos, una función que acepta una sola matriz de 5 elementos o un programa completo que lee 5 enteros de cualquier entrada estándar.
  3. El programa debe generar un entero de 32 bits con signo.
  4. El programa debe devolver 1 si y solo si las cinco entradas, interpretadas como una secuencia, coinciden con una secuencia aritmética específica de la elección del programador, llamada "clave". La función debe devolver 0 para todas las demás entradas.

Una secuencia aritmética tiene la propiedad de que cada elemento sucesivo de la secuencia es igual a su predecesor más alguna constante fija a.

Por ejemplo, 25 30 35 40 45es una secuencia aritmética ya que cada elemento de la secuencia es igual a su predecesor más 5. Asimismo, 17 10 3 -4 -11es una secuencia aritmética ya que cada elemento es igual a su precesor más -7.

Las secuencias 1 2 4 8 16y 3 9 15 6 12no son secuencias aritméticas.

Una clave puede ser cualquier secuencia aritmética que elija, con la única restricción de que no se permiten secuencias que impliquen desbordamiento de enteros. Es decir, la secuencia debe ser estrictamente creciente, estrictamente decreciente o tener todos los elementos iguales.

Como ejemplo, suponga que elige la clave 98021 93880 89739 85598 81457. Su programa debe devolver 1 si las entradas (en secuencia) coinciden con estos cinco números, y 0 en caso contrario.

Tenga en cuenta que los medios para proteger la clave deben ser de su propio diseño novedoso. Además, las soluciones probabilísticas que pueden devolver falsos positivos con cualquier probabilidad distinta de cero no están permitidas. En particular, no utilice ningún hash criptográfico estándar, incluidas las funciones de biblioteca para los hashes criptográficos estándar.

La puntuación

Los envíos más cortos sin descifrar por conteo de personajes serán declarados ganadores.

Si hay alguna confusión, no dude en preguntar o comentar.

El contra desafío

Se alienta a todos los lectores, incluidos los que han presentado sus propios programas, a "descifrar" los envíos. Un envío se agrieta cuando su clave se publica en la sección de comentarios asociados. Si un envío persiste durante 72 horas sin ser modificado o agrietado, se considera "seguro" y cualquier éxito posterior en el agrietamiento será ignorado por el concurso.

Consulte "Descargo de responsabilidad" a continuación para obtener detalles sobre la política actualizada de puntaje de craqueo.

Las presentaciones agrietadas se eliminan de la contienda (siempre que no sean "seguras"). No deben ser editados. Si un lector desea enviar un nuevo programa, debe hacerlo en una respuesta por separado.

Los cracker (s) con los puntajes más altos serán declarados ganadores junto con los desarrolladores de los programas ganadores.

Por favor no descifre su propia presentación.

La mejor de las suertes. :)

Tabla de clasificación

Penúltima clasificación (pendiente de seguridad de la presentación de Dennis CJam 49).

Armarios seguros

  1. CJam 49, Dennis
  2. CJam 62, Dennis seguro
  3. CJam 91, Dennis seguro
  4. Python 156, caja fuerte de Maarten Baert
  5. Perl 256, chilemagic safe
  6. Java 468, Geobits seguro

Galletas Imparables

  1. Peter Taylor [Ruby 130, Java 342, Mathematica 146 *, Mathematica 72 *, CJam 37]
  2. Dennis [Pyth 13, Python 86 *, Lua 105 *, GolfScript 116, C 239 *]
  3. Martin Büttner [Javascript 125, Python 128 *, Ruby 175 *, Ruby 249 *]
  4. Tyilo [C 459, Javascript 958 *]
  5. Freddieknets [Mathematica 67 *]
  6. Ilmari Karonen [Python27 182 *]
  7. nitroso [C 212 *]

* envío no conforme

Descargo de responsabilidad (actualizado a las 11:15 PM EST, 26 de agosto)

Con los problemas de puntuación llegando finalmente a la masa crítica (dado que dos tercios de los envíos descifrados no cumplen hasta ahora), clasifiqué a los mejores crackers en términos de número de envíos craqueados (primarios) y número total de caracteres en envíos crackeados compatibles (secundario).

Como antes, las presentaciones exactas quebradas, la duración de las presentaciones y su estado de cumplimiento / no cumplimiento están todos marcados para que los lectores puedan inferir sus propias clasificaciones si creen que las nuevas clasificaciones oficiales son injustas.

Mis disculpas por enmendar las reglas tan tarde en el juego.

COTO
fuente
66
¿Cómo va a verificar que los programas cumplan con el punto 4? ¿Espera que la gente edite sus respuestas seguras para agregar una prueba? ¿Se permiten los envíos probabilísticos sobre la base de suponer que las funciones hash son ideales y que la posibilidad de una colisión con otro elemento del espacio de 48 bits (según su estimación anterior) es insignificante?
Peter Taylor
2
El sistema de puntuación parece alentar a los crackers a ignorar los bloqueos más cortos porque obtienen mejores puntajes al romper dos bloqueos largos que dos pequeños.
Peter Taylor
3
@COTO Creo que el problema es que solo puedes obtener 2 puntajes de craqueo, y solo el más corto. Entonces, ¿por qué no esperar y esperar y aparece uno más? Por ejemplo, Martin ahora no tiene ningún incentivo para romper mi bloqueo (más largo), ya que ya ha roto dos más cortos. Cualquiera que rompa el mío ahora lo golpeará sin siquiera tener que hacer un segundo.
Geobits
1
Creo que un mejor sistema de puntuación podría ser la suma de los tiempos totales entre la pregunta y el crack. De esa forma, se puede superar un montón de otras fáciles, y la verdadera recompensa proviene de descifrar las realmente difíciles.
isaacg
1
Soy nuevo en el golf, así que tal vez sea una pregunta estúpida, lo siento. ¿Por qué la longitud del código se mide en caracteres y no en bytes? Este último es literalmente el espacio de memoria que ocupa un programa, por lo que para mí parece más lógico. P.ej. la respuesta de CJam es la más corta en caracteres, pero cuando se mira su tamaño (326 debido a Unicode) ni siquiera está en el top 5. Entonces, me pregunto, ¿es una convención común en el golf contar caracteres en lugar de bytes?
freddieknets

Respuestas:

3

CJam, 62 caracteres

"ḡꬼ쏉壥떨ሤ뭦㪐ꍡ㡩折量ⶌ팭뭲䯬ꀫ郯⛅彨ꄇ벍起ឣ莨ຉᆞ涁呢鲒찜⋙韪鰴ꟓ䘦쥆疭ⶊ凃揭"2G#b129b:c~

Stack Exchange es propenso a enviar caracteres no imprimibles, pero copiar el código de esta pasta y pegarlo en el intérprete de CJam funciona bien para mí.

Cómo funciona

Después de reemplazar la cadena Unicode con una cadena ASCII, se ejecuta el siguiente código:

" Push 85, read the integers from STDIN and collect everything in an array.               ";

85l~]

" Convert the array of base 4**17 digits into and array of base 2 digits.                 ";

4H#b2b

" Split into chunks of length 93 and 84.                                                  ";

93/~

" Do the following 611 times:

    * Rotate array A (93 elements) and B one element to the left.
    * B[83] ^= B[14]
    * T = B[83]
    * B[83] ^= B[0] & B[1] ^ A[23]
    * A[92] ^= A[26]
    * Rotate T ^ A[92] below the arrays.
    * A[92] ^= A[0] & A[1] ^ B[5].                                                        ";

{(X$E=^:T1$2<:&^2$24=^+\(1$26=^_T^@@1$2<:&^3$5=^+@}611*

" Discard the arrays and collects the last 177 generated bits into an array.              ";

;;]434>

" Convert the into an integer and check if the result is 922 ... 593.                     ";

2b9229084211442676863661078230267436345695618217593=

Este enfoque utiliza Bivium-B (consulte Análisis algebraico de cifrados similares a Trivium ), una versión debilitada del cifrado de flujo Trivium .

El programa usa la secuencia de enteros como estado inicial, actualiza el estado 434 veces (354 rondas logran una difusión completa) y genera 177 bits de salida, que se compara con los de la secuencia correcta.

Dado que el tamaño del estado es precisamente 177 bits, esto debería ser suficiente para identificar de forma exclusiva el estado inicial.

Ejecución de ejemplo

$ echo $LANG
en_US.UTF-8
$ base64 -d > block.cjam <<< IgThuKHqrLzsj4nlo6XrlqjhiKTrrabjqpDqjaHjoanmipjvpb7itozuoIDtjK3rrbLul7bkr6zqgKvvjafpg6/im4XlvajqhIfrso3uprrotbfvmL/hnqPojqjguonhhp7mtoHujLPuipzlkaLpspLssJzii5npn6rpsLTqn5PkmKbspYbnlq3itorlh4Pmj60iMkcjYjEyOWI6Y34=
$ wc -m block.cjam
62 block.cjam
$ cjam block.cjam < block.secret; echo
1
$ cjam block.cjam <<< "1 2 3 4 5"; echo
0
Dennis
fuente
6

CJam, 91 caracteres

q~]KK#bD#"᫖࿼듋ޔ唱୦廽⻎킋뎢凌Ḏ끮冕옷뿹毳슟夫΢眘藸躦䪕齃噳卤"65533:Bb%"萗縤ᤞ雑燠Ꮖ㈢ꭙ㈶タ敫䙿娲훔쓭벓脿翠❶셭剮쬭玓ୂ쁬䈆﹌⫌稟"Bb=

Stack Exchange es propenso a enviar caracteres no imprimibles, pero copiar el código de esta pasta y pegarlo en el intérprete de CJam funciona bien para mí.

Cómo funciona

Después de reemplazar la cadena Unicode con enteros (considerando los dígitos de los caracteres de los números base 65533), se ejecuta el siguiente código:

" Read the integers from STDIN and collect them in an array.                               ";

q~]

" Convert it into an integer by considering its elements digits of a base 20**20 number.   ";

KK#b

" Elevate it to the 13th power modulus 252 ... 701.                                        ";

D#
25211471039348320335042771975511542429923787152099395215402073753353303876955720415705947365696970054141596580623913538507854517012317194585728620266050701%

" Check if the result is 202 ... 866.                                                      ";

20296578126505831855363602947513398780162083699878357763732452715119575942704948999334568239084302792717120612636331880722869443591786121631020625810496866=

Dado que 13 es coprimo al totient del módulo (el totient es secreto, por lo que solo tendrá que confiar en mí), diferentes bases generarán diferentes resultados, es decir, la solución es única.

A menos que alguien pueda explotar el pequeño exponente (13), la forma más eficiente de romper este bloqueo es factorizar el módulo (ver problema RSA ). Elegí un número entero de 512 bits para el módulo, que debería soportar 72 horas de intentos de factorización.

Ejecución de ejemplo

$ echo $LANG
en_US.UTF-8
$ base64 -d > lock.cjam <<< cX5dS0sjYkQjIgHuiJHhq5bgv7zrk4velOWUse6zjuCtpuW7veK7ju2Ci+uOouWHjOG4ju+Rh+uBruWGleyYt+u/ueavs+6boOyKn+Wkq86i55yY6Je46Lqm5KqV6b2D5Zmz75Wp5Y2kIjY1NTMzOkJiJSIB6JCX57ik4aSe74aS6ZuR54eg4Y+G44ii6q2Z44i244K/5pWr5Jm/5aiy7ZuU7JOt67KT7rO26IS/57+g4p2275+K7IWt5Ymu7Kyt546T4K2C7IGs5IiG77mM4quM56ifIkJiPQ==
$ wc -m lock.cjam
91 lock.cjam
$ cjam lock.cjam < lock.secret; echo
1
$ cjam lock.cjam <<< "1 2 3 4 5"; echo
0
Dennis
fuente
He publicado una nueva versión desde que olvidé eliminar un personaje innecesario de la primera. La secuencia secreta sigue siendo la misma, por lo que puede intentar descifrar cualquiera de ellos.
Dennis
FYI, estoy abortando mi intento de factoring. msieve se estableció un límite de tiempo de 276 horas, pero eso fue solo para construir la base de factores. En ese momento found 1740001 rational and 1739328 algebraic entries; Han pasado casi 100 horas para procesarlos e informes sieving in progress b = 46583, 0 complete / 0 batched relations (need 44970493).
Peter Taylor
@PeterTaylor: Parece que 512 bits fueron excesivos. ¿Intentaste factorizar el entero en mi otra respuesta o en esta?
Dennis
Oh, vaya. Si, otro.
Peter Taylor
4

Python - 128

Probemos este:

i=input()
k=1050809377681880902769L
print'01'[all((i>1,i[0]<i[4],k%i[0]<1,k%i[4]<1,i[4]-i[3]==i[3]-i[2]==i[2]-i[1]==i[1]-i[0]))]

(Se espera que el usuario ingrese 5 números separados por comas, por ejemplo 1,2,3,4,5).

Falko
fuente
3
32416190039,32416190047,32416190055,32416190063,32416190071
Martin Ender
Wow, eso fue rápido! ¡Tienes razón! Y estoy fuera
Falko
3
Por cierto, esto no es realmente válido, porque sus cinco enteros no caben en un entero de 32 bits.
Martin Ender
4

Java: 468

La entrada se da como k(int[5]). Fianzas anticipadas si no están espaciadas uniformemente. De lo contrario, lleva un tiempo descubrir si los diez hashes son correctos. Para números grandes, "un poco" puede significar diez segundos o más, por lo que puede disuadir a los crackers.

//golfed
int k(int[]q){int b=q[1]-q[0],i,x,y,j,h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,998860524,888446062,1833324980,1391496617,2075731831};for(i=0;i<4;)if(q[i+1]-q[i++]!=b||b<1)return 0;for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));for(i=0;i<5;i++){for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));if(x!=h[i*2]||y!=h[i*2+1])return 0;}return 1;}int m(int a,int b,int c){long d=1;for(;b-->0;d=(d*a)%c);return (int)d;}

// line breaks
int k(int[]q){
    int b=q[1]-q[0],i,x,y,j,
    h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,
                  998860524,888446062,1833324980,1391496617,2075731831};
    for(i=0;i<4;)
        if(q[i+1]-q[i++]!=b||b<1)
            return 0;
    for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));
    for(i=0;i<5;i++){
        for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));
        if(x!=h[i*2]||y!=h[i*2+1])
            return 0;
    }
    return 1;
}
int m(int a,int b,int c){
    long d=1;for(;b-->0;d=(d*a)%c);
    return (int)d;
}
Geobits
fuente
1
Su código se cuelga si la secuencia aritmética de entrada está descendiendo. O al menos, toma realmente largo tiempo. Lo que me hace pensar que el código secreto está ascendiendo ...
Keith Randall
3
@KeithRandall Vaya. Agreguemos cuatro bytes para hacer que las secuencias descendentes tomen una cantidad de tiempo inusualmente corta , reforzando aún más su creencia.
Geobits
4

Java: 342

int l(int[]a){String s=""+(a[1]-a[0]);for(int b:a)s+=b;char[]c=new char[11];for(char x:s.toCharArray())c[x<48?10:x-48]++;for(int i=0;i<11;c[i]+=48,c[i]=c[i]>57?57:c[i],i++,s="");for(int b:a)s+=new Long(new String(c))/(double)b;return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;}

Aquí hay un casillero basado en cadenas que depende tanto del recuento de caracteres de entrada como de la entrada específica. La secuencia podría basarse en oscuras referencias de la cultura pop. ¡Que te diviertas!

Un poco ignorante:

int lock(int[]a){
    String s=""+(a[1]-a[0]);
    for(int b:a)
        s+=b;
    char[]c=new char[11];
    for(char x:s.toCharArray())
        c[x<48?10:x-48]++;
    for(int i=0;i<11;c[i]+=48,
                     c[i]=c[i]>57?57:c[i],
                     i++,
                     s="");
    for(int b:a)
        s+=new Long(new String(c))/(double)b;
    return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;
}
Geobits
fuente
2
8675309? 90210?
Malaquías
1
@Malachi Dos referencias sobresalientes, sin duda, pero no puedo confirmar ni negar su aplicabilidad a este ejercicio.
Geobits
jajaja, todavía no he descubierto completamente cómo funciona este desafío, puedo intentarlo más tarde cuando esté en casa.
Malaquías
1
El término inicial es -8675309, delta es 5551212.
Peter Taylor
@PeterTaylor Bien hecho :)
Geobits
4

Pitón, 147

Editar: versión más corta basada en el comentario de Dennis. También actualicé la secuencia para evitar filtrar información.

def a(b):
    c=1
    for d in b:
        c=(c<<32)+d
    return pow(7,c,0xf494eca63dcab7b47ac21158799ffcabca8f2c6b3)==0xa3742a4abcb812e0c3664551dd3d6d2207aecb9be

Basado en el problema de logaritmo discreto que se cree que es indescifrable, sin embargo, el principal que estoy usando es probablemente demasiado pequeño para ser seguro (y puede tener otros problemas, no lo sé). Y puede hacerlo por fuerza bruta, por supuesto, ya que las únicas incógnitas son dos enteros de 32 bits.

Maarten Baert
fuente
Los logaritmos discretos son mucho más difíciles de lo que pensaba. Mi galleta ha estado en esto por 26 horas. Me doy por vencido.
Dennis
Puede resolver el problema de los signos inicializando c=1, calculando c=(c<<32)+dy cambiando la constante en consecuencia.
Dennis
3

Javascript 125

Este debería resolverse bastante rápido. Seguiré con algo más fuerte.

function unlock(a, b, c, d, e)
{
    return (e << a == 15652) && (c >> a == 7826) && (e - b == d) && (d - c - a == b) ? 1 : 0;
}
rdans
fuente
66
0, 3913, 7826, 11739, 15652
Martin Ender
sí lo tienes :)
rdans
3

Rubí, 175

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
p a[2]*(a[1]^a[2]+3)**7==0x213a81f4518a907c85e9f1b39258723bc70f07388eec6f3274293fa03e4091e1?1:0

A diferencia del uso de un hash criptográfico o srand, esto es demostrablemente único (que es una pequeña pista). Toma cinco números a través de STDIN, delimitados por cualquier carácter o caracteres que no sean dígitos ni líneas nuevas. Salidas a STDOUT.

histocrat
fuente
Sí, olvidé que estaban firmados.
histocrat
2
622238809,1397646693,2173054577,2948462461,3723870345(mi suposición anterior tuvo un error, pero este está probado). Sin embargo, no creo que esto sea válido, porque el último número no cabe en un entero de 32 bits con signo.
Martin Ender
3

GolfScript (116 caracteres)

Toma la entrada como enteros separados por espacios.

~]{2.5??:^(&}%^base 2733?5121107535380437850547394675965451197140470531483%5207278525522834743713290685466222557399=
Peter Taylor
fuente
2
-51469355 -37912886 -24356417 -10799948 2756521
Dennis
Buen trabajo. ¿Explotaste el pequeño exponente?
Peter Taylor
2
No, factoricé el módulo. Tomó solo 13 segundos usando el tamiz polinomial cuadrático múltiple de primo y PyPy.
Dennis
En ese caso, bien podría abandonar mi actual juego de golf utilizando un módulo expresado de forma compacta. Si el resultado tiene que ser algo así como 1024 bits para evitar la factorización, entonces incluso usando una representación de base 256 será demasiado largo.
Peter Taylor
Espero que no. Mi respuesta utiliza la misma idea que la suya, pero con un módulo de 512 bits y un exponente aún más pequeño (13). Dado el límite de tiempo de 72 horas, eso podría ser suficiente ...
Dennis
3

C 459 bytes

RESUELTO POR Tyilo - LEER EDITAR A CONTINUACIÓN

int c (int* a){
int d[4] = {a[1] - a[0], a[2] - a[1], a[3] - a[2], a[4] - a[3]};
if (d[0] != d[1] || d[0] != d[2] || d[0] != d[3]) return 0;
int b[5] = {a[0], a[1], a[2], a[3], a[4]};
int i, j, k;
for (i = 0; i < 5; i++) { 
for (j = 0, k = 2 * i; j < 5; j++, k++) {
k %= i + 1;
b[j] += a[k];
}
}
if (b[0] == 0xC0942 - b[1] && 
b[1] == 0x9785A - b[2] && 
b[2] == 0x6E772 - b[3] && 
b[3] == 0xC0942 - b[4] && 
b[4] == 0xB6508 - b[0]) return 1;
else return 0;
}

Necesitamos a alguien para escribir una solución C, ¿no? No estoy impresionando a nadie con la longitud, no soy golfista. ¡Sin embargo, espero que sea un desafío interesante!

¡No creo que haya una manera obvia de descifrar este, y espero con impaciencia todos los intentos! Sé que esta solución es única. Ofuscación muy mínima, principalmente para cumplir con los requisitos de longitud. Esto se puede probar simplemente:

int main(){
    a[5] = {0, 0, 0, 0, 0} /* your guess */
    printf("%d\n", c(a));
    return 0;
}

PD: Hay un significado para a[0] como un número en sí mismo, ¡y me gustaría ver a alguien señalarlo en los comentarios!

EDITAR:

Solución: 6174, 48216, 90258, 132300, 174342

Una nota sobre grietas:

Si bien este no es el método utilizado (ver los comentarios), descubrí mi propio cifrado con una fuerza bruta muy fácil. Ahora entiendo que es de vital importancia hacer que los números sean grandes. El siguiente código puede descifrar cualquier cifrado donde upper_boundsea ​​un límite superior conocido a[0] + a[1] + a[2] + a[3] + a[4]. El límite superior en el cifrado anterior es 457464, que se puede derivar del sistema de ecuaciones b[]y algunos detalles del algoritmo. Se puede demostrar eso b[4] = a[0] + a[1] + a[2] + a[3] + a[4].

int a[5];
for (a[0] = 0; a[0] <= upper_bound / 5; a[0]++) {
    for (a[1] = a[0] + 1; 10 * (a[1] - a[0]) + a[0] <= upper_bound; a[1]++) {
        a[2] = a[1] + (a[1] - a[0]);
        a[3] = a[2] + (a[1] - a[0]);
        a[4] = a[3] + (a[1] - a[0]);
        if (c(a)) {
            printf("PASSED FOR {%d, %d, %d, %d, %d}\n", a[0], a[1], a[2], a[3], a[4]);
        }
    }
    printf("a[0] = %d Checked\n", a[0]);
}

Con a[0] = 6174esto, este ciclo rompió mi trabajo en poco menos de un minuto.

BrainSteel
fuente
66
Solución: 6174, 48216, 90258, 132300, 174342.
Tyilo
Wow eso fue rápido. Buena esa. Bruteforced, ¿o encontraste algo inteligente que me perdí?
BrainSteel
Utilicé la evaluación simbólica de Mathematica así: ghostbin.com/paste/jkjpf captura de pantalla: i.imgur.com/2JRo7LE.png
Tyilo
Re la edición: hice básicamente lo mismo, pero eludí la parte superior a 500k. Obtuve la respuesta y vi que Tyilo ya la había publicado :(
Geobits
@Geobits Esa es una suposición sorprendentemente precisa. Debería haber puesto más 0 en los extremos de esos números.
BrainSteel
3

Mathematica 80 67

f=Boole[(p=NextPrime/@#)-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Corriendo:

f[{1,2,3,4,5}] (* => 0 *)

Probablemente bastante fácil de descifrar, también podría tener múltiples soluciones.

Actualización: Golf mejorado al hacer lo que Martin Büttner sugirió. La funcionalidad de la función y la clave no ha cambiado.

Tyilo
fuente
@ MartinBüttner Mejorando las respuestas para obtener una puntuación más alta cuando las descifras. Inteligente; P
Tyilo
Eh, resulta que me salté el párrafo sobre la puntuación para el contra desafío. Pensé que era solo por diversión sin ningún puntaje. Aunque no creo que tenga sentido acortar las soluciones que quiero descifrar porque eso reduciría mi puntaje.
Martin Ender
44
{58871,5592,-47687,-100966,-154245}
freddieknets
@freddieknets No es la solución que utilicé al crearlo. No sabía que eso NextPrimepodría devolver valores negativos. ¿Cómo lo encontraste?
Tyilo
Entonces su clave no es única: p. Acabo de hacer algunas pruebas, realmente no hay tantos números donde NextPrime [#] - # se evalúe como 31, así que esa es una manera fácil de descifrarlo.
freddieknets
2

Python27, 283 182

Muy bien, tengo mucha confianza en mi casillero, sin embargo, es bastante largo ya que agregué cálculos 'difíciles de revertir' a la entrada, para hacerlo bien, difícil de revertir.

import sys
p=1
for m in map(int,sys.argv[1:6]):m*=3**len(str(m));p*=m<<sum([int(str(m).zfill(9)[-i])for i in[1,3,5,7]])
print'01'[p==0x4cc695e00484947a2cb7133049bfb18c21*3**45<<101]

editar: Gracias a colevk por seguir jugando al golf. Durante la edición me di cuenta de que había un error y un defecto en mi algoritmo, tal vez tendré mejor suerte la próxima vez.

estocástico
fuente
55
Esto es invariable al reordenar los argumentos, por lo que no es un casillero válido.
Peter Taylor
Además, sospecho que el código publicado es defectuoso: la clave 121174841 121174871 121174901 121174931 121174961funciona, pero solo si la lista [1,3,5,7]de la línea 7 se reemplaza por [1,3,5,7,11].
Ilmari Karonen
Maldición, sí, solo estaba arreglando mi error tipográfico, durante el cual cometí un error crucial en mi algoritmo, dejándolo muy fácil de descifrar: |
estokástico
En realidad, encontrar y corregir el error fue la parte difícil; dado su algoritmo, factorizar la constante fue algo obvio de probar.
Ilmari Karonen
2

Mathematica 142 146

EDITAR : la clave no era única, agregó 4 caracteres, ahora lo es.

n=NextPrime;
f=Boole[
    FromDigits /@ (
        PartitionsQ[n@(237/Plus@##) {1, ##} + 1] & @@@ 
            IntegerDigits@n@{Plus@##-37*Log[#3],(#1-#5)#4}
    ) == {1913001154,729783244}
]&

(Se agregaron espacios y líneas nuevas para facilitar la lectura, no se cuentan ni se necesitan).

Uso:

f[1,2,3,4,5]   (* => 0 *)
freddieknets
fuente
1
Término inicial 256208, delta -5.
Peter Taylor
Dang, entonces todavía no es único, ya que esta no es mi clave original. ¿Bruteforce?
freddieknets
Pruébelo, podría haber cometido un error porque no tengo acceso a Mathematica para probar. Cada etapa está usando la fuerza bruta, pero no es mucho tiempo de computadora. El enfoque es trabajar hacia atrás a la salida IntegerDigitsy luego factorizar para obtener candidatos para el término inicial y el delta.
Peter Taylor
Pero de ninguna manera este enfoque podría ser único de todos modos. La segunda de las cinco entradas solo se usa en una suma que se pasa a NextPrime; si lo variamos por más o menos uno, al menos uno de ellos dará el mismo primo siguiente.
Peter Taylor
sí, pero para una secuencia aritmética -como es la entrada requerida- se suponía que era única.
freddieknets
1

Craqueado por @Dennis en 2 horas


Solo una simple para comenzar, espero que esto se resuelva rápidamente.

Pyth , 13

h_^ZqU5m-CGdQ

Toma entradas separadas por comas en STDIN.

Ejecútelo así (-c significa tomar el programa como argumento de línea de comando):

$ echo '1,2,3,4,5' | python3 pyth.py -c h_^ZqU5m-CGdQ
0

Se arregló el programa: no había entendido la especificación.

Este lenguaje puede ser demasiado esotérico para esta competencia. Si OP lo cree, lo eliminaré.

isaacg
fuente
77
¿Acabas de regalar esa 1,2,3,4,5es la clave?
Peter Taylor
1
Cada entrada que intenté devolvió 1, ¿cambiaste 1 y 0 como salida?
Tyilo
Lo siento, no entendí la distinción Salida vs. Retorno: el programa debería funcionar ahora. Mismo algoritmo subyacente.
isaacg
3
97,96,95,94,93(Acabo de matar mi puntuación de craqueo.)
Dennis
@ Dennis Bien hecho. El sistema de puntuación de craqueo necesita ser cambiado: está creando algunos incentivos realmente extraños.
isaacg
1

Lua 105

Sospecho que no pasará mucho tiempo antes de que se rompa, pero aquí vamos:

function f(a,b,c,d,e)
   t1=a%b-(e-2*(d-b))
   t2=(a+b+c+d+e)%e
   t3=(d+e)/2
   print(t1==0 and t2==t3 and"1"or"0")
end

(espacios agregados para mayor claridad, pero no son parte del conteo)

Kyle Kanos
fuente
3, 7, 11, 15, 19o6, 14, 22, 30, 38
Dennis
@ Dennis: lamentablemente no es ninguno de esos. Tendré que trabajar en ello un poco más tarde para asegurar la no unicidad.
Kyle Kanos
t1==0cuando sea que Sesté aumentando. Además, ambas condiciones son homogéneas; si Ses una solución, también lo es kS.
Dennis
1

Perl - 256

sub t{($z,$j,$x,$g,$h)=@_;$t="3"x$z;@n=(7,0,split(//,$g),split(//,$h),4);@r=((2)x6,1,1,(2)x9,4,2,2,2);$u=($j+1)/2;for$n(0..$#r+1){eval{substr($t,$j,1)=$n[$n]};if($@){print 0; return}$j+=$r[$n]*$u}for(1..$x){$t=pack'H*',$t;}eval$t;if($@||$t!~/\D/){print 0}}

Tuve que poner mucha lógica de manejo de errores y esto definitivamente se puede reducir mucho más. Imprimirá un 1cuando obtenga los cinco números correctos. Con suerte, imprimirá un 0para todo lo demás (puede haber errores o nada, no lo sé). Si alguien quiere ayudar a mejorar el código o jugarlo más, ¡no dude en ayudar!


Llamar con:

t(1,2,3,4,5);
hmatt1
fuente
1

Rubí - 130

Basado en el registro de desplazamiento de retroalimentación lineal. Entradas por argumentos de línea de comando.
Debe ser único en función de la naturaleza de los LFSR. Pista: ascendente y todo positivo.

Dará más pistas si nadie lo resuelve pronto.

x=($*.map{|i|i.to_i+2**35}*'').to_i
(9**8).times{x=((x/4&1^x&1)<<182)+x/2}
p x.to_s(36)=="qnsjzo1qn9o83oaw0a4av9xgnutn28x17dx"?1:0
Vectorizado
fuente
3
Valor inicial 781783, incremento 17982811
Peter Taylor
@PeterTaylor Argh ... =)
Vectorizado el
1

Rubí, 249

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
r=(a[0]*a[1]).to_s(5).tr'234','(+)'
v=a[0]<a[1]&&!r[20]&&(0..3).select{|i|/^#{r}$/=~'%b'%[0xaa74f54ea7aa753a9d534ea7,'101'*32,'010'*32,'100'*32][i]}==[0]?1:0rescue 0
p v

Debe ser divertido. ¿Quién necesita las matemáticas?

histocrat
fuente
2
309, 77347, 154385, 231423, 308461Pero no creo que sea único.
Martin Ender
Si, no lo es. Para la misma expresión regular (es decir, producto de los dos primeros números), también encuentro 103, 232041, 463979, 695917, 927855y 3, 7966741, 15933479, 23900217, 31866955. Y estoy bastante seguro de que hay otras expresiones regulares válidas mediante el uso de +s adicionales .
Martin Ender
Lo siento, supongo que estropeé la cadena de prueba. Se suponía que solo había una expresión regular con una factorización única.
histocrático
Si desea intentar solucionarlo, asegúrese de tener en cuenta cuantificadores posesivos. También puedo crear una expresión regular más grande y equivalente insertando ()o similar.
Martin Ender
1

CJam, 49 caracteres

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b[1q~]8H#b%!

Pruébalo en línea.

Cómo funciona

" Push a string representing a base 65536 number and convert it to an integer.            ";

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b

" Prepend 1 to the integers read from STDIN and collect them into an array.               ";

[1q~]

" Convert that array into an integer by considering it a base 2**51 number.               ";

8H#b

" Push the logical NOT of the modulus of both computed integers.                          ";

%!

El resultado será 1 si y solo si el segundo entero es un factor del primero, que es un producto de dos números primos: uno correspondiente a la secuencia secreta y otro que no corresponde a ninguna secuencia válida. Por lo tanto, la solución es única.

Factorizar un número entero de 512 bits no es que difícil, pero espero que nadie será capaz de 72 horas. Mi versión anterior con un entero de 320 bits se ha roto .

Ejecución de ejemplo

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock512.cjam <<< IuiFleyYoeijg+SDrOqvs+uEkNaa76a/5b6L4KGG4ZOF76Gi46WE64eu4pSO5JSk5ayj6pGZ5Ji/7Zy64aWw57GD5YO+7I6n6Kuv65aG7qK04byr6aS+6IWO7rSn7YuvIjJHI2JbMXF+XThII2IlIQ==
$ wc -m flock512.cjam
49 flock512.cjam
$ cjam flock512.cjam < flock512.secret; echo
1
$ cjam flock512.cjam <<< "1 2 3 4 5"; echo
0
Dennis
fuente
He tenido msieve ejecutándose en él durante más de 24 horas, pero como su límite de tiempo autoimpuesto es de 276.51 horas de CPU y solo le he dado una CPU, no soy optimista.
Peter Taylor
0

Javascript 958

Convierte las entradas en varios tipos de datos y realiza algunas manipulaciones relevantes para cada tipo de datos en el camino. Debería revertirse con bastante facilidad para cualquiera que se tome el tiempo.

function encrypt(num)
{
    var dateval = new Date(num ^ (1024-1) << 10);

    dateval.setDate(dateval.getDate() + 365);

    var dateString = (dateval.toUTCString() + dateval.getUTCMilliseconds()).split('').reverse().join('');

    var result = "";

    for(var i = 0; i < dateString.length; i++)
        result += dateString.charCodeAt(i);

    return result;
}

function unlock(int1, int2, int3, int4, int5)
{
    return encrypt(int1) == "5549508477713255485850495848483249555749321109774324948324410511470" && encrypt(int2) == "5756568477713252485848495848483249555749321109774324948324410511470" && encrypt(int3) == "5149538477713248485856485848483249555749321109774324948324410511470" && encrypt(int4) == "5356498477713256535853485848483249555749321109774324948324410511470" && encrypt(int5) == "5748568477713251535851485848483249555749321109774324948324410511470" ? 1 : 0;
}
rdans
fuente
55
Bruto forzado:320689, 444121, 567553, 690985, 814417
Tyilo
@Tyilo Si te detienes ahora, creo que ninguna galleta puede superar tu puntaje. ;)
Martin Ender
2
@ MartinBüttner A menos que esto pueda ser menos de 512 por OP, no creo que cuente.
Geobits
0

C, 239 (agrietado por Dennis)

Ve aqui para mi envío actualizado.

Probablemente podría jugar al golf un poco más a fondo. Es cierto que no me he tomado el tiempo para demostrar que la clave es única (probablemente no lo sea), pero definitivamente está en el orden de una colisión de hash. Si lo rompes, comparte tu método :)

p(long long int x){long long int i;x=abs(x);
for (i=2;i<x;i++) {if ((x/i)*i==x) return 0;}return 1;}
f(a,b,c,d,e){char k[99];long long int m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);
sscanf(k,"%lld",&m);return p(a)&&p(b)&&p(c)&&p(d)&&p(e)&&p(m);}
O por
fuente
1
Por lo tanto, 0 0 0 0 0?
Dennis
Suspiro, eso fue un error, pero sí, eso funciona.
Orby
He actualizado con una versión corregida que debería ser un poco más interesante;)
Orby
Vea la versión corregida aquí .
Orby
0

C, 212 por Orby - Agrietado

https://codegolf.stackexchange.com/a/36810/31064 por Orby tiene al menos dos claves:

13 103 193 283 373
113 173 233 293 353

Orby preguntó por el método que usé para descifrarlo. La función p verifica si x es primo al verificar x%i==0todo i entre 2 y x (aunque usando en (x/i)*i==xlugar dex%i==0 ) y devuelve verdadero si x es un número primo. La función f verifica que todos a, b, c, dye sean primos. También verifica si el número m, una concatenación de las representaciones decimales de e, d, c, by a (en ese orden), es primo. La clave es tal que a, b, c, d, e y m son primos.

Green y Tao (2004) muestran que existen infinitas secuencias aritméticas de primos para cualquier longitud k, por lo que solo necesitamos buscar estas secuencias que también satisfacen que m sea primo. Al tomar mucho tiempo como limitado por -9.223372037e + 18 y 9.223372037e + 18, sabemos que para que la cadena concatenada encaje en un largo largo, los números tienen un límite superior de 9999. Entonces, al usar un script de Python para generar todos secuencias aritméticas dentro de todos los primos <10000 y luego verificando si su concatenación inversa es un primo, podemos encontrar muchas soluciones posibles.

Por alguna razón se me ocurrieron falsos positivos, pero los dos anteriores son válidos según el programa. Además, puede haber soluciones donde e es negativo y el resto es positivo (p usa el módulo de x), pero no busqué esas.

Las claves que proporcioné son todas secuencias aritméticas, pero el script de Orby no parece requerir que las entradas sean una secuencia aritmética, por lo que también puede haber claves no válidas.

nitroso
fuente
0

MATLAB: aparentemente inválido

Muy simple, solo tienes que generar el número aleatorio correcto.

function ans=t(a,b,c,d,e)
rng(a)
r=@(x)rng(rand*x)
r(b)
r(c)
r(d)
r(e)
rand==0.435996843156676

Todavía puede fallar, pero eso no debería ser un problema.

Dennis Jaheruddin
fuente
1
Este enfoque está prohibido en los comentarios. Si no se menciona en la pregunta, proponga una edición. Lo siento.
Peter Taylor
@PeterTaylor Supongo que estoy fuera, lo dejaré aquí sin puntaje ya que tengo curiosidad por saber si alguien puede encontrar una debilidad.
Dennis Jaheruddin
0

MATLAB (con caja de herramientas simbólica), 173 caracteres

Esta no es una entrada oficial y no contará para el puntaje de craqueo de nadie, pero le otorgará derechos de fanfarronear. ;)

function b=L(S),c=sprintf('%d8%d',S(1),S(2)-S(1));b=numel(unique(diff(S)))==1&&numel(c)==18&&all(c([8,9])==c([18,17]))&&isequal(c,char(sym(sort(c,'descend'))-sym(sort(c))));

La caja de herramientas simbólica solo es necesaria para manejar la resta de enteros grandes.

La fuerza bruta debe ser un perro, pero si está familiarizado con la serie que implica, la solución es trivial.

COTO
fuente
0

Pitón 2 (91)

Editar: Esto no está permitido porque el argumento para la unicidad es probabilístico. Me doy por vencido.


s=3
for n in input():s+=pow(n,s,7**58)
print s==0x8b5ca8d0cea606d2b32726a79f01adf56f12aeb6e

Toma listas de enteros como entrada, como [1,2,3,4,5] .

El bucle está destinado a operar en las entradas de una manera molesta, dejando una torre de sumas y exponentes. La idea es como un registro discreto, pero con complicación complicada en lugar de simplicidad matemática. Tal vez la composición del módulo es una vulnerabilidad, en cuyo caso podría hacer algo así7**58+8 .

Realmente no sé cómo probaría que mi clave es la única, pero el rango de salidas es al menos 10 veces mayor que el rango de entradas, ¿entonces probablemente? Aunque tal vez solo se pueda lograr una pequeña fracción de los posibles resultados. Siempre podría aumentar el número de dígitos a costa de los caracteres. Te dejaré a ti decidir qué es justo.

Feliz cracking

xnor
fuente
0

Mathematica - 72

Versión 2 de mi script, con la misma clave que la destinada para mi versión 1.

Básicamente, esto elimina los números primos negativos para NextPrime.

f=Boole[(p=Abs[NextPrime/@#])-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Corriendo:

f[{1,2,3,4,5}] (* => 0 *)
Tyilo
fuente
Suponiendo que he entendido correctamente lo que hace su código, obtengo varias soluciones, de las cuales la más pequeña es el término inicial 9244115, delta 25.
Peter Taylor
@ PeterTaylor Puedo confirmar que ese es válido.
Martin Ender
@PeterTaylor correcto, otra clave es 1073743739, 1073886396, 1074029053, 1074171710, 1074314367
Tyilo
0

Python, 86 caracteres

a,b,c,d,e=input()
print 1if(a*c^b*e)*d==0xd5867e26a96897a2f80 and b^d==48891746 else 0

Ingrese los números como 1,2,3,4,5.

> python 36768.py <<< "1,2,3,4,5"
0
> python 36768.py <<< "[REDACTED]"
1
Bocadillo
fuente
Esta no es una presentación válida; acepta la entrada 1,0,1,63021563418517255630720,0.
Dennis
@Dennis Fixed. Espero que sea válido ahora.
Merienda
1
19960211, 31167202, 42374193, 53581184, 64788175
Dennis
@Dennis Correcto e impresionante. Creo que soy muy pobre en matemáticas.
Merienda
2
@ Dennis, 63021563418517255630720no es un número de 32 bits.
Peter Taylor
0

Python, 78

(Agrietado por Tyilo en 14 minutos)

¡Divertido!

def L(a): return 1 if a==[(i-i**6) for i in bytearray(' ','utf-8')] else 0

De acuerdo, no se muestra correctamente aquí :(

Espera una lista de cinco números, por ejemplo. [1,2,3,4,5]

ElectricWarr
fuente
1
Bastante fácil:[-481890276, -594823292, -728999970, -887503650, -1073741792]
Tyilo
Creo que sí, bien hecho :)
ElectricWarr
0

CJam, 37 caracteres (rotos)

"煷➻捬渓类ⶥ땙ዶ꾫㞟姲̷ᐂ㵈禙鰳쥛忩蔃"2G#b[1q~]4G#b%!

Pruébalo en línea.

Cómo funciona

Mira mi nueva respuesta.

Ejecución de ejemplo

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock.cjam <<< IueFt+Keu+aNrOa4k+exu+K2peuVmeGLtuq+q+Oen+Wnsu6AhMy34ZCC47WI56aZ6bCz7KWb5b+p6JSDIjJHI2JbMXF+XTRHI2IlIQ==
$ wc -m flock.cjam
37 flock.cjam
$ cjam flock.cjam < flock.secret; echo
1
$ cjam flock.cjam <<< "1 2 3 4 5"; echo
0
Dennis
fuente
1
737262825 208413108 3974530688 3445680972 2916831257funciona pero no es una progresión aritmética. Factorizado en 3 horas 20 minutos. Aparentemente, los números de 512 bits eran factibles en 72 horas por $ 75 en EC2 hace dos años, por lo que creo que hubiera sido seguro.
Peter Taylor
@PeterTaylor: Eso devuelve 1, pero los últimos tres enteros son mayores que MAX_INT, por lo que no es una clave válida. Dicho esto, 3 h 20 m es bastante impresionante. El algoritmo que estaba usando tomó 16 horas para un semiprime de 256 bits ...
Dennis
Pensé que debía haber algunos números negativos allí en alguna parte porque los deltas eran casi correctos pero no del todo. Me pondré a ello.
Peter Taylor
1
737262825 208413109 -320436607 -849286323 -1378136039
Peter Taylor
@ PeterTaylor: Ese es el. Espero que la versión de 512 bits dure más.
Dennis
-2

C, 212 (agrietado)

Esta es la misma idea que mi presentación anterior , golfé más a fondo, con un error corregido que pasó 0,0,0,0,0 (Gracias a Dennis por señalar el error). Compilar con -std = c99.

#define L long long
p(L x){x=abs(x);for(L i=2;i<x;i++){if((x/i)*i==x)return 0;}return(x>1);}
f(a,b,c,d,e){char k[99];L m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);sscanf(k,"%lld",&m);
return p(a)&p(b)&p(c)&p(d)&p(e)&p(m);}
O por
fuente
Cualquier secuencia (aritmética o no) de primos negativos funcionará. Dos ejemplos: -7 -37 -67 -97 -127,-157 -127 -97 -67 -37
Dennis
Sí, mi código está lleno de errores. La respuesta que dio nitrous está en la línea de lo que estaba buscando. Pero buen trabajo señalando las respuestas más obvias.
Orby