L'obiettivo

In questa sfida, il tuo compito è quello di scrivere del codice che emetta uno dei suoi anagrammi scelti casualmente con una distribuzione uniforme, ma non dovrebbe mai generare se stesso.

Elaborazione

Dato nessun input, il tuo programma dovrebbe generare uno qualsiasi degli anagrammi del suo codice sorgente. Il tuo programma non dovrebbe mai produrre la sua fonte così com'è, cioè non dovrebbe mai essere un quine.

Ingresso

Il tuo programma non deve accettare alcun input. Tuttavia, se la tua lingua richiede input come necessità, puoi presumere che verrà data in minuscolo a. Tuttavia, non è necessario utilizzare l'input in alcun modo.

Produzione

Il tuo programma può essere emesso in qualsiasi modo tranne che scriverlo in una variabile È consentita la scrittura su file, console, schermo, ecc. Anche la funzione returnè consentita.

Regole aggiuntive

• Il codice sorgente del programma deve avere almeno 3 caratteri (non 3 byte).

• Il codice sorgente del tuo programma deve avere almeno 3 possibili anagrammi (escluso se stesso). Ad esempio, aabnon conta come invio valido poiché aabha solo due anagrammi diversi da aab( baae aba).

• Il tuo programma non deve produrre alcun errore.

• Il tuo programma dovrebbe generare esattamente i suoi anagrammi .

• Si applicano le feritoie standard e le regole del quine standard .

Esempio

Supponiamo che il codice sorgente del programma sia abc. Dovrebbe produrre casualmente uno dei seguenti (con distribuzione uniforme):

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

E non dovrebbe mai essere prodotto abc.

Criterio vincente

Questo è code-golf , quindi vince il codice più corto in byte! In caso di pareggio, vince la soluzione pubblicata in precedenza!

Gelatina , 15 byte

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

Solo per iniziare le cose; questo è quasi certamente battibile. Questa è fondamentalmente solo una combinazione di un costruttore di quine universale e una funzione "scegli una permutazione casuale diversa dall'input"; il secondo può essere migliorabile, il primo quasi certamente lo è.

Spiegazione

Costruttore universale di quine

“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}

Questo può essere visto come un quine se gestito da solo. È anche un vero e proprio quine dalla maggior parte delle definizioni che conosco; non legge la propria fonte (piuttosto, contiene un letterale "eval" ed è una copia di se stesso come argomento), può trasportare un payload (come visto qui!) e l' vesterno della stringa letterale è codificato vdall'interno.

Scegli un anagramma casuale

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

Questo è davvero inefficiente su una stringa così a lungo, quindi non sono stato in grado di testare il programma nel suo insieme, ma l'ho testato su stringhe più brevi e sembra funzionare correttamente.

CJam , 17 byte

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

Questo non finirà presto, quindi questa volta nessun collegamento TIO.

Come consolazione, ecco una soluzione da 20 byte che termina molto rapidamente:

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

Provalo online!

Spiegazione

{`"_~"+   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.
}_~

La soluzione da 20 byte invece mescola il codice sorgente fino a quando è diverso dall'originale.

Python 2, 117 byte

Sorprendentemente questa soluzione è più breve di quanto mi aspettassi. Mescola il codice sorgente, fino a quando non differisce dall'originale.

-2 byte, grazie a @ mbomb007
-3 byte, grazie a @Wondercricket

Provalo online

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

Questa è una delle quines di base in Python, che ho modificato

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

La generazione di anagrammi avviene tramite modulo casuale

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

Dove R contiene codice sorgente

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

Sono state necessarie virgolette triple poiché sono stato costretto a mantenere in codice i veri lineseparator. Gli Anagrammi avranno comunque 3 linee.

Java 7, 376 428 426 428 byte

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 e +2 byte per due correzioni di errori. Non stavo controllando (correttamente) se la stringa generata in modo casuale fosse uguale al codice sorgente originale. Le possibilità di questo sono piccole astronomicamente considerando la quantità di personaggi coinvolti, ma devo convalidarlo indipendentemente dal rispetto delle regole della sfida.

La mia prima risposta quine in Java ..
Provalo qui.

È possibile rimuovere entrambi Collections.shuffle(l)e aggiungere !davanti a entrambi x.equals(s)per verificare che l'output sia effettivamente uguale al programma:
Provalo qui.

Spiegazione:

• Il String scontiene il codice sorgente non formattato.
• %sè usato per inserire questa stringa in se stessa con s.format(...).
• %c, %1$cE la 34vengono utilizzati per formattare le virgolette.
• s.format(s,34,s) mette tutto insieme

E questa parte del codice è responsabile della produzione di un anagramma casuale:

// 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 byte

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

Questo crea un elenco troppo grande per TIO, quindi il collegamento utilizza una stringa più piccola, ma l'idea è la stessa.

Provalo online!

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

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

Utilizza sort () che restituisce casuale -1,0 o 1 per mescolare l'output.

Bash, 27 96 byte

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

folddivide il codice in righe, shufmescola le righe e trricompone il codice

risolto il problema dell'output stesso, ora non emetterà mai se stesso

Provalo online!