La tâche

Dans ce défi, votre tâche consiste à écrire du code qui génère l'une de ses anagrammes choisies au hasard avec une distribution uniforme, mais il ne doit jamais se produire lui-même.

Élaboration

En l'absence de saisie, votre programme devrait sortir l'une des anagrammes de son code source. Votre programme ne devrait jamais produire sa propre source telle quelle, c'est-à-dire qu'elle ne devrait jamais être une quine.

Contribution

Votre programme ne doit prendre aucune entrée. Cependant, si votre langue nécessite une saisie comme une nécessité, vous pouvez supposer qu'elle sera donnée en minuscules a. Cependant, vous ne devez en aucun cas utiliser l'entrée.

Production

Votre programme peut sortir de n'importe quelle façon sauf l'écrire dans une variable. L'écriture dans un fichier, une console, un écran, etc. est autorisée. La fonction returnest également autorisée.

Règles supplémentaires

• Le code source de votre programme doit avoir au moins 3 caractères (pas 3 octets).

• Le code source de votre programme doit avoir au moins 3 anagrammes possibles (hors lui-même). Par exemple, aabne compte pas comme une soumission valide car aabil n'a que deux anagrammes autres que aab( baaet aba).

• Votre programme ne doit produire aucune erreur.

• Votre programme devrait afficher ses anagrammes exactement .

• Les échappatoires standard et les règles de quine standard s'appliquent.

Exemple

Supposons que le code source de votre programme soit abc. Il doit générer au hasard l'un des éléments suivants (avec une distribution uniforme):

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

Et, il ne devrait jamais sortir abc.

Critère gagnant

Il s'agit de code-golf , donc le code le plus court en octets gagne! En cas d'égalité, la solution qui avait été publiée plus tôt l'emporte!

Gelée , 15 octets

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

Juste pour commencer. c'est presque certainement battable. Il s'agit simplement d'une combinaison d'un constructeur de quine universel et d'une fonction "choisir une permutation aléatoire autre que l'entrée"; ce dernier peut être améliorable, le premier l'est presque certainement.

Explication

Constructeur universel de 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}

Cela peut être considéré comme une quine s'il est géré par lui-même. C'est aussi un quine approprié par la plupart des définitions que je connais; il ne lit pas sa propre source (il contient plutôt un littéral qui est "évalué" et reçoit une copie de lui-même comme argument), il peut transporter une charge utile (comme on le voit ici!), et lev extérieur de la chaîne littéral est codé par l' vintérieur.

Choisissez une anagramme aléatoire

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

C'est vraiment inefficace sur une chaîne aussi longue, donc je n'ai pas pu tester le programme dans son ensemble, mais je l'ai testé sur des chaînes plus courtes et il semble fonctionner correctement.

CJam , 17 octets

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

Cela ne se terminera pas de si tôt, donc pas de lien TIO cette fois.

En guise de consolation, voici une solution de 20 octets qui se termine très rapidement:

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

Essayez-le en ligne!

Explication

{`"_~"+   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 solution de 20 octets mélange à la place le code source jusqu'à ce qu'il soit différent de l'original.

Python 2, 117 octets

Étonnamment, cette solution est plus courte que ce à quoi je m'attendais. Mélange le code source jusqu'à ce qu'il diffère de l'original.

-2 octets, grâce à @ mbomb007
-3 octets, grâce à @Wondercricket

Essayez-le en ligne

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

Ceci est l'un des quines de base en python, que j'ai modifié

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

La génération d'anagrammes se fait par module aléatoire

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

Où R contient le code source

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

Des guillemets triples étaient nécessaires car j'ai été obligé de conserver les séparateurs de lignes réels dans le code. Les anagrammes auront de toute façon 3 lignes.

Java 7, 376 428 426 428 octets

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 et +2 octets pour deux corrections de bugs .. Je ne vérifiais pas (correctement) si la chaîne générée de manière aléatoire était égale au code source d'origine. Les chances de cela sont astronomiques, compte tenu du nombre de personnages impliqués, mais je dois le valider malgré tout pour me conformer aux règles du défi.

Ma première réponse quine en Java ..
Essayez-le ici.

Vous pouvez supprimer les deux Collections.shuffle(l)et les ajouter !devant les deux x.equals(s)pour vérifier que la sortie est bien égale au programme:
Essayez-le ici.

Explication:

• Le String scontient le code source non formaté.
• %sest utilisé pour entrer cette chaîne en elle-même avec le s.format(...).
• %c, %1$cEt 34sont utilisés pour formater les guillemets doubles.
• s.format(s,34,s) met tout cela ensemble

Et cette partie du code est responsable de la sortie d'une anagramme aléatoire:

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

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

Cela crée une liste trop grande pour TIO, donc le lien utilise une chaîne plus petite, mais l'idée est la même.

Essayez-le en ligne!

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

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

Utilise sort () retournant aléatoire -1,0 ou 1 pour mélanger la sortie.

Bash, 27 96 octets

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

folddivise le code en lignes, shufmélange les lignes et trremet le code ensemble

a résolu le problème de la sortie elle-même, maintenant elle ne sortira jamais

Essayez-le en ligne!