A tarefa

Nesse desafio, sua tarefa é escrever um código que produza um de seus anagramas escolhidos aleatoriamente com distribuição uniforme, mas que nunca deve ser produzido sozinho.

Elaboração

Dado que não há informações, o seu programa deve produzir qualquer um dos anagramas do seu código fonte. Seu programa nunca deve produzir sua própria fonte como ela é, ou seja, nunca deve ser um problema.

Entrada

Seu programa não deve receber nenhuma entrada. No entanto, se o seu idioma exigir entrada como uma necessidade, você pode assumir que ele será fornecido em minúsculas a. Você não deve usar a entrada de forma alguma.

Resultado

Seu programa pode gerar qualquer saída, exceto gravá-lo em uma variável. A gravação em arquivo, console, tela etc. é permitida. A função também returné permitida.

Regras adicionais

• O código-fonte do seu programa deve ter pelo menos 3 caracteres (não 3 bytes).

• O código-fonte do seu programa deve ter pelo menos três possíveis anagramas (exceto ele próprio). Por exemplo, aabnão conta como um envio válido, pois aabpossui apenas dois anagramas diferentes de aab( baae aba).

• Seu programa não deve produzir nenhum erro.

• Seu programa deve exibir exatamente seus anagramas .

• Aplicam- se as lacunas padrão e as regras padrão de quine .

Exemplo

Suponha que o código fonte do seu programa seja abc. Ele deve gerar aleatoriamente qualquer um dos seguintes (com distribuição uniforme):

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

E, nunca deve produzir abc.

Critério vencedor

Isso é código-golfe , então o código mais curto em bytes vence! Em caso de empate, a solução postada anteriormente vence!

Gelatina , 15 bytes

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

Apenas para começar as coisas; isso é quase certamente imbatível. Isso é basicamente apenas uma combinação de um construtor universal de quine e uma função "escolher uma permutação aleatória que não seja a entrada"; o último pode ser improvável, o primeiro quase certamente é.

Explicação

Construtor de quine universal

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

Isso pode ser visto como um problema, se executado por si só. Também é uma solução adequada para a maioria das definições que conheço; ele não lê sua própria fonte (em vez disso, contém um literal que é "avaliado" e recebe uma cópia de si mesmo como argumento), pode carregar uma carga útil (como pode ser visto aqui!) e o vexterior da string literal é codificado por vdentro.

Escolha um anagrama aleatório

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

Isso é realmente ineficiente em uma string por tanto tempo, então não pude testar o programa como um todo, mas testei-o em strings mais curtas e ele parece funcionar corretamente.

CJam , 17 bytes

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

Isso não vai terminar tão cedo, então nenhum link TIO dessa vez.

Como um consolo, aqui está uma solução de 20 bytes que termina muito rapidamente:

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

Experimente online!

Explicação

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

Em vez disso, a solução de 20 bytes embaralha o código-fonte até que seja diferente do original.

Python 2, 117 bytes

Surpreendentemente, esta solução é mais curta do que eu esperava. Baralha o código-fonte, até que seja diferente do original.

-2 bytes, graças a @ mbomb007
-3 bytes, graças a @Wondercricket

Experimente 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

Este é um dos quines básicos em python, que eu modifiquei

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

A geração de anagramas é feita por módulo aleatório

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

Onde R contém código fonte

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

Foram necessárias aspas triplas, pois fui forçado a manter os verdadeiros participantes de linha em código. Anagramas terão 3 linhas de qualquer maneira.

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 e +2 bytes para duas correções de bugs. Eu não estava verificando (corretamente) se a String gerada aleatoriamente era igual ao código-fonte original. As chances disso são astronômicas pequenas, considerando a quantidade de caracteres envolvidos, mas eu tenho que validá-lo independentemente de cumprir as regras do desafio.

Minha primeira resposta rápida em Java ..
Experimente aqui.

Você pode remover os dois Collections.shuffle(l)e adicionar !na frente dos dois x.equals(s)para verificar se a saída realmente é igual ao programa:
Experimente aqui.

Explicação:

• O String scontém o código fonte não formatado.
• %sé usado para inserir essa String em si mesma com o s.format(...).
• %c, %1$cE 34são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto

E essa parte do código é responsável pela saída de um anagrama aleatório:

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

Isso cria uma lista muito grande para o TIO, portanto, o link usa uma string menor, mas a ideia é a mesma.

Experimente 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 bytes

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

Usa sort () retornando aleatoriamente -1,0 ou 1 para embaralhar a saída.

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 o código em linhas, shufembaralha as linhas etr junta o código novamente

corrigiu o problema de se exibir, agora nunca mais se exibirá

Experimente Online!