anagrams 태그가 지정된 17 개의 질문이 있음에도 불구하고 여전히이 질문이 없습니다.

당신의 작업

문자열을받을 때 가능한 모든 아나그램을 인쇄하는 프로그램이나 함수를 작성해야합니다. 이 질문의 목적 상, 아나그램은 원래 문자열과 동일한 문자를 포함하지만 원래 문자열의 정확한 사본이 아닌 문자열입니다. 아나그램은 실제 단어 일 필요는 없습니다.

입력

표준 입력 방법으로 길이가 0보다 큰 문자열을 사용할 수 있습니다. ASCII 문자를 포함 할 수 있습니다.

산출

입력 된 문자열의 가능한 모든 아나그램을 표준 방식으로 출력 할 수 있습니다. 동일한 문자열을 두 번 출력하거나 입력과 동일한 문자열을 출력해서는 안됩니다.

다른 규칙

표준 허점 은 허용되지 않습니다

채점

이것은 code-golf 이며 최소 바이트 수입니다.

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

하스켈, 48 40 바이트

import Data.List
a=tail.nub.permutations

온라인으로 사용해보십시오!

Leo의 tail팁 덕분에 8 바이트가 절약되었습니다 .

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"]

파이썬 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 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)

펄 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 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!