O desafio

Um simples desafio "espião contra espião".

Escreva um programa com as seguintes especificações:

1. O programa pode ser escrito em qualquer idioma, mas não deve exceder 512 caracteres (conforme representado em um bloco de código neste site).
2. O programa deve aceitar 5 números inteiros de 32 bits assinados como entradas. Pode assumir a forma de uma função que aceita 5 argumentos, uma função que aceita uma única matriz de 5 elementos ou um programa completo que lê 5 números inteiros de qualquer entrada padrão.
3. O programa deve gerar um número inteiro de 32 bits assinado.
4. O programa deve retornar 1 se e somente se as cinco entradas, interpretadas como uma sequência, corresponderem a uma sequência aritmética específica da escolha do programador, chamada de "chave". A função deve retornar 0 para todas as outras entradas.

Uma sequência aritmética tem a propriedade de que cada elemento sucessivo é igual ao seu predecessor mais alguma constante fixa a.

Por exemplo, 25 30 35 40 45é uma sequência aritmética, pois cada elemento da sequência é igual ao seu antecessor mais 5. Da mesma forma, 17 10 3 -4 -11é uma sequência aritmética, pois cada elemento é igual ao seu antecessor mais -7.

As sequências 1 2 4 8 16e 3 9 15 6 12não são sequências aritméticas.

Uma chave pode ser qualquer sequência aritmética de sua escolha, com a única restrição de que sequências que envolvem estouro de número inteiro não sejam permitidas. Ou seja, a sequência deve aumentar estritamente, diminuir estritamente ou ter todos os elementos iguais.

Como exemplo, suponha que você escolha a chave 98021 93880 89739 85598 81457. Seu programa deve retornar 1 se as entradas (em sequência) corresponderem a esses cinco números e 0, caso contrário.

Observe que os meios para proteger a chave devem ter seu próprio design inovador. Além disso, soluções probabilísticas que podem retornar falsos positivos com qualquer probabilidade diferente de zero não são permitidas. Em particular, não use hashes criptográficos padrão, incluindo funções de biblioteca para hashes criptográficos padrão.

A pontuação

Os envios mais curtos e sem quebra por contagem de caracteres serão declarados vencedores.

Se houver alguma confusão, não hesite em perguntar ou comentar.

O Contra-Desafio

Todos os leitores, incluindo aqueles que enviaram seus próprios programas, são incentivados a "quebrar" as inscrições. Um envio é quebrado quando sua chave é postada na seção de comentários associados. Se um envio persistir por 72 horas sem ser modificado ou quebrado, será considerado "seguro" e qualquer sucesso subsequente no cracking será ignorado por causa do concurso.

Consulte "Isenção de responsabilidade" abaixo para obter detalhes sobre a política atualizada de pontuação de cracking.

Os envios rachados são eliminados da disputa (desde que não sejam "seguros"). Eles não devem ser editados. Se um leitor deseja enviar um novo programa, ele deve fazê-lo em uma resposta separada.

Os crackers com maior pontuação serão declarados vencedores, juntamente com os desenvolvedores dos programas vencedores.

Por favor, não decifre sua própria submissão.

Boa sorte. :)

Entre os melhores

Penúltima classificação (pendente de segurança da inscrição de Dennis 'CJam 49).

Cacifos seguros

1. CJam 49, Dennis
2. CJam 62, Dennis a salvo
3. CJam 91, Dennis a salvo
4. Python 156, Maarten Baert em segurança
5. Perl 256, seguro chilemagic
6. Java 468, Geobits seguro

Bolachas Imparáveis

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

* envio não conforme

Isenção de responsabilidade (atualizado às 23h15 EST, 26 de agosto)

Com os problemas de pontuação finalmente atingindo a massa crítica (dado que dois terços dos envios rachados ainda não são compatíveis), classifiquei os principais crackers em termos de número de envios rachados (primário) e número total de caracteres em envios rachados compatíveis (secundário).

Como antes, os envios exatos ruíram, a duração dos envios e seu status de conformidade / não conformidade são todos marcados para que os leitores possam inferir suas próprias classificações se considerarem injustas as novas classificações oficiais.

Peço desculpas por alterar as regras tão tarde no jogo.

CJam, 62 caracteres

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

O Stack Exchange é propenso a agrupar caracteres não imprimíveis, mas copiar o código dessa pasta e colá -lo no interpretador CJam funciona bem para mim.

Como funciona

Depois de substituir a cadeia Unicode por uma cadeia ASCII, o seguinte código é executado:

" 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=

Essa abordagem usa o Bivium-B (consulte Análise algébrica de cifras do tipo Trivium ), uma versão enfraquecida da cifra de fluxo Trivium .

O programa usa a sequência de números inteiros como estado inicial, atualiza o estado 434 vezes (354 rodadas atingem a difusão total) e gera 177 bits de saída, comparados com os da sequência correta.

Como o tamanho do estado é precisamente 177 bits, isso deve ser suficiente para identificar exclusivamente o estado inicial.

Exemplo de execução

$ 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=

O Stack Exchange é propenso a agrupar caracteres não imprimíveis, mas copiar o código dessa pasta e colá -lo no interpretador CJam funciona bem para mim.

Como funciona

Depois de substituir a cadeia Unicode por números inteiros (considerando os dígitos dos caracteres dos números base 65533), o seguinte código é executado:

" 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=

Como 13 é coprime para o totiente do módulo (o totiente é secreto, então você só precisa confiar em mim), bases diferentes geram resultados diferentes, ou seja, a solução é única.

A menos que alguém possa explorar o pequeno expoente (13), a maneira mais eficiente de quebrar esse bloqueio é fatorar o módulo (consulte o problema RSA ). Eu escolhi um número inteiro de 512 bits para o módulo, que deve suportar 72 horas de tentativas de fatoração.

Exemplo de execução

$ 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

Vamos tentar 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]))]

(Espera que o usuário insira 5 números separados por vírgula, por exemplo 1,2,3,4,5.)

Java: 468

A entrada é fornecida como k(int[5]). Bails cedo, se não uniformemente espaçados. Caso contrário, é preciso um pouco para descobrir se todos os dez hashes estão corretos. Para números grandes, "um pouco" pode significar dez segundos ou mais, portanto pode dissuadir os 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;}

Aqui está um armário baseado em string que depende da contagem de caracteres de entrada e da entrada específica. A sequência pode ser baseada em referências obscuras da cultura pop. Diverta-se!

Um pouco destroçado:

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

Python, 147

Edit: versão mais curta com base no comentário de Dennis. Também atualizei a sequência para evitar vazar qualquer informação.

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

Baseado no problema discreto de logaritmo, que se acredita ser invencível, no entanto, o principal que estou usando é provavelmente pequeno demais para ser seguro (e pode ter outros problemas, não sei). E você pode fazer força bruta, é claro, já que as únicas incógnitas são dois números inteiros de 32 bits.

Javascript 125

Este deve ser quebrado rapidamente. Vou seguir com algo mais forte.

function unlock(a, b, c, d, e)
{
    return (e << a == 15652) && (c >> a == 7826) && (e - b == d) && (d - c - a == b) ? 1 : 0;
}

Ruby, 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

Ao contrário do uso de um hash criptográfico ou srand, isso é comprovadamente único (o que é uma pequena pista). Toma cinco números via STDIN, delimitado por qualquer caractere ou caracteres que não sejam de dígito, sem nova linha. Saídas para STDOUT.

GolfScript (116 caracteres)

Recebe a entrada como números inteiros separados por espaço.

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

Bytes C 459

RESOLVIDO POR Tyilo - LER EDITAR ABAIXO

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

Precisamos de alguém para escrever uma solução C, não é? Não estou impressionando ninguém, não sou jogador de golfe. Espero que seja um desafio interessante!

Eu não acho que haja uma maneira óbvia de decifrar essa, e espero ansiosamente todas as tentativas! Eu sei que esta solução é única. Ofuscação muito mínima, principalmente para atender aos requisitos de comprimento. Isso pode ser testado simplesmente:

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

PS Há um significado para a[0] como número por si só, e eu gostaria de ver alguém apontar isso nos comentários!

EDITAR:

Solução: 6174, 48216, 90258, 132300, 174342

Uma observação sobre o cracking:

Embora esse não seja o método usado (veja os comentários), eu decifrei minha própria cifra com uma força bruta muito fácil. Agora entendo que é de vital importância aumentar os números. O código a seguir pode decifrar qualquer cifra onde upper_boundexiste um limite superior conhecido a[0] + a[1] + a[2] + a[3] + a[4]. O limite superior na cifra acima é 457464, que pode ser derivado do sistema de equações b[]e de algumas análises do algoritmo. Isso pode ser demonstrado 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]);
}

Com a[0] = 6174, esse loop interrompeu meu trabalho em pouco menos de um minuto.

Mathematica 80 67

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

Corrida:

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

Provavelmente muito fácil de decifrar, também pode ter várias soluções.

Atualização: Golfe aprimorado, fazendo o que Martin Büttner sugeriu. A funcionalidade da função e da tecla não mudou.

Python27, 283 182

Tudo bem, estou muito confiante no meu armário, no entanto, é bastante longo, já que adicionei cálculos 'difíceis de reverter' à entrada, para torná-lo bem - difícil de reverter.

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: Agradecimentos a colevk pelo golfe adicional. Percebi durante a edição que havia um erro e uma falha no meu algoritmo, talvez tenha mais sorte na próxima vez.

Mathematica 142 146

EDIT : chave não era única, adicionou 4 caracteres, agora é.

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

(Espaços e novas linhas adicionados para facilitar a leitura, não são contados e não são necessários).

Uso:

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

Rachado por @Dennis em 2 horas

Simples para começar - espero que isso seja rapidamente quebrado.

Pitão , 13

h_^ZqU5m-CGdQ

Leva entrada separada por vírgula em STDIN.

Execute-o assim (-c significa assumir o programa como argumento da linha de comando):

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

Corrigido o programa - eu não tinha entendido as especificações.

Esse idioma pode ser esotérico demais para esta competição - se o OP achar isso, eu o removerei.

Lua 105

Eu suspeito que não demorará muito tempo para que seja quebrado, mas aqui vamos nós:

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

(espaços adicionados para maior clareza, mas não fazem parte da contagem)

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

Eu tive que colocar muita lógica de manipulação de erros e isso definitivamente pode ser muito mais eficiente. Ele será impresso 1quando você obtiver os cinco números corretos. Ele vai espero imprimir um 0para tudo o resto (pode haver erros ou nada, eu não sei). Se alguém quiser ajudar a melhorar o código ou jogar mais, fique à vontade para ajudar!

Ligue para:

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

Ruby - 130

Baseado no registro de mudança de feedback linear. Entradas por argumentos de linha de comando.
Deve ser exclusivo com base na natureza dos LFSRs. Pista: ascendente e tudo positivo.

Dará mais pistas se ninguém resolver isso em breve.

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

Ruby, 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

Deve ser divertido. Quem precisa de matemática?

CJam, 49 caracteres

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

Experimente online.

Como 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.                          ";

%!

O resultado será 1 se, e somente se, o segundo inteiro for um fator do primeiro, que é um produto de dois primos: o correspondente à sequência secreta e o outro que não corresponde a nenhuma sequência válida. Portanto, a solução é única.

Factorizing um número inteiro de 512 bits não é que difícil, mas eu espero que ninguém será capaz de em 72 horas. Minha versão anterior usando um número inteiro de 320 bits foi quebrada .

Exemplo de execução

$ 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

Converte as entradas em vários tipos de dados e executa algumas manipulações relevantes para cada tipo de dados ao longo do caminho. Deve ser facilmente revertido para qualquer pessoa que gaste algum tempo.

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 (Rachado por Dennis)

Vá aqui para o meu envio atualizado.

Provavelmente poderia ser jogado um pouco mais a fundo. É certo que eu não tomei tempo para provar que a chave é única (provavelmente não é), mas é definitivamente da ordem de uma colisão de hash. Se você o quebrar, compartilhe seu 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 - Rachado

https://codegolf.stackexchange.com/a/36810/31064 da Orby possui pelo menos duas chaves:

13 103 193 283 373
113 173 233 293 353

Orby pediu o método que eu usei para decifrá-lo. A função p verifica se x é primo verificando x%i==0todos os i entre 2 e x (embora esteja usando em (x/i)*i==xvez de x%i==0) e retorna true se x é um número primo. A função f verifica se todos os a, b, c, d e e são primos. Ele também verifica se o número m, uma concatenação das representações decimais de e, d, c, bec (nessa ordem), é primo. A chave é tal que a, b, c, d, e em são todos primos.

Green e Tao (2004) mostram que existem infinitas seqüências aritméticas de números primos para qualquer comprimento k, portanto, precisamos apenas procurar essas seqüências que também satisfaçam m ser primo. Ao demorar muito tempo, sendo delimitado por -9.223372037e + 18 e 9.223372037e + 18, sabemos que, para que a sequência concatenada se ajuste ao longo, os números têm um limite superior de 9999. Portanto, usando um script python para gerar tudo Se as seqüências aritméticas dentro de todos os números primos <10000 e, em seguida, verificando se a concatenação reversa é primordial, podemos encontrar muitas soluções possíveis.

Por alguma razão, criei falsos positivos, mas os dois acima são válidos de acordo com o programa. Além disso, pode haver soluções em que e é negativo e o restante é positivo (p usa o módulo de x), mas não procurei por elas.

As chaves que eu dei são todas sequências aritméticas, mas o script de Orby não parece realmente exigir que as entradas sejam uma sequência aritmética; portanto, também podem haver chaves inválidas.

MATLAB: aparentemente inválido

Muito simples, você só precisa gerar o número aleatório certo.

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

Ainda pode haver erros, mas isso não deve ser um problema.

MATLAB (com caixa de ferramentas simbólica), 173 caracteres

Esta não é uma entrada oficial e não será contabilizada na pontuação de ninguém, mas garantirá seus direitos de se gabar. ;)

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

A caixa de ferramentas simbólica é necessária apenas para lidar com a subtração de números inteiros grandes.

Forçar brutalmente deve ser um cachorro, mas se você estiver familiarizado com a série, a solução é trivial.

Python 2 (91)

Editar: isso não é permitido porque o argumento da exclusividade é probabilístico. Desisto.

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

Leva listas de números inteiros como entrada, como [1,2,3,4,5] .

O loop destina-se a operar sobre as entradas de maneira irritante, deixando uma torre de somas e expoentes. A idéia é como um log discreto, mas com complicação confusa em vez de simplicidade matemática. Talvez a composição do módulo seja uma vulnerabilidade; nesse caso, eu poderia torná-lo algo parecido 7**58+8.

Realmente não sei como provar que minha chave é a única, mas o intervalo de saídas é pelo menos 10 vezes maior que o intervalo de entradas, então provavelmente? Embora talvez apenas uma pequena fração dos resultados potenciais seja possível. Eu sempre poderia aumentar o número de dígitos ao custo de caracteres. Vou deixar você decidir o que é justo.

Feliz quebrando!

Mathematica - 72

Versão 2 do meu script, com a mesma chave que a destinada à minha versão 1.

Isso basicamente remove números primos negativos para NextPrime.

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

Corrida:

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

Digite os números como 1,2,3,4,5.

> python 36768.py <<< "1,2,3,4,5"
0
> python 36768.py <<< "[REDACTED]"
1

Python, 78

(Rachado por Tyilo em 14 minutos)

Diversão!

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

Ok, ele não é exibido corretamente aqui :(

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

CJam, 37 caracteres (quebrado)

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

Experimente online.

Como funciona

Veja minha nova resposta.

Exemplo de execução

$ 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 (Rachado)

Essa é a mesma ideia da minha submissão anterior , que jogou com mais profundidade, com um bug corrigido que ultrapassava 0,0,0,0,0 (Obrigado a Dennis por apontar o bug). Compile com -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);}