Mặc dù có 17 câu hỏi được gắn thẻ đảo chữ , chúng tôi vẫn không có câu hỏi này, vì vậy đây là.

Nhiệm vụ của bạn

Bạn phải viết một chương trình hoặc hàm, khi nhận được một chuỗi, in ra tất cả các đảo chữ có thể có của nó. Đối với mục đích của câu hỏi này, đảo chữ là một chuỗi chứa cùng ký tự với chuỗi gốc, nhưng không phải là bản sao chính xác của chuỗi gốc. Một đảo chữ cái không phải là hoặc chứa các từ thực tế.

Đầu vào

Bạn có thể chấp nhận chuỗi có thể có độ dài bất kỳ> 0, theo bất kỳ phương thức nhập chuẩn nào. Nó có thể chứa bất kỳ ký tự ASCII nào.

Đầu ra

Bạn có thể xuất tất cả các đảo chữ có thể có của chuỗi được nhập theo bất kỳ cách tiêu chuẩn nào. Bạn không được xuất cùng một chuỗi hai lần hoặc xuất một chuỗi bằng với đầu vào.

Các quy tắc khác

Lỗ hổng tiêu chuẩn không được phép

Chấm điểm

Đây là mã golf , ít byte thắng nhất.

05AB1E , 3 byte

œÙ¦

Một chức năng rời khỏi ngăn xếp với một danh sách các đảo chữ trên đầu (và là mục duy nhất của nó). Như một chương trình đầy đủ in một đại diện của danh sách đó.

Hãy thử trực tuyến!

Làm sao?

    - 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 byte

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

Hãy thử trực tuyến!

Mặc dù có tích hợp sẵn, từ "hoán vị" thực sự dài :(

MATL , 7 byte

tY@1&X~

Hãy thử trực tuyến!

Giải trình

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

trăn , 8 4

-{.p

Kiểm tra trực tuyến .

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

Japt , 6 byte

á â kU

Hãy thử trực tuyến!

Giải trình

 á â 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 byte

import Data.List
a=tail.nub.permutations

Hãy thử trực tuyến!

Đã lưu 8 byte nhờ tailmẹo của Leo .

CJam , 8 byte

l_e!\a-p

Hãy thử trực tuyến!

Giải trình

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

Toán học, 47 byte

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

Thạch , 4 byte

Œ!QḊ

Một liên kết đơn âm lấy danh sách các ký tự và trả về danh sách các danh sách các ký tự - tất cả các đảo chữ riêng biệt không bằng đầu vào.

Hãy thử trực tuyến! (chân trang tạo thành một chương trình tham gia danh sách theo dòng mới và bản in để tránh đại diện bị đập vỡ).

Làm sao?

Œ!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 byte

Là một hàm và trả về các chuỗi dưới dạng danh sách các ký tự (cảm ơn @ pizzapants184 vì đã cho tôi biết nó được cho phép):

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

Là một chức năng:

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

85 byte là một chương trình đầy đủ:

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

Có thể giảm một chút nếu xuất ra các chuỗi như ('a', 'b', 'c') được cho phép (tôi không chắc là như vậy).

Java 8, 245 239 237 byte

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 byte nhờ @ OlivierGrégoire .

Java verbose điển hình .. Tôi thấy rất nhiều câu trả lời <10 byte và ở đây tôi có hơn 200 byte .. XD

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Thử nó

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

Thử nó

Mở rộng

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

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

vô dụng

#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 byte

Giải pháp:

1_?x@prm@!#x:

Hãy thử trực tuyến!

Giải trình:

Đánh giá được thực hiện từ phải sang trái.

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 byte

Thông qua một câu trả lời trong quá khứ của tôi .

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 byte

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

Hãy thử trực tuyến!