Estou pensando em um número (Tópico do policial)

32

Linha do ladrão aqui

Nesse desafio de policiais , 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 ; 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.

Assistente de Trigo
fonte
11
Se você permitir funções criptográficas, eu recomendaria colocar um limite de tempo nos programas.
Okx 28/08/17
12
Eu derrotei esse desafio porque, na maioria dos idiomas, ele pode ser simplesmente quebrado usando um algoritmo de mapeamento ou um loop simples. Considero isso um pouco fácil demais para um desafio de policiais e ladrões .
Mr. Xcoder
2
Eu sinto que haverá muitos policiais que conhecem um (provavelmente o menor) valor aceito, mas não sabem se existem mais respostas certas ou quais são elas.
histocrat
12
@ Mr.Xcoder Você está livre para votar, no entanto, vou apontar que esse é o tipo de desafio e não, na minha opinião, uma falha. O desafio é principalmente divertido para policiais que precisam dificultar a força bruta quanto possível, diminuindo a velocidade da computação. Respostas mais criativas devem dificultar cada vez mais a força bruta, permitindo que usem números cada vez menores.
Wheat Wizard
11
@WheatWizard Presumo que não seria ganhar, mas isso não seria possível a rachar por exemplo, um programa que apenas compara a entrada para A(9,9)onde Aé a função de Ackerman.
flawr

Respostas:

10

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.

fergusq
fonte
11
Não existe intérprete online para o Tampio?
Shaggy
@ Shaggy Ainda não, infelizmente. Eu provavelmente deveria perguntar se poderia ser adicionado ao TIO.
Fergusq
Cracked
Assistente de trigo
5

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!

Ramillies
fonte
Cracked
Nitrodon
4

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.

Eli Richardson
fonte
Cracked
Gustavo Rodrigues
3

Geléia , pontuação: ... 1 ( 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!

Erik, o Outgolfer
fonte
Rachado
Mr. Xcoder
@ Mr.Xcoder Ele viveu muito tempo ...
Erik the Outgolfer
Acabei de adicionar ǀGe o intervalo 1...1000como entrada: P
Sr. Xcoder 28/08
Você viu a 5ȷ2_parte, certo?
Erik the Outgolfer
Não, eu nem olhei para o código lol. Acabou de adicionar o conjunto de teste e viram onde o 1é, então eu ter colado a seqüência desde o início até o 1em um script Python e contou o número de zeros antes que ...
Sr. Xcoder
3

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.

Sísifo
fonte
Cracked
Leaky Nun
@LeakyNun Uau, um pouco mais rápido do que eu esperava.
Sísifo
Encontrar um resolvedor de sudoku online não é difícil.
Leaky Nun
Há algum problema com seu verificador de sudoku: você verificou as linhas horizontais e as linhas verticais, mas apenas as três primeiras células.
Leaky Nun
@LeakyNun Você está certo, adeveria ser i+a. Eu fixo-lo, mas que é rachado qualquer maneira encolher de ombros
Sísifo
3

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!

flawr
fonte
O programa deve terminar sem erros em todas as entradas. Isso termina em um dia com memória ilimitada?
precisa saber é o seguinte
Você precisa de um pouco de memória, mas certamente não precisa de memória ilimitada. Provavelmente depende da implementação e do seu hardware. Obviamente, ele foi projetado para levar algum tempo para calcular, a fim de dificultar os ataques de força bruta e incentivar a análise do programa. Boa sorte :)
flawr
Rachado?
Christian Sievers
2

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 .

Quadratic_Koch_curve_type2_iterations.png

Sleafar
fonte
Rachado , eu acho; o tempo de execução é muito longo para verificar diretamente, mas verifiquei com valores mais fáceis e meu crack parece funcionar.
Nitrodon
1

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.

Mr. Xcoder
fonte
rachado
Erik o Outgolfer
1

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

Stewie Griffin
fonte
ele não parece mesmo ser executado em tio
Okx
11
@Okx O tempo limite é excedido no TIO, mas é executado na versão desktop.
Rɪᴋᴇʀ
11
Por que o voto negativo?
Wheat Wizard
3
@WheatWizard provavelmente porque é teoricamente possível que ele tenha vários números. Além disso, é meio tbh chato. Eu gostaria de ver mais soluções matemáticas, RNG é meio chato.
Rɪᴋᴇʀ
11
@Riker Mas porque você está adivinhando uma semente para o RNG, ele está usando o próprio RNG como sua função, que é realmente determinística. Mas sim, considerando que se baseia na dificuldade de inverter o que você espera ser uma função unidirecional, pode-se também, apenas criptografar uma string "verdadeira" com um número aleatório e, em seguida, o desafio quase equivale a quebrar qualquer esquema de criptografia escolhido para descobrir a chave privada.
Shufflepants
1

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
LyricLy
fonte
Cracked
Christian Sievers
1

Brain-Flak , pontuação 1574 ( rachada )

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

Experimente online!

Nitrodon
fonte
Cracked
Assistente de Trigo
1

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!

John Gowers
fonte
O intérprete online retorna "yes" para a entrada "1". Isso conta como rachado agora?
Sleafar
@ Sleafar Suspiro ... sim, isso foi um erro estúpido da minha parte.
John Gowers
No entanto, isso significa que esse desafio agora é inválido, pois há duas entradas que o fazem imprimir sim, então não tenho certeza se você pode reivindicá-lo. Adicionarei uma versão corrigida a este post, mas deixarei o original em seu caso.
John Gowers
1

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.

histocrata
fonte
1

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.

jstnthms
fonte
0

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.

Mr. Xcoder
fonte
Rachado
Mr. Xcoder
@ Mr.Xcoder Heh bem feito, acho que foi muito fácil
0

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.

sonar235
fonte
A entrada é retirada do stdin. A saída é 1 (para um número adivinhado corretamente) ou 0 (para um número adivinhado incorretamente).
sonar235
Não sei por que você fez deste um wiki da comunidade. Esta é a sua resposta que parece ter levado um trabalho considerável a ser feito. Eu certamente não chamaria essa resposta de evidência de que a pergunta está sendo quebrada também. Esta é uma resposta inteligente, que provavelmente pode ter uma boa pontuação (não posso nem provar que isso não funcione para 1). O objetivo de uma pergunta é sempre atrair respostas que abordem a questão de maneiras interessantes e inteligentes (e também para me divertir, mas não posso garantir o seu entretenimento), e, no que me diz respeito, isso é verdade.
Wheat Wizard
3
De fato, esta resposta é inválida. Ele quase certamente (com probabilidade astronômica de nenhuma sequência de 512 bits que corresponde ao hash) exec () outra coisa que provavelmente nem sequer é um código python válido antes de atingir o código pretendido.
Joshua
11
@ sonar235: Seu modelo de fragmento possui mais de 512 bits.
217 Joshua Joshua
11
Para expandir a resposta de Josué: seu pedaço de código tem 102 caracteres. Em particular, seu programa irá percorrer todas as seqüências de 100 caracteres antes de chegar ao seu código. Como seu código interage com caracteres no intervalo 0x00-0xFF, 256 ^ 100ou seja, é uma 2 ^ 800string. Enquanto isso, existem apenas 2 ^ 512possíveis hashes de 512 bits. Isso significa que as cordas sobre as quais você itera superam os possíveis hashes pelo menos 2 ^ 288para um - um número 10.000 vezes maior que o número de átomos no universo. A probabilidade desse hash em particular não ser utilizada é incrivelmente pequena .
John Gowers 29/08
0

Python 3 , 49 bytes, rachado por sonar235

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

Experimente online!

ED
fonte
Zero não é um número inteiro positivo fyi. Não sei se essa foi a solução pretendida, mas funciona.
Assistente de trigo
0 não é a solução pretendida.
ED
8
Uhh, sua página do TIO está mostrando a solução ...
LyricLy
2
Também "escrever um programa ou função que outputs um valor quando desde que o número como entrada e outro valor para todos os outros insumos inteiro positivo "
Jonathan Allan
2
Rachado por @ Sonar235 .
Dom Hastings
0

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
user902383
fonte
11
Eu não acho que a ofuscação fará qualquer coisa, exceto adicionar um primeiro passo irritante.
Engineer Toast
11
Cracked
pppery
2
@EngineerToast não, na verdade não, foi apenas para assustar pessoas preguiçosas.
user902383
0

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.

L3viathan
fonte
11
Você pode adicionar um link TIO, por favor?
Shaggy
11
Para futuros ladrões: o número inteiro não parece ser menor que 100000000.
Xcoder 28/08
11
@ Shaggy O tempo limite será excedido no TIO, demorou cerca de meia hora no meu computador para executar as bilhões de iterações do SHA256.
L3viathan
2
Algum ladrão gosta de formar uma equipe para resolver este? Só precisamos dividir os números abaixo de 1000 entre nós, para que tenhamos tempo de calcular os resumos iterados de SHA antes do prazo final.
John Gowers
2
A menos que você possa provar que 1 é a única solução, esta resposta é inválida. O ônus da prova deve recair sobre a pessoa que afirma ter uma resposta válida.
Dennis
0

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.

Dennis
fonte
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
fonte
0

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.

kamoroso94
fonte
8
Isso é garantido para ter exatamente um número de entrada correspondente?
Rɪᴋᴇʀ
@Riker: Eu acho que a calculadora da TI usa algum tipo de ponto flutuante internamente; se o RAND usar o mesmo ponto flutuante que o restante, tenho certeza de que há apenas uma solução.
Joshua Joshua
@ Josué Eu acredito que ele usa o algoritmo da L'Ecuyer .
kamoroso94
@ Josué "com certeza" não é suficiente. A menos que você possa provar que existe apenas 1 solução, essa não é uma resposta válida.
Rɪᴋᴇʀ
11
@Dennis: Teste para 196164532 * 2; se isso não for uma solução, não haverá outra solução.
Joshua Joshua
0

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

Shieru Asakoto
fonte
Rachado.
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, se correto, FalseFalse, caso contrário

O número era

15752963

Experimente online!

FantaC
fonte
-2

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.

Joshua
fonte
11
Isso não pode ter exatamente uma solução; há um número infinito de números inteiros, e a função MD5 tem um número finito de possíveis saídas, então deve haver uma colisão
pppery
@ppperry: Existem apenas 2 bilhões e mudam ints positivos.
21917 Joshua Joshua
Se você pensar dessa maneira, esse erro ocorre nas entradas maiores que 2 ^ 31 e, portanto, é inválido.
precisa saber é
@ppperry: Agora, não haverá erro nisso.
21717 Joshua Joshua
2
A menos que você possa provar que 1 é a única solução, esta resposta é inválida. O ônus da prova deve recair sobre a pessoa que afirma ter uma resposta válida.
Dennis