Die Herausforderung

Ich präsentiere Ihnen eine weitere Herausforderung zwischen Spion und Spion. In diesem Fall ist das zu schützende Datum jedoch kein Eingang, sondern ein Ausgang .

Die Regeln der Herausforderung sind einfach. Schreiben Sie eine Routine mit folgenden Angaben:

1. Die Routine kann in einer beliebigen Sprache geschrieben sein, darf jedoch 320 Byte nicht überschreiten.
2. Die Routine muss drei 32-Bit-Ganzzahlen mit Vorzeichen als Eingaben akzeptieren. Es kann die Form einer Funktion annehmen, die 3 Argumente akzeptiert, einer Funktion, die ein einzelnes Array mit 3 Elementen akzeptiert, oder eines vollständigen Programms, das 3 Ganzzahlen von einer beliebigen Standardeingabe liest.
3. Die Routine muss eine vorzeichenbehaftete 32-Bit-Ganzzahl ausgeben.
4. Für alle möglichen Eingaben muss die Routine zwischen 2 und 1000 (einschließlich) eindeutige Werte ausgeben. Die Anzahl der eindeutigen Werte, die eine Routine ausgeben kann, wird als Schlüssel bezeichnet .

Als Beispiel das C-Programm

int foo( int i1, int i2, int i3 ) {
    return 20 + (i1^i2^i3) %5;
}

hat einen Schlüssel von 9, da es (hoffentlich) nur Ausgang der neun Werte 16, 17, 18, 19, 20, 21, 22, 23, und 24.

Einige zusätzliche Einschränkungen sind wie folgt:

5. Die Routine muss vollständig deterministisch und zeitinvariant sein und identische Ausgaben für identische Eingaben zurückgeben. Die Routine sollte keine Pseudozufallszahlengeneratoren aufrufen.
6. Die Routine stützt sich möglicherweise nicht auf "versteckte Variablen" wie Daten in Dateien, Systemvariablen oder esoterische Sprachfunktionen. Beispielsweise sollten Routinen im Allgemeinen nicht auf Konstanten verweisen, es sei denn, die Konstanten sind im Code selbst eindeutig definiert. Von Routinen, die auf Compiler-Macken, Ausgaben von mathematisch undefinierten Operationen, Rechenfehlern usw. beruhen, wird ebenfalls dringend abgeraten. Im Zweifelsfall bitte nachfragen.
7. Sie (der Codierer) müssen genau wissen, wie viele eindeutige Ausgaben die Routine erzeugen kann, und sollten in der Lage sein, mindestens eine Eingabesequenz bereitzustellen, die jede Ausgabe erzeugt. (Da es möglicherweise Hunderte von eindeutigen Ausgaben geben kann, wird dieses Set immer nur dann angefordert, wenn Ihr Schlüssel angefochten wird.)

Da dieses Problem der klassischen Verschlüsselung weitaus weniger ähnelt als das vorherige, gehe ich davon aus, dass es einem breiteren Publikum zugänglich sein wird.

Je kreativer, desto besser.

Die Wertung

Die kürzeste (n) nicht geknackte (n) Einsendung (en) pro Byteanzahl wird (werden) zum Gewinner erklärt.

Bei Unklarheiten wenden Sie sich bitte an uns.

Die Gegen-Herausforderung

Alle Leser, einschließlich derer, die ihre eigenen Routinen eingereicht haben, werden aufgefordert, Einsendungen zu "knacken". Ein Beitrag wird geknackt, wenn sein Schlüssel im zugehörigen Kommentarbereich veröffentlicht wird. Wenn eine Einreichung 72 Stunden lang ohne Änderung oder Crack andauert, wird sie als "sicher" eingestuft und jeder nachfolgende Erfolg beim Cracken wird für den Wettbewerb ignoriert.

Pro Einsendung und Leser ist nur ein Crackversuch zulässig. Wenn ich zum Beispiel an Benutzer X sende: "Ihr Schlüssel ist 20" und ich irre mich, lehnt Benutzer X meine Vermutung als falsch ab und ich kann keine weiteren Vermutungen für diese Übermittlung mehr übermitteln.

Gebrochene Einsendungen werden von der Konkurrenz ausgeschlossen (sofern sie nicht "sicher" sind). Sie sollten nicht bearbeitet werden. Wenn ein Leser eine neue Routine einreichen möchte, sollte er dies in einer separaten Antwort tun.

Die Punktzahl eines Crackers ist die Anzahl der Einreichungen (entweder konform oder nicht konform), die er knackt. Bei Crackern mit identischer Anzahl wird die Rangfolge durch die Gesamtbytezahl aller geknackten Einsendungen bestimmt (je höher, desto besser).

Der / die Cracker mit der (den) höchsten Punktzahl (en) wird (werden) zusammen mit den Entwicklern der Gewinnroutine zum Gewinner erklärt.

Bitte knacken Sie nicht Ihren eigenen Beitrag.

Viel Glück. :)

Bestenliste

Zuletzt aktualisiert am 2. September, 10:45 EST

Unbewegliche Barrieren (ungerissene Vorlagen):

1. CJam, 105 [Dennis]

Unaufhaltsame Kräfte (Cracker):

1. Dennis [ Java, 269 ; C 58 ; Mathematica, 29 ]
2. Martin Büttner [ Java, 245 ]

CJam, 105 Bytes

1q~]4G#b2A#md"M-k^XM-WHM-n^GM-0%M-uwM-gM-^XeM-kM-^VO^Ph,M-^MM-^PM-qM-!M-8M-AM-OM-~tM-^FM-cM-h^AM-0M-0M-lM-@M-^[MF=M-^Z^SM-1M-KM-T2M-9M-UmSM-N
M-8M-^^M-n$4M-^M^SM-x M-OM-^@^?"256b@D#Y256#%2+md!A3#*)%)%

Das Obige verwendet Caret- und M-Notation, da es nicht druckbare Zeichen enthält. Nach der Konvertierung des Byte-Streams in eine Ganzzahl ( 256b) wird der folgende Code ausgeführt:

1q~]4G#b2A#md
12313030820310059479144347891900383683119627474072658988524821209446180284434934346766561958060381533656780340359503554566598728599799248566073353154035839
@D#Y256#%2+md!A3#*)%)%

Sie können diese Version online im CJam-Interpreter testen .

Wie es funktioniert

Diese Vorlage verwendet die Zahlentheorie anstelle der Verschleierung. Das Programm gibt für fast alle Eingaben 0 zurück. Aus den wenigen Eingaben, die zu einer Ausgabe ungleich Null führen, wird ein geheimer Modul abgeleitet, der auf die 10 niedrigstwertigen Bits der dritten Ganzzahl angewendet wird.

Die effizienteste Art, diese Herausforderung zu lösen (die mir einfällt), wäre die Faktorisierung der 512-Bit-Ganzzahl, die hoffentlich in 72 Stunden nicht erreichbar sein wird.

" Prepend 1 to the numbers read from STDIN and convert the resulting array into an integer
  (“N”) by considering them digits of a base 2**32 number.                                 ";

1q~]4G#

" Compute “N / 1024” and “N % 1024”.                                                       ";

2A#md

" Push a carefully selected 512 bit semi-prime (“S”).                                      ";

12313030820310059479144347891900383683119627474072658988524821209446180284434934346766561958060381533656780340359503554566598728599799248566073353154035839

" Compute P = (N / 1024) ** 13 % 2 ** 256 + 2.                                             ";

@D#Y256#%2+

" Compute “S / P” and “S % P”.                                                             ";

md

" Compute “M = (S / P) % (1000 * !(S % P) + 1) + 1”.

  “M” is the key if P is a divisor of S; otherwise, “M == 1”.                              ";

!A3#*)%)

" Compute the final output: “N % 1024 % M”.                                                ";

%

Beispiellauf

$ base64 -d > outputs.cjam <<< MXF+XTRHI2IyQSNtZCLrGNdI7gewJfV355hl65ZPEGgsjZDxobjBz/50huPoAbCw7MCbTUY9mhOxy9QyudVtU84KuJ7uJDSNE/ggz4B/IjI1NmJARCNZMjU2IyUyK21kIUEzIyopJSkl
$ wc -c outputs.cjam
105 outputs.cjam
$ LANG=en_US cjam outputs.cjam < outputs.secret; echo
1
$ LANG=en_US cjam outputs.cjam <<< '1 2 3'; echo
0

Java - 269

Vielen Dank für die Geduld aller, dies sollte nun behoben sein.

verkürzt:

int a(int a,int b,int c){double d=180-360.0/(int)(Math.abs(Math.sin(a*60))*50+2),e=180-360.0/(int)(Math.abs(Math.cos(b*60))*50+2),f=180-360.0/(int)(Math.atan2(c*60, a*60)*51+2);if(Math.abs(d+e+f-360)<.1)return Integer.valueOf((int)d+""+(int)e+""+(int)f);else return 1;}

Nicht gekürzt:

int a(int a, int b, int c) {
    double d = 180 - 360.0 / (int) (Math.abs(Math.sin(a * 60)) * 50 + 2);
    double e = 180 - 360.0 / (int) (Math.abs(Math.cos(b * 60)) * 50 + 2);
    double f = 180 - 360.0 / (int) (Math.atan2(c * 60, a * 60) * 51 + 2);
    if (Math.abs(d + e + f - 360) < .1)
        return Integer.valueOf((int) d + "" + (int) e + "" + (int) f);
    else
        return 1;
}

Ein Sampler

Natürlich kein offizieller Eintrag, und die Anzahl der Zeichen ist zu hoch, aber ich denke, wenn jemand eine nervenaufreibende Herausforderung haben möchte, kann er versuchen, zu bestimmen, wie viele eindeutige Ausgaben die folgende Funktion erzeugt (vorausgesetzt, drei Eingaben werden im OP beschrieben). :

function z(y,_,$){M=[];N=[];O=[];C=1792814437;P=72;r=t=0;(f=function(a,k,L){if(k<a.length){for(L=a[k],a[k]=0;a[k]<L;a[k]++)f(a,k+1)}else
if(!t){f([P-1,P-1],0,++t);N=M;while(t<2*P){s=!(t&1);f([P,P,P,P],0,++t);r=r||(s?0:t);t&1&&(N=O);O=[]}}else
((t<2)&&(((d=P*a[0]+(P+1)*a[1]+P)<(P<<6))&&(M[d]=(((y^~_)>>a[0])+((_^~$)>>(a[0]-32)))&1),((a[1]<P-a[0])&&
(M[a[1]+(P+1)*a[0]]=(($^C)>>a[0]+16-a[1])&1))||1))||((t&1)&&((O[P*a[2]+a[3]]|=M[a[1]+P*a[2]]&N[P*a[0]+a[3]]&&
!(a[0]-a[1]))||1))||(s|=N[(a[0]+1)*a[1]+a[3]]);})([],0,0);return r;}

Tatsächlich bin ich so zuversichtlich, dass es unknackbar ist, dass ich jeden, der es knackt, mit dem "Supreme Unstoppable Force of Nature Award" auszeichnen werde.

Weil sie es wirklich verdienen.

C, 58 Bytes (geknackt)

Ein einfaches:

f(a,b,c){return(long long)a*b*c-0x1d21344f8479d61dLL?0:a;}

Java - 245

Gebrochen von Martin Büttner

int a(int[]_$){return $($($_(_$[0],0)))+$_(_$[1],1)*11+$($($_(_$[1+1],0)))*(1+1);}int $_(int $,int $_){int OO=0,o=1,O=1;for($=$<0?-$:$;++O*O<=$;OO+=$%O<1?O:0,o+=$%O<1?1:0,$/=$%O<1?O--:1);return $_>0?o:OO+$;}int $(int $){return(int)Math.sqrt($);}

Füttere die Eingabe als int-Array: a(new int[]{1,2,3}) . Ich erwarte nicht, dass es 72 Stunden dauern wird, aber viel Spaß damit.

Hier ist es mit Zeilenumbrüchen, um es ein bisschen lesbarer zu machen:

int a(int[]_$){return $($($_(_$[0],0)))+$_(_$[1],
1)*11+$($($_(_$[1+1],0)))*(1+1);}int $_(int $,int
$_){int OO=0,o=1,O=1;for($=$<0?-$:$;++O*O<=$;OO+=
$%O<1?O:0,o+=$%O<1?1:0,$/=$%O<1?O--:1);return $_>
0?o:OO+$;}int $(int $){return(int)Math.sqrt($);}

Mathematica, 29 Bytes, Schlüssel: 715, Gebrochen von Dennis

Dies ist nur eine feste Version meiner ursprünglichen Antwort, die bei nicht positiven Eingaben nicht funktioniert hat.

f=Plus@@Mod[NextPrime@#,240]&

Nimmt eine Liste von ganzen Zahlen wie

f[{1,2,3}]

207 Zeichen in C / C ++, noch nicht verschleiert:

int x(int a, int b, int c) {
    int d, e, f;
    for (int i=0; i!=1<<31; ++i) {
        d=10*(b-a);
        e=a*(28-c)-b;
        f=a*b-2.7*c;
        a += d;
        b += e;
        c += f;
    }
    return ((a%5+5)*10+(b%5+5))*10+c%5+5;
}