Anagram etiketli 17 soru olmasına rağmen , hala bu soruya sahip değiliz, işte burada.

Senin görevin

Bir dize alırken, tüm olası anagramlarını yazdıran bir program veya işlev yazmalısınız. Bu sorunun amaçları doğrultusunda bir anagram, orijinal dizeyle aynı karakteri içeren ancak orijinal dizenin tam bir kopyası olmayan bir dizedir. Bir anagramın gerçek kelimeler olması veya içermesi gerekmez.

Giriş

Herhangi bir uzunlukta> 0 olabilecek dizeyi herhangi bir standart giriş yöntemiyle kabul edebilirsiniz. Herhangi bir ASCII karakteri içerebilir.

Çıktı

Girilen dizgenin tüm olası anagramlarını herhangi bir standart şekilde çıktılayabilirsiniz. Aynı dizeyi iki kez çıkarmamalı veya girdiye eşit bir dize çıkarmamalısınız.

Diğer Kurallar

Standart Loopholes'a izin verilmiyor

puanlama

Bu kod golf , en az bayt kazanır.

05AB1E , 3 bayt

œÙ¦

Yığını üstte anagramların bir listesiyle (ve tek öğesi olarak) bırakan bir işlev. Tam bir program olarak bu listenin bir temsilini yazdırır.

Çevrimiçi deneyin!

Nasıl?

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

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

Çevrimiçi deneyin!

Yerleşik olmasına rağmen, "permütasyon" kelimesi gerçekten uzun :(

MATL , 7 bayt

tY@1&X~

Çevrimiçi deneyin!

açıklama

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

pıhtı , 8 4

-{.p

Çevrimiçi test .

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

Japt , 6 bayt

á â kU

Çevrimiçi deneyin!

açıklama

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

import Data.List
a=tail.nub.permutations

Çevrimiçi deneyin!

Leo'nun tailucu sayesinde 8 bayt tasarruf etti .

CJam , 8 bayt

l_e!\a-p

Çevrimiçi deneyin!

açıklama

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 bayt

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

Jöle , 4 bayt

Œ!QḊ

Karakterlerin listesini alan ve karakterlerin listesini döndüren monadik bir bağlantı - girişe eşit olmayan farklı anagramlar.

Çevrimiçi deneyin! (altbilgi, aksi halde parçalanmış temsili önlemek için listeye satır satırlarına katılan ve yazdırılan bir program oluşturur).

Nasıl?

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

Bir işlev olarak ve dizeleri karakter listesi olarak döndürmek (@ pizzapants184 sayesinde bana izin verildiğini bildirmek için teşekkürler):

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

İşlev olarak:

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

Tam bir program olarak 85 bayt:

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

('A', 'b', 'c') olarak dizgilerin çıkışına izin verilirse biraz azaltılabilir (emin değilim).

Java 8, 245 239 237 bayt

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

@ OlivierGrégoire sayesinde -6 bayt .

Tipik ayrıntılı Java .. <10 baytlık cevapların birçoğunu görüyorum ve burada 200+ bayt ile beraberim .. XD

Açıklama:

Burada deneyin.

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 bayt

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

Dene

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

Dene

Expanded

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

#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 (ok) , 13 bayt

Çözüm:

1_?x@prm@!#x:

Çevrimiçi deneyin!

Açıklama:

Değerlendirme sağdan sola yapılır.

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 bayt

Geçmiş bir cevabımdan benimsendi .

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 bayt

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

Çevrimiçi deneyin!