La tarea

En este desafío, su tarea es escribir un código que genere uno de sus anagramas elegidos aleatoriamente con una distribución uniforme, pero nunca debería emitirse.

Elaboración

Sin ninguna entrada, su programa debería generar cualquiera de los anagramas de su código fuente. Su programa nunca debería generar su propia fuente tal como es, es decir, nunca debería ser una quine.

Entrada

Su programa no debe tomar ninguna entrada. Sin embargo, si su idioma requiere entrada como una necesidad, puede suponer que se le dará minúscula a. Sin embargo, no debe usar la entrada de ninguna manera.

Salida

Su programa puede generar resultados de cualquier manera, excepto escribirlo en una variable. Se permite escribir en archivos, consolas, pantallas, etc. La función también returnestá permitida.

Reglas Adicionales

• El código fuente de su programa debe tener al menos 3 caracteres (no 3 bytes).

• El código fuente de su programa debe tener al menos 3 anagramas posibles (excluyéndose a sí mismo). Por ejemplo, aabno cuenta como un envío válido ya que aabsolo tiene dos anagramas distintos de aab( baay aba).

• Su programa no debe producir ningún error.

• Su programa debe generar sus anagramas exactamente .

• Se aplican las lagunas estándar y las reglas de quine estándar .

Ejemplo

Supongamos que el código fuente de su programa es abc. Debería generar aleatoriamente cualquiera de los siguientes (con distribución uniforme):

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

Y, nunca debería salir abc.

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes. En caso de empate, ¡la solución que se publicó anteriormente gana!

Jalea , 15 bytes

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

Solo para comenzar las cosas; esto es casi seguro vencible. Esto es básicamente una combinación de un constructor universal de quine y una función "elegir una permutación aleatoria que no sea la entrada"; lo último puede ser mejorable, lo primero es casi seguro.

Explicación

Constructor universal 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}

Esto puede verse como una quine si se ejecuta solo. También es un quine apropiado según la mayoría de las definiciones que conozco; no lee su propia fuente (más bien, contiene un literal que es "evaluado" y se le da una copia de sí mismo como argumento), puede llevar una carga útil (como se ve aquí) y el vexterior de la cadena literal está codificado por el vinterior.

Elige un anagrama al azar

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

Esto es realmente ineficiente en una cadena de este tiempo, por lo que no he podido probar el programa en su conjunto, pero lo he probado en cadenas más cortas y parece funcionar correctamente.

CJam , 17 bytes

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

Esto no va a terminar pronto, por lo que esta vez no habrá un enlace TIO.

Como consuelo, aquí hay una solución de 20 bytes que termina muy rápidamente:

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

Pruébalo en línea!

Explicación

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

En cambio, la solución de 20 bytes baraja el código fuente hasta que sea diferente del original.

Python 2, 117 bytes

Sorprendentemente, esta solución es más corta de lo que esperaba. Baraja el código fuente, hasta que difiere del original.

-2 bytes, gracias a @ mbomb007
-3 bytes, gracias a @Wondercricket

Pruébalo en línea

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

Esta es una de las quines básicas en Python, que he modificado

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

La generación del anagrama se realiza mediante un módulo aleatorio.

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

Donde R contiene el código fuente

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

Se necesitaban comillas triples ya que me vi obligado a mantener los códigos de línea reales en código. Los anagramas tendrán 3 líneas de todos modos.

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 y +2 bytes para dos correcciones de errores. No estaba comprobando (correctamente) si la cadena de generación aleatoria era igual al código fuente original. Las posibilidades de esto son astronómicas pequeñas considerando la cantidad de personajes involucrados, pero tengo que validarlo independientemente de cumplir con las reglas del desafío.

Mi primera respuesta quine en Java ...
Pruébalo aquí.

Puede eliminar ambos Collections.shuffle(l)y agregarlos !delante de ambos x.equals(s)para verificar que la salida realmente sea igual al programa:
Pruébelo aquí.

Explicación:

• El String scontiene el código fuente sin formato.
• %sse utiliza para ingresar esta cadena en sí misma con el s.format(...).
• %c, %1$cy 34se usan para formatear las comillas dobles.
• s.format(s,34,s) lo pone todo junto

Y esta parte del código es responsable de generar un anagrama aleatorio:

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

Esto crea una lista que es demasiado grande para TIO, por lo que el enlace usa una cadena más pequeña, pero la idea es la misma.

Pruébalo en línea!

"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()}();

Utiliza sort () que devuelve aleatorio -1,0 o 1 para barajar la salida

Bash, 27 96 bytes

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

folddivide el código en líneas, shufbaraja las líneas y trvuelve a armar el código

solucionó el problema de que se produjera, ahora nunca se generará

Pruébalo en línea!