Pomimo otagowania 17 pytań anagramami , nadal nie mamy tego pytania, więc oto jest.

Twoje zadanie

Musisz napisać program lub funkcję, która po otrzymaniu ciągu wypisze wszystkie możliwe anagramy. Na potrzeby tego pytania anagram to ciąg znaków, który zawiera ten sam znak, co ciąg oryginalny, ale nie jest dokładną kopią ciągu oryginalnego. Anagram nie musi być ani zawierać rzeczywistych słów.

Wejście

Możesz zaakceptować ciąg znaków, który może mieć dowolną długość> 0, dowolną standardową metodą wprowadzania. Może zawierać dowolne znaki ASCII.

Wynik

Możesz wyprowadzić wszystkie możliwe anagramy wprowadzonego ciągu w dowolny standardowy sposób. Nie wolno wyprowadzać tego samego ciągu dwa razy ani wyprowadzać ciągu równego wejściu.

Inne zasady

Standardowe luki są niedozwolone

Punktacja

To jest golf golfowy , najmniej bajtów wygrywa.

05AB1E , 3 bajty

œÙ¦

Funkcja, która pozostawia stos z listą anagramów na górze (i jako jedyny element). Jako pełny program drukuje reprezentację tej listy.

Wypróbuj online!

W jaki sposób?

    - 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

Rubinowy , 45 bajtów

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

Wypróbuj online!

Pomimo wbudowanego słowa „permutacja” jest naprawdę długie :(

MATL , 7 bajtów

tY@1&X~

Wypróbuj online!

Wyjaśnienie

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

Test online .

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

Japt , 6 bajtów

á â kU

Wypróbuj online!

Wyjaśnienie

 á â 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 bajtów

import Data.List
a=tail.nub.permutations

Wypróbuj online!

Zaoszczędzono 8 bajtów dzięki wskazówce Leo tail.

CJam , 8 bajtów

l_e!\a-p

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Galaretka , 4 bajty

Œ!QḊ

Monadyczny link pobierający listę znaków i zwracający listę list znaków - wszystkie odrębne anagramy, które nie są równe wejściowi.

Wypróbuj online!(stopka tworzy program, który dołącza do listy za pomocą nowego wiersza i drukuje, aby uniknąć w innym przypadku rozbicia reprezentacji).

W jaki sposób?

Œ!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 bajtów

Jako funkcja i zwracanie ciągów znaków jako listy znaków (dzięki @ pizzapants184 za poinformowanie mnie, że jest dozwolone):

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

Jako funkcja:

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

85 bajtów jako pełny program:

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

Można to nieco zmniejszyć, jeśli wypuszczanie ciągów znaków („a”, „b”, „c”) jest dozwolone (nie jestem pewien, czy tak jest).

Java 8, 245 239 237 bajtów

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 bajtów dzięki @ OlivierGrégoire .

Typowa pełna Java. Widzę dużo <10 bajtowych odpowiedzi, a oto jestem z ponad 200 bajtami. XD

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Spróbuj

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

Spróbuj

Rozszerzony

*               # 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 bajty

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

bez golfa

#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 bajtów

Rozwiązanie:

1_?x@prm@!#x:

Wypróbuj online!

Wyjaśnienie:

Ocena jest przeprowadzana od prawej do lewej.

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 bajtów

Przyjęte z mojej poprzedniej odpowiedzi .

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 bajtów

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

Wypróbuj online!