แม้จะมีคำถาม 17 ข้อที่ติดแท็กแอนนาแกรมแต่เราก็ยังไม่มีคำถามนี้ดังนั้นจึงเป็นเช่นนี้

งานของคุณ

คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่เมื่อได้รับสตริงให้พิมพ์แอนนาแกรมที่เป็นไปได้ทั้งหมด สำหรับวัตถุประสงค์ของคำถามนี้แอนนาแกรมคือสตริงที่มีอักขระเหมือนกันกับสตริงดั้งเดิม แต่ไม่ใช่สำเนาที่แน่นอนของสตริงดั้งเดิม แอนนาแกรมไม่จำเป็นต้องเป็นหรือมีคำที่แท้จริง

อินพุต

คุณอาจยอมรับสตริงซึ่งอาจมีความยาวใด ๆ > 0 โดยวิธีการอินพุตมาตรฐาน มันอาจมีอักขระ ASCII ใด ๆ

เอาท์พุต

คุณสามารถส่งออกแอนนาแกรมที่เป็นไปได้ทั้งหมดของสตริงที่ป้อนเข้าด้วยวิธีมาตรฐาน คุณต้องไม่ส่งออกสตริงเดียวกันสองครั้งหรือส่งออกสตริงเท่ากับอินพุต

กฎอื่น ๆ

ช่องโหว่มาตรฐานไม่ได้รับอนุญาต

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟอย่างน้อยไบต์ชนะ

05AB1E , 3 ไบต์

œÙ¦

ฟังก์ชันที่ปล่อยให้สแต็กมีรายการของแอนนาแกรมอยู่ด้านบน (และเป็นรายการเดียว) ในฐานะที่เป็นโปรแกรมเต็มพิมพ์ตัวแทนของรายการที่

ลองออนไลน์!

อย่างไร?

    - push input
œ   - pop and push a list of all permutations (input appears at the head)
 Ù  - pop and push a list of unique items (sorted by first appearance)
  ¦ - pop and push a dequeued list (removes the occurrence of the input)
    - As a full program: implicit print of the top of the stack

Rubyขนาด 45 ไบต์

->x{(x.chars.permutation.map(&:join)-[x])|[]}

ลองออนไลน์!

แม้จะมีในตัวคำว่า "การเปลี่ยนแปลง" นั้นยาวมาก :(

MATL , 7 ไบต์

tY@1&X~

ลองออนไลน์!

คำอธิบาย

t     % Implicitly input a string, say of length n. Duplicate
Y@    % All permutations. May contain duplicates. Gives a 2D char array of 
      % size n!×n with each permutation in a row
1&X~  % Set symmetric difference, row-wise. Automatically removes duplicates.
      % This takes the n!×n char array and the input string (1×n char array)
      % and produces an m×n char array containing the rows that are present 
      % in exactly one of the two arrays
      % Implicitly display

pyth , 8 4

-{.p

ทดสอบออนไลน์

  .pQ     # all permutations of the (implicit) input string
 {        # de-duplicate
-    Q    # subtract (implicit) input

Japt , 6 ไบต์

á â kU

ลองออนไลน์!

คำอธิบาย

 á â kU
Uá â kU   // Ungolfed
          // Implicit: U = input string
Uá        // Take all permutations of U.
   â      // Remove duplicates.
     kU   // Remove U itself from the result.
          // Implicit: output resulting array, separated by commas

Haskell, 48 40 ไบต์

import Data.List
a=tail.nub.permutations

ลองออนไลน์!

บันทึกแล้ว 8 ไบต์ขอบคุณที่tailทิปของ Leo

CJam, 8 bytes

l_e!\a-p

Try it online!

Explanation

l    e# Read string from input
_    e# Duplicate
e!   e# Unique permutations. Gives a list of strings
\    e# Swap
a    e# Wrap in a singleton array
-    e# Set difference. This removes the input string
p    e# Pretty print the list

Mathematica, 47 bytes

Drop[StringJoin/@Permutations[Characters@#],1]&

Jelly, 4 bytes

Œ!QḊ

A monadic link taking a list of characters and returning a list of lists of characters - all distinct anagrams that are not equal to the input.

Try it online! (the footer forms a program that joins the list by newlines and prints to avoid the otherwise smashed representation).

How?

Œ!QḊ - Link: list of characters     e.g. "text"
Œ!   - all permutations of the list      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","extt","ettx","etxt","xtet","xtte","xett","xett","xtte","xtet","ttex","ttxe","tetx","text","txte","txet"]
  Q  - de-duplicate                      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]
   Ḋ - dequeue (the first one = input)          ["tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]

Python 3, 85 76 63 bytes

As a function, and returning strings as list of characters (thanks to @pizzapants184 for telling me it is allowed):

from itertools import*
lambda z:set(permutations(z))-{tuple(z)}

As a function:

from itertools import*
lambda z:map("".join,set(permutations(z))-{tuple(z)})

85 bytes as a full program:

from itertools import*
z=input()
print(*map("".join,set(permutations(z))-{tuple(z)}))

Could be reduced a bit if outputting strings as ('a', 'b', 'c') is allowed (I am not sure it is).

Java 8, 245 239 237 bytes

import java.util.*;s->{Set l=new HashSet();p("",s,l);l.remove(s);l.forEach(System.out::println);}void p(String p,String s,Set l){int n=s.length(),i=0;if(n<1)l.add(p);else for(;i<n;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,n),l));}

-6 bytes thanks to @OlivierGrégoire.

Typical verbose Java.. I see a lot of <10 byte answers, and here I am with 200+ bytes.. XD

Explanation:

Try it here.

import java.util.*;         // Required import for the Set and HashSet

s->{                        // Method (1) with String parameter and no return-type
  Set l=new HashSet();      //  Set to save all permutations in (without duplicates)
  p("",s);                  //  Determine all permutations, and save them in the Set
  l.remove(s);              //  Remove the input from the Set
  l.forEach(                //  Loop over the Set
    System.out::println);   //   And print all the items
}                           // End of method (1)

// This method will determine all permutations, and save them in the Set:
void p(String p,String s,Set l){
  int n=s.length(),         //  Length of the first input String
      i=0;                  //  And a temp index-integer
  if(n<1)                   //  If the length is 0:
    l.add(p);               //   Add the permutation input-String to the Set
  else                      //  Else:
    for(;i<n;               //   Loop over the first input-String
      p(                    //    And do a recursive-call with:
        p+s.charAt(i),      //     Permutation + char
        s.substring(0,i)+s.substring(++i,n),l)
                            //     Everything except this char
      );                    //   End of loop
}                           // End of method (2)

Perl 6,  39  38 bytes

*.comb.permutations».join.unique[1..*]

Try it

*.comb.permutations».join.unique.skip

Try it

Expanded

*               # WhateverCode lambda (this is the parameter)
.comb           # split into graphemes
.permutations\  # get all of the permutations
».join          # join each of them with a hyper method call
.unique         # make sure they are unique
.skip           # start after the first value (the input)

C++, 142 bytes

#include<algorithm>
void p(std::string s){auto b=s;sort(begin(s),end(s));do if(s!=b)puts(s.data());while(next_permutation(begin(s),end(s)));}

ungolfed

#include <algorithm>

void p(std::string s)
{
    auto b = s;                    // use auto to avoid std::string
    sort(begin(s), end(s));        // start at first permutation
    do
      if (s != b)                  // only print permutation different than given string
        puts(s.data());
    while (next_permutation(begin(s), end(s))); // move to next permutation
}

K (oK), 13 bytes

Solution:

1_?x@prm@!#x:

Try it online!

Explanation:

Evaluation is performed right-to-left.

1_?x@prm@!#x: / the solution
           x: / store input in variable x
          #   / count length of x, #"abc" => 3
         !    / range, !3 => 0 1 2
     prm@     / apply (@) function permutations (prm) to range
   x@         / apply (@) these pumuted indixes back to original input
  ?           / return distinct values
1_            / drop the first one (ie the original input)

JavaScript (ES6), 101 bytes

Adopted from a past answer of mine.

S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])

f=
S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])


console.log(
  f('ABC'),
  f('ABCD'),
  f('ABCC'),
  f('AABBC')
)

Perl 5, 89 + 2 (-F) = 91 bytes

$,=$_;$"=",";map{say if!$k{$_}++&&$,ne$_&&(join"",sort@F)eq join"",sort/./g}glob"{@F}"x@F

Try it online!