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.

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

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

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).

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;
}

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;
}

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.

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;
}

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.

GolfScript (116 caracteres)

Toma la entrada como enteros separados por espacios.

~]{2.5??:^(&}%^base 2733?5121107535380437850547394675965451197140470531483%5207278525522834743713290685466222557399=

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.

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.

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.

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 *)

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é.

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)

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);

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

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?

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

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;
}

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);}

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.

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.

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.

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

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 *)

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

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]

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

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);}