Die Aufgabe

Bei dieser Herausforderung besteht Ihre Aufgabe darin, Code zu schreiben, der eines seiner zufällig ausgewählten Anagramme mit gleichmäßiger Verteilung ausgibt, sich jedoch niemals selbst ausgeben sollte.

Ausarbeitung

Wenn keine Eingabe erfolgt, sollte Ihr Programm eines der Anagramme seines Quellcodes ausgeben. Ihr Programm sollte niemals seine eigene Quelle ausgeben, wie es ist, dh es sollte niemals eine Quine sein.

Eingang

Ihr Programm darf keine Eingaben annehmen. Wenn Ihre Sprache jedoch eine Eingabe erfordert, können Sie davon ausgehen, dass sie in Kleinbuchstaben angegeben wird a. Sie dürfen die Eingabe jedoch in keiner Weise verwenden.

Ausgabe

Ihr Programm kann auf jede andere Weise ausgegeben werden, außer in eine Variable zu schreiben. Das Schreiben in eine Datei, eine Konsole, einen Bildschirm usw. ist zulässig. Funktion returnist ebenfalls erlaubt.

Zusätzliche Regeln

• Der Quellcode Ihres Programms muss mindestens 3 Zeichen (nicht 3 Byte) enthalten.

• Der Quellcode Ihres Programms muss mindestens 3 mögliche Anagramme enthalten (außer sich selbst). Zählt beispielsweise aabnicht als gültige Übermittlung, da aabnur zwei andere Anagramme als aab( baaund aba) vorhanden sind.

• Ihr Programm darf keinen Fehler erzeugen.

• Ihr Programm sollte seine Anagramme genau ausgeben .

• Es gelten Standard-Lücken und Standard-Quine-Regeln .

Beispiel

Angenommen, der Quellcode Ihres Programms lautet abc. Es sollte zufällig eine der folgenden Optionen (mit gleichmäßiger Verteilung) ausgeben:

1. acb
2. bca
3. bac
4. cba
5. cab

Und es sollte niemals ausgegeben werden abc.

Gewinnkriterium

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes! Bei einem Unentschieden gewinnt die zuvor veröffentlichte Lösung!

Gelee , 15 Bytes

“v0¡µṾ;ḢŒ!QḊX”v

Nur um die Dinge in Gang zu bringen; das ist mit ziemlicher Sicherheit schlagbar. Dies ist im Grunde nur eine Kombination aus einem universellen Quine-Konstruktor und einer Funktion "Wählen Sie eine andere zufällige Permutation als die Eingabe". Letzteres mag verbesserungsfähig sein, Ersteres ist es mit ziemlicher Sicherheit.

Erläuterung

Universeller Quine-Konstruktor

“v0¡µṾ;Ḣ”v
“       ”v   Evaluate the following, given {itself} as argument:
 v0¡µ          No-op (which starts with "v")
     Ṿ         Escape string
      ;Ḣ       Append first character of {the argument}

Dies kann als Quine angesehen werden, wenn es von selbst ausgeführt wird. Nach den meisten Definitionen, die ich kenne, ist es auch eine richtige Quine. Es liest keine eigene Quelle (vielmehr enthält es ein Literal, das "ausgewertet" wurde, und erhält eine Kopie von sich selbst als Argument), es kann eine Nutzlast (wie hier zu sehen!) und die vAußenseite der Zeichenfolge tragen Das Literal wird von vinnen codiert .

Wähle ein zufälliges Anagramm

Œ!QḊX
Œ!     All permutations
  Q    Discard duplicates
   Ḋ   Discard the first (i.e. the string itself)
    X  Choose random element

Dies ist für eine so lange Zeichenfolge wirklich ineffizient, sodass ich das Programm nicht als Ganzes testen konnte, aber ich habe es für kürzere Zeichenfolgen getestet und es scheint korrekt zu funktionieren.

CJam , 17 Bytes

{`"_~"+m!(a-mR}_~

Dies wird nicht in Kürze abgeschlossen sein, daher gibt es diesmal keinen TIO-Link.

Als Trost ist hier eine 20-Byte-Lösung, die sehr schnell endet:

{`"_~"+:S{mr_S=}h}_~

Probieren Sie es online aus!

Erläuterung

{`"_~"+   e# Standard quine framework, leaves a string equal to the source
          e# code on the stack.
  m!      e# Get all permutations. The first one will always be the original order.
  (a      e# Remove that copy of the source code and wrap it in a new list.
  -       e# Remove all copies of the source code from the list of permutations.
  mR      e# Pick a random permutation.
}_~

Die 20-Byte-Lösung mischt stattdessen den Quellcode, bis er sich vom Original unterscheidet.

Python 2, 117 Bytes

Überraschenderweise ist diese Lösung kürzer als ich erwartet hatte. Mischt den Quellcode, bis er vom Original abweicht.

-2 Bytes, dank @ mbomb007
-3 Bytes, dank @Wondercricket

Probieren Sie es online aus

s=r"""from random import*;R='s=r\"""'+s+'\"""'+';exec s';L=R
while L==R:L=''.join(sample(R,len(R)))
print L""";exec s

Dies ist eine der grundlegenden Quines in Python, die ich geändert habe

s = r"print 's = r\"' + s + '\"' + '\nexec(s)'"
exec(s)

Das Erzeugen eines Anagramms erfolgt durch ein Zufallsmodul

L=R
while L==R:L=''.join(sample(L,len(L)))

Wobei R den Quellcode enthält

s=...
R='s=r\"""'+s+'\"""'+'\nexec s'

Es wurden dreifache Anführungszeichen benötigt, da ich gezwungen war, die tatsächlichen Lineseparatoren im Code zu belassen. Anagramme haben sowieso 3 Zeilen.

Java 7, 376 428 426 428 Bytes

import java.util.*;class M{public static void main(String[]a){String s="import java.util.*;class M{public static void main(String[]a){String s=%c%s%1$c,x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(%1$c%1$c));x.equals(s);s=s.join(%1$c%1$c,l))Collections.shuffle(l);System.out.print(s);}}",x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(""));x.equals(s);s=s.join("",l))Collections.shuffle(l);System.out.print(s);}}

+52 und +2 Bytes für zwei Fehlerkorrekturen. Ich habe nicht (korrekt) überprüft, ob der zufällig generierte String dem ursprünglichen Quellcode entspricht. Die Chancen dafür sind angesichts der Anzahl der beteiligten Zeichen astronomisch gering, aber ich muss es validieren, unabhängig davon, ob ich die Herausforderungsregeln einhalte.

Meine erste Quine- Antwort in Java.
Probieren Sie es hier aus.

Sie können beide entfernen Collections.shuffle(l)und !vor beiden hinzufügen x.equals(s), um zu überprüfen, ob die Ausgabe tatsächlich dem Programm entspricht:
Probieren Sie es hier aus.

Erläuterung:

• Das String senthält den unformatierten Quellcode.
• %swird verwendet, um diesen String mit dem in sich selbst einzugeben s.format(...).
• %c, %1$cUnd die 34werden verwendet , um die doppelten Anführungszeichen zu formatieren.
• s.format(s,34,s) fasst alles zusammen

Und dieser Teil des Codes ist für die Ausgabe eines zufälligen Anagramms verantwortlich:

// Strings `s` and `x` now both contain the source-code:
x=s=s.format(s,34,s);

// Create a list with the characters of this source-code-String and loop
for(List l=Arrays.asList(x.split(""));
    // as long as String `x` equals String `s`
    x.equals(s);
    // Shuffle the list, and set it to `s` in every iteration of the loop:
    s=s.join("",l))Collections.shuffle(l);
// End of loop (implicit / single-line body)

// And then print the random anagram to STDOUT:
System.out.print(x);

05AB1E , 22 Bytes

"34çìDJœ¦.R"34çìDJœ¦.R

Dadurch wird eine Liste erstellt, die für TIO zu groß ist. Daher verwendet der Link eine kleinere Zeichenfolge, aber die Idee ist dieselbe.

Probieren Sie es online aus!

"34çìDJœ¦.R"           # Push this string
            34ç        # Push "
               ì       # Prepend
                DJ     # Duplicate and join 
                  œ¦   # Push all permutations except the original
                    .R # Pick a random element

Javascript (ES6), 128 Bytes

!function a(){b="!"+a+"()",c=b.split(""),c.sort(()=>Math.round(Math.random())-.5),c!=b.split("")?console.log(c.join("")):a()}();

Verwendet sort () und gibt zufällig -1,0 oder 1 zurück, um die Ausgabe zu mischen.

Bash, 27 96 Bytes

i=`cat $0`&&e=`fold -w1 $0|shuf|tr -d '\n'`&&while [ "$e" = "$i" ]; do `$0`; exit; done&&echo $e

foldteilt den Code in Zeilen, shufmischt die Zeilen und trsetzt den Code wieder zusammen

Das Problem, dass es sich selbst ausgibt, wurde behoben. Jetzt wird es sich nie selbst ausgeben

Probieren Sie es online aus!