Este é um quebra - cabeça de policiais e ladrões, o fio dos ladrões pode ser encontrado aqui .

Sua tarefa será escrever dois programas (ou funções), de modo que eles sejam anagramas um do outro e um execute o inverso esquerdo do outro. Esses programas podem aceitar e gerar quantos números inteiros ou complexos forem desejados. Se você escolher pegar números como pontos de caráter ou qualquer outro meio razoável, deverá indicar que está fazendo isso em sua resposta. Se você optar por restringir o domínio de sua função, também deverá indicar o domínio restrito em sua resposta.

Você apresentará o primeiro programa na forma de uma resposta com o inverso esquerdo oculto para os ladrões encontrarem.

O programa mostrado deve implementar uma função injetiva (caso contrário, seria impossível a existência de uma resposta oculta).

Se sua resposta não tiver sido quebrada em uma semana, você poderá revelar a resposta oculta e marcá-la como segura . Respostas seguras não podem ser decifradas por ladrões e permanecerão desatualizadas indefinidamente.

O objetivo será criar a resposta mais curta e sem quebra em bytes.

Exemplo

Você pode mostrar o seguinte programa python que adiciona um à entrada

lambda x:~-x

Uma solução poderia ser:

lambda x:-~x

Isso subtrai um da entrada

Python 3, 80 bytes ( rachado )

bhmq = int(input())
print(bhmq ** 2)
(1 or [(sqrt),(specification+of*integerr)])

Domínio: números inteiros positivos. A função é apenas quadratura de um número. Entrada para stdin, saída para stdout, bem como na função inversa. Observe que o Python ignora a terceira linha aqui, porque é sintaticamente válida e 1 já é um valor verdadeiro, portanto o Python nem olha se a parte correta de 'ou' está bem definida.

Os ladrões devem escrever uma função sqrt que funcione corretamente em todos os quadrados diferentes de zero, imprimindo o valor inteiro como está, sem ponto flutuante (a saída '4' da entrada deve ser '2' ou '2 \ n', não '2,0' ou '2.0 \ n').

Python 3, 46 bytes, quebrado

lambda x:x*(1999888577766665//844333333222200)

Duplica a entrada.

7 , 9 bytes, rachado

Este programa é cheio de caracteres não imprimíveis, então aqui está um hexdump:

00000000: 2573 dc01 7e13 dcb6 1f                   %s..~....

Nota: isso usa uma rotina de entrada numérica que é incapaz de inserir números negativos; portanto, esse envio é restrito apenas a números inteiros não negativos.

Um problema com desafios de policiais e ladrões é que você não escreve explicações sobre o código (para dificultar o crack). Por outro lado, isso significa que não preciso me preocupar com o problema aqui.

Escolhi 7 como idioma porque, especialmente em sua notação compactada, é muito difícil de ler e não vejo por que deveria ser apenas eu quem precisava se dar ao trabalho de mover em pedaços de programas de 8 bits escritos em uma codificação de 3 bits. Boa sorte!

Explicação

Agora que o programa foi quebrado (por força bruta, infelizmente; isso sempre é um perigo nessas breves soluções), também posso explicar o que estava fazendo. Isso era realmente bastante solucionável ao ler o programa; Eu poderia ter dificultado muito, mas isso me pareceu uma péssima idéia quando existem brechas de força bruta.

Começaremos representando o programa em uma codificação mais natural. Como de costume, os números em negrito indicam os comandos que são executados imediatamente (não todos os quais são representável em um programa; 6e 7são, mas 2para 5que não são), números unbolded representam seus equivalentes escaparam ( 0a 5, todos os quais são representável no programa original; nota que 0é um escape 6e 1é um escape 7):

112 7 1 7 34002 77 023 67 13303

O conjunto de comandos disponíveis em uma fonte de 7 programas significa que é basicamente apenas um literal que representa a pilha original (não há mais nada que você possa fazer com apenas comandos escapados 6e 7). Portanto, a primeira coisa que um programa fará é colocar um monte de coisas na pilha. Veja como a pilha cuida da execução do programa ( |separa os elementos da pilha, como de costume em 7):

772 | 7 | 34662 | 023 73363

O elemento final da pilha é copiado para se tornar o código a ser executado (enquanto permanece na pilha). Por acaso, essa é a única parte do programa que é código; tudo o resto são apenas dados. Aqui está o que ele se traduz:

73363 
7       Empurre um elemento vazio para a pilha
  3 Faça a      saída do elemento de pilha superior, descarte o elemento abaixo
 73      Efeito combinado destes: descarte o elemento de pilha superior
   3 Faça a     saída do elemento de pilha superior, descarte o elemento abaixo
    6    Escape do elemento de pilha superior e depois anexá-lo ao elemento abaixo
     3   Solte o elemento da pilha superior e descarte o elemento abaixo

Em outras palavras, isso é basicamente apenas um monte de instruções de E / S. Vamos analisar isso em detalhes:

• 73descarta o 73363que ainda está no topo da pilha.
• 3produz o 023e descarta o 34662. Assim, pode-se ver que este 34662é um comentário, que foi usado para armazenar os bytes necessários na outra versão do programa. Quanto ao que 023ocorre quando a saída é selecionada, seleciona o formato de E / S 0 (inteiros) e, em seguida, 23é uma diretiva que solicita que a implementação insira um número inteiro (em 7, você insere através da saída de códigos específicos que solicitam entrada). A entrada é feita fazendo cópias do elemento da pilha abaixo, por exemplo, se o número inteiro da entrada for 10, o próximo elemento da pilha (atualmente 7) se tornará 7777777777. Portanto, estamos aceitando a entrada do usuário em decimal, mas ela está sendo armazenada como unária.
• 6escapa o elemento da pilha superior (alterando cada instância de 7para 1; é assim que as cadeias consistindo inteiramente de 7s são escapadas) e, em seguida, anexa-o ao elemento da pilha antes de ( 772). Portanto, nossos dados agora são algo parecidos 7721111111111.
• Por fim, 3gera o elemento de pilha em questão (e exibe um elemento de pilha em branco que faz parte da pilha inicial padrão). Seu valor é calculado com base no número de 1s e 7s, e subtraindo o número de 0s e 6s. (O 2meio é ignorado na maioria dos casos; se estiver no final da cadeia, ele se tornará uma nova linha à direita em vez de ser ignorada, mas as regras do PPCG não se importam com isso.) Assim, a saída é a original entrada mais 2.

Neste ponto, não há nada útil na pilha e nada no programa, portanto o programa é encerrado.

Como invertemos isso? É uma simples questão de alterar 11para 00, para que acrescentemos caracteres à entrada que a torna 2 menor, em vez de 2 maior. Existem 00oito dígitos octais convenientemente ocultos mais adiante no programa (para que os dígitos octais e bytes sejam alinhados um com o outro), para que possamos trocá-lo simplesmente 11no início.

JavaScript (ES6), 21 bytes, Cracked

Este é fácil.

b=>Math.pow(b,torc=3)

Retorna o cubo da entrada.

Python 2, 83 bytes, quebrado

#((()))****+,,---/2289;==oppppppqqqqqw~~
lambda n:pow(n,65537,10998167423251438693)

Isso é semelhante à minha outra resposta. No entanto, isso usa RSA de 64 bits e é criptograficamente bastante fraco. Se você pode roubar essa resposta, teoricamente também pode roubar a minha outra, com tempo suficiente.

Python 2, 47 bytes, Rachado

lambda x:x**2or (iron() and saxifrage.extend())

O domínio para esta função é {x ∈ ℤ | x> 0}. Ele esquadrinha sua entrada.

nmjcman101 encontrou a solução pretendida:

lambda x:sorted(a**2for a in range(x)).index(x)

JavaScript (ES6), 46 bytes, Rachado

x=>Math.log(x+(+String(t=985921996597669)[5]))

Esta função retorna ln(x+1)onde xé um número não negativo.

Uso

(x=>Math.log(x+(+String(t=985921996597669)[5])))(5)

Nota: Devido à natureza dos números de ponto flutuante, f(g(x))podem não ser exatamente iguais x. Exemplo:f(g(4))=3.9999999999999996

J, 8 bytes, quebrado

Outro simples para começar.

[:]+:[-:

Duplica a entrada.

Processing.js, 59 bytes, Rachado!

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

Esta função multiplica a entrada por 204( 17*-4*-3=204). Ele recebe um int como entrada e gera um float. Como esperado, o inverso divide a entrada por 204.

Um intérprete online para processing-js pode ser encontrado aqui .

J, 10 bytes, quebrado

1%~<:[@*>:

Outro simples. Retorna n ² -1.

JavaScript (ES6), 15 bytes, quebrado por Emigna

t=>(!!0+~~t+~0)

Esta função retorna n-1.

Você pode testá-lo como:

(t=>(!!0+~~t+~0))(6)

Rachado

Minha solução pretendida é um pouco diferente do crack de Emigna:

t=>t+(+!!~~~00)

J , 29 bytes ( Rachado por milhas)

5#.[:,(3 5&#:(-$]-)7)#.inv"0]

Este é um verbo que recebe um número inteiro positivo como entrada e faz o seguinte:

1. Converta nas bases 2 e 4.
2. Coloque a representação da base 4 com 0s para ter o mesmo comprimento da representação da base 2.
3. Concatene as duas representações (base 2 primeiro).
4. Interprete a concatenação como uma representação de base 5 e converta em número inteiro.

Experimente online!

Minha solução

A lógica é praticamente a mesma do crack. A conjunção de classificação "pode estar presa em muitos lugares diferentes (e eu a uso para livrar-se do desnecessário 0e 3), já que realmente não faz nada na solução.

(7-5)#.[:(]-:&#$,)5#.inv"0 3]

Processamento (java), 59 bytes, SAFE

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

Esta função multiplica a entrada por 204( 17*-4*-3=204). Ele recebe um int como entrada e gera um float. Como esperado, o inverso divide a entrada por204 . Nota: ambos os programas recebem um int como entrada e emitem um float.

Essa resposta é exatamente igual à minha outra resposta, exceto que minha outra resposta foi escrita em Processing.js. Conheça Processing-java, o primo menos detalhado do Java. Você pode fazer o download do Processing aqui em processing.org.

The Crack

float ap(int i){return i*pow(blue(get(0,0)),-1);}//++7*4*-3

Este programa divide o argumento por 204. Mas como? Vamos entrar na função.

i *                              //multiply i by
         blue( get(0, 0) )       //this (evaluates to 204)
    pow(                  , -1)  //raises to the -1 power (ie its reciprocal)

Simples o suficiente, mas como se blue( get(0, 0) )torna 204? Esta é a peça central desta submissão. Primeiro, get(0,0)obtém a cor do pixel localizado em (0,0)(no canto superior esquerdo da janela, que sempre abre em um esboço de Processamento). Em seguida, blue()obtém o valor azul desse pixel, que é 204!

Para chegar a essa submissão, experimentei imprimindo os diferentes atributos da cor obtida por get(0,0). Eu descobri que os, verde, azul, vermelho são valores alfa 204, 204, 204e 255, respectivamente. A partir disso, decidi fazer uma operação simples com esse número e terminei com este post.

JavaScript (ES6), 63 bytes Rachado por Ilmari Karonen

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

Hora de um atobabsurdo. Esta função retorna x*x+1onde xé um número não negativo.

Uso

(x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`))(5)

Pretendido

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

Há um grande número de soluções em potencial, mas eu esperava que os personagens principais jogassem fora a ordem de bytes o suficiente para dificultar isso. C'est laatob

Brain-Flak , 26 bytes, Rachado

Original

((((()()())){}[()]){}{}{})

My Crack

([(((()())){}()){}{}()]{})

1000000000 's crack

([(((()())()){}){}{}](){})

Python 2, 225 bytes, quebrado pelo Sp3000

#((()))****+,,---/000555666888;==oppppppqqqqqw~~
lambda n:pow(n,65537,9273089718324971160906816222280219512637222672577602579509954532420895497077475973192045191331307498433055746131266769952623190481881511473086869829441397)

O domínio desta função é [0, n), onde n é o grande número acima. Sim, esta função é invertível neste domínio. E, a menos que eu errei, quebrar essa resposta é tão difícil quanto quebrar o RSA de 512 bits.

J, 15 bytes

(".&,'10.')#.#:

Pega um número inteiro não negativo n , converte-o em uma lista de dígitos binários e combina esses dígitos como um número base 10.

Experimente online!