Незважаючи на те, що в 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

піт , 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

Математика, 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)));}

неозорий

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

Рішення:

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

Спробуйте в Інтернеті!