Discussione di ladro qui

In questa sfida di poliziotti e ladri la polizia penserà a un numero intero positivo. Scriveranno quindi un programma o una funzione che emette un valore quando viene fornito il numero come input e un altro valore per tutti gli altri input interi positivi. La polizia rivelerà quindi il programma in una risposta mantenendo il numero segreto. I ladri possono trovare una risposta trovando il numero.

Ecco il trucco: non si tratta di code-golf , ma il tuo punteggio sarà il numero segreto con un punteggio inferiore migliore. Ovviamente non puoi rivelare il tuo punteggio mentre i ladri stanno ancora cercando di trovarlo. Una risposta che non è stata decifrata una settimana dopo la sua pubblicazione potrebbe essere rivelata e segnata come sicura. Le risposte sicure non possono essere decifrate.

Probabilmente è ovvio, ma dovresti essere in grado di segnare la tua risposta. Cioè dovresti sapere esattamente quale valore è accettato dalla tua macchina decisionale. Sapere semplicemente che ce n'è uno non è abbastanza.

Uso delle funzioni crittografiche

A differenza della maggior parte delle sfide di poliziotti e ladri che ti chiedono di non usare le funzioni crittografiche, questa sfida non solo le consente interamente, ma le incoraggia. Sei libero di creare risposte in qualsiasi modo purché tu stia cercando di vincere. Detto questo, anche le risposte che utilizzano altri metodi sono benvenute qui. L'obiettivo della sfida è vincere e fintanto che non imbrogliare nulla è fuori dal tavolo.

Tampio , incrinato

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ä

Corri con:

python3 suomi.py file.suomi --io

Le istruzioni per l'installazione dell'interprete sono incluse nella pagina Github. Si prega di dire se hai difficoltà a farlo.

Il programma in pseudocodice. Il programma funziona molto lentamente perché il mio interprete è super inefficiente. Inoltre, non ho utilizzato alcuna ottimizzazione opt-in disponibile, che può ridurre il tempo di valutazione da diversi minuti a circa 10 secondi.

Perl 6 - Cracked!

In senso stretto, questa non è una proposta accettabile perché non è molto difficile vincere. Invece, spera di offrire un piacevole puzzle.

È un programma di "pura matematica" che vuole essere spezzato dalla contemplazione. Sono sicuro che potresti potenziare la soluzione (dopo aver ripulito qualche programmazione sciatta che ho intenzionalmente impegnato), ma per "credito completo" (: -)), dovresti essere in grado di spiegare cosa fa per motivi matematici .

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

Dovresti rompere la funzione f (). (Questa è la funzione che accetta un numero naturale e restituisce uno dei due risultati.) Avvertenza: come mostrato da @Nitrodon, il programma si comporta in modo errato e "accetta" un numero infinito di input. Poiché non ho idea di come risolverlo, osservo solo per i futuri risolutori che il numero che avevo in mente è inferiore a 70000 .

Se si tenta di eseguirlo in TIO, si verificherà il timeout. Questo è intenzionale. (Dal momento che non dovrebbe essere eseguito affatto!)

Alla fine, ho provato a scrivere un codice abbastanza chiaro. Dovresti essere in grado di leggerlo fluentemente anche se non hai familiarità con la lingua. Solo due osservazioni: le parentesi quadre [ op ] significano ridurre ("pieghevole", nel lingo di Haskell) un elenco con l'operatore op ; e il sub chiamato in postfix:<!>realtà definisce un operatore postfix chiamato! (cioè usato come 5!- fa esattamente quello che ti aspetteresti). Allo stesso modo per prefix:<∫>quello.

Spero che a qualcuno piaccia questo, ma non sono sicuro di avere la difficoltà giusta. Sentiti libero di colpirmi nei commenti :—).

Provalo online!

JavaScript, incrinato

L'ho offuscato il più possibile, al punto che non può rientrare in questa risposta.

Provalo qui! Fai clic su Esegui, quindi digita consoleguess(n)

Restituisce indefinito se si ottiene la risposta sbagliata, altrimenti restituisce vero.

Modifica: in qualche modo ho trascurato la parte sul mio punteggio è il numero. Oh bene, il mio numero è molto grande. Buona fortuna risolverlo comunque.

Jelly , punteggio: ... ¹ ( incrinato )

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

Provalo online!

^{1 Davvero mi aspettavo che lo rivelassi? Dai! Vabbè, ha un punteggio di 134. Ecco, l'ho detto!}

Python 2 (rotto)

Non consiglierei la forza bruta. Spero vi piacciano i generatori!

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]

Provalo online!

Uscite 1per il numero corretto, 0altrimenti.

Haskell , incrinato

Questo è puramente basato sull'aritmetica. Si noti che myfunè la funzione effettiva, mentre hè solo una funzione di supporto.

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

Provalo online!

Java, incrinato da 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);
    }
}

Volevo provare qualcosa di diverso dal solito hash e funzioni casuali. È possibile passare il numero come argomento della riga di comando. Emette 1se viene fornito il numero corretto e in caso 0contrario. Per piccoli numeri puoi anche provarlo online .

Suggerimento:

La parte principale del programma implementa una variante di un algoritmo molto noto. Una volta che sai cosa fa, sarai in grado di ottimizzare il programma dato per calcolare il numero segreto.

Spiegazione:

Questo programma implementa l'attraversamento della variante quadratica (tipo 2) della ben nota curva di Koch (immagine da Wikipedia): il numero segreto è la prima iterazione che non passa attraverso il punto (B, C). Come riconosciuto correttamente da Nitrodon , ad eccezione della prima iterazione, possiamo tranquillamente ignorare la ricorsione di tutte le parti della curva, che non attraversano il punto dato. Modificando di conseguenza una riga nel programma originale, possiamo verificare il numero corretto anche nell'interprete online .

Pyth, Cracked di Erik the Outgolfer *

Ho cercato di offuscarlo il più possibile.

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

Provalo qui!

* Il numero era 9.

Ottava, punteggio: ???

È praticamente garantito che nessun altro numero avrà esattamente gli stessi 20 numeri casuali alla fine dell'elenco 1e8dei numeri.

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

Uscite 1per il numero segreto, 0altrimenti.

Ho eseguito questo in Octave 4.2.0.

_{"I sleep e altri rallentamenti possono essere rimossi quando il bruteforcing."}

Buona fortuna :)

Ly , punteggio 239, crackato

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

Provalo online!

Non sto scommettendo su nessuno che conosca Ly qui, anche se so quanto facilmente possa cambiare ... sudorazione

Spiegazione:

(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 , punteggio 1574 ( cracking )

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

Provalo 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

Provalo online!

Nota: questo invio è stato modificato da quando è stato inviato. L'invio originale (sotto) non era valido e decifrato da Sleafar nei commenti qui sotto. (Un input di 1dà origine all'output yes, ma c'è un altro numero che dà lo stesso risultato.)

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

Provalo online!

Rubino , sicuro, segna:

63105425988599693916

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

Provalo online!

Spiegazione:

Il primo condizionale controlla il numero di input per narcisismo . Il thread per cui avevo originariamente scritto è stato casualmente inciso nello stesso momento in cui l'ho pubblicato, ma immagino che nessuno se ne sia accorto. Il secondo converte il numero in base 36, che utilizza le lettere come cifre e verifica se la stringa contiene "joe" o "tim". Si può provare (attraverso l'esaurimento) che esiste un solo numero narcisistico chiamato Joe o Tim (Joe), perché i numeri narcisistici sono limitati. Prova che sono finiti: il risultato di prendere un numero di n cifre, elevare ogni cifra all'ennesima potenza e la somma è delimitata sopra dan*9^n, mentre il valore di un numero di n cifre è limitato da n ^ 10. Il rapporto tra questi termini è n * (9/10) ^ n, che alla fine diminuisce monotonicamente all'aumentare di n. Una volta che scende al di sotto di 1, non ci possono essere numeri narcisistici a n cifre.

PHP, sicuro, punteggio:

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

Emette 1 se corretto, 0 altrimenti.

Modifica: non penso che nessuno abbia nemmeno provato a risolvere il problema perché:

sarebbe facile fare la forza bruta.

Spiegazione:

Prendo l'input e lo converto in "base 36", ma non inverto i resti per produrre il numero finale. Il numero 60256 è "1ahs" nella base 36. Unreversed, ovvero "sha1", che è una funzione in PHP. Il controllo finale è che sha1 (60256) è uguale all'hash.

Swift 3 (53 byte) - Incrinato

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

Come eseguirlo? - f(n:1).

Prova qui.

Python 3, punteggio: ???

Spero che questo, semmai, dimostri quanto sia davvero rotto un problema:

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

In sostanza, ciò che fa questo codice è pigramente generare ogni stringa possibile fino a quando una delle stringhe ha un hash che corrisponde esattamente hash_codesopra. Il codice non cancellato assume la forma base di:

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

Tranne che <insert number here>viene sostituito con un numero e ci sono commenti nel codice allo scopo di rendere il codice quasi indecifrabile.

Ho preso tutte le precauzioni per assicurarmi di non beneficiare di questo post. Per i principianti, è wiki della comunità, quindi non otterrò rep per questo. Inoltre, il mio punteggio è piuttosto grande, quindi spero che arrivi una risposta molto più creativa e vinca.

Spero che non siate tutti troppo furiosi per la mia risposta, volevo solo mostrare perché i post di poliziotti e ladri di solito vietano gli algoritmi di hashing.

Python 3 , 49 byte, Cracked by sonar235

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

Provalo online!

Java, punteggio: 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, punteggio 1 (sicuro)

Non è una soluzione molto interessante, ma meglio un poliziotto sicuro di un poliziotto 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))

Output 1per il numero di destinazione, 0altrimenti. L'input è preso dallo stdin. L'ultima parte ( and int(original.decode())<1000) esiste solo per garantire una sola risposta, altrimenti ci sarebbero ovviamente infinite risposte.

C (gcc) , punteggio ???

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

Poiché le soluzioni crittografiche sono incoraggiate, qui. Esattamente un numero intero positivo stamperà qualcosa , tutti gli altri non stamperanno nulla. Questo richiede molto tempo, quindi non può essere testato online.

Java, 164517378918, sicuro

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, punteggio: 196164532 non competitivo

Restituisce 1 per il numero segreto, 0 altrimenti.

Ans→rand
rand=1

Fare riferimento alla nota in questa pagina sul randcomando per ulteriori informazioni.

Python 3 , punteggio :?

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

Provalo online!

Semplice, ma potrebbe richiedere del tempo per la forza bruta ;-) In attesa di una crepa veloce ;-)

Nota in calce: le prime due e le ultime condizioni rendono la risposta unica.

A proposito, come viene calcolato il punteggio?

Suggerimento 1

Potresti aspettarti che ci siano 2 ⁶⁴ risposte all'interno 0 <= x < [the 25-digit prime], ma in realtà ce ne sono solo 4 e l'ultima condizione elimina le altre 3. Se riesci a risolvere il problema, allora saprai anche le altre 3 soluzioni.

Aceto , sicuro

  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

Emette TrueFalse se corretto, FalseFalse altrimenti

Il numero era

15752963

Provalo online!

C #, Mono, Linux, Alpha, punteggio 1 (sicuro)

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

Attento. Voglio dire che. Ci sono molti simulatori alfa là fuori. Usane uno con un jitter o questo non finirà.

Questo dipende dal fatto che Alpha è big-endian, facendo sì che System.BitConverter faccia la cosa sbagliata se qualcuno lo prova su x86 o x64. Ho scritto questa risposta per dimostrare la cattiveria della sfida più di ogni altra cosa.