Fil de voleur ici

Dans ce défi des flics et des voleurs , les flics penseront à un entier positif. Ils écriront ensuite un programme ou une fonction qui génère une valeur lorsque le nombre est fourni en entrée et une autre valeur pour toutes les autres entrées entières positives. Les flics révéleront ensuite le programme dans une réponse en gardant le numéro secret. Les voleurs peuvent trouver une réponse en trouvant le numéro.

Voici le hic: ce n'est pas du golf de code , au lieu de cela votre score sera le numéro secret avec un score inférieur étant meilleur. De toute évidence, vous ne pouvez pas révéler votre score pendant que les voleurs tentent toujours de le trouver. Une réponse qui n'a pas été révélée une semaine après sa publication peut voir son score révélé et être notée comme étant sûre. Les réponses sûres ne peuvent pas être fissurées.

Cela va probablement de soi, mais vous devriez pouvoir noter votre réponse. C'est-à-dire que vous devez savoir exactement quelle valeur est acceptée par votre machine de décision. Il ne suffit pas de savoir qu'il y en a un.

Utilisation des fonctions cryptographiques

Contrairement à la plupart des défis des flics et des voleurs qui vous demandent de ne pas utiliser de fonctions cryptographiques, ce défi les permet non seulement entièrement, mais les encourage. Vous êtes libre de créer des réponses de quelque manière que ce soit tant que vous essayez de gagner. Cela étant dit, les réponses utilisant d'autres méthodes sont également les bienvenues ici. Le but du défi est de gagner, et tant que vous ne trichez pas, rien n'est en jeu.

Tampio , fissuré

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ä

Courir avec:

python3 suomi.py file.suomi --io

Les instructions d'installation de l'interpréteur sont incluses dans la page Github. Veuillez indiquer si vous rencontrez des difficultés pour exécuter ceci.

Le programme en pseudocode. Le programme fonctionne très lentement car mon interprète est super inefficace. De plus, je n'ai utilisé aucune optimisation d'opt-in disponible, ce qui peut réduire le temps d'évaluation de plusieurs minutes à environ 10 secondes.

Perl 6 - Cracked!

Au sens strict, ce n'est pas une soumission acceptable car elle n'essaie pas très fort de gagner. Au lieu de cela, il espère offrir un puzzle agréable.

Il s'agit d'un programme de "mathématiques pures" qui est destiné à être brisé par la contemplation. Je suis sûr que vous pouvez forcer la solution (après avoir nettoyé une programmation bâclée que j'ai délibérément engagée), mais pour "crédit complet" (: -)), vous devriez être en mesure d'expliquer ce qu'il fait sur le plan mathématique .

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 * $_) }
}

Vous êtes censé casser la fonction f (). (C'est la fonction qui prend un nombre naturel et renvoie l'un des deux résultats.) Avertissement: Comme le montre @Nitrodon, le programme se comporte en fait de manière incorrecte et "accepte" un nombre infini d'entrées. Comme je n'ai aucune idée de la façon de le réparer, je remarque simplement pour les futurs solveurs que le nombre que j'avais en tête est inférieur à 70000 .

Si vous essayez d'exécuter cela dans TIO, il va expirer. C'est intentionnel. (Puisqu'il n'est pas censé être exécuté du tout!)

Enfin, j'ai essayé d'écrire du code raisonnablement clair. Vous devriez surtout pouvoir le lire couramment même si vous n'êtes pas familier avec la langue. Deux remarques seulement: les crochets [ op ] signifient réduire ("pliage", dans le jargon Haskell) une liste avec l'opérateur op ; et le sous appelé postfix:<!>définit en fait un opérateur postfix nommé! (c'est-à-dire utilisé comme 5!- il fait exactement ce que vous attendez). De même pour l' prefix:<∫>un.

J'espère que quelqu'un apprécie celui-ci, mais je ne sais pas si j'ai bien réussi. N'hésitez pas à me dénigrer dans les commentaires :—).

Essayez-le en ligne!

JavaScript, fissuré

J'ai obscurci cela autant que possible, au point où cela ne peut pas rentrer dans cette réponse.

Essayez-le ici! Cliquez sur Exécuter, puis tapez dans la consoleguess(n)

Renvoie undefined si vous obtenez la mauvaise réponse, renvoie true sinon.

Edit: D'une manière ou d'une autre, j'ai négligé la partie sur mon score étant le nombre. Eh bien, mon numéro est très très gros. Bonne chance pour le résoudre de toute façon.

Gelée , score: ... ¹ ( fissuré )

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

Essayez-le en ligne!

^{1 Vous vous attendiez vraiment à ce que je le révèle? Allons! Eh bien, il a un score de 134. Voilà, je l'ai dit!}

Python 2 (fissuré)

Je ne suggérerais pas la force brute. J'espère que vous aimez les générateurs!

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]

Essayez-le en ligne!

Sorties 1pour le nombre correct, 0sinon.

Haskell , craqué

Ceci est purement basé sur l'arithmétique. Notez que myfunc'est la fonction réelle, tandis que hc'est juste une fonction d'aide.

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

Essayez-le en ligne!

Java, cracké par 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);
    }
}

Je voulais essayer quelque chose de différent du hachage habituel et des fonctions aléatoires. Vous pouvez passer le nombre comme argument de ligne de commande. Affiche 1si le nombre correct est donné et 0sinon. Pour les petits nombres, vous pouvez également l' essayer en ligne .

Allusion:

La partie principale du programme implémente une variante d'un algorithme très connu. Une fois que vous savez ce qu'il fait, vous pourrez optimiser le programme donné pour calculer le numéro secret.

Explication:

Ce programme implémente la traversée de la variante quadratique (type 2) de la courbe de Koch bien connue (image de Wikipedia): Le nombre secret est la première itération qui ne passe pas par le point (B, C). Comme correctement reconnu par Nitrodon , à l'exception de la première itération, nous pouvons ignorer en toute sécurité la récursivité de toutes les parties de la courbe, qui ne passent pas par le point donné. En modifiant une ligne dans le programme d'origine en conséquence, nous pouvons vérifier le numéro correct même dans l' interpréteur en ligne .

Pyth, craqué par Erik l'Outgolfer *

J'ai essayé de masquer cela autant que possible.

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

Essayez-le ici!

* Le nombre était 9.

Octave, score: ???

Il est à peu près garanti qu'aucun autre numéro n'aura exactement les mêmes 20 nombres aléatoires à la fin de la liste 1e8de nombres.

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

Sorties 1pour le numéro secret, 0sinon.

J'ai exécuté cela dans Octave 4.2.0.

_{"Les mises en veille et autres ralentissements peuvent être supprimés lors du renforcement brutal."}

Bonne chance avec ça :)

Ly , score 239, fissuré

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

Essayez-le en ligne!

Je parie que personne ne connaît Ly ici, même si je sais à quel point cela pourrait changer facilement ... sueurs

Explication:

(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 ( fissuré )

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Remarque: Cette soumission a été modifiée depuis qu'elle a été soumise. La soumission originale (ci-dessous) était invalide et craquée par Sleafar dans les commentaires ci-dessous. (Une entrée de 1donne lieu à la sortie yes, mais il existe un autre nombre qui donne le même résultat.)

#!/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

Essayez-le en ligne!

Ruby , safe, score:

63105425988599693916

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

Essayez-le en ligne!

Explication:

Le premier conditionnel vérifie le numéro d'entrée pour le narcissisme . Le fil pour lequel j'ai écrit à l'origine a été heurté par hasard à peu près au même moment où j'ai posté cela, mais je suppose que personne ne l'a remarqué. Le second convertit le nombre en base 36, qui utilise des lettres comme chiffres, et vérifie si la chaîne contient "joe" ou "tim". Il peut être prouvé (par épuisement) qu'il n'y a qu'un seul nombre narcissique nommé Joe ou Tim (Joe), car les nombres narcissiques sont finis. Preuve qu'ils sont finis: le résultat de la prise d'un nombre à n chiffres, en élevant chaque chiffre à la nième puissance, et la sommation est délimitée ci-dessus parn*9^n, tandis que la valeur d'un nombre à n chiffres est limitée ci-dessous par n ^ 10. Le rapport entre ces termes est n * (9/10) ^ n, qui diminue finalement de façon monotone lorsque n augmente. Une fois qu'il tombe en dessous de 1, il ne peut y avoir aucun nombre narcissique à n chiffres.

PHP, sûr, 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";

Sorties 1 si correct, 0 sinon.

Edit: Je ne pense pas que quiconque ait même essayé de casser cela parce que:

il serait facile de forcer brutalement.

Explication:

Je prends l'entrée et la convertis en "base 36", mais je n'inverse pas les restes pour produire le nombre final. Le nombre 60256 est "1ahs" en base 36. Inversé, c'est-à-dire "sha1", qui est une fonction en PHP. La dernière vérification est que sha1 (60256) est égal au hachage.

Swift 3 (53 octets) - Cracké

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

Comment faire ça? - f(n:1).

Testez ici.

Python 3, score: ???

Avec un peu de chance, cela démontre à quel point c'est vraiment un problème:

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

Essentiellement, ce que ce code fait est de générer paresseusement toutes les chaînes possibles jusqu'à ce que l'une des chaînes ait un hachage qui correspond exactement hash_codeci-dessus. Le code non haché prend la forme de base de:

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

Sauf <insert number here>est remplacé par un nombre et il y a des commentaires dans le code dans le but de rendre le code presque impossible à deviner.

J'ai pris toutes les précautions pour m'assurer de ne pas bénéficier de ce post. Pour commencer, c'est le wiki de la communauté, donc je ne gagnerai pas de représentant pour cela. De plus, mon score est plutôt élevé, donc j'espère qu'une réponse beaucoup plus créative viendra et gagnera.

J'espère que vous n'êtes pas tous trop furieux de ma réponse, je voulais juste montrer pourquoi les postes de flics et de voleurs interdisent généralement les algorithmes de hachage.

Python 3 , 49 octets, fissuré par sonar235

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

Essayez-le en ligne!

Java, score: 3.141.592 ( Cracked )

\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, score 1 (sûr)

Pas une solution très intéressante, mais mieux un flic sûr qu'un flic mort.

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

Sorties 1pour le nombre cible, 0sinon. L'entrée provient de stdin. La dernière partie ( and int(original.decode())<1000) n'existe que pour assurer une seule réponse, sinon il y aurait évidemment une infinité de réponses.

C (gcc) , score ???

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

Puisque les solutions cryptographiques sont encouragées, ici. Exactement un entier positif imprimera quelque chose , tous les autres n'imprimeront rien. Cela prend beaucoup de temps et ne peut donc pas être testé en ligne.

Java, 164517378918, sûr

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, score: 196164532 non concurrent

Renvoie 1 pour le numéro secret, 0 sinon.

Ans→rand
rand=1

Reportez-vous à la note sur cette page sur la randcommande pour plus d'informations.

Python 3 , score:?

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

Essayez-le en ligne!

Simple, mais peut prendre du temps à la force brute ;-) Dans l'attente d'une fissure rapide ;-)

Note de bas de page: les deux premières et les dernières conditions rendent la réponse unique.

BTW comment le score est-il calculé?

Indice 1

Vous pouvez vous attendre à ce qu'il y ait 2 ⁶⁴ réponses à l'intérieur 0 <= x < [the 25-digit prime], mais en réalité il n'y en a que 4, et la dernière condition élimine les 3 autres. Si vous pouvez résoudre ce problème, vous connaîtrez également les 3 autres solutions.

Aceto , sûr

  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

Génère TrueFalse si correct, FalseFalse sinon

Le nombre était

15752963

Essayez-le en ligne!

C #, Mono, Linux, Alpha, score 1 (sûr)

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

Prudent. Je suis sérieux. Il existe de nombreux simulateurs alpha. Utilisez-en un avec une gigue ou cela ne se terminera pas.

Cela dépend du fait qu'Alpha est big-endian, ce qui fait que System.BitConverter fait la mauvaise chose si quelqu'un essaie cela sur x86 ou x64. J'ai écrit cette réponse pour démontrer la méchanceté du défi plus que toute autre chose.