Linha do ladrão aqui

Nesse desafio de policiais e ladrões , os policiais pensarão em um número inteiro positivo. Eles escreverão um programa ou função que gera um valor quando fornecido o número como entrada e outro valor para todas as outras entradas inteiras positivas. Os policiais então revelam o programa em uma resposta, mantendo o número em segredo. Ladrões podem quebrar uma resposta encontrando o número.

Aqui está o problema: este não é um código de golfe ; sua pontuação será o número secreto, com uma pontuação menor sendo melhor. Obviamente, você não pode revelar sua pontuação enquanto os ladrões ainda estão tentando encontrá-la. Uma resposta que não foi quebrada uma semana após a postagem pode ter sua pontuação revelada e ser marcada como segura. Respostas seguras não podem ser quebradas.

Provavelmente, é desnecessário dizer, mas você deve conseguir sua resposta. Ou seja, você deve saber exatamente qual valor é aceito pela sua máquina de decisão. Simplesmente saber que existe um não é suficiente.

Uso de funções criptográficas

Ao contrário da maioria dos desafios de policiais e ladrões que pedem para você não usar funções criptográficas, esse desafio não apenas permite que eles sejam totalmente incentivados, mas também os incentiva. Você é livre para criar respostas de qualquer forma, enquanto estiver tentando vencer. Dito isto, respostas usando outros métodos também são bem-vindas aqui. O objetivo do desafio é vencer e, desde que você não trapaceie, nada estará fora da mesa.

Tampio , Rachado

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ä

Correr com:

python3 suomi.py file.suomi --io

As instruções para instalar o intérprete estão incluídas na página do Github. Por favor, diga se você tem alguma dificuldade em executar isso.

O programa em pseudocódigo. O programa executa muito lentamente porque meu intérprete é super ineficiente. Além disso, não usei nenhuma otimização de ativação disponível, o que pode reduzir o tempo de avaliação de vários minutos para cerca de 10 segundos.

Perl 6 - Rachado!

Em sentido estrito, este não é um envio aceitável, porque não se esforça muito para vencer. Em vez disso, espera oferecer um quebra-cabeça agradável.

É um programa de "matemática pura" que se destina a ser quebrado pela contemplação. Tenho certeza de que você pode usar a solução com força bruta (depois de limpar uma programação desleixada que comprometi propositalmente), mas, para obter "crédito total" (: -)), você deve ser capaz de explicar o que ela faz em termos matemáticos .

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

Você deveria quebrar a função f (). (Essa é a função que pega um número natural e retorna um dos dois resultados.) Aviso: Como mostra o @Nitrodon, o programa realmente se comporta incorretamente e "aceita" um número infinito de entradas. Como não tenho idéia de como corrigi-lo, apenas observo para os futuros solucionadores que o número que eu tinha em mente é menor que 70000 .

Se você tentar executar isso no TIO, o tempo limite será excedido . Isso é intencional. (Como não deveria ser executado!)

Por fim, tentei escrever um código razoavelmente claro. Você deve conseguir lê-lo com fluência, mesmo que não esteja familiarizado com o idioma. Apenas duas observações: os colchetes [ op ] significam reduzir ("dobrar", na linguagem Haskell) uma lista com o operador op ; e o sub chamado postfix:<!>realmente define um operador postfix chamado! (ou seja, usado como 5!- ele faz exatamente o que você esperaria). Da mesma forma para o prefix:<∫>primeiro.

Espero que alguém goste deste, mas não tenho certeza se entendi bem a dificuldade. Sinta-se à vontade para me criticar nos comentários :—).

Experimente online!

JavaScript, Rachado

Eu ofusquei isso o máximo que posso, a ponto de não caber nessa resposta.

Experimente aqui! Clique em Executar e digite no consoleguess(n)

Retorna indefinido se você receber a resposta errada; retorna true caso contrário.

Edit: De alguma forma eu ignorei a parte sobre a minha pontuação ser o número. Oh, bem, meu número é muito, muito grande. Boa sorte resolvendo assim mesmo.

Geléia , pontuação: ... ¹ ( rachado )

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

Experimente online!

^{1 Realmente esperava que eu revelasse? Vamos! Oh, bem, tem 134 pontos. Lá, eu disse!}

Python 2 (rachado)

Eu não sugeriria força bruta. Espero que você goste de geradores!

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]

Experimente online!

Saídas 1para o número correto, 0caso contrário.

Haskell , cracked

Isso é puramente baseado em aritmética. Observe que essa myfuné a função real, enquanto hé apenas uma função auxiliar.

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

Experimente online!

Java, rachado por 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);
    }
}

Eu queria tentar algo diferente do que o habitual hash e funções aleatórias. Você pode passar o número como um argumento de linha de comando. Saída 1se o número correto for fornecido e 0caso contrário. Para números pequenos, você também pode experimentá-lo online .

Dica:

A parte principal do programa implementa uma variante de um algoritmo muito conhecido. Depois de saber o que faz, você poderá otimizar o programa fornecido para calcular o número secreto.

Explicação:

Este programa implementa a travessia da variante quadrática (tipo 2) da conhecida curva de Koch (imagem da Wikipedia): O número secreto é a primeira iteração que não passa pelo ponto (B, C). Como corretamente reconhecido pelo Nitrodon , exceto na primeira iteração, podemos ignorar com segurança a recursão de todas as partes da curva, que não passam pelo ponto especificado. Alterando uma linha no programa original de acordo, podemos verificar o número correto, mesmo no intérprete online .

Pitão, rachado por Erik, o Outgolfer *

Eu tentei ofuscar isso o máximo possível.

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

Experimente aqui!

* O número era 9.

Oitava, pontuação: ???

É praticamente garantido que nenhum outro número terá exatamente os mesmos 20 números aleatórios no final da lista 1e8de números.

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

Saídas 1para o número secreto, 0caso contrário.

Eu executei isso no Octave 4.2.0.

_{"Dorme e outras lentidões podem ser removidas quando forçadas a brutalidade."}

Boa sorte com isso :)

Ly , pontuação 239, rachada

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

Experimente online!

Estou apostando em ninguém que conhece Ly aqui, embora eu saiba com que facilidade isso pode mudar ... suores

Explicação:

(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 , pontuação 1574 ( rachada )

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

Experimente 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

Experimente online!

Nota: Este envio foi modificado desde que foi enviado. O envio original (abaixo) foi inválido e decifrado por Sleafar nos comentários abaixo. (Uma entrada de 1dá origem à saída yes, mas há outro número que dá o mesmo resultado.)

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

Experimente online!

Ruby , seguro, pontuação:

63105425988599693916

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

Experimente online!

Explicação:

A primeira condicional verifica o número de entrada para narcisismo . O tópico para o qual escrevi foi coincidentemente publicado na mesma época em que publiquei isso, mas acho que ninguém percebeu. O segundo converte o número na base 36, que usa letras como dígitos, e verifica se a sequência contém "joe" ou "tim". Pode-se provar (por exaustão) que existe apenas um número narcísico chamado Joe ou Tim (Joe), porque os números narcísicos são finitos. Prova de que são finitos: o resultado de pegar um número de n dígitos, elevar cada dígito à enésima potência e somar é limitado acima porn*9^n, enquanto o valor de um número de n dígitos é limitado abaixo por n ^ 10. A razão entre esses termos é n * (9/10) ^ n, que eventualmente diminui monotonicamente à medida que n aumenta. Quando ele cai abaixo de 1, não pode haver números narcisistas de n dígitos.

PHP, seguro, pontuação:

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

Saídas 1, se correto, 0 caso contrário.

Edit: Eu não acho que alguém sequer tentou quebrar isso porque:

seria fácil a força bruta.

Explicação:

Pego a entrada e a converto em "base 36", mas não inverto os restantes para produzir o número final. O número 60256 é "1ahs" na base 36. Sem reversão, que é "sha1", que é uma função do PHP. A verificação final é que sha1 (60256) é igual ao hash.

Swift 3 (53 bytes) - Rachado

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

Como executar isso? - f(n:1).

Teste aqui.

Python 3, pontuação: ???

Esperemos que isso, se alguma coisa, demonstre como esse problema é realmente quebrado:

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

Essencialmente, o que esse código faz é gerar preguiçosamente todas as strings possíveis até que uma das strings tenha um hash que corresponda exatamente hash_codeacima. O código unhashed assume a forma básica de:

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

Exceto <insert number here>é substituído por um número e há comentários no código com o objetivo de tornar o código quase impossível de adivinhar.

Tomei todas as precauções para garantir que eu não me beneficie com este post. Para iniciantes, é um wiki da comunidade, portanto não receberei representantes por isso. Além disso, minha pontuação é bastante grande, por isso espero que uma resposta muito mais criativa apareça e vença.

Espero que vocês não fiquem muito furiosos com a minha resposta, eu só queria mostrar por que os postos de policiais e ladrões geralmente banem algoritmos de hash.

Python 3 , 49 bytes, rachado por sonar235

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

Experimente online!

Java, pontuação: 3141592 ( Rachado )

\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, pontuação 1 (seguro)

Não é uma solução muito interessante, mas é melhor um policial seguro do que um policial morto.

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

Saídas 1para o número de destino, 0caso contrário. A entrada é retirada do stdin. A última parte ( and int(original.decode())<1000) existe apenas para garantir apenas uma resposta, caso contrário, obviamente haveria infinitas respostas.

C (gcc) , pontuação ???

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

Como as soluções criptográficas são incentivadas, aqui. Exatamente um número inteiro positivo imprimirá algo , todos os outros não imprimirão nada. Isso leva muito tempo, portanto não pode ser testado online.

Java, 164517378918, seguro

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, pontuação: 196164532 não concorrente

Retorna 1 para o número secreto, 0 caso contrário.

Ans→rand
rand=1

Consulte a nota nesta página no randcomando para obter mais informações.

Python 3 , pontuação :?

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

Experimente online!

Simples, mas pode levar algum tempo para força bruta ;-) Ansioso para um rápido crack ;-)

Nota de rodapé: as duas primeiras e as últimas condições tornam a resposta única.

BTW como a pontuação é calculada?

Dica 1

Você pode esperar que haja 2 ⁶⁴ respostas dentro 0 <= x < [the 25-digit prime], mas na verdade existem apenas 4, e a última condição elimina as outras 3. Se você conseguir resolver isso, também conhecerá as outras 3 soluções.

Aceto , seguro

  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

Emite TrueFalse, se correto, FalseFalse, caso contrário

O número era

15752963

Experimente online!

C #, Mono, Linux, Alpha, pontuação 1 (seguro)

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

Cuidado. Quero dizer. Existem muitos simuladores alfa por aí. Use um com instabilidade ou isso não terminará.

Isso depende do fato de o Alpha ser big-endian, fazendo com que o System.BitConverter faça a coisa errada se alguém tentar fazer isso em x86 ou x64. Escrevi esta resposta para demonstrar a maldade do desafio mais do que qualquer outra coisa.