Nous savons tous ce qu'est un quine . Un quine inversé est un programme non vide qui imprime l'inverse de son code source sans lire son code source, et se compose uniquement de caractères ASCII imprimables (espace à travers ~).

Ici, «inverse du code source» signifie ce qui suit: la sortie de votre programme doit contenir chaque caractère ASCII imprimable (m - c) fois, où c est le nombre de fois que ce caractère apparaît dans votre code, et m est le maximum nombre de fois qu'un caractère est répété dans votre code.

(En d'autres termes: votre code + votre sortie = permutation de m fois tout en ASCII imprimable.)

Par exemple, si votre programme est 12345, alors m = 1 , et vous devez sortir toute permutation de cette chaîne:

 !"#$%&'()*+,-./06789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Si votre programme est AAB, alors m = 2 , et vous devez sortir toute permutation de:

  !!""##$$%%&&''(())**++,,--..//00112233445566778899::;;<<==>>??@@BCCDDEEFFGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYYZZ[[\\]]^^__``aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~

Notez qu'il y a deux As manquants et un manquant B.

Bien qu'un programme qui contient tous les caractères ASCII imprimables et ne produise rien ne soit un quine inverse valide (satisfaisant m = 1 ), une telle réponse ne serait pas très compétitive, étant donné sa longueur.

Vous devez écrire un programme qui est un quine inversé, comme décrit dans le paragraphe ci-dessus. Comme il s'agit de code-golf , le programme le plus court en octets gagnera. Bonne chance!

Brain-Flak , 221 207 octets

Comprend +1 pour -A

(((((((()()()()){}){}()){}){})()){}{}){({}[()]<((((((()()()()){}){}){})<>[()()()])[()])((((()()()){})){}{})<>((()()()()){}){({}[()]<(({})())>)}{}({}()())<>{{({}<>[()]<(({})())><>)}{}<>(({}())()())<>}<>>)}{}

Essayez-le en ligne!

# Push 206 (the number of times to duplicate the output)
(((((((()()()()){}){}()){}){})()){}{})

# For 0 to 206
{({}[()]<

    # Push 32 on this stack and 18, 28 and 29 to the other
    # 18, 28 and 29 are the distances between the sets of braces 
    ((((((()()()()){}){}){})<>[()()()])[()])((((()()()){})){}{})<>

    # For 0 to 8
    ((()()()()){}){({}[()]<

        # Push TOS, TOS + 1
        (({})())

    # end For 0 to 8
    >)}{}

    # Push TOS + 2 
    # skips '(' and ')'
    ({}()())

    # For each value on the off stack (18, 28, 28)
    <>{

        # For 0 to that number
        {({}<>[()]<

            # Push TOS, TOS + 1
            (({})())

        # End for 0 to that number
        ><>)}{}

        # Push TOS + 1, TOS + 3 (skips this set of braces)
        <>(({}())()())<>

    # End for each value on the off stack (18, 28, 28)
    }<>

 # End for 0 to 206
 >)}{}

CJam , 17 octets

{s95c+'|,32>\-}_~

Essayez-le en ligne!

Impressions

 !"#$%&()*./014678:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^`abdefghijklmnopqrtuvwxyz

Explication

Le but était de modifier le quine standard

{"_~"}_~

de sorte qu'aucun caractère ne soit répété dans le programme. La raison en est que CJam a un opérateur différent défini que nous pouvons utiliser pour supprimer des caractères de la plage ASCII imprimable, mais il ne prend pas en compte le nombre d'occurrences. L'implémentation manuelle serait probablement plus longue, donc je devais m'assurer que chaque personnage n'apparaît qu'une seule fois et nous n'avons pas à nous soucier des occurrences.

{      e# Quine framework. Executes the block while leaving another copy of the
       e# block on the stack.
  s    e#   Stringify the block, giving us "{s95c+'|,32>\-}".
  95c  e#   Convert 95 to a character, which gives us '_' without repeating
       e#   it in the source code.
  +    e#   Append it to the string. We don't need to worry about '~', we'll just
       e#   leave it out of the printable ASCII range to begin with.
  '|,  e#   Get a character range from the null byte up to '{'. This omits "|}~",
       e#   but those are in the program anyway, it doesn't matter.
  32>  e#   Discard the unprintable characters.
  \-   e#   Subtract the source string from the printable ASCII range.
}_~

Python 3 , 83 octets

print(~2/8,6>9)#!"$%&'*+14:;<=?@ABCDEGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdfghjkmoquvwxyz{|}

Essayez-le en ligne!

Impressions -0.375 False.

05AB1E , 95 61 60 octets (pas 58 b / c je n'aime pas celui-là)

A?9L<J, !"'#$%&()*+-./:;=>@BCDEFGHIKMNOPQRSTUVWXYZ[\]^_`{|}~

Essayez-le en ligne!

Ancienne réponse invalidée par des "caractères ASCII uniquement", de nombreuses commandes ne sont pas valides ici.

Il s'imprime abcdefghijklmnopqrstuvwxyz012345678une fois car il n'y a pas de caractères en double.

Version avec BCDEFGHIKMNOPQRSTUVWXYZsupprimé:

Travail en cours ... Je pense que ~ 60 octets est aussi bas que possible sans caractères non ASCII dans 05AB1E ..

05AB1E , 58 octets

T5+FA'uK?Au"ADLJFKST"SK?9L<5KJ?} !#$%&()*>-./:;=@[]^_`{|~\

Essayez-le en ligne!

Imprime la sortie x12 en raison des caractères répétés:

['""', '55', '???', 'AAA', 'FF', 'JJ', 'KKKK', 'LL', 'SS', 'TT', 'uu']

Il ne se termine pas non plus correctement, y travaillant maintenant ...

Les anciennes réponses non valides (en raison de caractères non ASCII) ont été supprimées, voir l'historique des modifications.

Java 8, 106 99 190 octets

class i {/*{}!"#$%&'()+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefghjkmnopqrtuvwxyz|~!"#$%&'()+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`claibdefghjkmnopqrtuvwxyz|~*/}

Javascript (ES6), 103 101 octets

_=>` !"#$%&'()*+,-.0123456789:;<?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^abcdefghijklmnopqrstuvwxyz{|}~`//_=>\\

Ancienne solution (103 octets en utilisant alert)

alert;;alert`\ \!"#$%&'()*+,-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_bcdfghijkmnopqsuvwxyz{|}~`

Ancienne solution (non valide) (96 octets)

alert()// !"#$%&'*+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdfghijkmnopqsuvwxyz{|}~