O fio do ladrão está aqui

A tarefa dos policiais é escrever uma função ou programa que, quando recebe uma entrada, produz uma cadeia determinística finita. Se o programa receber uma entrada diferente, ele deverá retornar uma saída diferente.

Regras:

• As submissões consistem em
  • Nome do idioma
    • Se algum sinalizador for usado, ele deverá ser revelado.
  • Contagem de bytes do programa
  • Contagem de bytes da saída
  • Resultado
    • Se for particularmente longo, forneça uma pasta ou algo semelhante
    • Se contiver imprimíveis, forneça um hexdump.
    • Novas linhas e espaços em branco à direita devem ser incluídos na saída
  • De onde vem a entrada (STDIN, linha de comando, etc. )
• Se aplicável, você pode assumir que o byte representando o EOF não está presente na entrada, a menos que você use esse byte no seu programa.
• Se o seu programa estiver com problemas, adicione um link para a resposta correspondente no tópico do ladrão no seu título.
• Seu programa não é seguro até que uma semana se passe e você o marca.
• Eu desaprovo técnicas como propagação aleatória com as funções de entrada ou hash criptográfico. Não consigo impedi-los, mas não aceitarei uma solução que utilize um deles . Observe também que algumas dessas técnicas podem ter colisões, onde uma sequência diferente produz a mesma saída.
• Seu objetivo é ter a menor saída possível. A solução mais curta e segura postada dentro de três semanas após a publicação desta pergunta vence!

A tarefa do ladrão é encontrar um programa de tamanho igual ou inferior ao original, que também obedeça às regras acima.

Se um ladrão quebrar seu programa com uma solução diferente da pretendida, você terá a oportunidade de desdobrá-lo, provando que a solução do ladrão está incorreta. Você pode fazer isso encontrando uma entrada no programa do ladrão que produzirá a mesma saída.

Submissão de exemplo:

brainfuck, 10 bytes, Pontuação: 10

]<.[<],>[,

Esta solução é , [>,] <[. <], Que simplesmente inverte a entrada

Boa sorte!

7 , 31 caracteres, pontuação 30, seguro, mas possivelmente quebrado?

Um programa 7 normalmente é apenas um número, mas pode conter espaços em branco, dividindo-o em vários números. Portanto, essa submissão consiste em dois números (que são implicitamente concatenados pelo intérprete 7), e o programa também aceita dois números como entrada, via entrada padrão. (Os "31 caracteres" no cabeçalho são o comprimento total dos dois números, mais um caractere de espaço em branco que os separa; os dígitos que compõem os números são interpretados como octais quando usados ​​como um programa, mas decimais quando usados ​​como entrada e são os dígitos que são iguais nos dois casos, não os números reais.Tenha em atenção que é irrelevante quando tratado como um programa ou quando é tratado como uma entrada, se você os separa com um espaço ou uma nova linha; espero que não invalidar o envio.)

A saída esperada é o seguinte número (expresso aqui em decimal, pois esse é o formato de saída que o 7 intérprete usa):

238363505302130098723162537059

Observe que o 7 intérprete vinculado a partir do wiki da Esolang armazena internamente números em unário, o que significa que é improvável que você tenha memória suficiente para realmente executar o programa em si mesmo para ver o que faz. Eu verifiquei o programa elaborando seu comportamento manualmente e testando-o em pequenas entradas para verificar se ele fez o que eu esperava que ele fizesse. Uma abordagem alternativa seria escrever um intérprete que use um método mais eficiente de armazenar números.

Evitar rachaduras aqui foi um pouco doloroso, mas agora estou finalmente satisfeito que dois números diferentes dos do próprio programa são capazes de produzir 238363505302130098723162537059 como saída. ( EDIT 1 semana depois: posso estar errado, dependendo de como você interpreta a pergunta; veja abaixo. )

Solução

O programa original era:

711170237403706
111723603700633

Este programa utiliza dois números $x$ e $y$ e calcula o resultado da expressão $3xy-y-2$ (ou seja, $y(3x-1)-2$ ). Se realizarmos esse cálculo em $x=711170237403706$ e $y=111723603700633$ , obteremos o resultado $238363505302130098723162537059$ conforme necessário .

Pretendia-se que nenhuma outra entrada desse o resultado desejado porque:

A entrada deve ser escolhida de forma que $y(3x-1)-2=238363505302130098723162537059$ , ou seja, $y(3x-1)=238363505302130098723162537061$ (adicionando 2 aos dois lados). Esse número é um semiprime, com apenas dois fatores: $111723603700633$ e $2133510712211117$ . Somente um desses números, $2133510712211117$ , pode ser expresso na forma $3x-1$ (dando $(3 \times 711170237403706)-1=2133510712211117$ ). Portanto, podemos identificar exclusivamente qual número é$x$ e qual é$y$ , o que significa que apenas uma entrada funciona.

No entanto, dependendo de como você interpreta a pergunta, pode haver uma segunda entrada que produz a saída desejada (invalidando assim esta solução):

Infelizmente, existem duas partições multiplicativas de um semiprime em dois fatores: um é dividi-lo nos dois fatores primos, mas o outro é a partição trivial que consiste em $1$ e no próprio número. $1$ não pode ser escrito no formato $3x-1$ com o número inteiro $x$ , mas a saída desejada pode ser; portanto, um meta-crack potencial envolve fornecer a entrada como $79454501767376699574387512354$ e $1$ . No entanto, o primeiro número aqui envolve caracteres ( $8$ e $9$) que não estão no conjunto de caracteres para 7 programas. Portanto, se a entrada estiver restrita a estar no mesmo conjunto de caracteres que o programa, esta solução será válida; mas se a entrada contendo caracteres de fora do conjunto de caracteres do programa for permitida, esta solução será inválida.

Explicação

Veja como a solução pretendida funciona:

711170237403706 111723603700633
7 7 7 Separadores de elementos de empilhamento
 111 023 403706 111723603700633 Elementos iniciais da pilha
 111 Número 3, em unário
     023 DSL de E / S para "insira um número"
         403706 111723603700633 Programa principal
(Implícito: execute uma cópia do elemento principal do programa, preservando o original)
         40 Troque {023} acima de {program}, escapando-o
           3 Faça E / S usando {023}; pop {programa}
     0 E / S: numérico
      23 Digite um número, copiando {111} várias vezes
            706 Anexe "6" ao número (diminuindo-o)
                11 Empurre dois elementos da pilha vazia
                  17236 Empurre um elemento de pilha "23" (sem escape)
                       0 Escape {23}, consumindo um elemento vazio
                        3 Faça E / S usando {23}; pop {o elemento abaixo}
                    23 Copie a parte superior da entrada da pilha várias vezes
                         7006 Anexar "66" (ou seja, subtrair 2)
                             3 Saída {como um número}
                              3 Saia do programa (devido à pilha baixa)

Os 7 principais e os 3 finais não são necessários para a funcionalidade do programa, eles estão lá apenas para obter os principais fatores de saída. Ajuda a seguir este programa se você entender o formato numérico; os números são armazenados em uma variante em que unária 1e 7aumentar o valor de 1, e 0e 6diminuir o valor de 1 (introduzindo, assim, 66diminui o valor de 2, repetindo os multiplica Número lo, e assim por diante). As entradas são feitas repetindo um elemento da pilha (portanto, se o elemento da pilha for 12345e a entrada for $3$ , o novo elemento da pilha será $123451234512345$ ).

Node.js v10.9.0 , 40 bytes, Pontuação: 40, Rachado

Entrada

Esta é uma função que aceita exatamente um parâmetro.

Resultado

&`nij.9=j.,)r31n=+(=ooj`[o.o.)1.s](>=6>t

Uma árvore de pêra , 46 bytes de ASCII, pontuação 0, rachada

A entrada é obtida da entrada padrão. A saída esperada (na saída padrão) é uma sequência vazia (ou seja, quando o programa é apresentado como argumento, nenhuma saída deve ser impressa).

Em outras palavras, o desafio aqui é escrever um programa A Pear Tree que não produza nada na saída padrão quando fornecido na entrada padrão e que produz algo na saída padrão quando recebe algo diferente dele na entrada padrão, sem usar mais de 46 bytes. (Consegui fazer isso mantendo o programa em ASCII imprimível também, apesar do A Pear Tree frequentemente usar caracteres não ASCII e não imprimíveis.) Essa é efetivamente a tarefa de escrever um programa de identificação automática , com um formato de saída específico (ou seja, sequência nula quando a identificação for bem-sucedida); no entanto, uma árvore de pêra tem pelo menos duas reviravoltas que tornam a tarefa um pouco mais difícil do que parece quando realizada neste idioma específico (e foi por isso que a escolhi para o envio da minha polícia).

Minha solução

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

eval(k=q(print$\=$_="eval(k=q($k))"ne$_;MZpa))

Experimente online!

Em vez de usar exit, em vez disso, defino $_(saída implícita) e $\(nova linha após saída, incluindo saída implícita) a sequência nula se houver uma correspondência (e 1se não houver correspondência). A printainda é necessária porque a saída implícita só é ativada se houver pelo menos um byte de entrada (portanto, precisamos imprimir explicitamente algo se recebermos uma string vazia como entrada, que é diferente do programa).

Todo programa A Pear Tree precisa conter uma soma de verificação em algum lugar (é o que está MZpanesta solução). Tanto a minha solução quanto o crack selecionam nomes de variáveis ​​(e variam outros detalhes menores do código) para fazer com que a soma de verificação seja composta inteiramente por letras ASCII.

Perl 5 -p0777, 10 bytes, 10, seguro

W)9r46<(k

O último caractere aqui é "shift out", código de caractere 14 (decimal) / 0E (hex). Todos os outros são ASCII imprimíveis.

Como estamos usando o argumento implícito de E / S do Perl -p0777, a entrada é proveniente da entrada padrão e a saída é enviada para a saída padrão.

Solução

O programa faz o seguinte:

NUL preenche a entrada com pelo menos 10 caracteres e depois XORs com a sequência svgOUT_TOP

o que significa que o próprio programa, a única entrada que produz a saída desejada, é:

$ _ ^ = abc | $ ^

Experimente online!

Explicação

Perl tem um número de variáveis ​​de propósito especial. Por exemplo, ao usar -p0777E / S implícita, $_é entrada no início do programa e saída no final do programa.

A maioria dessas variáveis ​​possui um valor padrão muito simples. No entanto, o valor padrão de $^, o formato de topo da página atualmente selecionado, é a sequência muito mais longa STDOUT_TOP. Como tal, podemos usar isso como um método de ofuscação muito conciso via XORing $^com o valor que queremos ofuscar (neste caso, o programa).

Para ocultar o avisador _TOPno final, eu preenchi o próprio programa com 10 caracteres, adicionando um abc|, o que significa que todos os caracteres do STDOUT_TOPXOR seriam preenchidos com algo; a escolha de abc|no início era uma maneira fácil de manter a saída praticamente imprimível (e tornar mais difícil perceber que eu estava usando um XOR com uma sequência composta principalmente de letras maiúsculas, porque em ASCII, as letras minúsculas do XOR são minúsculas).

Python 3, 50 bytes quebrado

Entrada e saída de / para stdin / -out. A saída é diferente para cada entrada diferente. Saída exclusiva quando fornecido o código fonte:

218216195196222130136136132192197195196130241204136209197216206130201131244155157154215136138204197216138201138195196138195196218223222130131247131131

(Isso é 150 dígitos)

Boa sorte!

05AB1E , 35 bytes, Pontuação: 7

Entrada:
Destdin

Resultado:
QÕ Ƿe

Cubix , 18 bytes, Pontuação 18, seguro

É uma pena que esse desafio não tenha atraído mais atenção, mas é assim que acontece às vezes. Eu deixaria isso inseguro, mas decidi postar a solução antes de me esquecer.

Isso deve ser bastante fácil de quebrar.

Entrada destdin

Resultado

$`*2aJPJ#74(o);89

Edit: devo mencionar que isso espera a fonte em sua forma abreviada ... e agora notei que há um byte ausente (não imprimível) do resultado que quebrei ao publicar. Deve copiar agora. Os valores hexadecimais são24 60 2a 13 32 61 4a 50 4a 23 37 34 28 6f 29 3b 38 39

O conceito era remover a impressão do primeiro caractere e remover o índice inverso do caractere, por exemplo, [chars] - [0, len ([chars]) .. 2]

O código é

$r;#AoW\U-@</u.?;;

que mapeia para o cubo a seguir

    $ r
    ; #
A o W \ U - @ <
/ u . ? ; ; . .
    . .
    . .

Experimente aqui

Geléia , 14 bytes, Pontuação: 21, Seguro

O programa e o tamanho da saída são contados usando a página de código Jelly.

Entrada

Primeiro argumento da linha de comandos.

Resultado

-§ḋẇ"*YdĖDƘ>Ẉed€Ç+æạɦ

Solução

ØJiⱮÄÆNPḃØ⁵ịØJ

Experimente online!

JavaScript Firefox, <10 bytes, Pontuação: 52, da entrada do argumento de função, Cracked

ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ==


btoa

btoa(btoa) codifica a seguinte string:

function btoa() {
    [native code]
}

que dá:

"ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ=="

_{apenas copiado}

GCC 61-> 61 bytes

70 4F 92 73 08 D4 03 E7 65 DC D6 89 B5 AD BA 90 
97 26 31 10 F6 FA 0A 30 8F 24 69 0A A7 8B 59 9E 
A2 42 D5 67 B8 12 3A 1E 9D 25 80 F9 6B 25 32 C2 
EE 46 3F 8D 7E 0C 73 0F F0 93 C6 68 50

Programa completo, obtenha entrada de stdin e saída para stdout

Perl 6, 43 bytes, Pontuação: 15, de stdin

49671296789805

Pepe , 23 bytes, pontuação: 23, decifrado por MickyT

Entrada:

padrão

Resultado:

RDCbn@?K]<[G98765TSR^PO

J , 26 bytes, Pontuação: 52, Seguro

O programa não é um REPL, mas um script completo que aceita stdine imprime explicitamente em stdout.

Entrada

Entrada padrão.

Resultado

6fc42353c98217ef5a2908a3c63d090aa9a55b2558b61294e06a

Não, não é um método de criptografia.

Solução

echo]hfd]257x#.3&u:stdin''
                   stdin'' Take the whole input
               3&u:        Convert to codepoints
         257x#.     Convert base 257 to integer
     hfd]           "Hex from Decimal"
echo]               Print to stdout

Experimente online!

Barril , 6 bytes, Pontuação: 6

Entrada

De stdin, usando?

Resultado

5\x1c"\x1c"9

Lembre-se de que essas são seqüências de escape para bytes não imprimíveis. Substitua os escapes pelos caracteres literais. Texto bruto disponível aqui

Boa sorte com este! Vejo vocês na próxima semana!

 Perl 6, 31 bytes, Pontuação: 39, de stdin - Rachado

Rachado aqui

().1111111111112222235abcegijkmnorstvy

Solução bruta. Pode sobreviver.