Несмотря на 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

Рубин , 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подсказке Лео .

CJam , 8 байт

l_e!\a-p

Попробуйте онлайн!

объяснение

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 байт

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

Желе , 4 байта

Œ!QḊ

Монадическая ссылка, принимающая список символов и возвращающая список списков символов - все различные анаграммы, которые не равны входным данным.

Попробуйте онлайн! (нижний колонтитул формирует программу, которая соединяет список новыми строками и печатает, чтобы избежать разбитого представления).

Как?

Œ!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 байта

Как функция и возвращая строки в виде списка символов (спасибо @ pizzapants184 за сообщение, что это разрешено):

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

Как функция:

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

85 байт как полная программа:

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

Может быть немного уменьшен, если разрешен вывод строк как ('a', 'b', 'c') (я не уверен, что это так).

Java 8, 245 239 237 байт

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 байт благодаря @ OlivierGrégoire .

Типичная многословная Java .. Я вижу много <10-байтовых ответов, и вот я с 200+ байтами .. XD

Объяснение:

Попробуй это здесь.

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 байт

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

Попытайся

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

Попытайся

расширенный

*               # 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 байта

#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 (ок) , 13 байтов

Решение:

1_?x@prm@!#x:

Попробуйте онлайн!

Объяснение:

Оценка выполняется справа налево.

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 байт

Принято из моего прошлого ответа .

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 байт

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

Попробуйте онлайн!