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.

code-golf quine permutations

— Assistente de Trigo
fonte

2

@LeakyNun Não, não pode ser um problema.

— Wheat Wizard

2

O código emitido precisa ser um programa válido?

— MD XF

11

@MDXF Não, não.

— Wheat Wizard

2

@Okx Ele deve seguir nossos requisitos padrão para um quine (que não seja um quine).

— Wheat Wizard

11

@LeakyNun Lembre-se, eu não acho que os programas de 0 byte tenham anagramas que diferem dos originais!

— 911 Neil

29

Pitão , 2 bytes

)(

Saídas

()

Experimente online!

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

— Cajado
fonte

3

Isso significa que você descobriu que ()é um quine muito mais curto que o bem conhecido jN*2]"jN*2] ?

— Jim

11

@ Jim não, porque isso não é capaz de carga útil: c

— Rod

9

V , 4 bytes

2ii2

Saídas:

i2i2

Experimente online!

— Riley
fonte

2x inserir i2?

— CalculatorFeline

11

Sim. 2 -> do the next thing twice i -> insert the following

— Riley

Ah, entendi, pensei que fosse o Vim.

— Wheat Wizard

@WheatWizard Não, esta é uma modificação trivial do padrão V quine.

— Riley

11

@isaacg: não, no Vim, você precisará pressionar ESC quando terminar, o que é um problema, porque não há caractere ESC na saída.

9

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

— Kritixi Lithos
fonte

":1+>o<!é um pouco mais curto.

— Wheat Wizard

Graças @WheatWizard, que era um campo de golfe puro :)

— Kritixi Lithos

11

Você pode obter 7 bytes:":1->o#

— Conor O'Brien

@ ConorO'Brien Obrigado pela dica, isso é realmente inteligente.

— Kritixi Lithos

Obrigado :) Eu estou agradavelmente surpreendido que ele funciona melhor aqui do que na Quine real

— Conor O'Brien

9

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.

— 6infinity8
fonte

8

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

— CalculatorFeline
fonte

Opa, versão antiga :(

— CalculatorFeline

11

@Downvoter Por favor, cancele a votação.

— CalculatorFeline

7

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.

— Assistente de Trigo
fonte

Você pode usar em pvez de puts?! Tanto tempo perdido ...

— Magic Octopus Urn

4

@carusocomputing Não é exatamente a mesma coisa que coloca. p xé equivalente aputs x.inspect

— Conor O'Brien

6

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

— Neil
fonte

11

Por que não usar em *2vez de .repeat(2), isso não funciona?

— Magic Octopus Urn

11

@carusocomputing JavaScript não sobrecarregar *para cordas

— Conor O'Brien

11

@carusocomputing Isso me deu uma ideia, obrigado!

— 911 Neil

4

Klein , 7 + 6 = 13 bytes

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

":1+@!

Experimente online!

Isso gera

:1+@!"

— Assistente de Trigo
fonte

4

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.

— ETHproductions
fonte

Outro 10-byter:Q+"+Q² " ²

— Conor O'Brien

@ ConorO'Brien Sim, e você sempre pode organizar os 4 caracteres dentro da string em cada uma das 24 permutações possíveis. Além disso, acredito que você sempre pode substituir os dois espaços por novas linhas

— ETHproductions

3

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.

— Maçaneta da porta
fonte

3

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
$

— Martin Ender
fonte

3

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

— Coronel Panic
fonte

11

Acho que a última resposta aqui viola as regras do quine (todos os caracteres na saída servem ao mesmo propósito que o caractere correspondente na entrada). Os outros estão bem, no entanto.

2

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="

— Laikoni
fonte

Basta apenas um Quine anagrama em vez de um verdadeiro Quine ....

— Feathercrown

2

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

— Urna de polvo mágico
fonte

11

Explicação, por favor. Além disso, bytes pode (provavelmente) ser salvo usando o *2como preenchimento entre aspas:{"""{""*""2""}"""*2}

— CalculatorFeline

@CalculatorFeline é bastante auto-explicativo. Mas sim, essa é uma ideia <s> 100% </s> 9% melhor do que a minha.

— Magic Octopus Urn

3

Na verdade, é apenas 9% melhor: P

— Calculadora #

2

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''∞∞

— Urna de polvo mágico
fonte

2

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.

— Martin Ender
fonte

Eu estava prestes a postar isso ... "` _" _` também funciona

— Luis Mendo

1

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.

— Maçaneta da porta
fonte

1

PHP , 44 bytes

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

Experimente online!

— Jörg Hülsermann
fonte

1

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*`".

— Gato de negócios
fonte

1

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

— MegaTom
fonte

Sim. mas o mesmo acontece ". Qual é a restrição sobre isso exatamente?

— MegaTom 7/06

Eu não acho que isso "seja considerado leitura da própria fonte, é apenas uma string literal. gno entanto, é flagrantemente lendo sua própria fonte.

— Wheat Wizard

@WheatWizard okay. Eu mudarei isso.

— MegaTom 7/06

":1+>:#,_@!também funciona, mas não é mais curto.

— Assistente de trigo

' 2+"8k,@para 9 bytes

— ovs

1

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.

— steenbergh
fonte

1

Befunge-98 , 8 bytes

"'$<@,k7

Experimente online!

— ovs
fonte

1

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

— Datboi
fonte

1

JavaScript (ES6), 15 bytes

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

Saídas:

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

Snippet:

Mostrar snippet de código

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

console.log(f());

Expandir snippet

— Rick Hitchcock
fonte

1

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)

— Luke
fonte

Eu acredito que você pode simplesmente usar o quine padrão e alterá-lo ciclicamente (para algo como R"'!+Onão testado).

— Martin Ender

@ MartinEnder: você está certo. Atualizada. Obrigado por ajudar.

— Luke

1

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.

— Ben
fonte

11

Eu não acho que isso seja válido. Nossa definição de site exige que os quines tenham um "codificador" e um "decodificador", isso proíbe literalmente o tipo quines.

— Wheat Wizard

Todas as regras para quines seguem para esse desafio.

— Assistente de trigo

@ WheatWizard: O .codifica em si, mas não acho que 0sim? Um 0 além do ponto decimal não pode ser considerado como um zero inicial antes do ponto decimal; este é um efeito colateral da impressão de um flutuador. Portanto, sob as antigas regras do quine, não há problema aqui. (Eu não tenho certeza se as novas regras entraram em vigor ainda.)

@ ais523 não sei. Talvez isso deva ser resolvido por uma meta questão.

— Assistente de trigo

1

JavaScript (mais um), 11 bytes

f=_=>'=f'+f

Chamado com f(), saídas

=f_=>'=f'+f

Mostrar snippet de código

f=_=>'=f'+f

console.log(f());

Expandir snippet

— GOTO 0
fonte

1

Python 3, 31 bytes

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

— aaay aaay
fonte

1

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.

— Weijun Zhou
fonte

0

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

— Riley
fonte

Golf anagram Quine

O que é um anagrama quine?

Pitão , 2 bytes

V , 4 bytes

> <> , 9 8 7 bytes

Explicação

Brainfuck, 158 bytes

Saída

Explicação

Python 3, 32 bytes

Ruby , 8 bytes

Explicação

JavaScript (ES6), 40 32 bytes

Klein , 7 + 6 = 13 bytes

Japonês , 10 9 bytes

Explicação

Ruby, 20 bytes

Retina , 8 bytes

Explicação

Repl de Python, 4 bytes

Haskell , 38 39 bytes

Groovy, 24 20 bytes

Saída:

Explicação:

05AB1E , 10 bytes

Saída:

Explicação:

CJam , 6 bytes

Explicação

Bash, 36 bytes

PHP , 44 bytes

CJam , 8 bytes

Explicação

Anterior, 11 bytes

QBIC , 8 bytes

Befunge-98 , 8 bytes

Ohm , 14 bytes

Explicação

JavaScript (ES6), 15 bytes

Fissão 2 , 9 8 6 bytes

Explicação

Mathematica, 2 bytes

JavaScript (mais um), 11 bytes

Stax , 8 4 bytes

Explicação

05AB1E , 13 bytes