Inversões ocultas (tópico dos policiais)

35

Este é um quebra cabeça de 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

Assistente de Trigo
fonte
Podemos ter números inteiros imaginários / complexos?
Stewie Griffin
@stewie se você indicar, você pode #
Wheat Wizard
11
Anagrama é definido como permutando os caracteres ou permutando os bytes (em idiomas que não usam um conjunto de caracteres de byte único)?
1. " Você apresentará um dos programas " parece sugerir que podemos escolher qual apresentar, mas a frase continua " com o inverso esquerdo oculto ", o que implica que devemos apresentar um específico. Qual e? 2. A pergunta especifica especificamente " programa " e não parece permitir funções, mas o exemplo é uma função e não um programa. Qual e?
Peter Taylor
A capitalização importa?
Kritixi Lithos

Respostas:

12

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

Volfrâmio
fonte
11
Eu gosto deste. É enganosamente difícil de decifrar
Assistente de Trigo
3
Bem-vindo ao ppcg! Bom primeiro post!
Rɪᴋᴇʀ
11
Deixa pra lá, eu errei. A questão ainda permanece.
orlp
11
Eu diria 'não', se realmente posso colocar essa restrição pelas regras do desafio.
Wolfram
11
Rachado?
Zgarb
11

Python 3, 46 bytes, quebrado

lambda x:x*(1999888577766665//844333333222200)

Duplica a entrada.

Lynn
fonte
3
Como o 'Python' funciona em policiais e ladrões? Podemos escolher uma versão arbitrária para atacar sua resposta?
orlp 16/01/19
Oh, este é o Python 3 especificamente, desculpe. O mesmo /acontece com a divisão de flutuação.
Lynn
3
Bem, você acabou de provar que esse desafio não vale o meu tempo. Se movendo.
mbomb007
11

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

Comunidade
fonte
Nota lateral: você não precisa explicar seu código, mas saber o que seu programa faz seria bom.
GB
@ GB: Dei uma explicação completa do programa (incluindo uma explicação de como o crack funciona).
7

JavaScript (ES6), 21 bytes, Cracked

Este é fácil.

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

Retorna o cubo da entrada.

Arnauld
fonte
11
Cracked
Emigna
6

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.

orlp
fonte
4
Rachado.
Ilmari Karonen
5

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)

Assistente de Trigo
fonte
11
Haha, o amor as compostas chamadas de função
FlipTack
11
Rachado Isso foi divertido, fiquei preso no anagrama que me restava!
precisa saber é o seguinte
5

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

SLuck49
fonte
Rachado. Isso foi realmente divertido :-)
ETHproductions
4

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 .

Kritixi Lithos
fonte
11
Rachado.
Ilmari Karonen
4

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)

insertusernamehere
fonte
2
Cracked
Emigna
4

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]
Zgarb
fonte
Eu não entendo J, mas meus experimentos mostram que isso na verdade leva inteiro nas bases 2 e 4, adiciona zeros ao final da base 4 para tornar seu comprimento igual e só então concatena. Esses zeros são destinados?
Wolfram
Wolfram @ Os zeros são destinados, é o que eu tentei dizer com "simultaneamente". Caso contrário, não acho que seria reversível.
Zgarb 18/01/19
@ Wolfram Adicionei uma descrição mais explícita.
Zgarb
Rachado .
miles
4

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.

Kritixi Lithos
fonte
Eu pensei que Kotlin era o primo menos detalhado de Java! Eu admito que a família de idiomas C é bastante grande ... mas como seria a árvore genealógica realmente ... #
9897
Eu acredito que você conseguiu, ninguém quebrou sua postagem e já faz uma semana.
miles
3

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

SLuck49
fonte
Rachado.
Ilmari Karonen
Você acabou de repassar acidentalmente seu código de desafio como a solução pretendida? :)
Ilmari Karonen
@IlmariKaronen Obrigado, isso vai me ensinar a copiar / colar ... lol, sim, certo: P
SLuck49
2

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.

orlp
fonte
11
Forçar com força bruta é consideravelmente mais fácil do que a RSA com força bruta, porque você já possui um anagrama aproximado da constante de que precisa. Por outro lado, é provável que ainda seja muito difícil de gerenciar na prática.
4
Lembre-se de que existe uma meta post referente à randomização nos desafios de CnR: meta.codegolf.stackexchange.com/questions/10793/…
Kritixi Lithos
5
@KritixiLithos Minha resposta não contém randomização, hashes ou código criptográfico embutido. É literalmente uma exponenciação modular.
precisa saber é
2
Sua resposta visa intencionalmente um problema que é difícil de resolver e, portanto, corresponde ao meta post (especialmente porque ele menciona o RSA diretamente). Eu acho que, mesmo que você meta-brinque, seu script ainda merece meu voto negativo.
Christoph
4
Rachado
SP3000
0

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!

milhas
fonte