Нить грабителя здесь

В этом задании «полицейские и грабители» полицейские будут думать о целых положительных числах. Затем они напишут программу или функцию, которая выводит одно значение, когда предоставляется число в качестве ввода, и другое значение для всех других положительных целочисленных входов. Копы покажут программу в ответе, сохраняя номер в секрете. Грабители могут взломать ответ, найдя номер.

Вот подвох: это не код-гольф , вместо этого ваш счет будет секретным числом, а более низкий показатель будет лучше. Очевидно, вы не можете раскрыть свой счет, пока грабители все еще пытаются его найти. Ответ, который не был взломан через неделю после публикации, может иметь оценку и быть отмеченным как безопасный. Безопасные ответы не могут быть взломаны.

Это, вероятно, само собой разумеется, но вы должны быть в состоянии оценить свой ответ. То есть вы должны точно знать, какое значение принимает ваша машина принятия решений. Недостаточно просто знать, что он есть.

Использование криптографических функций

В отличие от большинства задач полиции и грабителей, которые просят вас не использовать криптографические функции, эта задача не только полностью разрешает их, но и поощряет их. Вы можете создавать ответы любым способом, пока вы пытаетесь победить. При этом ответы с использованием других методов также приветствуются здесь. Цель этого задания - победить, и пока вы не обманываете, ничего не остается в стороне.

Тампио , Трещины

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 ] означают сокращение («сворачивание», в языке Haskell) списка с оператором op ; и вызываемая подпрограмма postfix:<!>фактически определяет постфиксный оператор с именем! (т.е. используется как 5!- он делает именно то, что вы ожидаете). Аналогично для prefix:<∫>одного.

Я надеюсь, что кому-то понравится этот, но я не уверен, правильно ли я понял проблему. Не стесняйтесь избивать меня в комментариях :—).

Попробуйте онлайн!

JavaScript, Cracked

Я настолько запутал это, насколько смог, до такой степени, что это не вписывается в этот ответ.

Попробуй это здесь! Нажмите Run, затем введите в консолиguess(n)

Возвращает неопределенное значение, если вы получили неправильный ответ, в противном случае возвращает 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

Попробуйте онлайн!

Ява, взломанная нитродоном

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иначе. Для небольших номеров вы также можете попробовать это онлайн .

Подсказка:

Основная часть программы реализует вариант очень известного алгоритма. Как только вы узнаете, что он делает, вы сможете оптимизировать данную программу для вычисления секретного числа.

Объяснение:

Эта программа реализует обход квадратичного варианта (тип 2) хорошо известной кривой Коха (изображение из Википедии): Секретное число - это первая итерация, которая не проходит через точку (B, C). Как правильно распознал Нитродон , за исключением первой итерации, мы можем смело игнорировать рекурсию всех частей кривой, которые не проходят через данную точку. Изменяя строку в исходной программе, мы можем проверить правильный номер даже в онлайн-переводчике .

Пиф, взломанный Эриком Искателем *

Я пытался запутать это как можно больше.

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противном случае.

Я запустил это в октаве 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». Можно доказать (посредством исчерпания), что существует только одно нарциссическое число, названное Джо или Тимом (Джо), потому что нарциссические числа конечны. Доказательство того, что они конечны: результат взятия 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 в противном случае.

Редактировать: я не думаю, что кто-то даже пытался взломать это, потому что:

было бы легко грубой силой.

Объяснение:

Я беру входные данные и преобразовываю их в «базу 36», но я не переворачиваю остатки, чтобы получить окончательное число. Число 60256 - это «1ahs» в базе 36. Необращенный, то есть «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>что заменяется на число, и в коде есть комментарии с целью сделать код почти неузнаваемым.

Я принял все меры предосторожности, чтобы не получить пользу от этого поста. Для начала, это вики сообщества, поэтому я не буду получать за это репутацию. Кроме того, мой счет довольно большой, поэтому, надеюсь, придет гораздо более креативный ответ и победит.

Надеюсь, вы все не слишком взбешены моим ответом, я просто хотел показать, почему посты полицейских и грабителей обычно запрещают алгоритмы хеширования.

Python 3 , 49 байт, взломан sonar235

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

Попробуйте онлайн!

Java, оценка: 3141592 ( 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, оценка 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");
}

Так как криптографические решения приветствуются, здесь. Ровно одно положительное целое будет что-то печатать , все остальные ничего не будут печатать. Это занимает много времени, поэтому его нельзя протестировать в Интернете.

Ява, 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, оценка: 196164532 не конкурирует

Возвращает 1 для секретного номера, 0 в противном случае.

Ans→rand
rand=1

Обратитесь к примечанию на этой странице о randкоманде для получения дополнительной информации.

Python 3 , оценка:?

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

Попробуйте онлайн!

Просто, но может потребоваться некоторое время для грубой силы ;-) С нетерпением ждем быстрого взлома ;-)

Сноска: первые два и последние условия делают ответ уникальным.

Кстати, как рассчитывается счет?

Подсказка 1

Вы можете ожидать, что внутри будет 2 ⁶⁴ ответа 0 <= x < [the 25-digit prime], но на самом деле их только 4, а последнее условие устраняет остальные 3. Если вы можете взломать это, то вы также будете знать другие 3 решения.

Ацето , безопасный

  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

Выводит TrueFalse, если правильно, FalseFalse в противном случае

Номер был

15752963

Попробуйте онлайн!

C #, Mono, Linux, Alpha, оценка 1 (безопасно)

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

Осторожный. Я серьезно. Там много альфа-симуляторов. Используйте один с джиттером или это не закончится.

Это зависит от того факта, что Alpha является байтовым порядком байтов, в результате чего System.BitConverter делает неправильные действия, если кто-то пытается это сделать на x86 или x64. Я написал этот ответ, чтобы продемонстрировать серьезность проблемы больше, чем что-либо еще.