Räuber-Thread hier

In dieser Cops-and-Robbers- Challenge wird sich Cops eine positive ganze Zahl ausdenken. Sie schreiben dann ein Programm oder eine Funktion, die einen Wert ausgibt, wenn die Zahl als Eingabe bereitgestellt wird, und einen anderen Wert für alle anderen positiven Ganzzahleingaben. Die Polizei wird dann das Programm in einer Antwort enthüllen, die die Nummer geheim hält. Räuber können eine Antwort knacken, indem sie die Nummer finden.

Hier ist der Haken: Dies ist kein Code-Golf , sondern Ihre Punktzahl ist die Geheimzahl, wobei eine niedrigere Punktzahl besser ist. Offensichtlich kannst du deine Punktzahl nicht verraten, während Räuber immer noch versuchen, sie zu finden. Bei einer Antwort, die eine Woche nach dem Posten nicht geknackt wurde, wird möglicherweise die Punktzahl angezeigt und als sicher eingestuft. Sichere Antworten können nicht geknackt werden.

Es ist wahrscheinlich selbstverständlich, aber Sie sollten in der Lage sein, Ihre Antwort zu bewerten. Das heißt, Sie sollten genau wissen, welchen Wert Ihre Entscheidungsmaschine akzeptiert. Nur zu wissen, dass es einen gibt, reicht nicht aus.

Verwendung von kryptografischen Funktionen

Im Gegensatz zu den meisten Cops und Räubern, bei denen Sie aufgefordert werden, keine kryptografischen Funktionen zu verwenden, werden sie bei dieser Herausforderung nicht nur vollständig zugelassen, sondern ermutigt. Sie können auf jede Art und Weise Antworten erstellen, solange Sie versuchen, zu gewinnen. Antworten mit anderen Methoden sind hier allerdings auch willkommen. Das Ziel der Herausforderung ist es, zu gewinnen, und solange Sie nicht schummeln, ist nichts vom Tisch.

Tampio , Gebrochen

m:n tulos on luvun funktio tulostettuna m:ään, missä luku on x:n kerrottuna kahdella seuraaja, kun x on luku m:stä luettuna
x:n funktio on luku sadalla kerrottuna sadalla salattuna, missä luku on x alempana sadan seuraajaa tai nolla
x:n seuraajan edeltäjä on x
x:n negatiivisena edeltäjä on x:n seuraaja negatiivisena
nollan edeltäjä on yksi negatiivisena
x salattuna y:llä on örkin edeltäjä, missä örkki on x:n seuraajan seuraaja jaettuna y:llä korotettuna kahteen
sata on kiven kolo, missä kivi on kallio katkaistuna maanjäristyksestä
kallio on yhteenlasku sovellettuna mannerlaatan jäseniin ja tulivuoren jäseniin
tulivuori on nolla lisättynä kallioon
mannerlaatta on yksi lisättynä mannerlaattaan
maanjäristys on kallion törmäys
a:n lisättynä b:hen kolo on yhteenlasku kutsuttuna a:lla ja b:n kololla
tyhjyyden kolo on nolla
x:n törmäys on x tutkittuna kahdellatoista, missä kaksitoista on 15 ynnä 6
x ynnä y on y vähennettynä x:stä

Laufen mit:

python3 suomi.py file.suomi --io

Die Anweisungen zum Installieren des Interpreters finden Sie auf der Github-Seite. Bitte sagen Sie, wenn Sie irgendwelche Schwierigkeiten haben, dies auszuführen.

Das Programm im Pseudocode. Das Programm arbeitet sehr langsam, weil mein Interpreter sehr ineffizient ist. Außerdem habe ich keine verfügbaren Opt-In-Optimierungen verwendet, wodurch sich die Auswertungszeit von einigen Minuten auf etwa 10 Sekunden reduzieren lässt.

Perl 6 - Gebrochen!

Streng genommen ist dies keine akzeptable Einreichung, da es nicht sehr schwer ist, zu gewinnen. Stattdessen hofft es, ein angenehmes Puzzle zu bieten.

Es ist ein "reines Mathe" -Programm, das durch Kontemplation geknackt werden soll. Ich bin mir sicher, dass Sie die Lösung brutal erzwingen können (nachdem Sie einige schlampige Programme bereinigt haben, die ich absichtlich begangen habe), aber für "volle Gutschrift" (: -)) sollten Sie in der Lage sein, zu erklären, was sie aus mathematischen Gründen tut .

sub postfix:<!>(Int $n where $n >= 0)
{
	[*] 1 .. $n;
}

sub series($x)
{
	[+] (0 .. 107).map({ (i*($x % (8*π))) ** $_ / $_! });
}

sub prefix:<∫>(Callable $f)
{
	my $n = 87931;
	([+] (0 .. $n).map({
		π/$n * ($_ == 0 || $_ == $n ?? 1 !! 2) * $f(2*π * $_/$n)
	})).round(.01);
}

sub f(Int $in where $in >= 0)
{
	∫ { series($_)**11 / series($in * $_) }
}

Sie sollen die Funktion f () knacken. (Dies ist die Funktion, die eine natürliche Zahl annimmt und eines der beiden Ergebnisse zurückgibt.) Warnung: Wie von @Nitrodon gezeigt, verhält sich das Programm tatsächlich falsch und "akzeptiert" eine unbegrenzte Anzahl von Eingaben. Da ich keine Ahnung habe, wie das Problem behoben werden kann, stelle ich für die zukünftigen Löser nur fest, dass die Zahl, an die ich gedacht habe, unter 70000 liegt .

Wenn Sie versuchen , dies in TIO zu laufen, es wird eine Zeitüberschreitung. Das ist beabsichtigt. (Da es gar nicht laufen soll!)

Schließlich habe ich versucht, einigermaßen klaren Code zu schreiben. Sie sollten es größtenteils fließend lesen können, auch wenn Sie mit der Sprache nicht vertraut sind. Nur zwei Bemerkungen: die eckigen Klammern [ op ] bedeuten das Reduzieren ("Falten", in Haskell-Jargon) einer Liste mit dem Operator op ; und das aufgerufene Sub postfix:<!>definiert tatsächlich einen Postfix-Operator namens! (dh verwendet wie 5!- es macht genau das, was Sie erwarten würden). Ähnliches gilt für den prefix:<∫>einen.

Ich hoffe, dass jemand Spaß daran hat, aber ich bin nicht sicher, ob ich die Schwierigkeit richtig verstanden habe. Fühlen Sie sich frei, mich in den Kommentaren zu schlagen: -).

Probieren Sie es online!

JavaScript, geknackt

Ich habe dies so oft verschleiert, bis es nicht mehr in diese Antwort passt.

Probieren Sie es hier aus! Klicken Sie auf Ausführen und geben Sie die Konsole einguess(n)

Gibt undefined zurück, wenn Sie die falsche Antwort erhalten, andernfalls true.

Edit: Irgendwie habe ich übersehen, dass meine Punktzahl die Zahl ist. Na ja, meine Nummer ist sehr sehr groß. Trotzdem viel Glück beim Lösen.

Gelee , Gäste: ... ¹ ( geknackt )

5ȷ2_c⁼“ḍtṚøWoḂRf¦ẓ)ṿẒƓSÑÞ=v7&ðþạẆ®GȯżʠṬƑḋɓḋ⁼Ụ9ḌṢE¹’

Probieren Sie es online!

^{1 Wirklich erwartet, dass ich es enthülle? Komm schon! Na ja, es hat eine Punktzahl von 134. Dort habe ich es gesagt!}

Python 2 (geknackt)

Ich würde keine rohe Gewalt vorschlagen. Hoffe du magst Generatoren!

print~~[all([c[1](c[0](l))==h and c[0](l)[p]==c[0](p^q) for c in [(str,len)] for o in [2] for h in [(o*o*o+o/o)**o] for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]] + [{i+1 for i in f(r[5])}=={j(i) for j in [q[3]] for i in l} for q in [(range,zip,str,int)] for r in [[3,1,4,1,5,9]] for g in [q[1]] for s in [[p(l)[i:i+r[5]] for p in [q[2]] for i in [r[5]*u for f in [q[0]] for u in f(r[5])]]] for l in s + g(*s) + [[z for y in [s[i+a][j:j+r[0]] for g in [q[0]] for a in g(r[0])] for z in y] for k in [[w*r[0] for i in [q[0]] for w in i(r[0])]] for i in k for j in k] for f in [q[0]]]) for l in [int(raw_input())]][0]

Probieren Sie es online!

Ansonsten wird 1für die richtige Nummer 0ausgegeben.

Haskell , geknackt

Dies basiert rein auf Arithmetik. Beachten Sie, dass dies myfundie eigentliche Funktion ist, während hes sich nur um eine Hilfsfunktion handelt.

h k = sum $ map (\x -> (x*x)**(-1) - 1/(x**(2-1/(fromIntegral k)))) [1..2*3*3*47*14593]
myfun inp | inp == (last $ filter (\k -> h k < (-7.8015e-5)  )[1..37*333667-1]) = 1
          | otherwise = 0

main = print $ show $ myfun 42 -- replace 42 with your input

Probieren Sie es online!

Java, geknackt von Nitrodon

import java.math.BigDecimal;

public class Main {
    private static final BigDecimal A = BigDecimal.valueOf(4);
    private static final BigDecimal B = BigDecimal.valueOf(5, 1);
    private static final BigDecimal C = BigDecimal.valueOf(-191222921, 9);
    private static BigDecimal a;
    private static BigDecimal b;
    private static int c;

    private static boolean f(BigDecimal i, BigDecimal j, BigDecimal k, BigDecimal l, BigDecimal m) {
        return i.compareTo(j) == 0 && k.compareTo(l) >= 0 && k.compareTo(m) <= 0;
    }

    private static boolean g(int i, int j, BigDecimal k) {
        c = (c + i) % 4;
        if (j == 0) {
            BigDecimal l = a; BigDecimal m = b;
            switch (c) {
                case 0: a = a.add(k); return f(C, b, B, l, a);
                case 1: b = b.add(k); return f(B, a, C, m, b);
                case 2: a = a.subtract(k); return f(C, b, B, a, l);
                case 3: b = b.subtract(k); return f(B, a, C, b, m);
                default: return false;
            }
        } else {
            --j;
            k = k.divide(A);
            return g(0, j, k) || g(1, j, k) || g(3, j, k) || g(3, j, k) || g(0, j, k) || g(1, j, k) || g(1, j, k) || g(3, j, k);
        }
    }

    private static boolean h(int i) {
        a = BigDecimal.ZERO; b = BigDecimal.ZERO; c = 0;
        return g(0, i, BigDecimal.ONE);
    }

    public static void main(String[] args) {
        int i = Integer.valueOf(args[0]);
        System.out.println(!h(i) && h(i - 1) ? 1 : 0);
    }
}

Ich wollte etwas anderes als die üblichen Hash- und Zufallsfunktionen ausprobieren. Sie können die Nummer als Befehlszeilenargument übergeben. Gibt aus, 1ob die richtige Nummer angegeben ist und 0ansonsten. Für kleine Nummern können Sie es auch online ausprobieren .

Hinweis:

Der Hauptteil des Programms implementiert eine Variante eines sehr bekannten Algorithmus. Sobald Sie wissen, was es tut, können Sie das angegebene Programm optimieren, um die Geheimzahl zu berechnen.

Erläuterung:

Dieses Programm implementiert die Durchquerung der quadratischen Variante (Typ 2) der bekannten Koch-Kurve (Bild aus Wikipedia): Die Geheimzahl ist die erste Iteration, die den Punkt (B, C) nicht passiert. Wie von Nitrodon richtig erkannt, können wir mit Ausnahme der ersten Iteration die Rekursion aller Teile der Kurve ignorieren, die den angegebenen Punkt nicht passieren. Durch entsprechende Änderung einer Zeile im Originalprogramm können wir auch im Online-Interpreter die korrekte Nummer überprüfen .

Pyth, Gebrochen von Erik der Outgolfer *

Ich habe versucht, dies so gut wie möglich zu verschleiern.

hqQl+r@G7hZ@c." y|çEC#nZÙ¦Y;åê½9{ü/ãѪ#¤
ØìjX\"¦Hó¤Ê#§T£®úåâ«B'3£zÞz~Уë"\,a67Cr@G7hZ

Probieren Sie es hier aus!

* Die Nummer war 9.

Oktave, Partitur: ???

Es ist so gut wie garantiert, dass keine andere Zahl genau die gleichen 20 Zufallszahlen am Ende 1e8der Zahlenliste hat.

function val = cnr(num)
rand("seed", num);
randomints = randi(flintmax-1,1e4,1e4);
val = isequal(randomints(end+(-20:0))(:), ...
 [7918995738984448
  7706857103687680
  1846690847916032
  6527244872712192
  5318889109979136
  7877935851634688
  3899749505695744
  4256732691824640
  2803292404973568
  1410614496854016
  2592550976225280
  4221573015797760
  5165372483305472
  7184095696125952
  6588467484033024
  6670217354674176
  4537379545153536
  3669953454538752
  5365211942879232
  1471052739772416
  5355814017564672](:));
end

Ansonsten Ausgaben 1für die Geheimzahl 0.

Ich habe dies in Octave 4.2.0 ausgeführt.

_{"Schlaf und andere Verlangsamungen können beim Bruteforcen beseitigt werden."}

Viel Glück damit :)

Ly , 239 Punkte, geknackt

(1014750)1sp[l1+sp1-]28^RrnI24^=u;

Probieren Sie es online!

Ich vertraue darauf, dass niemand Ly hier kennt, obwohl ich weiß, wie leicht sich das ändern könnte ... schwitzt

Erläuterung:

(1014750)1sp[l1+sp1-]              # meaningless code that counts up to 1014750 and discards the result
                     28^Rr         # range from 255 to 0
                          nI       # get the index from the range equal to the input
                            24^=   # check if it's 16
                                u; # print the result

Brain-Flak , Score 1574 ( geknackt )

<>(((((((((((((((((((([([(((()()()){}){}){}])]){})))){}{}{}{}()){}){})){}{})){}{})){}((((((((()()){}){}){}){}[()]){}){}){}){}())){})){}){}{}{}){})(((((((((((((((((((()()){}){}()){}){}){}()){}){}()){}){})){}{}())){}{})){}{}){}){}){})(((((((((((((((()()){}()){}()){}){}){}()){}){}){}()){}){}){}()){}()){}()){})<>{({}[()])<>({}({})<({}({})<({}({})<({}({}))>)>)>)<>}({}<>(){[()](<{}>)}<>)

Probieren Sie es online!

dc

#!/bin/dc
[[yes]P] sy [[no]P] sn [ly sp] sq [ln sp] sr [lp ss] st [ln ss] su
?  sa
119560046169484541198922343958138057249252666454948744274520813687698868044973597713429463135512055466078366508770799591124879298416357795802621986464667571278338128259356758545026669650713817588084391470449324204624551285340087267973444310321615325862852648829135607602791474437312218673178016667591286378293
la %
d 0 r 0
=q !=r
10 154 ^ 10 153 ^ +
d la r la
<t !<u
1 la 1 la
>s !>n

Probieren Sie es online!

Hinweis: Diese Übermittlung wurde seit ihrer Übermittlung geändert. Die ursprüngliche Einreichung (unten) war ungültig und wurde von Sleafar in den Kommentaren unten geknackt. (Eine Eingabe von 1ergibt die Ausgabe yes, aber es gibt eine andere Zahl, die das gleiche Ergebnis liefert.)

#!/bin/dc
[[yes]P] sy [[no]P] sn [ly sp] sq [ln sp] sr
?  sa
119560046169484541198922343958138057249252666454948744274520813687698868044973597713429463135512055466078366508770799591124879298416357795802621986464667571278338128259356758545026669650713817588084391470449324204624551285340087267973444310321615325862852648829135607602791474437312218673178016667591286378293
la %
d 0 r 0
=q !=r
10 154 ^ 10 153 ^ +
d la r la
<p !<n

Probieren Sie es online!

Ruby , sicher, Gäste:

63105425988599693916

#!ruby -lnaF|
if /^#{eval [$F,0]*"**#{~/$/}+"}$/ && $_.to_i.to_s(36)=~/joe|tim/
  p true
else
  p false
end

Probieren Sie es online!

Erläuterung:

Die erste Bedingung prüft die eingegebene Zahl auf , während der Wert einer n-stelligen Zahl unten durch n ^ 10 begrenzt ist. Das Verhältnis zwischen diesen Termen ist n * (9/10) ^ n, das schließlich monoton abnimmt, wenn n zunimmt. Sobald es unter 1 fällt, kann es keine n-stelligen narzisstischen Zahlen geben. Narzissmus . Der Thread, für den ich ursprünglich geschrieben habe, wurde zufällig zur selben Zeit wie ich gepostet habe, aber ich glaube, niemand hat es bemerkt. Die zweite konvertiert die Zahl in die Basis 36, die Buchstaben als Ziffern verwendet, und prüft, ob die Zeichenfolge "joe" oder "tim" enthält. Es kann (durch Erschöpfung) bewiesen werden, dass es nur eine narzisstische Zahl gibt, die entweder Joe oder Tim (Joe) heißt, weil die narzisstischen Zahlen endlich sind. Beweisen Sie, dass sie endlich sind: Das Ergebnis der Aufnahme einer n-stelligen Zahl, der Erhöhung jeder Ziffer auf die n-te Potenz und der Summierung ist oben durch begrenztn*9^n

PHP, safe, score:

60256

<?php

$a = $argv[1];

$b ='0123456789abcdefghijklmnopqrstuvwxyz';

$c = strlen($b);

$d = '';
$e = $a;
while ($e) {
    $d .= $b[$e % $c];
    $e = floor($e / $c);
}

echo ((function_exists($d) && $d($a) === '731f62943ddf6733f493a812fc7aeb7ec07d97b6') ? 1 : 0) . "\n";

Gibt 1 aus, wenn richtig, sonst 0.

Edit: Ich glaube nicht, dass jemand versucht hat, dies zu knacken, weil:

Es wäre leicht, Gewalt anzuwenden.

Erläuterung:

Ich nehme die Eingabe und wandle sie in "Basis 36" um, aber ich kehre die Reste nicht um, um die endgültige Zahl zu erhalten. Die Zahl 60256 ist "1ahs" in der Basis 36. Unreversed, das ist "sha1", was eine Funktion in PHP ist. Die letzte Überprüfung ist, dass sha1 (60256) dem Hash entspricht.

Swift 3 (53 Bytes) - Gebrochen

func f(n:Int){print(n==1+Int(.pi*123456.0) ?222:212)}

Wie führe ich das aus? - f(n:1).

Hier testen.

Python 3, Ergebnis: ???

Hoffentlich zeigt dies, wenn überhaupt, wie problematisch dies wirklich ist:

from hashlib import sha3_512

hash_code = 'c9738b1424731502e1910f8289c98ccaae93d2a58a74dc3658151f43af350bec' \
            'feff7a2654dcdd0d1bd6952ca39ae01f46b4260d22c1a1b0e38214fbbf5eb1fb'


def inc_string(string):
    length = len(string)
    if length == 0 or all(char == '\xFF' for char in string):
        return '\x00' * (length + 1)
    new_string = ''
    carry = True
    for i, char in enumerate(string[::-1]):
        if char == '\xFF' and carry:
            new_string = '\x00' + new_string
            carry = True
        elif carry:
            new_string = chr(ord(char) + 1) + new_string
            carry = False
        if not carry:
            new_string = string[0:~i] + new_string
            break
    return new_string


def strings():
    string = ''
    while True:
        yield string
        string = inc_string(string)


def hash_string(string):
    return sha3_512(string.encode('utf-8')).hexdigest()


def main():
    for string in strings():
        if hash_string(string) == hash_code:
            exec(string)
            break


main()

Im Wesentlichen wird durch diesen Code jede mögliche Zeichenfolge verzögert generiert, bis eine der Zeichenfolgen einen Hash hat, der genau mit der hash_codeobigen übereinstimmt . Der ungeöffnete Code hat die Grundform:

num = int(input('Enter a number:\n'))
if num == <insert number here>:
    print(1)
else:
    print(0)

Mit Ausnahme von <insert number here>wird durch eine Zahl ersetzt und es gibt Kommentare im Code, um den Code so gut wie unwahrscheinlich zu machen.

Ich habe alle Vorsichtsmaßnahmen getroffen, um sicherzustellen, dass ich von diesem Beitrag nicht profitiere. Für den Anfang ist es Community-Wiki, so dass ich keine Wiederholung dafür bekomme. Außerdem ist meine Punktzahl ziemlich groß, so dass hoffentlich eine viel kreativere Antwort kommt und gewinnt.

Hoffe ihr seid nicht zu wütend auf meine Antwort, ich wollte nur zeigen, warum Cops und Räuber Posts normalerweise Hashalgorithmen verbieten.

Python 3 , 49 Bytes, Cracked von sonar235

x = input()
print(int(x)*2 == int(x[-1]+x[0:-1]))

Probieren Sie es online!

Java, Kerbe: 3141592 ( gebrochen )

\u0070\u0075\u0062\u006c\u0069\u0063\u0020\u0063\u006c\u0061\u0073\u0073\u0020\u004d\u0061\u006e\u0067\u006f\u0020\u007b
\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006f\u0069\u0064\u0020\u0063\u006f\u006e\u0076\u0065\u0072\u0074\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u0020\u0073\u0029\u007b\u0066\u006f\u0072\u0028\u0063\u0068\u0061\u0072\u0020\u0063\u0020\u003a\u0020\u0073\u002e\u0074\u006f\u0043\u0068\u0061\u0072\u0041\u0072\u0072\u0061\u0079\u0028\u0029\u0029\u007b\u0020\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u0028\u0022\u005c\u005c\u0075\u0030\u0030\u0022\u002b\u0049\u006e\u0074\u0065\u0067\u0065\u0072\u002e\u0074\u006f\u0048\u0065\u0078\u0053\u0074\u0072\u0069\u006e\u0067\u0028\u0063\u0029\u0029\u003b\u007d\u007d
\u0070\u0075\u0062\u006c\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006f\u0069\u0064\u0020\u006d\u0061\u0069\u006e\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u005b\u005d\u0020\u0061\u0072\u0067\u0073\u0029\u0020\u007b\u0069\u006e\u0074\u0020\u0078\u0020\u0020\u003d\u0020\u0049\u006e\u0074\u0065\u0067\u0065\u0072\u002e\u0070\u0061\u0072\u0073\u0065\u0049\u006e\u0074\u0028\u0061\u0072\u0067\u0073\u005b\u0030\u005d\u0029\u003b
\u0064\u006f\u0075\u0062\u006c\u0065\u0020\u0061\u003d\u0020\u0078\u002f\u0038\u002e\u002d\u0033\u0039\u0032\u0036\u0039\u0039\u003b\u0064\u006f\u0075\u0062\u006c\u0065\u0020\u0062\u0020\u003d\u0020\u004d\u0061\u0074\u0068\u002e\u006c\u006f\u0067\u0031\u0030\u0028\u0028\u0069\u006e\u0074\u0029\u0020\u0028\u0078\u002f\u004d\u0061\u0074\u0068\u002e\u0050\u0049\u002b\u0031\u0029\u0029\u002d\u0036\u003b
\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u006c\u006e\u0028\u0028\u0061\u002f\u0062\u003d\u003d\u0061\u002f\u0062\u003f\u0022\u0046\u0061\u0069\u006c\u0022\u003a\u0022\u004f\u004b\u0022\u0020\u0029\u0029\u003b
\u007d\u007d

Python 3, Punktzahl 1 (sicher)

Keine sehr interessante Lösung, aber besser ein sicherer Cop als ein toter Cop.

import hashlib

def sha(x):
    return hashlib.sha256(x).digest()

x = input().encode()
original = x

for _ in range(1000000000):
    x = sha(x)

print(int(x==b'3\xdf\x11\x81\xd4\xfd\x1b\xab19\xbd\xc0\xc3|Y~}\xea83\xaf\xa5\xb4]\xae\x15wN*!\xbe\xd5' and int(original.decode())<1000))

Ansonsten Ausgaben 1für die Zielnummer 0. Die Eingabe erfolgt aus stdin. Der letzte Teil ( and int(original.decode())<1000) existiert nur, um nur eine Antwort zu gewährleisten, sonst gäbe es offensichtlich unendlich viele Antworten.

C (gcc) , Punktzahl ???

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <wmmintrin.h>

#include <openssl/bio.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>

union State
{
    uint8_t u8[128];
    __m128i i128[8];
} state;

void encrypt()
{
    BIO *key = BIO_new_mem_buf
    (
        "-----BEGIN PUBLIC KEY-----\n"
        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC5CBa50oQ3gOPHNt0TLxp96t+6\n"
        "i2KvOp0CedPHdJ+T/wr/ATo7Rz+K/hzC7kQvsrEcr0Zkx7Ll/0tpFxekEk/9PaDt\n"
        "wyFyEntgz8SGUl4aPJkPCgHuJhFMyUflDTywpke3KkSv3V/VjRosn+yRu5mbA/9G\n"
        "mnOvSVBFn3P2rAOTbwIDAQAB\n"
        "-----END PUBLIC KEY-----\n",
        -1
    );

    RSA *rsa = PEM_read_bio_RSA_PUBKEY(key, &rsa, NULL, NULL);

    uint8_t ciphertext[128];

    RSA_public_encrypt(128, state.u8, ciphertext, rsa, RSA_NO_PADDING);
    memcpy(state.u8, ciphertext, 128);
}

void verify()
{
    if (memcmp
    (
        "\x93\xfd\x38\xf6\x22\xf8\xaa\x2f\x7c\x74\xef\x38\x01\xec\x44\x19"
        "\x76\x56\x27\x7e\xc6\x6d\xe9\xaf\x60\x2e\x68\xc7\x62\xfd\x2a\xd8"
        "\xb7\x3c\xc9\x78\xc9\x0f\x6b\xf0\x7c\xf8\xe5\x3c\x4f\x1c\x39\x6e"
        "\xc8\xa8\x99\x91\x3b\x73\x7a\xb8\x56\xf9\x28\xe7\x2e\xb2\x82\x5c"
        "\xb8\x36\x24\xfb\x26\x96\x32\x91\xe5\xee\x9f\x98\xdf\x44\x49\x7b"
        "\xbc\x6c\xdf\xe9\xe7\xdd\x26\x37\xe5\x3c\xe7\xc0\x2d\x60\xa5\x2e"
        "\xb8\x1f\x7e\xfd\x4f\xe0\x83\x38\x20\x48\x47\x49\x78\x18\xfb\xd8"
        "\x62\xaf\x0a\xfb\x5f\x64\xd1\x3a\xfd\xaf\x4b\xaf\x93\x23\xf4\x36",
        state.u8,
        128
    ))
        exit(0);
}

static inline void quarterround(int offset)
{
    int dest = (offset + 1) % 8, src = offset % 8;

    state.i128[dest] = _mm_aesenc_si128(state.i128[src], state.i128[dest]);
}

int main(int argc, char *argv[])
{
    if (argc != 2)
        exit(0);

    uint64_t input = strtoull(argv[1], NULL, 0);

    state.i128[0] = _mm_set_epi32(0, 0, input >> 32, input);

    for (uint64_t round = 0; round < 0x1p45; round += 2)
    {
        quarterround(0);
        quarterround(2);
        quarterround(4);
        quarterround(6);

        quarterround(7);
        quarterround(1);
        quarterround(3);
        quarterround(5);
    }

    encrypt();
    verify();
    puts("something");
}

Da werden hier kryptografische Lösungen gefördert. Genau eine positive Ganzzahl gibt etwas aus , alle anderen geben nichts aus. Dies dauert lange und kann nicht online getestet werden.

Java, 164517378918, sicher

import java.math.*;import java.util.*;
public class T{
    static boolean f(BigInteger i){if(i.compareTo(BigInteger.valueOf(2).pow(38))>0)return false;if(i.longValue()==0)return false;if(i.compareTo(BigInteger.ONE)<0)return false;int j=i.multiply(i).hashCode();for(int k=3^3;k<2000;k+=Math.abs(j%300+1)){j+=1+(short)k+i.hashCode()%(k+1);}return i.remainder(BigInteger.valueOf(5*(125+(i.hashCode()<<11))-7)).equals(BigInteger.valueOf(0));}
    @SuppressWarnings("resource")
    public static void main(String[]a){long l=new Scanner(System.in).nextLong();boolean b=false;for(long j=1;j<10;j++){b|=f(BigInteger.valueOf(l-j));}System.out.println(f(BigInteger.valueOf(l))&&b);}
}

TI-BASIC, Wertung: 196164532 nicht konkurrierend

Gibt 1 für die Geheimzahl zurück, sonst 0.

Ans→rand
rand=1

Weitere Informationen finden Sie im Hinweis auf dieser Seite zum randBefehl .

Python 3 , Punktzahl :?

def check(x):
    if x < 0 or x >= 5754820589765829850934909 or pow(x, 18446744073709551616, 5754820589765829850934909) != 2093489574700401569580277 or x % 4 != 1:
        return "No way ;-("
    return "Cool B-)"

Probieren Sie es online!

Einfach, aber es kann einige Zeit dauern, bis es brachial wird ;-) Freue mich auf einen schnellen Riss ;-)

Fußnote: Die ersten beiden und die letzten Bedingungen machen die Antwort einzigartig.

Übrigens, wie die Punktzahl berechnet wird?

Tipp 1

Sie können erwarten, dass es 2 ⁶⁴ Antworten innerhalb gibt 0 <= x < [the 25-digit prime], aber tatsächlich gibt es nur 4, und die letzte Bedingung beseitigt die anderen 3. Wenn Sie dies knacken können, dann kennen Sie auch die anderen 3 Lösungen.

Aceto , sicher

  P'*o*7-9JxriM'lo7*9Yxx.P',xe*ikCKxlI.D+∑\a€'#o*84/si5s:i»I9Ji8:i+∑€isi.s1+.i2\H/iQxsUxsxxsxiss*i1dJi/3d2*Ji-d*id*IILCh98*2JixM'e9hxBNRb!p

Gibt TrueFalse aus, wenn dies korrekt ist, andernfalls FalseFalse

Die Nummer war

15752963

Probieren Sie es online!

C #, Mono, Linux, Alpha, Punktzahl 1 (sicher)

class Program
{
public static void Main()
{
//Excluding out-of-range inputs at ppperry's request; does not change solution
//original code:
//var bytes = System.BitConverter.GetBytes((long)int.Parse(System.Console.ReadLine()));
int i;
if (!int.TryParse(System.Console.ReadLine(), out i || i <= 0 || i > 1000000) { System.Console.WriteLine(0); Environment.Exit(0); }
var bytes = System.BitConverter.GetBytes((long)i);
using (var x = System.Security.Cryptography.HashAlgorithm.Create("MD5"))
{
    for (int i = 0; i < 1000000; ++i)
            for (int j = 0; j < 86400; ++j)
                    bytes = x.ComputeHash(bytes);
}
if (bytes[0] == 91 && bytes[1] == 163 && bytes[2] == 41 && bytes[3] == 169)
    System.Console.WriteLine(1);
else
    System.Console.WriteLine(0);
}
}

Vorsichtig. Ich meine es so. Es gibt viele Alpha-Simulatoren. Verwenden Sie eine mit einem Jitter oder dies wird nicht beendet.

Dies hängt von der Tatsache ab, dass Alpha Big-Endian ist, was dazu führt, dass System.BitConverter das Falsche tut, wenn jemand dies auf x86 oder x64 versucht. Ich habe diese Antwort geschrieben, um die Schlechtigkeit der Herausforderung vor allem zu demonstrieren.