Anagram Quines (Cops 'Thread)

26

Ceci est un défi entre . Le fil des voleurs peut être trouvé ici

Votre défi est d'écrire un programme qui génère une anagramme de son code source mais pas le code source original lui-même.

Par exemple, le programme Python suivant,

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

impressions

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

qui a tous les mêmes caractères que sa source d'origine mais dans un ordre différent.

Une fois que vous avez trouvé un tel programme, incluez la sortie du programme comme réponse en omettant le programme qui le génère. Comme vous l'avez peut-être deviné, les voleurs chercheront à découvrir le programme que vous avez caché ou tout programme qui correspond aux spécifications. Votre objectif est de créer le programme le plus court que les voleurs ne puissent pas casser.

Règles

  • Comme avec la plupart des défis des , si votre réponse reste non fissurée pendant une semaine, vous pouvez ajouter la solution prévue à votre réponse et la marquer comme sûre . Une fois en sécurité, les voleurs ne peuvent répondre à une réponse.

  • Vous n'avez pas besoin d'inclure la langue de la solution envisagée, mais si vous n'incluez pas la langue, les voleurs peuvent la craquer dans n'importe quelle langue antérieure au défi, tandis que si vous spécifiez la langue, ils ne peuvent la craquer que dans celle fournie.

  • Les règles standard pour Quines s'appliquent.

Assistant de blé
la source
Ma question habituelle: dans une langue où les octets ne correspondent pas à des caractères, l'anagramme est-il au niveau de l'octet ou du caractère?
@ ais523 ce devrait être une anagramme des octets.
Wheat Wizard
4
Étroitement lié
DJMcMayhem
Les règles de quine habituelles s'appliquent-elles aux voleurs? S'appliquent-ils aux flics?
Dennis
1
@Fatalize S'il ne modifie pas la sortie, c'est bien mais la sortie doit être statique.
Wheat Wizard

Réponses:

12

Brain-Flak , 231 octets fissuré par le blé Assistant

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

Le programme d'origine utilise l' -Aargument.

Voici les chiffres:

( -> 74
) -> 74
{ -> 34
} -> 34
[ -> 7
] -> 7
Riley
la source
Craqué !
Wheat Wizard
5

Python 2, 96 octets, craqué par math_junkie

Sortie:

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

Jouez au golf pour la première fois! J'espère que ce n'est pas trop facile.

Agargara
la source
2
J'ai un misérable print(''), chr() + ''jusqu'à présent
drolex
2
Fissuré!
drogué de mathématiques
4

Haskell, 107 octets, fissuré par nimi

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

Il existe une nouvelle ligne de fin supplémentaire.


Solution originale:


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

Essayez-le en ligne!

Mon idée principale était d'écrire un quine qui trie son propre code source avant de le sortir sans utiliser de sortfonction de bibliothèque . Ce n'est qu'après un premier essai de craquage par nimi que je me suis rendu compte que le code du programme pouvait être trié manuellement, codé en dur dans le programme, puis imprimé en doublant chaque lettre. Cependant, le nombre limité de personnages disponibles rend cette approche plus lourde et le crack réussi de nimi est assez similaire à mon programme d'origine.

Explication:

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
la source
@nimi Oui, c'est un programme complet. N'est-ce pas une règle standard pour les quines?
Laikoni
Pas certain. Nous avions auparavant des quines qui permettaient des fonctions. Et même si les programmes complets sont standard, le "programme" du défi pourrait être interprété comme écrasant les valeurs par défaut et autoriser également les fonctions .
nimi
@nimi Je suis désolé que la version précédente soit trompeuse. Je l'avais écrit après avoir vu votre première tentative et avant de remarquer qu'il n'était pas valide selon les spécifications. Je l'ai même publié, puis j'ai rapidement reculé dans l'espoir que personne ne l'a vu, comme vous pouvez le voir dans l'historique des révisions. Après avoir vu votre version fixe, je suis revenu à cette version, sans considérer que la description ne convenait plus.
Laikoni
Je ne savais pas si vous faisiez référence à ma réponse, c'est pourquoi j'ai supprimé mon commentaire. Il est en effet possible d'utiliser une chaîne pré-triée (à remplacer ;par un NL): i[]d=[d,d];main=print$i[]=<<"$$ ... |||"--et tous les caractères manquants après le --. J'ai trouvé cette version après ma réponse du fil des voleurs et après que vous ayez révélé votre réponse avec l'explication maintenant modifiée.
nimi
4

Langauge non spécifié, 124 octets,

Dans le thème de la réponse de DJMcMayhem, il s'agit des 32 premiers caractères ASCII (à part 0x00 ) imprimés quatre fois chacun. Puisqu'aucun de ceux-ci n'est visible, je n'ai pas inclus le code réel dans ma réponse.

Voici l'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            ............

Voici cependant du Python qui l'imprime (et une nouvelle ligne) si vous le souhaitez:

print"".join(chr(x)*4for x in range(1,32))
Assistant de blé
la source
4

Pyth , 32 octets, fissuré par math_junkie

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

Solution originale

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

Essayez-le en ligne!

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
Barre
la source
Fissuré!
drogué de mathématiques
4

V , 21 octets (sûr!)


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

Notez la nouvelle ligne principale.

Comme cela contient des non imprimables, voici un hexdump:

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

Pour aider les gens, voici un lien vers le quine V extensible standard


Voici la version originale:

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

Essayez-le en ligne!

La version lisible est:

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

La façon dont cela fonctionne consiste à incorporer le tri dans le quine extensible par défaut. En pensant aux V-quines à cause de cette réponse, j'ai réalisé que le quine extensible standard pouvait être raccourci de trois octets, donc cette solution aurait pu être:

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

Explication:

ñ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
la source
1
renifler je sens des regex frais
Kritixi Lithos
3

Langue non spécifiée, 254 octets Cracké par @Dennis!

Je doute que cela gagnera pour la brièveté, mais ce sera pénible à craquer, donc ça vaut quand même le coup.

En raison d'un bug, l'ordre de 0x0b, 0x0c, 0x0as'est un peu mélangé, mais c'est certainement la vraie sortie.

J'ai pensé que je ne spécifierais pas la langue juste pour pouvoir voir dans quelles langues différentes cela est possible. Puisque la sortie est principalement non-ASCII, voici un hexdump de la sortie:

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

C'est chaque caractère ASCII à l'exception de 0x00et 0x0Dparce qu'ils ont tous deux causé un comportement étrange sur TIO. Amusez-vous à craquer! >: D


Le code d'origine était en V.

Essayez-le en ligne

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

Fondamentalement, tout ce qui Svient d'insérer les ordures dans le tampon. Le 0xEEdébut est juste pour s'assurer que tout ce qui se passe après la nouvelle ligne ne se passe pas dans une boucle ou une macro. Ensuite, nous faisons

¬<C-a>   "Insert every character in the range 0x01-0xFF
DJMcMayhem
la source
2
Fissuré.
Dennis
2

Octave , 91 octets

a=['111111111123666667eeegggkkknnszEEGn};:;:'];
''''''''''(),,,,,-[[[]]]aaaddip;;=ds1010]);
drolex
la source
Fissuré!
junkie de mathématiques
Pas tout à fait ... vous obtenez un extra '' à la fin de la sortie
drolex
Ça devrait être bon maintenant
junkie de mathématiques
Ça y est. Bien joué!
drolex
2

PHP, 130 octets (sûr)

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

Solution originale

Je ne pouvais pas comprendre que ce n'était pas fissuré

<?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
la source
0

Devinez, 43 octets

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

C'était un appel difficile de partager ou non de quelle langue il s'agissait, mais je pense que cette option est meilleure. Notez qu'il y a une nouvelle ligne de fin.

Bijan
la source
1
Une réponse n'est sûre que si vous ajoutez la solution prévue à la réponse. Jusque-là, cette réponse n'est pas sûre.
mbomb007