强盗的线程在这里

在这个警察强盗挑战中，警察会想到一个正整数。然后，他们将编写一个程序或函数，当提供数字作为输入时输出一个值，而对于所有其他正整数输入则输出另一个值。然后，警察会在答案中显示该程序，并将数字保密。强盗可以通过找到数字来破解答案。

要注意的是：这不是 代码高尔夫，而是您的分数将是秘密数字，分数越低越好。显然，在强盗仍在尝试寻找分数时，您无法透露分数。发布一周后仍未破解的答案可能会显示其分数并标记为安全。安全答案无法破解。

可能不言而喻，但您应该能够为答案打分。那就是您应该确切知道决策机器接受什么值。仅仅知道有一个是不够的。

密码功能的使用

与大多数警察和强盗要求您不要使用加密功能的挑战不同，此挑战不仅完全允许他们使用，而且鼓励他们使用。只要您想赢，就可以以任何方式自由创建答案。话虽如此，这里也欢迎使用其他方法的答案。挑战的目标是获胜，只要您不作弊，就不会有什么失败。

Tampio，破获

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ä

运行：

python3 suomi.py file.suomi --io

Github页面中包含安装解释器的说明。请告知您在执行此操作时是否遇到任何困难。

伪代码程序。该程序执行非常缓慢，因为我的解释器效率极低。另外，我没有使用任何可用的加入优化，这可以将评估时间从几分钟减少到大约10秒。

Perl 6的 - 裂纹！

从严格意义上讲，这不是可接受的提交方式，因为它不会非常努力地赢得胜利。相反，它希望提供一个令人愉快的难题。

这是一个“纯数学”程序，旨在通过沉思来破解。我敢肯定，您可以蛮力解决该问题（在清理了我有意提交的草率编程之后），但是对于“满分”（：-）），您应该能够在数学上解释它的作用。

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

您应该破解函数f（）。（该函数采用一个自然数并返回两个结果之一。）警告：如@Nitrodon所示，该程序实际上行为错误，并且“接受” 无限数量的输入。由于我不知道如何解决它，因此我只为将来的求解器指出我所考虑的数字少于70000。。

如果您尝试在TIO中运行它，它将超时。这是故意的。（因为它根本不应该运行！）

最后，我尝试编写一些合理清晰的代码。即使您不熟悉该语言，您也应该能够流利地阅读它。仅作两点说明：方括号[ op ]表示将运算符op缩小（在Haskell lingo中为“折叠”）；子调用postfix:<!>实际上定义了一个后缀运算符！（即使用5!-确实可以达到您的期望）。同样的prefix:<∫>。

我希望有人喜欢这个，但是我不确定我是否遇到了困难。请随时在评论中抨击我：-)。

在线尝试！

JavaScript， 破解

我已经尽可能地混淆了这一点，以至于它不适合这个答案。

在这里尝试！ 单击运行，然后在控制台中键入guess(n)

如果答案错误，则返回undefined，否则返回true。

编辑：不知何故，我忽略了关于我的分数是数字的部分。哦，我的人数非常多。无论如何，祝你好运。

果冻得分：... ¹（破裂）

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

在线尝试！

^{1真的希望我透露它吗？来吧！哦，它的总分是134。我说了！}

Python 2 （破解）

我不建议蛮力。希望你喜欢发电机！

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]

在线尝试！

输出1正确的数字，0否则。

哈斯克尔，破获

这完全基于算术。请注意，这myfun是实际功能，而h仅仅是辅助功能。

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

在线尝试！

Java，由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);
    }
}

我想尝试一些不同于通常的哈希和随机函数的方法。您可以将数字作为命令行参数传递。1如果给出正确的数字，则输出，0否则给出。如果数量较少，您也可以在线尝试。

暗示：

该程序的主要部分实现了一种非常著名的算法的变体。一旦知道了它的作用，就可以优化给定的程序以计算密码。

说明：

该程序实现了众所周知的Koch曲线（来自Wikipedia的图片）的二次方（类型2）的遍历： 秘密数是不经过点（B，C）的第一次迭代。根据Nitrodon的正确认识，除了第一次迭代，我们可以安全地忽略曲线的所有部分的递归，这些递归不会通过给定点。通过相应地更改原始程序中的一行，即使在在线解释器中，我们也可以检查正确的号码。

佩斯（Pyth），被野蛮人埃里克（Erik）破解 *

我试图尽可能地对此进行混淆。

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

在这里尝试！

*数字为9。

八度，得分：???

几乎可以保证，其他任何数字在数字列表的末尾都不会具有完全相同的20个随机1e8数。

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

输出1密码，0否则。

我在Octave 4.2.0中运行了它。

_{暴力破解时，可以消除睡眠和其他速度下降。}

祝你好运:)

赖，得分239，破解

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

在线尝试！

尽管我知道这很容易改变... 汗

说明：

(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（分数1574）（破解）

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

在线尝试！

直流电

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

在线尝试！

注意：此提交自提交以来已被修改。原始提交内容（如下）无效，Sleafar在以下评论中将其破解。（输入1会产生输出yes，但还有一个数字会得出相同的结果。）

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

在线尝试！

红宝石，安全，得分：

63105425988599693916

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

在线尝试！

说明：

第一个条件检查输入数字是否为，而n位数字的值在下面限制为n ^ 10。这些项之间的比率为n *（9/10）^ n，最终随着n的增加而单调减小。一旦降到1以下，就不会有n位自恋数字。自恋。我最初编写的线程在发布此消息的同时碰巧碰到了，但我想没人注意到。第二个将数字转换为以36为底的数字，该数字使用字母作为数字，并检查字符串是否包含“ joe”或“ tim”。可以证明（通过穷举），只有一个自恋数字被命名为Joe或Tim（乔），因为自恋数字是有限的。证明它们是有限的：取一个n位数字，将每个位提高到n的幂，然后求和的结果由n*9^n

PHP，安全，得分：

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

如果正确，则输出1，否则输出0。

编辑：我认为没有人甚至试图破解它，因为：

蛮力很容易。

说明：

我接受输入并将其转换为“ base 36”，但是我不反转余数以产生最终数字。数字60256在基数36中为“ 1ahs”。不可逆，即“ sha1”，这是PHP中的函数。最终检查是sha1（60256）等于哈希。

Swift 3（53字节）- 破解

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

如何运行呢？– f(n:1)。

在这里测试。

Python 3，得分：???

希望这（如果有的话）能够说明这个问题的真实程度：

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

本质上，此代码的作用是延迟生成所有可能的字符串，直到其中一个字符串具有与hash_code上面完全匹配的哈希为止。原始的代码采用以下基本形式：

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

除了<insert number here>用数字代替，并且代码中包含注释以使代码几乎不可猜测。

我已采取一切预防措施，以确保我不会从这篇文章中受益。对于初学者来说，这是社区Wiki，所以我不会因此而获得代表。而且，我的分数相当高，因此希望能有更多创造性的答案并能赢。

希望大家不要对我的回答太生气，我只是想炫耀为什么警察和强盗帖子通常禁止哈希算法。

Python 3，49字节，由sonar235破解

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

在线尝试！

Java，得分：3141592（破解）

\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，得分1（安全）

这不是一个非常有趣的解决方案，但是比死掉的警察更好。

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

输出1目标号码，0否则。输入来自标准输入。最后一部分（and int(original.decode())<1000）仅用于确保一个答案，否则显然会有无限多个答案。

C（gcc），得分???

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

由于鼓励使用密码解决方案，因此在这里。恰好一个正整数将打印某些内容，所有其他正整数将不打印任何内容。这需要很长时间，因此无法在线进行测试。

Java，164517378918，安全

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

Returns 1 for secret number, 0 otherwise.

Ans→rand
rand=1

Refer to the note on this page on the rand command for more info.

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

Try it online!

Simple, but may take some time to brute-force ;-) Looking forward to a fast crack ;-)

Footnote: the first two and the last conditions make the answer unique.

BTW how the score is calculated?

Hint 1

You may expect there will be 2⁶⁴ answers within 0 <= x < [the 25-digit prime], but actually there are only 4, and the last condition eliminates the other 3. If you can crack this, then you will also know the other 3 solutions.

Aceto, safe

  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

Outputs TrueFalse if correct, FalseFalse otherwise

The number was

15752963

Try it online!

C#, Mono, Linux, Alpha, score 1 (safe)

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

Careful. I mean it. There's plenty of alpha simulators out there. Use one with a jitter or this won't finish.

This depends on the fact that Alpha is big-endian, causing System.BitConverter to do the wrong thing if somebody tries this on x86 or x64. I wrote this answer to demonstrate the badness of the challenge more than anything else.