Estoy pensando en un número (Hilo de policía)

32

Hilo de ladrón aquí

En este desafío de policías , 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 , 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.

Asistente de trigo
fuente
1
Si permite funciones criptográficas, recomendaría poner un límite de tiempo a los programas.
Okx
12
Desestimé este desafío porque, en la mayoría de los idiomas, se puede descifrar simplemente usando un algoritmo de mapeo o un bucle simple. Considero que es un poco demasiado fácil para un desafío de policías y ladrones .
Sr. Xcoder
2
Siento que habrá muchos policías que conocen un valor aceptado (probablemente el más pequeño) pero no saben si hay más respuestas correctas o cuáles son.
histocrat
12
@ Mr.Xcoder Usted es libre de votar sin embargo, señalaré que ese es el punto del desafío y no, en mi opinión, un defecto. El desafío es principalmente divertido para los policías que tienen que dificultar la fuerza bruta lo más posible al ralentizar el cálculo. Las respuestas más creativas deberían hacer que la fuerza bruta sea cada vez más difícil, permitiéndoles usar números cada vez más pequeños.
Wheat Wizard
1
@WheatWizard supongo que no sería ganar, pero no sería posible a agrietarse por ejemplo, un programa que simplemente compara la entrada de A(9,9)donde Aes la función de Ackerman.
flawr

Respuestas:

10

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.

fergusq
fuente
1
¿No hay un intérprete en línea para Tampio?
Shaggy
@ Shaggy Todavía no, por desgracia. Probablemente debería preguntar si podría agregarse a TIO.
fergusq
Cracked
Wheat Wizard
5

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!

Ramillies
fuente
Agrietado
Nitrodon
4

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.

Eli Richardson
fuente
Agrietado
Gustavo Rodrigues
3

Gelatina , puntaje: ... 1 ( 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!

Erik el Outgolfer
fuente
Agrietado
Sr. Xcoder
@ Mr.Xcoder Vivió mucho ...
Erik the Outgolfer
Acabo de agregar ǀGy el rango 1...1000como entrada: P
Sr. Xcoder
Viste la 5ȷ2_parte ¿verdad?
Erik the Outgolfer
No, ni siquiera miré el código jajaja. Acabo de agregar el conjunto de pruebas y vi dónde 1está, luego pegué la cadena desde el principio hasta que estaba 1en un script de Python y conté el número de ceros antes ...
Sr. Xcoder
3

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.

Sísifo
fuente
Cracked
Leaky Nun
@LeakyNun Wow, un poco más rápido de lo que esperaba.
Sísifo
Encontrar un solucionador de sudoku en línea no es difícil.
Leaky Nun
Hay algún problema con su verificador de sudoku: verificó bien las líneas horizontales y las verticales, pero solo verificó las primeras tres celdas.
Leaky Nun
@LeakyNun Tienes razón, y adebería serlo i+a. Lo arreglé, pero de todos modos está agrietado encogiéndose de hombros
Sisyphus
3

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!

falla
fuente
El programa debe finalizar sin error en todas las entradas. ¿Esto incluso termina dentro de un día en memoria ilimitada?
michi7x7
Necesitas bastante memoria pero ciertamente no necesitas memoria ilimitada. Probablemente depende de la implementación y de su hardware. Pero obviamente está diseñado para tomarse un tiempo para computar para dificultar los ataques de fuerza bruta y alentar el análisis del programa. Buena suerte :)
flawr
¿Agrietado?
Christian Sievers
2

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 .

Quadratic_Koch_curve_type2_iterations.png

Sleafar
fuente
Agrietado , creo; el tiempo de ejecución es demasiado largo para verificar directamente, pero lo comprobé con valores más fáciles y mi crack parece funcionar.
Nitrodon
1

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

Stewie Griffin
fuente
ni siquiera parece correr en tio
Okx
1
@Okx Se agota el tiempo de espera en TIO, pero se ejecuta en la versión de escritorio.
Rɪᴋᴇʀ
1
¿Por qué el voto negativo?
Wheat Wizard
3
@WheatWizard probablemente porque es teóricamente posible que tenga varios números. Además, es un poco aburrido tbh. Me hubiera gustado ver más soluciones matemáticas, RNG es un poco aburrido.
Rɪᴋᴇʀ
1
@Riker Pero como estás adivinando una semilla para el RNG, está usando el RNG en sí mismo como su función, que en realidad es determinista. Pero sí, teniendo en cuenta que se basa en la dificultad de invertir lo que esperas que sea una función unidireccional, también se podría cifrar una cadena "verdadera" con un número aleatorio y luego el desafío casi equivale a romper el esquema de cifrado elegido. para descubrir la clave privada.
Shufflepants
1

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
LyricLy
fuente
Agrietado
Christian Sievers
1

Brain-Flak , puntuación 1574 ( agrietada )

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

Pruébalo en línea!

Nitrodon
fuente
Cracked
Wheat Wizard
1

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!

John Gowers
fuente
El intérprete en línea devuelve "sí" para la entrada "1". ¿Cuenta esto como agrietado ahora?
Sleafar
@Sleafar Sigh ... sí, fue un estúpido error de mi parte.
John Gowers
Sin embargo, eso significa que este desafío ahora no es válido, ya que hay dos entradas que hacen que se imprima sí, por lo que no estoy seguro de si puede reclamarlo. Agregaré una versión corregida a esta publicación, pero deje el original en caso de que lo esté.
John Gowers
1

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.

histocrat
fuente
1

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.

jstnthms
fuente
0

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í.

Sr. Xcoder
fuente
Agrietado
Sr. Xcoder
@ Mr.Xcoder Heh bien hecho, supongo que fue demasiado fácil
0

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.

sonar235
fuente
La entrada se toma de stdin. La salida es un 1 (para un número adivinado correctamente) o un 0 (para un número adivinado incorrectamente).
sonar235
No sé por qué has hecho de esto un wiki comunitario. Esta es su respuesta que parece que tomó mucho trabajo hacer. Ciertamente tampoco llamaría a esta respuesta evidencia de que la pregunta se ha roto tampoco. Esta es una respuesta inteligente, que probablemente podría puntuar bien, (ni siquiera puedo probar que esto no funcione para 1). El punto de una pregunta siempre es atraer respuestas que aborden la pregunta de manera inteligente e interesante (y también divertirse, pero no puedo responder por su entretenimiento), y en lo que a mí respecta, esto lo hace.
Wheat Wizard
3
De hecho, esta respuesta no es válida. Es casi seguro que (con probabilidad astronómica de que ninguna cadena de longitud 512 bits coincida con el hash) exec () sea algo que probablemente ni siquiera sea un código válido de Python antes de llegar al código deseado.
Joshua
1
@ sonar235: su plantilla de fragmentos tiene más de 512 bits.
Joshua
1
Para ampliar la respuesta de Joshua: su código tiene 102 caracteres de longitud. En particular, su programa iterará sobre cada cadena de 100 caracteres antes de llegar a su código. Como su código itera sobre caracteres en el rango 0x00-0xFF, es decir 256 ^ 100o 2 ^ 800cadenas. Mientras tanto, solo hay 2 ^ 512posibles hashes de 512 bits. Eso significa que las cadenas que iteras superan en número a los posibles hashes al menos 2 ^ 288a uno, un número 10,000 veces mayor que el número de átomos en el universo. La probabilidad de que ese hash en particular no se use es increíblemente pequeña .
John Gowers
0

Python 3 , 49 bytes, descifrado por sonar235

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

Pruébalo en línea!

ED
fuente
Zero no es un número entero positivo para tu información. No sé si esa fue la solución prevista, pero funciona.
Wheat Wizard
0 no es la solución prevista.
ED
8
Uhh, tu página TIO muestra la solución ...
LyricLy
2
También "escriba un programa o función que genere un valor cuando se le proporcione el número como entrada y otro valor para todas las demás entradas enteras positivas "
Jonathan Allan
2
Agrietado por @ Sonar235 .
Dom Hastings
0

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
usuario902383
fuente
1
No creo que la ofuscación vaya a hacer nada excepto agregar un primer paso molesto.
Engineer Toast
1
Agrietado
pppery
2
@EngineerToast no, no realmente, fue solo para asustar a la gente perezosa.
user902383
0

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.

L3viatán
fuente
1
¿Puedes agregar un enlace TIO, por favor?
Shaggy
1
Para futuros ladrones: el número entero no parece estar en menor que 100000000.
Sr. Xcoder
1
@Shaggy Se agotó el tiempo de espera en TIO, tardé aproximadamente media hora en mi computadora para ejecutar los mil millones de iteraciones de SHA256.
L3viathan
2
¿Algún ladrón quiere formar un equipo para resolver este? Solo necesitamos dividir los números de menos de 1000 entre nosotros para tener tiempo de calcular los resúmenes iterados de SHA antes de la fecha límite.
John Gowers
2
A menos que pueda probar que 1 es la única solución, esta respuesta no es válida. La carga de la prueba debe recaer en la persona que dice tener una respuesta válida.
Dennis
0

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.

Dennis
fuente
0

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);}
}
SuperJedi224
fuente
0

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.

kamoroso94
fuente
8
¿Se garantiza que tiene exactamente un número de entrada coincidente?
Rɪᴋᴇʀ
@Riker: Creo que la calculadora TI utiliza algún tipo de coma flotante internamente; Si RAND usa el mismo punto flotante que el resto, estoy bastante seguro de que solo hay una solución.
Joshua
@Joshua Creo que usa el algoritmo de L'Ecuyer .
kamoroso94
@Joshua "bastante seguro" no es suficiente. A menos que pueda probar que solo existe una solución, esta no es una respuesta válida.
Rɪᴋᴇʀ
1
@ Dennis: Sonda para 196164532 * 2; si esa no es una solución, entonces no hay otra solución.
Joshua
0

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 64 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.

Shieru Asakoto
fuente
Agrietado.
Bubbler
0

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!

FantaC
fuente
-2

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.

Joshua
fuente
1
Esto no puede tener exactamente una solución; hay un número infinito de enteros, y la función MD5 tiene un número finito de salidas posibles, por lo que debe haber una colisión
pppery
@ppperry: Sin embargo, solo hay 2 mil millones y cambian las entradas positivas.
Joshua
Si lo piensa de esa manera, esto genera errores en las entradas mayores de 2 ^ 31 y, por lo tanto, no es válido.
pppery
@ppperry: ahora no habrá error en eso.
Joshua
2
A menos que pueda probar que 1 es la única solución, esta respuesta no es válida. La carga de la prueba debe recaer en la persona que dice tener una respuesta válida.
Dennis