Hilo de ladrón aquí

En este desafío de policías y ladrones , los policías pensarán en un número entero positivo. Luego escribirán un programa o función que genere un valor cuando se les proporcione el número como entrada y otro valor para todas las demás entradas enteras positivas. Los policías revelarán el programa en una respuesta manteniendo el número en secreto. Los ladrones pueden descifrar una respuesta al encontrar el número.

Aquí está el truco: este no es un código de golf , sino que su puntaje será el número secreto con un puntaje más bajo mejor. Obviamente, no puede revelar su puntaje mientras los ladrones todavía están tratando de encontrarlo. Una respuesta que no se haya descifrado una semana después de su publicación puede tener su puntaje revelado y marcado como seguro. Las respuestas seguras no se pueden descifrar.

Probablemente no sea necesario decirlo, pero debería poder calificar su respuesta. Es decir, debe saber exactamente qué valor acepta su máquina de decisión. Simplemente saber que hay uno no es suficiente.

Uso de funciones criptográficas.

A diferencia de la mayoría de los desafíos de policías y ladrones que le piden que no use funciones criptográficas, este desafío no solo los permite por completo, sino que los alienta. Usted es libre de crear respuestas de cualquier manera, siempre que intente ganar. Dicho esto, las respuestas que utilizan otros métodos también son bienvenidas aquí. El objetivo del desafío es ganar, y mientras no hagas trampa, no hay nada fuera de la mesa.

Tampio , agrietado

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ä

Corre con:

python3 suomi.py file.suomi --io

Las instrucciones para instalar el intérprete se incluyen en la página de Github. Indique si tiene alguna dificultad para ejecutar esto.

El programa en pseudocódigo. El programa funciona muy lentamente porque mi intérprete es super ineficiente. Además, no utilicé ninguna optimización opcional disponible, lo que puede reducir el tiempo de evaluación de varios minutos a unos 10 segundos.

Perl 6 - ¡Agrietado!

En un sentido estricto, esta no es una presentación aceptable porque no se esfuerza mucho por ganar. En cambio, espera ofrecer un rompecabezas agradable.

Es un programa de "matemática pura" que está destinado a ser descifrado por la contemplación. Estoy seguro de que podría aplicar la solución a la fuerza bruta (después de limpiar una programación descuidada que he cometido a propósito), pero para "crédito completo" (: -)), debería ser capaz de explicar lo que hace en términos 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 * $_) }
}

Se supone que debes descifrar la función f (). (Esa es la función que toma un número natural y devuelve uno de los dos resultados). Advertencia: como lo muestra @Nitrodon, el programa en realidad se comporta incorrectamente y "acepta" un número infinito de entradas. Como no tengo idea de cómo solucionarlo, solo comento para los solucionadores futuros que el número que tenía en mente es menor que 70000 .

Si intenta ejecutar esto en TIO, que será el tiempo de espera. Esto es intencional (¡Ya que no se supone que se ejecute en absoluto!)

Finalmente, intenté escribir un código razonablemente claro. Deberías poder leerlo con fluidez, incluso si no estás familiarizado con el idioma. Solo dos comentarios: los corchetes [ op ] significan reducir ("plegar", en la jerga de Haskell) una lista con el operador op ; y el sub llamado postfix:<!>realmente define un operador postfix llamado! (es decir, se usa como 5!: hace exactamente lo que cabría esperar). Del mismo modo para el prefix:<∫>uno.

Espero que alguien disfrute de este, pero no estoy seguro de haber entendido bien la dificultad. No dudes en criticarme en los comentarios :—).

Pruébalo en línea!

JavaScript, agrietado

He ofuscado esto tanto como puedo, hasta el punto de que no cabe dentro de esta respuesta.

Pruébalo aquí! Haga clic en Ejecutar, luego escriba la consolaguess(n)

Devuelve indefinido si obtiene la respuesta incorrecta, de lo contrario devuelve verdadero.

Editar: De alguna manera, pasé por alto la parte de que mi puntaje era el número. Oh bueno, mi número es muy muy grande. Buena suerte resolviéndolo de todos modos.

Gelatina , puntaje: ... ¹ ( agrietado )

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

Pruébalo en línea!

^{1 ¿ Realmente esperaba que lo revelara? ¡Venga! Bueno, tiene un puntaje de 134. ¡Ahí lo dije!}

Python 2 (agrietado)

No sugeriría fuerza bruta. Espero que les gusten los generadores!

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]

Pruébalo en línea!

Salidas 1para el número correcto, de lo 0contrario.

Haskell , agrietado

Esto se basa únicamente en la aritmética. Tenga en cuenta que esa myfunes la función real, mientras que hes solo una función 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

Pruébalo en línea!

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

Quería probar algo diferente a las funciones hash y aleatorias habituales. Puede pasar el número como argumento de línea de comando. Salidas 1si se da el número correcto y de lo 0contrario. Para números pequeños, también puede probarlo en línea .

Insinuación:

La parte principal del programa implementa una variante de un algoritmo muy conocido. Una vez que sepa lo que hace, podrá optimizar el programa dado para calcular el número secreto.

Explicación:

Este programa implementa el recorrido de la variante cuadrática (tipo 2) de la conocida curva de Koch (imagen de Wikipedia): el número secreto es la primera iteración que no pasa por el punto (B, C). Como Nitrodon reconoce correctamente , a excepción de la primera iteración, podemos ignorar con seguridad la recurrencia de todas las partes de la curva, que no pasan por el punto dado. Al cambiar una línea en el programa original en consecuencia, podemos verificar el número correcto incluso en el intérprete en línea .

Pyth, agrietado por Erik el Outgolfer *

Traté de ofuscar esto tanto como sea posible.

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

Pruébalo aquí!

* El número era 9.

Octava, puntuación: ???

Está prácticamente garantizado que ningún otro número tendrá exactamente los mismos 20 números aleatorios al final de la lista de 1e8 de 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

Salidas 1 para el número secreto, de lo 0contrario.

Ejecuté esto en Octave 4.2.0.

_{"Los sueños y otras ralentizaciones se pueden eliminar cuando se hace fuerza bruta".}

Buena suerte con eso :)

Ly , puntaje 239, agrietado

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

Pruébalo en línea!

No cuento con que nadie conozca a Ly aquí, aunque sé con qué facilidad eso podría cambiar ... sudores

Explicación:

(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 , puntuación 1574 ( agrietada )

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

Pruébalo en línea!

corriente continua

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

Pruébalo en línea!

Nota: Este envío se ha modificado desde que se envió. La presentación original (a continuación) fue inválida y descifrada por Sleafar en los comentarios a continuación. (Una entrada de 1da lugar a la salida yes, pero hay otro número que da el mismo 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

Pruébalo en línea!

Rubí , seguro, puntaje:

63105425988599693916

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

Pruébalo en línea!

Explicación:

El primer condicional verifica el número de entrada narcisismo . El hilo para el que escribí originalmente coincidió casualmente cuando publiqué esto, pero supongo que nadie se dio cuenta. El segundo convierte el número a la base 36, que usa letras como dígitos, y verifica si la cadena contiene "joe" o "tim". Se puede demostrar (por agotamiento) que solo hay un número narcisista llamado Joe o Tim (Joe), porque los números narcisistas son finitos. Prueba de que son finitos: el resultado de tomar un número de n dígitos, elevar cada dígito a la enésima potencia y la suma se limita arriba porn*9^n, mientras que el valor de un número de n dígitos está limitado a continuación por n ^ 10. La relación entre estos términos es n * (9/10) ^ n, que eventualmente disminuye monotónicamente a medida que n aumenta. Una vez que cae por debajo de 1, no puede haber números narcisistas de n dígitos.

PHP, seguro, puntuación:

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

Salidas 1 si es correcto, 0 de lo contrario.

Editar: No creo que nadie haya intentado descifrar esto porque:

Sería fácil forzar la fuerza bruta.

Explicación:

Tomo la entrada y la convierto en "base 36", pero no invierto el resto para producir el número final. El número 60256 es "1ahs" en la base 36. Sin invertir, es decir "sha1", que es una función en PHP. La comprobación final es que sha1 (60256) es igual al hash.

Swift 3 (53 bytes) - Agrietado

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

¿Cómo ejecutar esto? - f(n:1).

Prueba aquí.

Python 3, puntuación: ???

Esperemos que esto, si acaso, demuestre cuán roto es un problema que realmente es:

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

Esencialmente, lo que hace este código es generar perezosamente todas las cadenas posibles hasta que una de las cadenas tenga un hash que coincida exactamente hash_code anterior. El código sin mostrar toma la forma básica de:

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

Excepto <insert number here>se reemplaza con un número y hay comentarios en el código con el propósito de hacer que el código sea casi indiscutible.

He tomado todas las precauciones para asegurarme de no beneficiarme de esta publicación. Para empezar, es wiki comunitario, por lo que no obtendré reputación por ello. Además, mi puntaje es bastante grande, así que espero que aparezca una respuesta mucho más creativa y gane.

Espero que no estén demasiado furiosos con mi respuesta, solo quería mostrar por qué las publicaciones de policías y ladrones generalmente prohíben los algoritmos de hash.

Python 3 , 49 bytes, descifrado por sonar235

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

Pruébalo en línea!

Java, puntuación: 3141592 ( Agrietado )

\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, puntaje 1 (seguro)

No es una solución muy interesante, pero es mejor un policía seguro que un policía muerto.

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

Salidas 1para el número objetivo, de lo 0contrario. La entrada se toma de stdin. La última parte ( and int(original.decode())<1000) existe solo para garantizar una sola respuesta, de lo contrario obviamente habría infinitas respuestas.

C (gcc) , puntuación ???

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

Dado que se recomiendan soluciones criptográficas, aquí. Exactamente un número entero positivo imprimirá algo , todos los demás no imprimirán nada. Esto lleva mucho tiempo, por lo que no se puede probar en línea.

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, puntaje: 196164532 no competidor

Devuelve 1 para el número secreto, 0 de lo contrario.

Ans→rand
rand=1

Consulte la nota en esta página sobre el randcomando para obtener más información.

Python 3 , puntuación :?

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

Pruébalo en línea!

Simple, pero puede tomar algo de tiempo para la fuerza bruta ;-) Esperando un crack rápido ;-)

Nota al pie: las dos primeras y las últimas condiciones hacen que la respuesta sea única.

Por cierto, ¿cómo se calcula la puntuación?

Pista 1

Puede esperar que haya 2 ⁶⁴ respuestas dentro 0 <= x < [the 25-digit prime], pero en realidad solo hay 4, y la última condición elimina las otras 3. Si puede resolver esto, también sabrá las otras 3 soluciones.

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 si es correcto, FalseFalse de lo contrario

El numero era

15752963

Pruébalo en línea!

C #, Mono, Linux, Alpha, puntaje 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);
}
}

Cuidadoso. Lo digo en serio. Hay muchos simuladores alfa por ahí. Use uno con nerviosismo o esto no terminará.

Esto depende del hecho de que Alpha es big-endian, lo que hace que System.BitConverter haga lo incorrecto si alguien intenta esto en x86 o x64. Escribí esta respuesta para demostrar la maldad del desafío más que cualquier otra cosa.