Anagram Quines (Tópico dos policiais)

26

Este é um desafio de que o Fio dos Ladrões pode ser encontrado aqui

Seu desafio é escrever um programa que produza um anagrama de seu código fonte, mas não o código fonte original.

Por exemplo, o seguinte programa Python,

print`'print*2``'*2`

impressões

'print*2``print*2``'

que tem todos os mesmos caracteres que sua fonte original, mas em uma ordem diferente.

Depois de encontrar esse programa, inclua a saída do programa como resposta, omitindo o programa que o gera. Como você deve ter adivinhado, os ladrões procurarão descobrir o programa que você ocultou ou qualquer outro programa que atenda às especificações. Seu objetivo é criar o programa mais curto que os ladrões não possam decifrar.

Regras

  • Como na maioria dos desafios de , se sua resposta permanecer sem solução por uma semana, você poderá adicionar a solução pretendida à sua resposta e marcá-la como Segura . Uma vez segura, uma resposta não pode ser quebrada pelos ladrões.

  • Você não precisa incluir o idioma da solução pretendida; no entanto, se você não incluir os idiomas, os ladrões podem decifrá-lo em qualquer idioma anterior ao desafio, enquanto que, se você especificar o idioma, eles poderão decifrá-lo somente no idioma fornecido.

  • Aplicam-se regras padrão para Quines.

Assistente de Trigo
fonte
Minha pergunta usual: em um idioma em que bytes não correspondem a caracteres, o anagrama está no nível de byte ou caractere?
@ ais523 deve ser um anagrama dos bytes.
Assistente de trigo
As regras comuns de quine se aplicam aos ladrões? Eles se aplicam a policiais?
Dennis
1
@Fatalize Se não alterar a saída, está correto, mas a saída deve ser estática.
Assistente de Trigo

Respostas:

12

Brain-Flak , 231 bytes Rachado pelo Assistente de Trigo

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

O programa original usa o -Aargumento

Aqui estão as contagens:

( -> 74
) -> 74
{ -> 34
} -> 34
[ -> 7
] -> 7
Riley
fonte
Rachado !
Assistente de trigo
5

Python 2, 96 bytes, quebrado por math_junkie

Saída:

B97.off]xo) wnd[ri0'of{r1({r6-{r{rri) {r1(xo0'sjD;0'0'qhF=1({r{r2)4+}twnri2)wnlcof) yp) ) xomd2)

Código de golfe pela primeira vez! Espero que não seja muito fácil.

Agargara
fonte
2
Eu tenho um miserável print(''), chr() + ''até agora
drolex 28/02/19
2
Rachado!
matemática viciado em
4

Haskell, 107 bytes, Rachado por nimi

"$$$$'''''''',,----....::<<<<<<<<========>>>>[[[[[[[[]]]]]]]]aaddddddddddddiiiiiiiiiiiimmnnnnpprrtt||||||"

Há uma nova linha posterior à direita.


Solução original:


main=print$id=<<[[id|i<-"main=print$id=<<[[id|i<-,i==d]>>d:[d]|d<-['$'..'|']]",i==d]>>d:[d]|d<-['$'..'|']]

Experimente online!

Minha idéia principal era escrever um quine que classifica seu próprio código-fonte antes de produzi-lo sem usar uma sortfunção de biblioteca . Somente depois de uma tentativa inicial de cracking por nimi , ocorreu-me que o código do programa poderia ser classificado manualmente, codificado no programa e depois impresso enquanto dobra cada letra. No entanto, os limitados caracteres disponíveis tornam essa abordagem mais complicada e o crack bem-sucedido de nimi é bastante semelhante ao meu programa original.

Explicação:

main=print$                                      -- full program which prints the following string
  id=<<[[id|i<-"...",i==d]>>d:[d]|d<-['$'..'|']]
                                 |d<-['$'..'|']  -- for each char d in "$%&'()*+,-./012 ... xyz{|"
        [id|i<-"...",i==d]                       -- build a list with as many elements as d is contained in the string
                          >>d:[d]                -- replicate the string "dd" as often as the previous list is long 
  id=<<[                                       ] -- concatenate the resulting list of srings to one single string
Laikoni
fonte
@nimi Sim, é um programa completo. Esta não é uma regra padrão para quines?
Laikoni
Não tenho certeza. Tínhamos quines antes que funções permitidas. E mesmo que programas completos sejam padrão, o "programa" no desafio pode ser interpretado como sobrescrevendo os padrões e também permitindo funções .
nimi 24/02
@ nimi Me desculpe, a versão anterior era enganosa. Eu o escrevi depois de ter visto sua primeira tentativa e antes de perceber que não era válido de acordo com as especificações. Eu até publiquei e depois revirei rapidamente na esperança de que ninguém o visse, como você pode ver no histórico de revisões. Depois de ver sua versão fixa, voltei a esta versão, sem considerar que a descrição não era mais adequada.
Laikoni
Não tinha certeza se você estava se referindo à minha resposta, por isso excluí meu comentário. É realmente possível usar uma string pré-classificada (substitua ;por uma NL): i[]d=[d,d];main=print$i[]=<<"$$ ... |||"--e todos os caracteres ausentes após o --. Encontrei esta versão depois da minha resposta do tópico de ladrões e depois de você ter revelado sua resposta com a explicação agora alterada.
nimi 25/02
4

Idioma não especificado, 124 bytes,

No tema da resposta de DJMcMayhem, este é o primeiro 32 caracteres ASCII (além de 0x00) impresso quatro vezes cada. Como nada disso é visível, não incluí o código real na minha resposta.

Aqui está o hexdump:

00000000: 0101 0101 0202 0202 0303 0303 0404 0404  ................
00000010: 0505 0505 0606 0606 0707 0707 0808 0808  ................
00000020: 0909 0909 0a0a 0a0a 0b0b 0b0b 0c0c 0c0c  ................
00000030: 0d0d 0d0d 0e0e 0e0e 0f0f 0f0f 1010 1010  ................
00000040: 1111 1111 1212 1212 1313 1313 1414 1414  ................
00000050: 1515 1515 1616 1616 1717 1717 1818 1818  ................
00000060: 1919 1919 1a1a 1a1a 1b1b 1b1b 1c1c 1c1c  ................
00000070: 1d1d 1d1d 1e1e 1e1e 1f1f 1f1f            ............

No entanto, aqui está um Python que o imprime (e uma nova linha) se você quiser:

print"".join(chr(x)*4for x in range(1,32))
Assistente de Trigo
fonte
4

Pitão , 32 bytes, Rachado por math_junkie

J+J=JJ 1-2#pTN%"J+J=JJ 1-2#pTN%"

Solução original

J2#p+"J+J=JJ 1-2#pTN%"N=J-J1 %TJ

Experimente online!

J2                               # Assign 2 to the variable J
  #                              # Infinite loop, break on error
    +"J+J=JJ 1-2#pTN%"N          # appending a '"' to the string 'J+J=JJ 1-2#pTN%'
   p                             # print the string above
                       =J-J1     # subtract 1 from J and assign back to J
                             %TJ # calculated 10%J, with a blank space before to supress output,
                                 # on the 3rd iteration this will be 10%0 that will generate an
                                 # erro and will break out the loop
Cajado
fonte
Rachado!
matemática viciado em
4

CJam, 46 bytes, quebrado por math_junkie

3658:93]93]]]95_959599c101101$::]]]]]]____ccee
Gato de negócios
fonte
2
Rachado!
matemática viciado em
4

V , 21 bytes (Seguro!)


"&./124ipq|ÍÓÚîñòÿ

Observe a nova linha principal.

Como contém imprimíveis, aqui está um hexdump:

00000000: 0a16 1b22 262e 2f31 3234 6970 717c cdd3  ..."&./124ipq|..
00000010: daee f1f2 ff                             .....

Para ajudar algumas pessoas, aqui está um link para o padrão V extensível


Aqui está a versão original:

ñi241"qp|Ó./ò&
ÚÍîÿ

Experimente online!

A versão legível é:

ñi<C-v>241<esc>"qp|Ó./ò&
ÚÍîÿ

A maneira como isso funciona é incorporando a classificação ao quine extensível padrão. Como eu estava pensando em V-quines por causa dessa resposta, percebi que o quine extensível padrão pode ser reduzido em três bytes, então essa solução poderia ter sido:

ñiéÑ~"qp|Ó./ò&
ÚÍîÿ

Explicação:

ñi<C-v>241<esc>"qp  " Standard V-quine. Everything after this is recorded into register 'q'
                    " so we can do whatever we want without ruining it's "quine-ness"


|       " Go the first character on the line (I just realized now that this is pointless)
 Ó./ò&  " Put every character on a newline
Ú       " Sort every line
 Íî     " Join all lines together
   ÿ    " Necessary for V-quines
DJMcMayhem
fonte
1
cheirar, sinto cheiro de regex fresco
Kritixi Lithos,
3

Idioma não especificado, 254 bytes Rachado por @Dennis!

Duvido que isso ganhe por brevidade, mas será uma dor de cabeça, por isso ainda vale a pena fazer.

Devido a um erro, a ordem 0x0b, 0x0c, 0x0aficou um pouco confusa, mas essa é definitivamente a saída real.

Eu imaginei que não especificaria o idioma apenas para que eu pudesse ver em quais idiomas diferentes isso é possível. Como a saída é principalmente não ASCII, aqui está um hexdump da saída:

00000000: 0102 0304 0506 0708 090b 0c0a 0e0f 1011  ................
00000010: 1213 1415 1617 1819 1a1b 1c1d 1e1f 2021  .............. !
00000020: 2223 2425 2627 2829 2a2b 2c2d 2e2f 3031  "#$%&'()*+,-./01
00000030: 3233 3435 3637 3839 3a3b 3c3d 3e3f 4041  23456789:;<=>?@A
00000040: 4243 4445 4647 4849 4a4b 4c4d 4e4f 5051  BCDEFGHIJKLMNOPQ
00000050: 5253 5455 5657 5859 5a5b 5c5d 5e5f 6061  RSTUVWXYZ[\]^_`a
00000060: 6263 6465 6667 6869 6a6b 6c6d 6e6f 7071  bcdefghijklmnopq
00000070: 7273 7475 7677 7879 7a7b 7c7d 7e7f 8081  rstuvwxyz{|}~...
00000080: 8283 8485 8687 8889 8a8b 8c8d 8e8f 9091  ................
00000090: 9293 9495 9697 9899 9a9b 9c9d 9e9f a0a1  ................
000000a0: a2a3 a4a5 a6a7 a8a9 aaab acad aeaf b0b1  ................
000000b0: b2b3 b4b5 b6b7 b8b9 babb bcbd bebf c0c1  ................
000000c0: c2c3 c4c5 c6c7 c8c9 cacb cccd cecf d0d1  ................
000000d0: d2d3 d4d5 d6d7 d8d9 dadb dcdd dedf e0e1  ................
000000e0: e2e3 e4e5 e6e7 e8e9 eaeb eced eeef f0f1  ................
000000f0: f2f3 f4f5 f6f7 f8f9 fafb fcfd feff       ..............

Esse é todo caractere ASCII, exceto por 0x00e 0x0Dporque ambos causaram um comportamento estranho no TIO. Divirta-se quebrando! >: D


O código original estava em V.

Experimente online

Hexdump:

00000000: ee02 0304 0506 0708 090b 0c0e 0f10 1112  ................
00000010: 1314 1516 1718 191a 1b1c 1d1e 1f20 2122  ............. !"
00000020: 2324 2526 2728 292a 2b2c 2d2e 2f30 3132  #$%&'()*+,-./012
00000030: 3334 3536 3738 393a 3b3c 3d3e 3f40 4142  3456789:;<=>?@AB
00000040: 4344 4546 4748 494a 4b4c 4d4e 4f50 5152  CDEFGHIJKLMNOPQR
00000050: 5455 5657 5859 5a5b 5c5d 5e5f 6061 6263  TUVWXYZ[\]^_`abc
00000060: 6465 6667 6869 6a6b 6c6d 6e6f 7071 7273  defghijklmnopqrs
00000070: 7475 7677 7879 7a7b 7c7d 7e7f 8081 8283  tuvwxyz{|}~.....
00000080: 8485 8687 8889 8a8b 8c8d 8e8f 9091 9293  ................
00000090: 9495 9697 9899 9a9b 9c9d 9e9f a0a1 a2a3  ................
000000a0: a4a5 a6a7 a8a9 aaab adae afb0 b1b2 b3b4  ................
000000b0: b5b6 b7b8 b9ba bbbc bdbe bfc0 c1c2 c3c4  ................
000000c0: c5c6 c7c8 c9ca cbcc cdce cfd0 d1d2 d3d4  ................
000000d0: d5d6 d7d8 d9da dbdc ddde dfe0 e1e2 e3e4  ................
000000e0: e5e6 e7e8 e9ea ebec edef f0f1 f2f3 f4f5  ................
000000f0: f6f7 f8f9 fafb fcfd feff 0a53 ac01       ...........S..

Basicamente, tudo o que é Sjusto insere lixo no buffer. O 0xEEprincípio é apenas para garantir que tudo após a nova linha não ocorra em parte de um loop ou macro. Então nós fazemos

¬<C-a>   "Insert every character in the range 0x01-0xFF
DJMcMayhem
fonte
2
Rachado.
Dennis
2

Oitava , 91 bytes

a=['111111111123666667eeegggkkknnszEEGn};:;:'];
''''''''''(),,,,,-[[[]]]aaaddip;;=ds1010]);
drolex
fonte
Rachado!
matemática viciado em
Não é bem assim ... você recebe um extra '' no final da saída
drolex 6/17/17
Deve ser bom agora
viciado em matemática
É isso. Bem feito!
Drolex 7/03
2

PHP, 130 bytes (Seguro)

    $$$$$$''''(((((((()))))))),,22;;;;;;<<==??\\\\____aaccddeeeeeeeehhhhiiiillllmmoooooopppppppppprrrrrrrrssssssssttttttttttvvvvvv

Solução original

Eu não conseguia entender que não estava rachado

<?php $v=str_split(str_repeat('<?php\ $v=str_split(str_repeat(\'\',2));sort($v);echo\ implode($v);',2));sort($v);echo implode($v);
Jörg Hülsermann
fonte
0

Adivinha, 43 bytes

{4"2)4q):)u(4o'{4t:q(e)(",(t22(u()o)?,?'2e

Foi uma decisão difícil compartilhar ou não o idioma, mas acho que essa opção é melhor. Observe que há uma nova linha à direita.

Bijan
fonte
1
Uma resposta só é segura se você adicionar a solução pretendida à resposta. Até então, essa resposta não é segura.
Mbomb007