Em esta pergunta eu perguntei-lhe para adivinhar uma Quine anagrama baseado em sua saída. No entanto, parece que ainda não temos uma pergunta sobre o golfe de um anagrama. Portanto, sua tarefa será fazer o menor quine de anagramas possível.

O que é um anagrama quine?

Um anagrama quine é um programa não vazio que imprime um anagrama de seu código fonte, além da fonte original.

Aqui está um exemplo de um anagrama quine no Python 2:

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

Você não deve ler sua própria fonte para esse desafio.

Pitão , 2 bytes

)(

Saídas

()

Experimente online!

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

V , 4 bytes

2ii2

Saídas:

i2i2

Experimente online!

> <> , 9 8 7 bytes

Com 1 byte de golfe, graças ao @WheatWizard, usando-o !e incrementando-o para obter"

Golpeou 1 byte graças a @ ConorO'Brien usando em #vez de<!

":1->o#

Experimente online!

Saídas "#o>-1:.

Explicação

":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 bytes

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

Experimente online!

Pode não ser a versão mais curta, mas pelo menos funciona.

Curiosamente , o código de saída pode realmente ser executado (e termina).

Saída

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

Explicação

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

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

Python 3, 32 bytes

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

Imprime p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, saída classificada:\n""""""""""""(())**22iinnpprrtt

Ruby , 8 bytes

p"p*2"*2

Experimente online!

Isso imprime

"p*2p*2"

Explicação

Isso funciona de maneira semelhante à resposta python na pergunta. Ele fará a string e, em p*2p*2seguida, usar Ruby pimprimirá a representação da string.

JavaScript (ES6), 40 32 bytes

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

Não há brincadeira com Function.toString também. Como um bônus, o código dentro da string parece legal. Editar: salvou 8 bytes usando em +vez de repeat(2).

Klein , 7 + 6 = 13 bytes

Aqui está uma resposta com base na resposta > <> .

":1+@!

Experimente online!

Isso gera

:1+@!"

Japonês , 10 9 bytes

Encontrou uma maneira melhor :-)

Q+2ç"Q+2ç

Saídas "Q+2çQ+2ç. Teste online!

Explicação

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

Também pode ser Qi2ç"Qi2ç, que imprime Qi2çQi2ç". Este é mais próximo do padrão japonês Japt:

"iQ ²"iQ ²

Mas não acredito que exista uma maneira fácil de colocar as aspas no meio da sequência de caracteres para um quine de 9 bytes.

Ruby, 20 bytes

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

Isso gera

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

Aproveitando a %q(...)sintaxe de string do Ruby , que suporta parênteses aninhados.

Retina , 8 bytes

_

$nn$

Experimente online!

Impressões

n$_
n$

Ambos contêm um _, dois n, dois $e três feeds de linha.

Observe que um avanço de linha seguido por quase qualquer outro caractere é uma solução trivial, mas é questionável se é válido, porque o segundo caractere apenas se codifica e o avanço de linha realmente não codifica nenhum caractere de saída.

Explicação

_

Substitua a entrada vazia por a _.

$nn$

Combine uma sequência vazia, o que acontece antes ou depois do _e insira um avanço de linha ( $n), um ne um $. Desde que nós inserido pela primeira vez que _, este adiciona cada um desses personagens, duas vezes, de modo que o ne $conta para o $n, e nós temos dois dos três linefeeds que precisamos na saída. O terceiro avanço de linha é impresso porque o Retina imprime um avanço de linha à direita por padrão.

Também poderíamos usar n$n$nesta etapa, que imprimiria:

n
$_n
$

Repl de Python, 4 bytes

Esta é a minha primeira solução Code Golf, por isso espero que cumpra as regras. No interpretador interativo Python 2 ou 3:

>>> (1),
(1,)

A saída é um anagrama da entrada.

Outro:

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

No Python 2:

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

No Python 3:

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

Atualização 15/06/2017: Mais uma:

>>> 01.
1.0

Haskell , 38 39 bytes

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

Experimente online! Saída:

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

Edit: +1 byte porque eu esqueci anteriormente a nova linha implícita à direita de print.

Alternativa: (mesma contagem de bytes, mas não contém coruja ASCII)

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

Experimente online!

Saída:

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

Groovy, 24 20 bytes

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

-4 graças ao CalculatorFeline, o espaço em branco não era necessário, afinal!

Saída:

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

Explicação:

Fechamento anônimo que, quando chamado, retorna {""*""2""}duas vezes (concatenado).

05AB1E , 10 bytes

'∞∞''∞'JJ∞

Experimente online!

Saída:

∞∞''JJ''∞∞

Explicação:

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 bytes

"_`"_`

Experimente online!

Impressões

_`"_`"

Explicação

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

Bash, 36 bytes

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

Isso gera

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

(e cria o arquivo fcomo um efeito colateral, mas isso é permitido por meta .)

O programa e a saída têm uma nova linha à direita.

Processo do pensamento: achei que a maneira mais fácil de gerar uma string duas vezes, além de atribuí-la a uma variável, era

tee f<<<string
cat f

A string precisa ser citada porque conterá espaços e <caracteres, então eu tive

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

que quase funciona, exceto que não gera as aspas. Felizmente, o Bash suporta concatenação literal de cadeia de caracteres, simplesmente colocando-as próximas uma da outra, de modo que anexar "''"ao herestring e inserir ""dentro da parte de aspas simples produz essa solução.

PHP , 44 bytes

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

Experimente online!

CJam , 8 bytes

"2*`"2*`

Experimente online!

Explicação

Semelhante ao exemplo Python na pergunta

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

A saída é "2*`2*`".

Anterior, 11 bytes

' 2+">:#,_@

Impressões:

+2 '@_,#:>"

Explicação:

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

QBIC , 8 bytes

?A+@?A@+

Eu só descobri como fazer uma Quine adequada em QBIC. Para criar um anagrama, basta alternar entre os caracteres na string literal. Existem 24 anagramas possíveis dessa maneira.

Befunge-98 , 8 bytes

"'$<@,k7

Experimente online!

Ohm , 14 bytes

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

Experimente online!

Saída:

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

Explicação

"æ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 bytes

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

Saídas:

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

Snippet:

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

console.log(f());

Fissão 2 , 9 8 6 bytes

R"'!+O

Experimente online!

Explicação

Um átomo é criado em R, que se move para a direita. Esse átomo se depara com a ", que inicia o modo de impressão. No modo de impressão, todos os caracteres (até a correspondência ") são impressos. Isso significa que ele é impresso '!+ORneste caso. Depois, tudo o que resta é imprimir ", o que é feito pelos caracteres restantes. '!define a massa do átomo para o código de caractere de !e a +incrementa para o código de caractere de ". Em seguida, o código do caractere é gerado porO e o átomo é destruído, finalizando o programa.

(Na verdade, isso é apenas uma rotação do quine mais curto)

Mathematica, 2 bytes

.0

Saída:

0.

Um número começando com um ponto decimal, como .123é interpretado como 0.123, então .0é interpretado como 0.0. Como a parte do número após o ponto decimal é zero, o Mathematica não o imprime.

JavaScript (mais um), 11 bytes

f=_=>'=f'+f

Chamado com f(), saídas

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 bytes

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

Stax , 8 4 bytes

.S.S

Execute e depure online!

Uma porta direta desta resposta .

Versão antiga, 8 bytes

..b..LbL

Execute e depure online!

Versão alternativa com um truque bastante barato que pode ser aplicado a quines adequados em quase qualquer idioma.

"43bL"34bL

Execute e depure online!

Porque "34bL"34bLé uma solução adequada em Stax.

Ainda outra versão, usando apenas literais de cadeia de caracteres simples.

''c'Lc'cccLcLL

Execute e depure online!

Explicação

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

"34çJ∞"34çJ∞

Saídas:

34çJ∞""∞Jç43

Experimente 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