Golf you an anagram for great good!

Question

The Task

In this challenge, your task is to write some code which outputs one of its anagrams chosen randomly with uniform distribution but it should never output itself.

---

Elaboration

Given no input, your program should output any one of the anagrams of its source code. Your program should never output its own source as it is, i.e. it should never be a quine.

---

Input

Your program must not take any input. However, if your language requires input as a necessity, you may assume that it will be given lowercase a. You must not use the input in any way, though.

---

Output

Your program can output in any way except writing it to a variable. Writing to file, console, screen, etc. is allowed. Function return is allowed as well.

---

Additional Rules

• Your program's source code must have at least 3 chars (not 3 bytes).

• Your program's source code must have at least 3 possible anagrams (excluding itself). For example, aab does not count as a valid submission as aab only has two anagrams other than aab (baa and aba).

• Your program must not produce any error.

• Your program should output its anagrams exactly.

• Standard Loopholes and Standard quine rules apply.

---

Example

Suppose your program's source code is abc. It should randomly output any one of the following (with uniform distribution):

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

And, it should never output abc.

---

Winning Criterion

This is code-golf, so the shortest code in bytes wins! In case of a tie, the solution which was posted earlier wins!

Answer 1

Python 2, 117 bytes

Surprisingly this solution is shorter than I expected. Shuffles source code, until it differs from the original.

-2 bytes, thanks to @mbomb007
-3 bytes, thanks to @Wondercricket

Try it 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

This is one of the basic quines in python, that I've modified

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

Generating anagram is done by random module

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

Where R contains sourcecode

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

Triple quotes were needed as I was forced to keep actual lineseparators in code. Anagrams will have 3 lines anyway.

Answer 2

Jelly, 15 bytes

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

Just to get things started; this is almost certainly beatable. This is basically just a combination of a universal quine constructor and a "pick a random permutation other than the input" function; the latter may be improvable, the former almost certainly is.

Explanation

Universal quine constructor

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

This can be seen to be a quine if run by itself. It's also a proper quine by most definitions I know of; it doesn't read its own source (rather, it contains a literal that's "eval"ed, and is given a copy of itself as an argument), it can carry a payload (as seen here!), and the v outside the string literal is encoded by the v inside.

Pick a random anagram

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

This is really inefficient on a string this long, so I haven't been able to test the program as a whole, but I've tested it on shorter strings and it appears to function correctly.

Answer 3

CJam, 17 bytes

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

This isn't going to finish any time soon, so no TIO link this time.

As a consolation, here is a 20 byte solution that does terminate very quickly:

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

Try it online!

Explanation

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

The 20 byte solution instead shuffles the source code until its different from the original.

Answer 4

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 and +2 bytes for two bug-fixes.. I wasn't checking (correctly) if the randomly generating String was equal to the original source-code. The chances of this are astronomical small considering the amount of characters involved, but I have to validate it regardless to comply to the challenge rules.

My first quine answer in Java..
Try it here.

You can remove both Collections.shuffle(l) and add ! in front of both the x.equals(s) to verify that the output indeed equals the program:
Try it here.

Explanation:

• The String s contains the unformatted source code.
• %s is used to input this String into itself with the s.format(...).
• %c, %1$c and the 34 are used to format the double-quotes.
• s.format(s,34,s) puts it all together

And this part of the code is responsible for outputting a random anagram:

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

Answer 5

Vyxal D, 14 bytes

`q‛:Ė+:Ṗ$o℅`:Ė

Try it Online!

For a version that doesn't require ~1.2TB of RAM:

Vyxal D, 16 bytes

`q‛:Ė+D{|Þ℅~=`:Ė

Try it Online!

Both of these use a fairly generic quine structure combined with some "generate some permutation other than the input" code.

Generic quine structure

`        `:Ė # Evaluate the previous code on itself
 q.          # Uneval
     +       # Append
  ‛:Ė        # ":Ė"
      ...    # Apply some transformation

 Ṗ    # Get all permutations of the input
: $o  # Remove the original string
    ℅ # Choose a random element

 {      # While   
D |  ~= # The current string equals the input
   Þ℅   # Shuffle it

Answer 6

05AB1E, 22 bytes

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

This creates a list that is too big for TIO, so the link uses a smaller string, but the idea is the same.

Try it 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

Answer 7

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

Uses sort() returning random -1,0, or 1 to shuffle the output.

Answer 8

PowerShell Core, 72 bytes

&($f={for(;$r-eq$o){$r=-join(($o="&(`$f={$f})")|% t*y|Random -c 72)}$r})

Try it online!

This is a variation of the quine &($f={"&(`$f={$f})"})

&($f={for(;$r-eq$o){$r=-join(($o="&(`$f={$f})")|% t*y|Random -c 72)}$r})
                             ($o="&(`$f={$f})")                          # Stores the original quine in $o
                    $r=-join(                  |% t*y|Random -c 72)      # Shuffles the characters and store it in $r
      for(;$r-eq$o){                                               }$r   # Exit the while loop and print when the shuffled quine is not the same as the origin quine
&($f={                                                                }) # Quine structure, to create a function and run it automatically

A 74 bytes recursive approach

Answer 9

Bash, 27 96 bytes

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

fold divides the code in lines, shuf shuffles the lines, and tr put the code back together

fixed the issue of it outputing itself, now it will never output itself

Try it Online!