W tym pytaniu poprosiłem cię o odgadnięcie quinu anagramowego na podstawie jego wyników. Wygląda jednak na to, że nie mamy jeszcze pytania, aby zagrać w golfa na anagramie. Twoim zadaniem będzie stworzenie możliwie najkrótszego quine'a z anagramami.

Co to jest anagram quine?

Anagram quine to niepusty program, który drukuje anagram swojego kodu źródłowego, inny niż oryginalne źródło.

Oto przykład quinu anagramowego w Pythonie 2:

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

Nie powinieneś czytać własnego źródła tego wyzwania.

Pyth , 2 bajty

)(

Wyjścia

()

Wypróbuj online!

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

V , 4 bajty

2ii2

Wyjścia:

i2i2

Wypróbuj online!

> <> , 9 8 7 bajtów

Grał w golfa 1 bajt dzięki @WheatWizard za pomocą ! i zwiększając go, aby uzyskać"

Grał w golfa 1 bajt dzięki @ ConorO'Brien, używając #zamiast<!

":1->o#

Wypróbuj online!

Wyjścia "#o>-1: .

Wyjaśnienie

":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 bajtów

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

Wypróbuj online!

To może nie być najkrótsza wersja, ale przynajmniej działa.

Ciekawostką jest , że kod wyjściowy może być faktycznie wykonany (i się kończy).

Wydajność

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

Wyjaśnienie

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

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

Python 3, 32 bajty

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

Wydruki p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, posortowane dane wyjściowe:\n""""""""""""(())**22iinnpprrtt

Rubinowy , 8 bajtów

p"p*2"*2

Wypróbuj online!

To drukuje

"p*2p*2"

Wyjaśnienie

Działa to podobnie do odpowiedzi na python w pytaniu. Spowoduje to utworzenie ciągu, p*2p*2a następnie użycie ruby pwydrukuje reprezentację ciągu.

JavaScript (ES6), 40 32 bajtów

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

Nie ma też problemu z Function.toString. Jako bonus, kod wewnątrz łańcucha wygląda prawie legalnie. Edycja: Zapisano 8 bajtów, używając +zamiast repeat(2).

Klein , 7 + 6 = 13 bajtów

Oto odpowiedź oparta na odpowiedzi > <> .

":1+@!

Wypróbuj online!

To wychodzi

:1+@!"

Japt , 10 9 bajtów

Znalazłem lepszy sposób :-)

Q+2ç"Q+2ç

Wyjścia "Q+2çQ+2ç. Przetestuj online!

Wyjaśnienie

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

Mógłby też być Qi2ç"Qi2ç, który drukuje Qi2çQi2ç". Ten jest bliższy standardowemu Quine Japt:

"iQ ²"iQ ²

Ale nie wierzę, że istnieje jakikolwiek prosty sposób na zaklinowanie cudzysłowu na środku ciągu 9-bajtowego quine.

Ruby, 20 bajtów

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

To wychodzi

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

Wykorzystanie %q(...)składni napisów Ruby , która obsługuje zagnieżdżone nawiasy.

Siatkówka , 8 bajtów

_

$nn$

Wypróbuj online!

Wydruki

n$_
n$

Oba zawierają jeden _, dwa n, dwa$ i trzy kanały.

Zauważ, że wysuw wiersza, po którym następuje prawie jakikolwiek inny znak, jest trywialnym rozwiązaniem, ale wątpliwe jest, czy jest poprawny, ponieważ drugi znak tylko koduje się sam, a wysuw wiersza tak naprawdę nie koduje żadnego znaku wyjściowego.

Wyjaśnienie

_

Zamień puste dane wejściowe na _.

$nn$

Dopasuj pusty ciąg, który dzieje się zarówno przed, jak i po, _i wstaw linefeed ( $n), an ni a $. Odkąd po raz pierwszy to wstawiliśmy _, dodaje to każdy z tych znaków dwa razy, więc ni $uwzględniają$n i otrzymujemy dwa z trzech kanałów, których potrzebujemy w danych wyjściowych. Trzecie podawanie linii jest drukowane, ponieważ Retina domyślnie drukuje końcowe podawanie linii.

Na n$n$tym etapie moglibyśmy również użyć , aby wydrukować:

n
$_n
$

Python Repl, 4 bajty

To moje pierwsze rozwiązanie Code Golf, więc mam nadzieję, że będzie zgodne z zasadami. W interaktywnym tłumaczu Python 2 lub 3:

>>> (1),
(1,)

Dane wyjściowe są anagramem danych wejściowych.

Inne:

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

W Python 2:

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

W Python 3:

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

Aktualizacja 2017-06-15: Jeszcze jedno:

>>> 01.
1.0

Haskell , 38 39 bajtów

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

Wypróbuj online! Wydajność:

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

Edycja: bajt +1, ponieważ wcześniej zapomniałem o niejawnej końcowej linii nowego print.

Alternatywnie: (ta sama liczba bajtów, ale nie zawiera ASCII-owl)

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

Wypróbuj online!

Wydajność:

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

Groovy, 24 20 bajtów

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

-4 dzięki Kalkulatorowi, białe znaki nie były wcale potrzebne!

Wydajność:

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

Wyjaśnienie:

Anonimowe zamknięcie, które po wywołaniu zwraca {""*""2""}dwa razy (konkatenowane).

05AB1E , 10 bajtów

'∞∞''∞'JJ∞

Wypróbuj online!

Wydajność:

∞∞''JJ''∞∞

Wyjaśnienie:

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 bajtów

"_`"_`

Wypróbuj online!

Wydruki

_`"_`"

Wyjaśnienie

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

Bash, 36 bajtów

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

To wychodzi

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

(i tworzy plik fjako efekt uboczny, ale jest to dozwolone na meta .)

Zarówno program, jak i wynik mają końcowy znak nowej linii.

Proces myślowy: doszedłem do wniosku, że najprostszym sposobem na dwukrotne wyprowadzenie ciągu, oprócz przypisania go do zmiennej, było zrobienie

tee f<<<string
cat f

Ciąg musi być cytowany, ponieważ będzie zawierał spacje i <znaki, więc miałem

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

co prawie działa, z wyjątkiem tego, że nie wyświetla cudzysłowów. Na szczęście Bash obsługuje dosłowne łączenie łańcuchów znaków, po prostu umieszczając je obok siebie, więc dołączenie "''"do tustringu i wstawienie ""do części pojedynczego cytatu daje to rozwiązanie.

PHP , 44 bajty

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

Wypróbuj online!

CJam , 8 bajtów

"2*`"2*`

Wypróbuj online!

Wyjaśnienie

Podobne do przykładu Python w pytaniu

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

Dane wyjściowe to "2*`2*`".

Befunge, 11 bajtów

' 2+">:#,_@

Wydruki:

+2 '@_,#:>"

Wyjaśnienie:

' 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@+

I just figured out how to do a proper quine in QBIC. Making an anagram out of it is done by simply switching around the characters in the string literal. There are 24 possible anagrams this way.

Befunge-98, 8 bytes

"'$<@,k7

Try it online!

Ohm, 14 bytes

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

Try it online!

Output:

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

Explanation

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

Outputs:

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

Snippet:

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

console.log(f());

Fission 2, 9 8 6 bytes

R"'!+O

Try it online!

Explanation

An atom is created at R, which moves right. This atom then comes across a ", which starts printing mode. In printing mode, all characters (until the matching ") are printed. This means it prints '!+OR in this case. Then, all that is left is printing ", which is done by the remaining characters. '! sets the atom's mass to the character code of !, and + increments it to the character code of ". Then, the character code is output by O and the atom is destroyed, ending the program.

(Actually, this is just a rotation of the shortest quine)

Mathematica, 2 bytes

.0

Output:

0.

A number starting with a decimal point such as .123 is interpreted as 0.123, so .0 is interpreted as 0.0. Since the part of the number after the decimal point is zero, Mathematica does not print it.

JavaScript (yet another one), 11 bytes

f=_=>'=f'+f

Called with f(), outputs

=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

Run and debug online!

A direct port of this answer.

Old version, 8 bytes

..b..LbL

Run and debug online!

Alternative version with a pretty cheap trick that can be applied to proper quines in almost any language.

"43bL"34bL

Run and debug online!

Because "34bL"34bL is a proper quine in Stax.

Yet another version, using only single-char string literals.

''c'Lc'cccLcLL

Run and debug online!

Explanation

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

Outputs:

34çJ∞""∞Jç43

Try it 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