Golf ein Anagramm Quine

24

In dieser Frage habe ich Sie gebeten, ein Anagramm-Quine anhand seiner Ausgabe zu erraten. Es sieht jedoch so aus, als hätten wir noch keine Frage, ob wir ein Anagramm-Quine spielen wollen. Ihre Aufgabe wird es also sein, das kürzeste Anagramm zu machen, das Sie können.

Was ist ein Anagramm Quine?

Ein Anagramm-Quine ist ein nicht leeres Programm, das ein anderes Anagramm seines Quellcodes als den ursprünglichen Quellcode ausgibt.

Hier ist ein Beispiel für ein Anagramm-Quine in Python 2:

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

Sie sollten Ihre eigene Quelle für diese Herausforderung nicht lesen.

Weizen-Assistent
quelle
2
@LeakyNun Nein, es kann kein Quine sein.
Weizen-Assistent
2
Muss der ausgegebene Code ein gültiges Programm sein?
MD XF
1
@ MDXF Nein, tut es nicht.
Weizen-Assistent
2
@Okx Es sollte unseren Standardanforderungen für ein Quine entsprechen (außer dass es ein Quine ist).
Wheat Wizard
1
@LeakyNun Ich glaube nicht, dass 0-Byte-Programme Anagramme haben, die sich vom Original unterscheiden!
Neil

Antworten:

29

Pyth , 2 Bytes

)(

Ausgänge

()

Probieren Sie es online!

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple
Stange
quelle
3
Bedeutet das, dass Sie herausgefunden haben, dass ()das Quin viel kürzer ist als das bekannte jN*2]"jN*2] ?
Jim
1
@ Jim Nein, weil dies nicht Nutzlast-fähig ist: c
Rod
9

V , 4 Bytes

2ii2

Ausgänge:

i2i2

Probieren Sie es online!

Riley
quelle
2x einfügen i2?
CalculatorFeline
1
Ja. 2 -> do the next thing twice i -> insert the following
Riley
Ah ich verstehe, ich dachte das wäre Vim.
Weizen Zauberer
@ WheatWizard Nein, dies ist eine triviale Modifikation des Standard-V-Quines.
Riley
1
@isaacg: Nein, in Vim müssten Sie ESC drücken, wenn Sie fertig sind. Dies ist ein Problem, da die Ausgabe kein ESC-Zeichen enthält.
9

> <> , 9 8 7 Bytes

1 Byte dank @WheatWizard durch Verwenden !und Inkrementieren abrufen"

Golfed 1 Byte dank @ ConorO'Brien mit #anstelle von<!

":1->o#

Probieren Sie es online!

Ausgänge "#o>-1:.

Erläuterung

":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
quelle
":1+>o<!ist etwas kürzer.
Wheat Wizard
@ WheatWizard Vielen Dank, das war ein ordentliches Golf :)
Kritixi Lithos
1
Sie können 7 Bytes erhalten:":1->o#
Conor O'Brien
@ ConorO'Brien Danke für den Tipp, das ist echt schlau.
Kritixi Lithos
Danke :) Ich bin angenehm überrascht, dass es hier besser funktioniert als in der eigentlichen Quine
Conor O'Brien
9

Brainfuck, 158 Bytes

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

Probieren Sie es online!

Es ist möglicherweise nicht die kürzeste Version, aber es funktioniert zumindest.

Es macht Spaß , dass der Ausgabecode tatsächlich ausgeführt werden kann (und nicht mehr funktioniert).

Ausgabe

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

Erläuterung

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

<<<>>>>>>>>>-----+++            Junk to complete the anagram.
6Unendlichkeit8
quelle
8

Python 3, 32 Bytes

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

Drucke p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, sortierte Ausgabe:\n""""""""""""(())**22iinnpprrtt

CalculatorFeline
quelle
Ups, alte Version :(
CalculatorFeline
1
@Downvoter Bitte stornieren.
CalculatorFeline
7

Ruby , 8 Bytes

p"p*2"*2

Probieren Sie es online!

Dies wird gedruckt

"p*2p*2"

Erläuterung

Dies funktioniert ähnlich wie die Python-Antwort in der Frage. Es wird die Zeichenfolge machenp*2p*2 und mit Ruby's pwird die Darstellung der Zeichenfolge gedruckt.

Weizen-Assistent
quelle
Sie können panstelle von puts?! So viel verschwendete Zeit ...
Magic Octopus Urn
4
@carusocomputing Es ist nicht genau das Gleiche wie Puts. p xentsprichtputs x.inspect
Conor O'Brien
6

JavaScript (ES6), 40 32 Bytes

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

Kein Herumspielen mit Function.toString. Als Bonus sieht der Code in der Zeichenfolge fast legal aus. Bearbeiten: 8 Bytes mit +anstelle von gespeichert repeat(2).

Neil
quelle
1
Warum nicht *2statt verwenden .repeat(2), geht das nicht?
Magic Octopus Urn
1
@carusocomputing JavaScript nicht *für Zeichenfolgen überladen
Conor O'Brien
1
@carusocomputing Das gab mir eine Idee, danke!
Neil
4

Japt , 10 9 Bytes

Einen besseren Weg gefunden :-)

Q+2ç"Q+2ç

Ausgänge "Q+2çQ+2ç. Testen Sie es online!

Erläuterung

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

Könnte auch sein Qi2ç"Qi2ç, was druckt Qi2çQi2ç". Dieser ist näher an der Standard-Japt-Quine:

"iQ ²"iQ ²

Aber ich glaube nicht, dass es eine einfache Möglichkeit gibt, das Anführungszeichen in der Mitte der Zeichenfolge für ein 9-Byte-Quine zu verkeilen.

ETHproductions
quelle
Ein weiterer 10-Byte:Q+"+Q² " ²
Conor O'Brien
@ ConorO'Brien Ja, und Sie können jederzeit die 4 Zeichen in der Zeichenfolge in jeder der 24 möglichen Permutationen anordnen. Ich glaube auch, dass Sie immer beide Leerzeichen durch Zeilenumbrüche ersetzen können
ETHproductions
3

Ruby, 20 Bytes

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

Dies gibt aus

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

Nutzen Sie Rubys %q(...)String-Syntax, die verschachtelte Klammern unterstützt.

Türknauf
quelle
3

Retina , 8 Bytes


_

$nn$

Probieren Sie es online!

Druckt


n$_
n$

Beide enthalten einen _, zwei n, zwei $und drei Zeilenvorschübe.

Beachten Sie, dass ein Zeilenvorschub gefolgt von fast jedem anderen Zeichen eine triviale Lösung darstellt. Es ist jedoch fraglich, ob er gültig ist, da das zweite Zeichen nur sich selbst codiert und der Zeilenvorschub keines der Ausgabezeichen wirklich codiert.

Erläuterung


_

Ersetzen Sie die leere Eingabe durch a _.


$nn$

Entspricht einer leeren Zeichenfolge, die vor oder nach dem steht, _und fügt einen Zeilenumbruch ( $n), ein nund ein $. Da wir das zuerst eingefügt haben, _wird jedes dieser Zeichen zweimal hinzugefügt, so dass die nund das $berücksichtigen $n, und wir erhalten zwei der drei Zeilenvorschübe, die wir in der Ausgabe benötigen. Der dritte Zeilenvorschub wird gedruckt, da Retina standardmäßig einen nachfolgenden Zeilenvorschub druckt.

Wir könnten auch n$n$in dieser Phase verwenden, die dann drucken würde:

n
$_n
$

Martin Ender
quelle
3

Python Repl, 4 Bytes

Dies ist meine erste Code Golf-Lösung, daher hoffe ich, dass sie den Regeln entspricht. Im interaktiven Interpreter von Python 2 oder 3:

>>> (1),
(1,)

Die Ausgabe ist ein Anagramm der Eingabe.


Ein weiterer:

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

In Python 2:

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

In Python 3:

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

Update 15.06.2017: Noch eine:

>>> 01.
1.0
Oberst Panic
quelle
1
Ich denke, die letzte Antwort hier verstößt gegen die Quine-Regeln (alle Zeichen in der Ausgabe dienen demselben Zweck wie das übereinstimmende Zeichen in der Eingabe). Den anderen geht es aber gut.
2

Haskell , 38 39 Bytes

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

Probieren Sie es online! Ausgabe:

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

Edit: +1 Byte, weil ich vorher den impliziten Zeilenumbruch von vergessen habe print.


Alternative: (Gleiche Byteanzahl, enthält aber keine ASCII-Eule)

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

Probieren Sie es online!

Ausgabe:

"main=print$e++e;e=main=print$e++e;e="
Laikoni
quelle
Nur kaum ein Anagramm als ein echtes ...
Feathercrown
2

Groovy, 24 20 Bytes

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

-4 dank CalculatorFeline wurde das Leerzeichen doch nicht benötigt!

Ausgabe:

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

Erläuterung:

Anonymer Abschluss, der beim Aufrufen {""*""2""}zweimal zurückgegeben wird (verkettet).

Magische Kraken-Urne
quelle
1
Erklärung bitte. Außerdem können (wahrscheinlich) Bytes gespeichert werden, indem der *2Abstand zwischen Anführungszeichen verwendet wird:{"""{""*""2""}"""*2}
CalculatorFeline
@CalculatorFeline ist ziemlich selbsterklärend. Aber ja, das ist eine <s> 100% </ s> 9% bessere Idee als meine.
Magic Octopus Urn
3
Eigentlich ist es nur 9% besser: P
CalculatorFeline
2

05AB1E , 10 Bytes

'∞∞''∞'JJ∞

Probieren Sie es online!

Ausgabe:

∞∞''JJ''∞∞

Erläuterung:

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''∞∞
Magische Kraken-Urne
quelle
2

CJam , 6 Bytes

"_`"_`

Probieren Sie es online!

Druckt

_`"_`"

Erläuterung

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.
Martin Ender
quelle
Ich wollte dies posten ... "` _ "
Luis Mendo
1

Bash, 36 Bytes

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

Dies gibt aus

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

(und erstellt die Datei fals Nebeneffekt, aber das ist per Meta erlaubt .)

Sowohl das Programm als auch die Ausgabe haben einen nachgestellten Zeilenumbruch.

Denkprozess: Ich stellte mir vor, dass der einfachste Weg, einen String zweimal auszugeben, neben der Zuweisung zu einer Variablen, der folgende ist

tee f<<<string
cat f

Die Zeichenfolge muss in Anführungszeichen gesetzt werden, da sie Leerzeichen und <Zeichen enthält

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

Was fast funktioniert, außer dass die Anführungszeichen nicht ausgegeben werden. Glücklicherweise unterstützt Bash die Verkettung von Zeichenfolgen, indem sie einfach nebeneinander platziert und so angehängt werden"''" an den Herestring und das Einfügen ""in den einfachen Anführungszeichen-Teil ergibt diese Lösung.

Türknauf
quelle
1

CJam , 8 Bytes

"2*`"2*`

Probieren Sie es online!

Erläuterung

Ähnlich dem Python-Beispiel in der Frage

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

Die Ausgabe ist "2*`2*`".

Geschäfts-Katze
quelle
1

Befunge, 11 Bytes

' 2+">:#,_@

Drucke:

+2 '@_,#:>"

Erläuterung:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End
MegaTom
quelle
Ja. aber das tut es auch ". Was ist die Einschränkung genau?
MegaTom
Ich denke nicht, dass dies "als eigene Quelle betrachtet wird, es ist nur ein String-Literal. gAllerdings ist es ziemlich krass, seine eigene Quelle zu lesen.
Weizen-Assistent
@ WheatWizard okay. Ich werde es ändern.
MegaTom
":1+>:#,_@!funktioniert auch aber es ist nicht kürzer.
Wheat Wizard
' 2+"8k,@für 9 Bytes
Ovs
1

QBIC , 8 Bytes

?A+@?A@+

Ich habe gerade herausgefunden, wie man in QBIC eine richtige Quine macht. Um ein Anagramm daraus zu erstellen, müssen Sie einfach die Zeichen im String-Literal umschalten. Auf diese Weise gibt es 24 mögliche Anagramme.

steenbergh
quelle
1

Ohm , 14 Bytes

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

Probieren Sie es online!

Ausgabe:

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

Erläuterung

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

Spaltung 2 , 9 8 6 Bytes

R"'!+O

Probieren Sie es online!

Erläuterung

Bei entsteht ein Atom R, das sich nach rechts bewegt. Dieses Atom stößt dann auf einen ", der den Druckmodus startet. Im Druckmodus werden alle Zeichen (bis zur Übereinstimmung ") gedruckt. Dies bedeutet, dass '!+ORin diesem Fall gedruckt wird. Dann wird nur noch gedruckt ", was von den verbleibenden Zeichen erledigt wird. '!Setzt die Masse des Atoms auf den Zeichencode von !und +erhöht sie auf den Zeichencode von ". Dann wird der Zeichencode von ausgegeben Ound das Atom zerstört, wodurch das Programm beendet wird.

(Eigentlich ist dies nur eine Rotation der kürzesten Quine)

Luke
quelle
Ich glaube, Sie können einfach die Standard-Quine verwenden und sie zyklisch verschieben (also so etwas wie R"'!+Oungetestet).
Martin Ender
@MartinEnder: Du hast recht. Aktualisiert. Danke fürs Helfen.
Luke
1

Mathematica, 2 Bytes

.0

Ausgabe:

0.

Eine Zahl, die mit einem Dezimalpunkt beginnt, wie dies .123interpretiert wird 0.123, .0wird interpretiert als 0.0. Da der Teil der Zahl nach dem Komma Null ist, druckt Mathematica ihn nicht aus.

Ben
quelle
1
Ich denke nicht, dass das gültig ist. Unsere Site-Definition erfordert, dass Quines einen "Encoder" und einen "Decoder" haben. Dies verbietet nur Quines vom Typ Literal.
Weizen-Assistent
Alle Regeln für Quines übertragen sich auf diese Herausforderung.
Weizen-Assistent
@WheatWizard: Die .verschlüsselt sich selbst, aber ich glaube die 0macht das nicht? Eine 0 hinter dem Komma kann nicht als Kodierung einer führenden Null vor dem Komma angesehen werden. Letzteres ist ein Nebeneffekt beim Drucken eines Gleitkommas. Unter den alten Quine-Regeln gibt es hier also kein Problem. (Ich bin nicht sicher, ob die neuen Regeln noch in Kraft getreten sind.)
@ ais523 Ich weiß es nicht. Vielleicht sollte dies durch eine Meta-Frage angesprochen werden.
Weizen-Assistent
1

Python 3, 31 Bytes

a='a=%r;pritn(a%%a)';print(a%a)
aaay aaay
quelle
1

Stax , 8 4 Bytes

.S.S

Online ausführen und debuggen!

Ein direkter Port dieser Antwort .

Alte Version, 8 Bytes

..b..LbL

Online ausführen und debuggen!

Alternative Version mit einem ziemlich billigen Trick, der auf richtige Quines in fast jeder Sprache angewendet werden kann.

"43bL"34bL

Online ausführen und debuggen!

weil "34bL"34bL in Stax steckt eine richtige Quine.

Noch eine andere Version, bei der nur einzelne Zeichenfolgenliterale verwendet werden.

''c'Lc'cccLcLL

Online ausführen und debuggen!

Erläuterung

.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
quelle
0

05AB1E , 13 Bytes

"34çJ∞"34çJ∞

Ausgänge:

34çJ∞""∞Jç43

Probieren Sie es 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
quelle