チャレンジ

単純な「スパイ対スパイ」チャレンジ。

次の仕様でプログラムを作成します。

1. プログラムは任意の言語で記述できますが、512文字を超えてはなりません（このサイトのコードブロックで表されています）。
2. プログラムは、入力として5つの符号付き32ビット整数を受け入れなければなりません。5つの引数を受け入れる関数、単一の5要素配列を受け入れる関数、または標準入力から5つの整数を読み取る完全なプログラムの形式をとることができます。
3. プログラムは、1つの符号付き32ビット整数を出力する必要があります。
4. プログラムは、シーケンスとして解釈される5つの入力が、プログラマが選択した特定の算術シーケンス（「キー」と呼ばれる）と一致する場合にのみ1を返す必要があります。この関数は、他のすべての入力に対して0を返す必要があります。

算術シーケンスには、シーケンスの各連続要素が、その前身に何らかの固定定数を加えたものに等しいという特性がありますa。

たとえば、25 30 35 40 45シーケンスの各要素はその前身に5を加えたものに等しいため17 10 3 -4 -11、算術シーケンスです。同様に、各要素はその前身に-7を加えたものに等しいため、算術シーケンスです。

シーケンス1 2 4 8 16と3 9 15 6 12は、算術シーケンスではありません。

キーは、整数オーバーフローを伴うシーケンスが許可されていないという唯一の制限事項がありますが、任意の算術シーケンスを選択できます。つまり、シーケンスは厳密に増加、厳密に減少、またはすべての要素が等しくなければなりません。

例として、キーを選択するとします98021 93880 89739 85598 81457。プログラムは、入力が（順番に）これら5つの数値に一致する場合は1を返し、そうでない場合は0を返す必要があります。

キーを保護する手段は、独自の斬新なデザインである必要があることに注意してください。また、ゼロ以外の確率で誤検知を返す可能性のある確率的ソリューションは許可されていません。特に、標準暗号化ハッシュのライブラリ関数を含む、標準暗号化ハッシュを使用しないでください。

スコアリング

文字数ごとの最短のクラックされていない提出物が勝者と宣言されます。

混乱がある場合は、お気軽に質問またはコメントしてください。

カウンターチャレンジ

独自のプログラムを提出した人を含むすべての読者は、提出物を「クラック」することをお勧めします。キーが関連するコメントセクションに投稿されると、提出物がクラックされます。提出物が変更またはクラックされることなく72時間持続する場合、「安全」とみなされ、その後のクラックの成功はコンテストのために無視されます。

更新されたクラッキングスコアポリシーの詳細については、以下の「免責事項」を参照してください。

クラックされたサブミッションは競合から排除されます（「安全」でない場合）。編集しないでください。読者が新しいプログラムを提出したい場合は、別の回答で提出する必要があります。

最高スコアのクラッカーが、受賞プログラムの開発者とともに受賞者として宣言されます。

自分の提出物をクラックしないでください。

幸運を祈ります。:)

リーダーボード

最後から2番目の順位（デニスのCJam 49提出の安全性の保留）。

安全なロッカー

1. CJam 49、デニス
2. CJam 62、デニス セーフ
3. CJam 91、デニス セーフ
4. Python 156、Maarten Baert セーフ
5. Perl 256、chilemagic セーフ
6. Java 468、Geobits セーフ

止められないクラッカー

1. ピーター・テイラー [Ruby 130、Java 342、Mathematica 146 *、Mathematica 72 *、CJam 37]
2. デニス[Pyth 13、Python 86 *、Lua 105 *、GolfScript 116、C 239 *]
3. MartinBüttner[Javascript 125、Python 128 *、Ruby 175 *、Ruby 249 *]
4. ティロ[C 459、Javascript 958 *]
5. freddieknets [Mathematica 67 *]
6. イルマリ・カロネン[Python27 182 *]
7. 亜硝酸[C 212 *]

*非準拠の提出

免責事項（更新日11:15 PM EST、8月26日）

スコアリングの問題が最終的にクリティカルマスに達したため（クラックされたサブミッションの3分の2がこれまでに準拠していない場合）、クラックされたサブミッションの数（プライマリ）および準拠したクラックされたサブミッションの文字の総数でトップクラッカーをランク付けしました（セカンダリ）。

以前と同様に、正確な提出物にクラックが発生し、提出物の長さ、および準拠/非準拠のステータスはすべてマークされているため、新しい公式ランキングが不公平であると読者が判断した場合、読者は自分のランキングを推測できます。

ゲームの後半でルールを修正したことに対する謝罪。

CJam、62文字

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

Stack Exchangeは印刷できない文字を傷つける傾向がありますが、このペーストからコードをコピーしてCJamインタープリターに貼り付けるとうまくいきます。

使い方

Unicode文字列をASCII文字列に置き換えた後、次のコードが実行されます。

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

このアプローチでは、ストリーム暗号であるTriviumの弱体化バージョンであるBivium-B（Triviumのような暗号の代数分析を参照）を使用します。

プログラムは整数のシーケンスを初期状態として使用し、状態を434回更新し（354ラウンドで完全な拡散を実現）、177ビットの出力を生成し、正しいシーケンスの出力と比較します。

状態のサイズは177ビットであるため、初期状態を一意に識別するにはこれで十分です。

実行例

$ 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文字

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

Stack Exchangeは印刷できない文字を傷つける傾向がありますが、このペーストからコードをコピーしてCJamインタープリターに貼り付けるとうまくいきます。

使い方

Unicode文字列を整数で置き換えた後（基数65533の数字を考慮して）、次のコードが実行されます。

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

13はモジュラスのtotientと互いに素であるため（totientは秘密なので、あなたは私を信頼する必要があります）、異なるベースは異なる結果を生成します。つまり、ソリューションは一意です。

誰かが小さな指数（13）を悪用できない限り、このロックを解除する最も効率的な方法は、係数を因数分解することです（RSA問題を参照）。モジュラスには512ビット整数を選択しました。これは、72時間の因数分解試行に耐える必要があります。

実行例

$ 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

これを試してみましょう：

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

（5つのコンマ区切りの数値を入力するようにユーザーに期待します1,2,3,4,5。

Java：468

入力はとして与えられますk(int[5])。等間隔でない場合は早めにベイルします。それ以外の場合、10個のハッシュがすべて正しいかどうかを少し理解する必要があります。大きな数の場合、「ビット」は10秒以上を意味する可能性があるため、クラッカーを思いとどまらせる可能性があります。

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

入力文字数と特定の入力の両方に依存する文字列ベースのロッカーは次のとおりです。シーケンスは、あいまいなポップカルチャー参照に基づいている場合があります。楽しむ！

少し自由：

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

編集：デニスのコメントに基づいて短いバージョン。情報の漏洩を防ぐため、シーケンスも更新しました。

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

割れないと考えられている離散対数問題に基づいていますが、私が使用している素数はおそらく安全ではありません（そして、他の問題があるかもしれません）。もちろん、2つの32ビット整数のみが不明であるため、ブルートフォースできます。

Javascript 125

これはすぐにクラックされるはずです。もっと強力なものをフォローアップします。

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

ルビー、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

暗号化ハッシュまたはを使用するのとは異なりsrand、これは証明できるほどユニークです（わずかな手がかりです）。STDINを介して、数字でも改行でもない文字で区切られた5つの数字を受け取ります。STDOUTへの出力。

GolfScript（116文字）

スペースで区切られた整数として入力を受け取ります。

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

C 459バイト

Tyiloが解決-下記の編集を読む

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

Cソリューションを作成するために誰かが必要ですよね？私は長さに感動していません。ゴルファーではありません。しかし、それが興味深い挑戦であることを願っています！

これをクラックする明白な方法があるとは思いません。すべての試みを待ち望んでいます！私はこのソリューションがユニークであることを知っています。主に長さの要件を満たすための、非常に最小限の難読化。これは簡単にテストできます：

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

PS a[0]数字としてそれ自体が重要であり、コメントで誰かが指摘してくれることを望みます！

編集：

溶液： 6174, 48216, 90258, 132300, 174342

クラッキングに関する注意：

これは使用される方法ではありませんが（コメントを参照）、たまたま非常に簡単なブルートフォースで自分の暗号を解読しました。私は今、数字を大きくすることが極めて重要であることを理解しています。次のコードupper_boundは、の既知の上限である暗号を解読できa[0] + a[1] + a[2] + a[3] + a[4]ます。上記の暗号の上限は457464、です。これは、の連立方程式b[]とアルゴリズムの一部の作業から導き出すことができます。それを示すことができます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]);
}

でa[0] = 6174、このループは1分弱で私の作業を中断しました。

Mathematica 80 67

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

ランニング：

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

おそらく非常に簡単にクラックできますが、複数のソリューションがあるかもしれません。

更新： MartinBüttnerが提案したことを行うことでゴルフが改善されました。関数とキーの機能は変更されていません。

Python27、283 182

申し分なく、私はロッカーに非常に自信を持っていますが、入力に「逆にするのが難しい」計算を追加し、うまく逆行させるのが難しいため、かなり長いです。

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]

編集：colevk、さらにゴルフをしてくれてありがとう。編集中にバグとアルゴリズムの欠陥があることに気付きました。多分次回は運が良くなるでしょう。

Mathematica 142 146

編集：キーは一意ではなく、4文字追加されました。

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

（読みやすくするためにスペースと改行が追加されました。カウントされず、不要です）。

使用法：

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

@Dennisによる2時間のクラック

物事を始めるための簡単なもの-これがすぐにクラックされることを完全に期待しています。

パイス、13

h_^ZqU5m-CGdQ

STDINでコンマ区切りの入力を取ります。

次のように実行します（-cはプログラムをコマンドライン引数として使用することを意味します）。

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

プログラムを修正しました-私は仕様を理解していませんでした。

この言語は、このコンペティションでは難解すぎるかもしれません-OPがそう考えるなら、私はそれを削除します。

ルア105

ひびが入るのにそう長くはかからないと思うが、ここで行く：

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

（明確にするために追加されたスペースは、カウントの一部ではありません）

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

私は多くのエラー処理ロジックを入れなければなりませんでしたが、これは間違いなくもっと多くのことができます。1正しい5つの数字を取得すると、a が出力されます。それはなりますうまくいけば印刷する0他のすべてのために（エラーまたは何もかもしれないが、私は知りません）。コードの改善やゴルフの改善を手伝いたい人がいれば、気軽に手伝ってください！

で呼び出す：

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

ルビー-130

線形フィードバックシフトレジスタに基づいています。コマンドライン引数による入力。
LFSRの性質に基づいて一意である必要があります。手がかり：昇順ですべてポジティブ。

誰もすぐに解決しない場合、より多くの手がかりを与えます。

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

ルビー、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

楽しいはずです。誰が数学を必要としますか？

CJam、49文字

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

オンラインでお試しください。

使い方

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

%!

2番目の整数が最初の因子である場合にのみ、結果は1になります。これは、2つの素数の積です。1つは秘密シーケンスに対応し、もう1つは有効なシーケンスに対応しません。したがって、ソリューションはユニークです。

512ビット整数を因数分解することはそれほど難しくありませんが、72時間以内に誰もそれができないことを望みます。320ビット整数を使用した私の以前のバージョンは壊れています。

実行例

$ 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

入力をいくつかのデータ型に変換し、途中で各データ型に関連するいくつかの操作を実行します。時間のかかる人はかなり簡単に元に戻す必要があります。

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（デニスによる亀裂）

行くここに私の更新申請のために。

おそらくもう少し徹底的にゴルフすることができます。確かに、キーが一意であることを証明するのに時間をかけていません（おそらくそうではありません）が、それは間違いなくハッシュ衝突のオーダーです。あなたがそれをクラックする場合、あなたの方法を共有してください:)

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 by Orby-クラック

Orbyのhttps://codegolf.stackexchange.com/a/36810/31064には少なくとも2つのキーがあります。

13 103 193 283 373
113 173 233 293 353

Orbyは、私がそれをクラックするために使用した方法を求めました。関数pはx%i==0、2からxの間のすべてのiをチェックすることによりxが素数かどうかをチェックします（ただし、(x/i)*i==x代わりにを使用x%i==0します）。xが素数の場合、trueを返します。関数fは、a、b、c、d、eがすべて素数であることを確認します。また、e、d、c、b、aの10進表現の連結である数値m（この順序で）が素数であるかどうかもチェックします。キーは、a、b、c、d、eおよびmがすべて素数であるようなものです。

Green and Tao（2004）は、任意の長さkに対して素数の算術シーケンスが無限に存在することを示しているので、mが素数であるこれらのシーケンスを探すだけです。-9.223372037e + 18および9.223372037e + 18で囲まれているように長い時間を取ることにより、連結された文字列がlong longに収まるように、数字の上限が9999であることがわかります。すべての素数内の算術シーケンス<10000で、その逆連結が素数であるかどうかをチェックすると、多くの可能な解決策を見つけることができます。

なんらかの理由で、私は誤検知を思いつきましたが、上記の2つはプログラムに従って有効です。さらに、eが負で残りが正である（pがxのモジュラスを使用する）ソリューションがあるかもしれませんが、私はそれらを探しませんでした。

私が与えたキーはすべて算術シーケンスですが、Orbyのスクリプトは実際には入力が算術シーケンスであることを要求していないようです。そのため、無効なキーもある可能性があります。

MATLAB：どうやら無効

非常に簡単で、正しい乱数を生成するだけです。

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

それでもエラーが出る可能性がありますが、それは問題ではないはずです。

MATLAB（Symbol Toolboxを使用）、173文字

これは公式のエントリではなく、誰のクラッキングスコアにもカウントされませんが、気違い自慢の権利を相殺します。;）

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

シンボリックツールボックスは、大きな整数の減算を処理するためにのみ必要です。

それを強引に強制するのは犬であるべきですが、それが関係するシリーズに精通しているなら、解決策は簡単です。

パイソン2（91）

編集：一意性の引数は確率的であるため、これは許可されません。あきらめる。

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

入力として整数のリストを受け取ります [1,2,3,4,5]。

このループは、入力に対して煩わしい方法で操作し、合計と指数の塔を残すことを目的としています。この考え方は離散対数に似ていますが、数学的単純さの代わりに厄介な複雑さを伴います。モジュラスの複合性が脆弱性である可能性があります。その場合、次のようにできます。7**58+8ます。

私のキーが唯一のものであることをどのように証明するかは本当にわかりませんが、出力の範囲は入力の範囲より少なくとも10倍大きいので、おそらく？おそらく、潜在的なアウトプットのほんの一部しか達成できませんが。文字数を犠牲にして、常に桁数を増やすことができました。何が公正かを決めるのはあなた次第です。

ハッピークラッキング！

Mathematica-72

バージョン1向けのキーと同じキーを持つ、バージョン2のスクリプト。

これは基本的にの負の素数を削除しNextPrimeます。

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

ランニング：

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

Python、86文字

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

のような番号を入力します1,2,3,4,5。

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

Python、78

（14分でTyiloによりクラック）

楽しい！

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

さて、ここでは正しく表示されません:(

5つの数字のリストが必要です。[1,2,3,4,5]

CJam、37文字（破損）

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

オンラインでお試しください。

使い方

私の新しい答えをご覧ください。

実行例

$ 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（割れた）

これは、以前の提出と同じ考え方で、より徹底的にゴルフを行い、バグを修正して0,0,0,0,0を渡しました（バグを指摘してくれたDennisに感謝します）。-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);}