Sappiamo tutti cos'è un quine . Un quine invertito è un programma non vuoto che stampa l'inverso del suo codice sorgente senza leggere il suo codice sorgente ed è costituito esclusivamente da caratteri ASCII stampabili (spazio attraverso ~).

Qui, "inverso del codice sorgente" significa quanto segue: l'output del programma deve contenere ogni carattere ASCII stampabile (m - c) volte, dove c è il numero di volte in cui detto carattere si presenta nel codice e m è il massimo numero di volte che un carattere viene ripetuto nel tuo codice.

(In altre parole: il tuo codice + il tuo output = permutazione di m volte tutto stampabile-ASCII.)

Ad esempio, se il tuo programma è 12345, allora m = 1 e dovresti emettere qualsiasi permutazione di questa stringa:

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

Se il tuo programma è AAB, allora m = 2 e dovresti emettere qualsiasi permutazione di:

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

Nota come ci sono due As mancanti e una mancante B.

Sebbene un programma che contenga tutti i caratteri ASCII stampabili e non produca nulla sia un valore inverso valido (soddisfacente m = 1 ), tale risposta non sarebbe molto competitiva, data la sua lunghezza.

Devi scrivere un programma invertito, come descritto nel paragrafo precedente. Poiché si tratta di code-golf , vincerà il programma più breve in byte. In bocca al lupo!

Brain-Flak , 221 207 byte

Include +1 per -A

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

Provalo online!

# 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 byte

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

Provalo online!

stampe

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

Spiegazione

L'obiettivo era modificare il quine standard

{"_~"}_~

tale che nessun carattere viene ripetuto nel programma. La ragione di ciò è che CJam ha un operatore diverso impostato che possiamo usare per rimuovere caratteri dall'intervallo ASCII stampabile, ma non tiene conto del numero di occorrenze. L'implementazione a mano sarebbe probabilmente più lunga, quindi dovevo assicurarmi che ogni personaggio apparisse una sola volta e non dovessimo preoccuparci di eventi.

{      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 byte

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

Provalo online!

Stampe -0.375 False.

05AB1E , 95 61 60 byte (non 58 b / c non mi piace quello)

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

Provalo online!

Vecchia risposta invalidata da "solo caratteri ASCII", molti comandi non sono validi qui.

Stampa abcdefghijklmnopqrstuvwxyz012345678una volta in quanto non ci sono caratteri duplicati.

Versione BCDEFGHIKMNOPQRSTUVWXYZrimossa:

Lavori in corso ... Penso che ~ 60 byte sia basso quanto si ottiene senza caratteri non ASCII in 05AB1E ..

05AB1E , 58 byte

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

Provalo online!

Stampa l'output x12 a causa dei caratteri ripetuti:

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

Inoltre non termina in modo corretto, lavorando su quello ora ...

Sono state rimosse vecchie risposte non valide (dovute a caratteri non ASCII), consultare la cronologia delle modifiche.

Java 8, 106 99 190 byte

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

Javascript (ES6), 103 101 byte

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

Vecchia soluzione (103 byte usando alert)

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

Vecchia soluzione (non valida) (96 byte)

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