이 질문은 많이 떨어져 기반 이 질문 하지만, 추가로 많은 어려움을 야기한다.

당신의 작업

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

입력

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

산출

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

다른 규칙

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

채점

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

05AB1E , 7 바이트

Œ€œ˜Ù¹K

입력에서 문자열을 받아 스택에 문자열 목록을 남기는 함수입니다. 전체 프로그램으로서 목록의 표현이 인쇄됩니다.

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

어떻게?

        - push input
Π      - all substrings
 €œ     - for €ach: all permutations
   ˜    - flatten
    Ù   - de-duplicate
     ¹  - push 1st input onto top of stack
      K - pop a,b; push a without any b's (remove the copy of the input from the list)
        - as a full program: implicit print of the top of the stack

Brachylog (2), 7 바이트

{sp}ᶠdb

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

설명

{sp}ᶠdb
{  }ᶠ    Find all
  p        permutations of
 s         a substring of {the input}
     d   Remove duplicates (leaving the list otherwise in the same order)
      b  Remove the first (the input itself)

젤리 , 9 바이트

ẆŒ!€;/QḟW

리스트를 받아들이고 입력 자체를 제외한 모든 별개의 서브 아나그램리스트를 리턴하는 모나드 링크.

온라인으로 사용해보십시오! 바닥 글은 줄 바꿈과 결합하여 결과 목록을 예쁘게 인쇄합니다.

어떻게?

ẆŒ!€;/QḟW - Link: list of characters, s
Ẇ         - all contiguous sublists of s
 Œ!€      - all permutations for €ach sublist now a list of lists of lists)
     /    - reduce by:
    ;     -   concatenation (flattens the list by one level)
      Q   - de-duplicate (gets the unique entries)
        W - wrap s in a list (otherwise filtering will attempt to remove characters)
       ḟ  - filter discard from left if in right (remove the one equal to the input)

피스, 12

-{.n.pM.:Q)]

온라인 테스트 .

         Q       # input
       .: )      # all substrings
    .pM          # all permutations of all substrings
  .n             # flatten
 {               # deduplicate
-          ]Q    # subtract (list of) (implicit) input

Japt , 10 바이트

à má c â Å

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

내가 사용하는 것이있어 à, á및 â도 순서대로, 한 가지 대답에 모두. 이런 우연이...

설명

 à má c â Å
Uà má c â s1  // Ungolfed
              // Implicit: U = input string
Uà            // Take all combinations of characters in the input string.
   má         // Map each combination to all of its permutations.
      c       // Flatten into a single array.
        â     // Uniquify; remove all duplicates.
          s1  // Remove the first item (the input) from the resulting array.
              // Implicit: output resulting array, separated by commas

Mathematica, 60 바이트

DeleteCases[""<>#&/@Permutations[c=Characters@#,Tr[1^c]],#]&

Permutations선택적 숫자 인수를 사용하여 순열에 사용할 입력 값 수를 알려줍니다. 입력 길이를 지정하면 중복되지 않고 입력의 모든 하위 세트에 대한 순열이 생성됩니다. 입력을 제거하기 만하면됩니다.

자바 (8), 313 (312) 306 바이트

import java.util.*;s->{Set l=new HashSet();for(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),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+++1,n),l));}

의 수정 된 버전을 내 대답은 여기에 , p("",s,l);로 대체되었습니다for(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));

링크 된 답변의 @ OlivierGrégoire 덕분에 -6 바이트 .

이 부분에 대한 설명 :

여기에서 시도하십시오.

for(int l=s.length(),i=0,j;i<l;i++)
                               // Loop (1) from 0 to the length of the String (exclusive)
  for(j=i+1;j<=l;              //  Loop (2) from 1 to the length of the String (exclusive)
    p("",                      //   Call the permutation-method,
    s.substring(i,j+++1),l));  //   with a substring from `i` to `j` (inclusive)
                               //  End of loop (2) (implicit / single-line body)
                               // End of loop (1) (implicit / single-line body)

펄 6 , 75 바이트

{unique(flat $_,.comb.combinations.skip».permutations.map(*».join)).skip}

시도 해봐

넓히는:

{                    # bare block lambda with implicit parameter ｢$_｣

  unique(            # return each (sub)anagram once

    flat             # unstructure the following (List of Lists into flat List)
      $_,            # the input (so we can skip it at the end)

      .comb          # split the input into graphemes
      .combinations  # get all the combinations
      .skip\         # skip the first empty combination
      ».permutations # get all the permutations of each combination
      .map(*».join)  # join the inner permutations

  ).skip             # skip the first value (the input)
}