In questa domanda ti ho chiesto di indovinare un quino di anagrammi in base al suo output. Tuttavia sembra che non abbiamo ancora una domanda che chiede di giocare a golf con un quinto di anagrammi. Quindi il tuo compito sarà quello di rendere il quino anagramma più breve che puoi.

Cos'è un anagram quine?

Un anagram quine è un programma non vuoto che stampa un anagramma del suo codice sorgente, diverso dalla sua fonte originale.

Ecco un esempio di un anagramma in Python 2:

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

Non dovresti leggere la tua fonte per questa sfida.

Pyth , 2 byte

)(

Uscite

()

Provalo online!

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

V , 4 byte

2ii2

Uscite:

i2i2

Provalo online!

> <> , 9 8 7 byte

Golfato 1 byte grazie a @WheatWizard usando !e incrementandolo per ottenere"

Golfato 1 byte grazie a @ ConorO'Brien usando #invece di<!

":1->o#

Provalo online!

Uscite "#o>-1:.

Spiegazione

":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

Brainfuck, 158 byte

>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++

Provalo online!

Potrebbe non essere la versione più breve, ma almeno funziona.

Fatto curioso , il codice di output può essere effettivamente eseguito (e termina).

Produzione

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]

Spiegazione

>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

Python 3, 32 byte

stampare ( "" "p" r "i" n "t" 2 ( ") *" "" * 2)

Stampe p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, output ordinato:\n""""""""""""(())**22iinnpprrtt

Rubino , 8 byte

p"p*2"*2

Provalo online!

Questo stampa

"p*2p*2"

Spiegazione

Funziona in modo simile alla risposta Python nella domanda. Farà la stringa p*2p*2quindi usando Ruby pstamperà la rappresentazione della stringa.

JavaScript (ES6), 40 32 byte

f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

Niente scherzi con Function.toString. Come bonus, il codice all'interno della stringa sembra quasi legale. Modifica: salvato 8 byte utilizzando +invece di repeat(2).

Klein , 7 + 6 = 13 byte

Ecco una risposta basata sulla risposta > <> .

":1+@!

Provalo online!

Questo produce

:1+@!"

Japt , 10 9 byte

Trovato un modo migliore :-)

Q+2ç"Q+2ç

Uscite "Q+2çQ+2ç. Provalo online!

Spiegazione

Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

Potrebbe anche essere Qi2ç"Qi2ç, che stampa Qi2çQi2ç". Questo è più vicino allo standard Japt Quine:

"iQ ²"iQ ²

Ma non credo che ci sia un modo semplice per bloccare le virgolette nel mezzo della stringa per un quine a 9 byte.

Rubino, 20 byte

$><<%q($><<%q()*2)*2

Questo produce

$><<%q()*2$><<%q()*2

Sfruttando la %q(...)sintassi delle stringhe di Ruby , che supporta le parentesi nidificate.

Retina , 8 byte

_

$nn$

Provalo online!

stampe

n$_
n$

Entrambi contengono uno _, due n, due $e tre avanzamenti di riga.

Si noti che un avanzamento di riga seguito da quasi tutti gli altri caratteri è una soluzione banale, ma è discutibile se sia valido, poiché il secondo carattere codifica solo se stesso e l'alimentatore di linea non codifica in realtà nessuno dei due caratteri di output.

Spiegazione

_

Sostituire l'ingresso vuoto con a _.

$nn$

Corrisponde a una stringa vuota, che si verifica sia prima che dopo _e inserire un avanzamento riga ( $n), an ne a $. Da quando lo abbiamo inserito per la prima volta _, questo aggiunge ciascuno di quei caratteri due volte, quindi il simbolo ne $rappresenta il $n, e otteniamo due dei tre avanzamenti di riga di cui abbiamo bisogno nell'output. Il terzo avanzamento riga viene stampato perché Retina stampa un avanzamento riga predefinito per impostazione predefinita.

Potremmo anche usare n$n$in questa fase, che poi stamperebbe:

n
$_n
$

Python Repl, 4 byte

Questa è la mia prima soluzione Code Golf, quindi spero che soddisfi le regole. Nell'interprete interattivo Python 2 o 3:

>>> (1),
(1,)

L'output è un anagramma dell'input.

Un altro:

>>> 2*'2*'
'2*2*'

In Python 2:

>>> type('rst <>'),
(<type 'str'>,)

In Python 3:

>> {1, 0}
{0, 1}

Aggiornamento 15/06/2017: Ancora un altro:

>>> 01.
1.0

Haskell , 38 39 byte

main=print$[0,0]>>"main=print$[0,0]>>"

Provalo online! Produzione:

"main=print$[0,0]>>main=print$[0,0]>>"

Modifica: +1 byte perché in precedenza avevo dimenticato la nuova riga implicita di print.

Alternativa: (stesso conteggio byte ma non contiene gufo ASCII)

main=print$e++e;e="main=print$e++e;e="

Provalo online!

Produzione:

"main=print$e++e;e=main=print$e++e;e="

Groovy, 24 20 byte

{"""{""*""2""}"""*2}

-4 grazie a CalculatorFeline, lo spazio bianco non era necessario dopo tutto!

Produzione:

{""*""2""}{""*""2""}

Spiegazione:

Chiusura anonima che, quando viene chiamata, ritorna {""*""2""}due volte (concatenata).

05AB1E , 10 byte

'∞∞''∞'JJ∞

Provalo online!

Produzione:

∞∞''JJ''∞∞

Spiegazione:

Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

CJam , 6 byte

"_`"_`

Provalo online!

stampe

_`"_`"

Spiegazione

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

Bash, 36 byte

tee f<<<'tee f<<<""cat f'"''"
cat f

Questo produce

tee f<<<""cat f''
tee f<<<""cat f''

(e crea il file fcome effetto collaterale, ma è consentito per meta .)

Sia il programma che l'output hanno una nuova riga finale.

Processo di pensiero: ho pensato che il modo più semplice di produrre una stringa due volte, oltre a assegnarlo a una variabile, fosse fare

tee f<<<string
cat f

La stringa deve essere citata perché conterrà spazi e <caratteri, quindi l'ho fatto

tee f<<<'tee f<<<cat f'
cat f

che quasi funziona, tranne per il fatto che non genera le virgolette. Fortunatamente, Bash supporta la concatenazione letterale di stringhe semplicemente posizionandole una accanto all'altra, quindi "''"accodare l'estrazione e l'inserimento ""all'interno della singola parte di citazione produce questa soluzione.

PHP , 44 byte

<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

Provalo online!

CJam , 8 byte

"2*`"2*`

Provalo online!

Spiegazione

Simile all'esempio di Python nella domanda

"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

L'output è "2*`2*`".

Befunge, 11 byte

' 2+">:#,_@

stampe:

+2 '@_,#:>"

Spiegazione:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

QBIC , 8 byte

?A+@?A@+

Ho appena capito come fare un quine corretto in QBIC. La creazione di un anagramma è fatta semplicemente cambiando letteralmente i caratteri nella stringa. Ci sono 24 possibili anagrammi in questo modo.

Befunge-98 , 8 byte

"'$<@,k7

Provalo online!

Ohm , 14 byte

"æ3M.Cæ"æ3M."C

Provalo online!

Produzione:

æ3M.CæC.M3æ"""

Spiegazione

"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

JavaScript (ES6), 15 byte

f=(s='f=')=>f+s

Uscite:

(s='f=')=>f+sf= 

Frammento:

f=(s='f=')=>f+s

console.log(f());

Fissione 2 , 9 8 6 byte

R"'!+O

Provalo online!

Spiegazione

Viene creato un atomo Rche si sposta a destra. Questo atomo si imbatte quindi in a ", che avvia la modalità di stampa. In modalità stampa, "vengono stampati tutti i caratteri (fino alla corrispondenza ). Ciò significa che '!+ORin questo caso stampa . Quindi, tutto ciò che rimane è la stampa" , che viene eseguita dai caratteri rimanenti. '!imposta la massa dell'atomo sul codice carattere di !e la +incrementa sul codice carattere di ". Quindi, il codice carattere viene emesso da Oe l'atomo viene distrutto, terminando il programma.

(In realtà, questa è solo una rotazione del quino più corto)

Mathematica, 2 byte

.0

Produzione:

0.

Un numero che inizia con un punto decimale come .123viene interpretato come 0.123, quindi .0viene interpretato come 0.0. Poiché la parte del numero dopo il punto decimale è zero, Mathematica non lo stampa.

JavaScript (ancora un altro), 11 byte

f=_=>'=f'+f

Chiamato con f(), uscite

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 byte

a='a=%r;pritn(a%%a)';print(a%a)

Stax , 8 4 byte

.S.S

Esegui ed esegui il debug online!

Una porta diretta di questa risposta .

Vecchia versione, 8 byte

..b..LbL

Esegui ed esegui il debug online!

Versione alternativa con un trucco piuttosto economico che può essere applicato a quines appropriate in quasi tutte le lingue.

"43bL"34bL

Esegui ed esegui il debug online!

Perché "34bL"34bLè una vera quina in Stax.

Ancora un'altra versione, usando solo letterali di stringa a carattere singolo.

''c'Lc'cccLcLL

Esegui ed esegui il debug online!

Spiegazione

.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

05AB1E , 13 byte

"34çJ∞"34çJ∞

Uscite:

34çJ∞""∞Jç43

Provalo online!

"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline